adding secret santa cordapp

Author: davidawad

Advanced/secret-santa/LICENCE

@@ -0,0 +1,13 @@
+  Copyright 2016, R3 Limited.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Advanced/secret-santa/README.md

@@ -0,0 +1,85 @@
+![](./clients/src/main/webapp/src/Components/img/secret_corda.png)
+
+# Corda Secret Santa
+
+This is an imlementation of Secret Santa using Corda as a tool to store multiple game states.
+
+It has a material-ui frontend that lets users create and self-service their own secret santa games. The frontend is implemented in ReactJS and the backend is implemented with a Spring Boot server and some corda flows.
+
+You can create a game using the web frontend (or just calling the api directly with Postman), and once the game is stored, players can look up their assignments using their game id, and the app also supports an optional sendgrid integration so that you can have emails sent to the players as well.
+
+> One tip if you're using intellij one recommendation is to open the project from the intellij dialog, don't import the project directly.
+
+## Usage
+
+There's essentially five processes you'll need to be aware of.
+
+- Three Corda nodes, a notary, santa, and an elf
+- The backend webserver that runs the REST endpoints for the corda nodes
+- The frontend webserver, a react app that sends requests to the backend.
+
+
+#### Pre-Requisites
+
+If you've never built a cordapp before you may need to configure gradle and java in order for this code example to run. See [our setup guide](https://docs.corda.net/getting-set-up.html).
+
+
+### Running these services
+
+#### The three Corda nodes
+To run the corda nodes you just need to run the `deployNodes` gradle task and the nodes will be available for you to run directly.
+
+```
+./gradlew deployNodes
+./build/nodes/runnodes
+```
+
+#### The backend webserver
+
+Run the `runSantaServer` Gradle task. By default, it connects to the node with RPC address `localhost:10006` with
+the username `user1` and the password `test`, and serves the webserver on port `localhost:10056`.
+
+```
+./gradlew runSantaServer
+```
+
+The frontend will be visible on [localhost:10056](http://localhost:10056)
+
+##### Background Information
+
+`clients/src/main/java/com/secretsanta/webserver/` defines a simple Spring webserver that connects to a node via RPC and allows you to interact with the node over HTTP.
+
+The API endpoints are defined in `clients/src/main/java/com/secretsanta/webserver/Controller.java`
+
+
+#### The frontend webserver
+
+The react server can be started by going to `clients/src/main/webapp`, running `npm install` and then `npm start`.
+
+```
+cd clients/src/main/webapp
+npm install
+npm start
+```
+
+The frontend will be visible on [localhost:8888](http://localhost:8888)
+
+#### Configuring Email with SendGrid
+
+If you'd like to start sending email you'll need to make an account on [sendgrid.com](http://sendgrid.com) and configure a verified sender identity.
+
+Once you've done that, create an API key and place it into `Controller.java`(the webserver for the corda nodes). After which point you can set the `sendEmail` param to `true` in your requests. In order to configure the frontend to send emails, just open `CONSTANTS.js` and set the `SEND_EMAIL` param to `true` instead of `false`.
+
+
+### Testing Utilities
+
+
+#### Using Postman for backend testing
+
+I've included some simple postman tests to run against the santa server that will be helpful to you if you plan on using this. You'll find them in the `postman` folder.
+
+
+#### Running tests inside IntelliJ
+
+There are unit tests for the corda state, contract, and tests for both flows used here. You'll find them inside of the various test folders.
+

Advanced/secret-santa/TRADEMARK

@@ -0,0 +1,4 @@
+Corda and the Corda logo are trademarks of R3CEV LLC and its affiliates. All rights reserved.
+
+For R3CEV LLC's trademark and logo usage information, please consult our Trademark Usage Policy at
+https://www.r3.com/trademark-policy/.

Advanced/secret-santa/build.gradle

@@ -0,0 +1,176 @@
+buildscript { //properties that you need to build the project
+    Properties constants = new Properties()
+    file("$projectDir/./constants.properties").withInputStream { constants.load(it) }
+
+    ext {
+        corda_release_group = constants.getProperty("cordaReleaseGroup")
+        corda_core_release_group =  constants.getProperty("cordaCoreReleaseGroup")
+        corda_release_version = constants.getProperty("cordaVersion")
+        corda_core_release_version = constants.getProperty("cordaCoreVersion")
+        corda_gradle_plugins_version = constants.getProperty("gradlePluginsVersion")
+        kotlin_version = constants.getProperty("kotlinVersion")
+        junit_version = constants.getProperty("junitVersion")
+        quasar_version = constants.getProperty("quasarVersion")
+        log4j_version = constants.getProperty("log4jVersion")
+        slf4j_version = constants.getProperty("slf4jVersion")
+        corda_platform_version = constants.getProperty("platformVersion").toInteger()
+
+        // springboot
+        spring_boot_version = '2.0.2.RELEASE'
+        spring_boot_gradle_plugin_version = '2.0.2.RELEASE'
+
+        accounts_release_version = '1.0'
+        accounts_release_group = 'com.r3.corda.lib.accounts'
+        confidential_id_release_group = "com.r3.corda.lib.ci"
+        confidential_id_release_version = "1.0"
+    }
+
+    repositories {
+        mavenLocal()
+        mavenCentral()
+        jcenter()
+        maven { url 'https://jitpack.io' }
+        maven { url 'https://repo.gradle.org/gradle/libs-releases' }
+        maven { url 'http://software.r3.com/artifactory/corda-lib' }
+        maven { url 'https://software.r3.com/artifactory/corda-releases' }
+    }
+
+    dependencies {
+        classpath "net.corda.plugins:cordapp:$corda_gradle_plugins_version"
+        classpath "net.corda.plugins:cordformation:$corda_gradle_plugins_version"
+        classpath "net.corda.plugins:quasar-utils:$corda_gradle_plugins_version"
+        classpath "org.springframework.boot:spring-boot-gradle-plugin:$spring_boot_gradle_plugin_version"
+        classpath "net.corda.plugins:cordapp:$corda_gradle_plugins_version"
+
+        classpath "com.sendgrid:sendgrid-java:4.7.0"
+        classpath "com.sendgrid:java-http-client:4.3.6"
+    }
+}
+
+allprojects {//Properties that you need to compile your project (The application)
+    apply from: "${rootProject.projectDir}/repositories.gradle"
+    apply plugin: 'java'
+
+    repositories {
+        mavenLocal()
+        jcenter()
+        mavenCentral()
+        maven { url 'https://jitpack.io' }
+        maven { url 'https://software.r3.com/artifactory/corda' }
+    }
+
+    tasks.withType(JavaCompile) {
+        options.compilerArgs << "-parameters" // Required by Corda's serialisation framework.
+    }
+
+//    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile) {
+//        kotlinOptions {
+//            languageVersion = "1.2"
+//            apiVersion = "1.2"
+//            jvmTarget = "1.8"
+//            javaParameters = true   // Useful for reflection.
+//        }
+//    }
+
+    jar {
+        // This makes the JAR's SHA-256 hash repeatable.
+        preserveFileTimestamps = false
+        reproducibleFileOrder = true
+        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    }
+}
+
+apply plugin: 'net.corda.plugins.cordapp'
+apply plugin: 'net.corda.plugins.cordformation'
+apply plugin: 'net.corda.plugins.quasar-utils'
+
+sourceSets {
+    main {
+        resources {
+            srcDir rootProject.file("config/dev")
+        }
+    }
+}
+
+//Module dependencis
+dependencies {
+    // Corda dependencies.
+    cordaCompile "$corda_core_release_group:corda-core:$corda_core_release_version"
+    cordaCompile "$corda_release_group:corda-node-api:$corda_release_version"
+    cordaRuntime "$corda_release_group:corda:$corda_release_version"
+
+    // CorDapp dependencies.
+    cordapp project(":workflows")
+    cordapp project(":contracts")
+
+    cordaCompile "org.slf4j:jul-to-slf4j:$slf4j_version"
+    cordaCompile "org.apache.logging.log4j:log4j-web:${log4j_version}"
+    cordaCompile "org.apache.logging.log4j:log4j-slf4j-impl:${log4j_version}"
+}
+
+//Task to build the jar for ganache.
+task ganache {
+    subprojects {
+        if (it.project.name != "clients") {
+            dependsOn jar
+            doLast {
+                copy {
+                    from "${buildDir}/libs"
+                    into "${rootDir}/build/libs"
+                }
+            }
+        }
+    }
+}
+
+//Task to deploy the nodes in order to bootstrap a network
+task deployNodes(type: net.corda.plugins.Cordform, dependsOn: ['jar']) {
+
+    /* This property will load the CorDapps to each of the node by default, including the Notary. You can find them
+     * in the cordapps folder of the node at build/nodes/Notary/cordapps. However, the notary doesn't really understand
+     * the notion of cordapps. In production, Notary does not need cordapps as well. This is just a short cut to load
+     * the Corda network bootstrapper.
+     */
+
+    //Java version check
+    if (JavaVersion.current() != JavaVersion.VERSION_1_8){
+        throw new GradleException("This build must be run with java 8")
+    }
+
+    nodeDefaults {
+        projectCordapp { deploy = true }
+        cordapp project(':contracts')
+        cordapp project(':workflows')
+    }
+
+    node {
+        name "O=Notary,L=London,C=GB"
+        notary = [validating : false]
+        p2pPort 10002
+        rpcSettings {
+            address("localhost:10003")
+            adminAddress("localhost:10043")
+        }
+    }
+    node {
+        name "O=Santa,L=London,C=GB"
+        p2pPort 10006
+        rpcSettings {
+            address("localhost:10016")
+            adminAddress("localhost:10046")
+        }
+        rpcUsers = [[ user: "user1", "password": "test", "permissions": ["ALL"]]]
+    }
+
+    node {
+        name "O=Elf,L=London,C=GB"
+        p2pPort 10007
+        rpcSettings {
+            address("localhost:10017")
+            adminAddress("localhost:10027")
+        }
+
+        rpcUsers = [[ user: "user1", "password": "test", "permissions": ["ALL"]]]
+    }
+
+}

Advanced/secret-santa/clients/build.gradle

@@ -0,0 +1,63 @@
+buildscript {
+    repositories {
+        maven {
+            url = uri("https://plugins.gradle.org/m2/")
+        }
+    }
+}
+
+apply plugin: 'org.springframework.boot'
+
+sourceSets {
+    main {
+        resources {
+            srcDir rootProject.file("config/dev")
+        }
+    }
+}
+
+dependencies {
+    implementation 'com.google.code.gson:gson:2.8.5'
+
+    // Corda dependencies.
+    compile "$corda_release_group:corda-rpc:$corda_release_version"
+
+    // CorDapp dependencies.
+    compile project(":contracts")
+    compile project(":workflows")
+    compile("org.springframework.boot:spring-boot-starter-websocket:$spring_boot_version") {
+        exclude group: "org.springframework.boot", module: "spring-boot-starter-logging"
+    }
+    compile "org.apache.logging.log4j:log4j-slf4j-impl:${log4j_version}"
+    compile "org.apache.logging.log4j:log4j-web:${log4j_version}"
+    compile "org.slf4j:jul-to-slf4j:$slf4j_version"
+
+    // SendGrid
+    implementation 'com.sendgrid:sendgrid-java:4.7.0'
+    compile 'com.sendgrid:sendgrid-java:4.7.0'
+}
+
+springBoot {
+    mainClassName = "net.corda.samples.secretsanta.webserver.Server"
+}
+
+/* The Client is the communication channel between the external and the node. This task will help you immediately
+ * execute your rpc methods in the main method of the client.kt. You can somewhat see this as a quick test of making
+ * RPC calls to your nodes.
+ */
+task runSantaClient(type: JavaExec, dependsOn: assemble) {
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'net.corda.samples.secretsanta.Client'
+    args 'localhost:10016', 'user1', 'test'
+}
+
+/**
+ * This task will start the springboot server that connects to the santa node (via RPC connection). All of the http requests
+ * are in the Controller file.
+ *
+ */
+task runSantaServer(type: JavaExec, dependsOn: assemble) {
+    classpath = sourceSets.main.runtimeClasspath
+    main = 'net.corda.samples.secretsanta.webserver.Starter'
+    args '--server.port=10056', '--config.rpc.host=localhost', '--config.rpc.port=10016', '--config.rpc.username=user1', '--config.rpc.password=test'
+}

Advanced/secret-santa/clients/src/main/java/net/corda/samples/secretsanta/Client.java

@@ -0,0 +1,48 @@
+package net.corda.samples.secretsanta;
+
+import net.corda.client.rpc.CordaRPCClient;
+import net.corda.client.rpc.CordaRPCConnection;
+import net.corda.core.identity.CordaX500Name;
+import net.corda.core.messaging.CordaRPCOps;
+import net.corda.core.node.NodeInfo;
+import net.corda.core.utilities.NetworkHostAndPort;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+
+import static net.corda.core.utilities.NetworkHostAndPort.parse;
+
+/**
+ * Connects to a Corda node via RPC and performs RPC operations on the node.
+ *
+ * The RPC connection is configured using command line arguments.
+ */
+public class Client {
+    private static final Logger logger = LoggerFactory.getLogger(Client.class);
+
+    public static void main(String[] args) {
+        // Create an RPC connection to the node.
+        if (args.length != 3) throw new IllegalArgumentException("Usage: Client <node address> <rpc username> <rpc password>");
+        final NetworkHostAndPort nodeAddress = parse(args[0]);
+        final String rpcUsername = args[1];
+        final String rpcPassword = args[2];
+        final CordaRPCClient client = new CordaRPCClient(nodeAddress);
+        final CordaRPCConnection clientConnection = client.start(rpcUsername, rpcPassword);
+        final CordaRPCOps proxy = clientConnection.getProxy();
+
+        // Interact with the node.
+        // Example #1, here we print the nodes on the network.
+        final List<NodeInfo> nodes = proxy.networkMapSnapshot();
+        System.out.println("\n-- Here is the networkMap snapshot --");
+        logger.info("{}", nodes);
+
+        // Example #2, here we print the PartyA's node info
+        CordaX500Name name = proxy.nodeInfo().getLegalIdentities().get(0).getName();//nodeInfo().legalIdentities.first().name
+        System.out.println("\n-- Here is the node info of the node that the client connected to --");
+        logger.info("{}", name);
+
+        //Close the client connection
+        clientConnection.close();
+    }
+}