コード例 #1
0
        public void TestTransformGoNotEqual()
        {
            var smartContractDescriptor = new SmartContractDescriptor
            {
                Name      = "main",
                Functions = new List <SmartContractDescriptor.Function>
                {
                    new SmartContractDescriptor.Function
                    {
                        Name = "DeployWinnerTakesAll"
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "WatchProjectSupported"
                    }
                }
            };

            var test = SmartContractDescriptorGenerator.Transform("", "Go");

            Assert.NotNull(test);
            Assert.NotEqual(smartContractDescriptor.Name, test.Name);
            Assert.NotNull(test.Functions);
            Assert.NotNull(test.Events);
        }
コード例 #2
0
        public void TestTransformGoEqual()
        {
            var smartContractDescriptor = new SmartContractDescriptor
            {
                Name      = "main",
                Functions = new List <SmartContractDescriptor.Function>
                {
                    new SmartContractDescriptor.Function
                    {
                        Name = "DeployWinnerTakesAll"
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "bindWinnerTakesAll"
                    }
                }
            };

            var test = SmartContractDescriptorGenerator.Transform(
                new StreamReader(_assembly.GetManifestResourceStream(_goResourceName) !).ReadToEnd(), "Go");

            Assert.NotNull(test);
            Assert.Equal(smartContractDescriptor.Name, test.Name);
            Assert.Equal(smartContractDescriptor.Functions.First().Name, test.Functions.First().Name);
            Assert.Equal(smartContractDescriptor.Functions.Last().Name, test.Functions.Last().Name);
        }
コード例 #3
0
        private static Template CreateFreshTemplate(Stream stream, SmartContractDescriptor smartContractDescriptor,
                                                    string packageName, string callbackUrl)
        {
            var reader   = new StreamReader(stream);
            var template = new Template(reader.ReadToEnd(), '€', '€');

            stream.Position = 0;
            template.Add("packageName", packageName);
            template.Add("sclAddress", smartContractDescriptor.SclAddress);
            template.Add("callbackUrl", callbackUrl);
            template.Add("contractPackageName", smartContractDescriptor.Name.ToLower());
            template.Add("contractName", ToUpperFirstLetter(smartContractDescriptor.Name));
            return(template);
        }
コード例 #4
0
        public void TestBuildCallbackUrlEmpty()
        {
            var smartContractDescriptor = new SmartContractDescriptor
            {
                Name      = "main",
                Functions = new List <SmartContractDescriptor.Function>
                {
                    new SmartContractDescriptor.Function
                    {
                        Name = "DeployWinnerTakesAll"
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "bindWinnerTakesAll"
                    }
                }
            };
            var path = ClientApplicationGenerator.Build(JsonConvert.SerializeObject(smartContractDescriptor), "package", "");

            Assert.NotNull(path);
        }
コード例 #5
0
        public void TestTransformSolidityEqual()
        {
            var smartContractDescriptor = new SmartContractDescriptor
            {
                Name      = "test",
                Functions = new List <SmartContractDescriptor.Function>
                {
                    new SmartContractDescriptor.Function
                    {
                        Name = "f"
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "g"
                    }
                },
                Events = new List <SmartContractDescriptor.Event>
                {
                    new SmartContractDescriptor.Event
                    {
                        Name = "e"
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "a"
                    }
                }
            };

            var test = SmartContractDescriptorGenerator.Transform(
                new StreamReader(_assembly.GetManifestResourceStream(_solidityResourceName) !).ReadToEnd(),
                "Solidity");

            Assert.NotNull(test);
            Assert.Equal(smartContractDescriptor.Name, test.Name);
            Assert.Equal(smartContractDescriptor.Functions.First().Name, test.Functions.First().Name);
            Assert.Equal(smartContractDescriptor.Functions.Last().Name, test.Functions.Last().Name);
            Assert.Equal(smartContractDescriptor.Events.First().Name, test.Events.First().Name);
            Assert.Equal(smartContractDescriptor.Events.Last().Name, test.Events.Last().Name);
        }
コード例 #6
0
        public void TestTransformSolidityNotEqual()
        {
            var smartContractDescriptor = new SmartContractDescriptor
            {
                Name      = "test",
                Functions = new List <SmartContractDescriptor.Function>
                {
                    new SmartContractDescriptor.Function
                    {
                        Name = "f"
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "g"
                    }
                },
                Events = new List <SmartContractDescriptor.Event>
                {
                    new SmartContractDescriptor.Event
                    {
                        Name = "e"
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "a"
                    }
                }
            };

            var test = SmartContractDescriptorGenerator.Transform("",
                                                                  "Solidity");

            Assert.NotNull(test);
            Assert.NotEqual(smartContractDescriptor.Name, test.Name);
            Assert.Null(test.Functions);
            Assert.Null(test.Events);
        }
コード例 #7
0
        private static string BuildJavaApplication(SmartContractDescriptor smartContractDescriptor,
                                                   string packageName, string callbackUrl)
        {
            var files               = new List <KeyValuePair <string, string> >();
            var assembly            = Assembly.GetExecutingAssembly();
            var paths               = assembly.GetManifestResourceNames();
            var controllerHeader    = string.Empty;
            var controllerFunctions = string.Empty;
            var controllerEvents    = string.Empty;
            var controllerFooter    = string.Empty;

            foreach (var path in paths)
            {
                var stream = assembly.GetManifestResourceStream(path);
                if (stream != null)
                {
                    if (path.Contains("FunctionParameter"))
                    {
                        var smartContractPath = path.Replace("smartcontract", smartContractDescriptor.Name.ToLower());
                        foreach (var function in smartContractDescriptor.Functions)
                        {
                            var tempPath = smartContractPath.Replace("Function", ToUpperFirstLetter(function.Name));

                            var functionTemplate = CreateFreshTemplate(stream, smartContractDescriptor, packageName,
                                                                       callbackUrl);
                            functionTemplate.Add("functionParameterName", ToUpperFirstLetter(function.Name));
                            foreach (var parameter in function.Inputs)
                            {
                                functionTemplate.Add("parameterarray",
                                                     new[] { parameter.Name });
                            }

                            files.Add(new KeyValuePair <string, string>(CreateDirectory(tempPath, packageName),
                                                                        Regex.Escape(functionTemplate.Render())));
                        }

                        continue;
                    }

                    if (path.Contains("ControllerHeader"))
                    {
                        var template = CreateFreshTemplate(stream, smartContractDescriptor, packageName,
                                                           callbackUrl);
                        controllerHeader = template.Render();
                        continue;
                    }

                    if (path.Contains("ControllerFunctions"))
                    {
                        foreach (var function in smartContractDescriptor.Functions)
                        {
                            var template = CreateFreshTemplate(stream, smartContractDescriptor, packageName,
                                                               callbackUrl);
                            template.Add("functionParameter", ToUpperFirstLetter(function.Name));
                            var privateFunction = new Function
                            {
                                Name         = function.Name,
                                FirstCapital = ToUpperFirstLetter(function.Name)
                            };
                            template.Add("functionArray", new[] { privateFunction });
                            foreach (var parameter in function.Inputs)
                            {
                                var privateParameter = new Parameter
                                {
                                    FirstCapital = ToUpperFirstLetter(parameter.Name),
                                    Name         = parameter.Name,
                                    ParamType    = parameter.Type
                                };
                                template.Add("inputparameterarray",
                                             new[] { privateParameter });
                            }

                            foreach (var parameter in function.Outputs)
                            {
                                var privateParameter = new Parameter
                                {
                                    FirstCapital = ToUpperFirstLetter(parameter.Name),
                                    Name         = parameter.Name,
                                    ParamType    = parameter.Type
                                };
                                template.Add("outputparameterarray", new[] { privateParameter });
                            }

                            controllerFunctions += template.Render();
                        }

                        continue;
                    }

                    if (path.Contains("ControllerEvents"))
                    {
                        foreach (var scEvent in smartContractDescriptor.Events)
                        {
                            var template = CreateFreshTemplate(stream, smartContractDescriptor, packageName,
                                                               callbackUrl);
                            var privateEvent = new Event
                            {
                                Name         = scEvent.Name,
                                FirstCapital = ToUpperFirstLetter(scEvent.Name)
                            };
                            template.Add("eventArray", new[] { privateEvent });
                            foreach (var parameter in scEvent.Outputs)
                            {
                                var privateParameter = new Parameter
                                {
                                    FirstCapital = ToUpperFirstLetter(parameter.Name),
                                    Name         = parameter.Name,
                                    ParamType    = parameter.Type
                                };
                                template.Add("eventoutputparameterarray", new[] { privateParameter });
                            }

                            controllerEvents += template.Render();
                        }

                        continue;
                    }

                    if (path.Contains("ControllerFooter"))
                    {
                        var template = CreateFreshTemplate(stream, smartContractDescriptor, packageName,
                                                           callbackUrl);
                        controllerFooter = template.Render();
                        continue;
                    }

                    if (path.Contains("SmartContract"))
                    {
                        var smartContractPath = path.Replace("smartcontract", smartContractDescriptor.Name.ToLower());
                        smartContractPath = smartContractPath.Replace("SmartContract",
                                                                      ToUpperFirstLetter(smartContractDescriptor.Name));
                        files.Add(new KeyValuePair <string, string>(CreateDirectory(smartContractPath, packageName),
                                                                    Regex.Escape(
                                                                        $"{controllerHeader}{controllerFunctions}{controllerEvents}{controllerFooter}")));
                        continue;
                    }

                    files.Add(new KeyValuePair <string, string>(CreateDirectory(path, packageName),
                                                                Regex.Escape(CreateFreshTemplate(stream, smartContractDescriptor, packageName, callbackUrl)
                                                                             .Render())));
                }
            }

            return(WriteFiles(files) ? ApplicationDirectory : "Something went wrong");
        }
コード例 #8
0
        public void TestTransformJavaScriptNotEqual()
        {
            var smartContractDescriptor = new SmartContractDescriptor
            {
                Name      = "diary",
                Functions = new List <SmartContractDescriptor.Function>
                {
                    new SmartContractDescriptor.Function
                    {
                        Name = "registerMilkBatch"
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "transportMilkBatch"
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "registerMilkCarton",
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "transportCarton",
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "registerCartonInInventory",
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "registerSelling"
                    }
                },
                Events = new List <SmartContractDescriptor.Event>
                {
                    new SmartContractDescriptor.Event
                    {
                        Name = "milkBatchRegistered",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "milkBatchTransported",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "cartonRegistered",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "cartonTransported",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "cartonRegisteredInInventory",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "cartonSold",
                    }
                }
            };

            var test = SmartContractDescriptorGenerator.Transform("",
                                                                  "JavaScript");

            Assert.NotNull(test);
            Assert.NotEqual(smartContractDescriptor.Name, test.Name);
            Assert.NotNull(test.Functions);
            Assert.NotNull(test.Events);
        }
コード例 #9
0
        public void TestTransformJavaScriptEqual()
        {
            var smartContractDescriptor = new SmartContractDescriptor
            {
                Name      = "diary",
                Functions = new List <SmartContractDescriptor.Function>
                {
                    new SmartContractDescriptor.Function
                    {
                        Name = "registerMilkBatch"
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "transportMilkBatch"
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "registerMilkCarton",
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "transportCarton",
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "registerCartonInInventory",
                    },
                    new SmartContractDescriptor.Function
                    {
                        Name = "registerSelling"
                    }
                },
                Events = new List <SmartContractDescriptor.Event>
                {
                    new SmartContractDescriptor.Event
                    {
                        Name = "milkBatchRegistered",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "milkBatchTransported",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "cartonRegistered",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "cartonTransported",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "cartonRegisteredInInventory",
                    },
                    new SmartContractDescriptor.Event
                    {
                        Name = "cartonSold",
                    }
                }
            };

            var test = SmartContractDescriptorGenerator.Transform(
                new StreamReader(_assembly.GetManifestResourceStream(_javaScriptResourceName) !).ReadToEnd(),
                "JavaScript");

            Assert.NotNull(test);
            Assert.Equal(smartContractDescriptor.Name, test.Name);
            Assert.Equal(smartContractDescriptor.Functions.First().Name, test.Functions.First().Name);
            Assert.Equal(smartContractDescriptor.Functions.Last().Name, test.Functions.Last().Name);
            Assert.Equal(smartContractDescriptor.Events.First().Name, test.Events.First().Name);
            Assert.Equal(smartContractDescriptor.Events.Last().Name, test.Events.Last().Name);
        }