public async Task <IActionResult> PutPackageTemplate([FromRoute] int id, [FromBody] PackageTemplate packageTemplate) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != packageTemplate.Id) { return(BadRequest()); } _context.Entry(packageTemplate).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PackageTemplateExists(id)) { return(NotFound()); } else { throw; } } return(Ok(packageTemplate)); }
private static string CreateTestPackage(string suffix = "") { var options = new PackageTemplateOptions() { name = $"com.unity.packagecreatortests{suffix}", displayName = $"Package Creator Tests {suffix}".Trim(), rootNamespace = $"Unity.PackageCreatorTests{suffix}" }; return(PackageTemplate.CreatePackage(options)); }
public async Task <IActionResult> PostPackageTemplate([FromBody] PackageTemplate packageTemplate) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _context.PackageTemplates.Add(packageTemplate); await _context.SaveChangesAsync(); return(CreatedAtAction("GetPackageTemplate", new { id = packageTemplate.Id }, packageTemplate)); }
public void TestValidationErrorsAreConcatenated() { var options = new PackageTemplateOptions(); try { PackageTemplate.CreatePackage(options); Assert.Fail("Expected PackageTemplate.CreatePackage to throw"); } catch (Exception e) { Assert.AreEqual($"options parameter is invalid:{Environment.NewLine}name is required{Environment.NewLine}displayName is required", e.Message); } }
public void TestParametersAreValidated(string name, string displayName, string rootNamespace, string templateFolder, string expectedMessage) { var options = new PackageTemplateOptions() { name = name, displayName = displayName, rootNamespace = rootNamespace, templateFolder = templateFolder }; try { PackageTemplate.CreatePackage(options); Assert.Fail("Expected PackageTemplate.CreatePackage to throw"); } catch (Exception e) { Assert.AreEqual($"options parameter is invalid:{Environment.NewLine}{expectedMessage}", e.Message); } }
public string Index(string id) { if (id == null) { var data = new List <IndexTemplate>(); foreach (var book in context.Book) { data.Add(new IndexTemplate(context, book)); } var serializer = new SerializerBuilder().EmitDefaults().Build(); return(serializer.Serialize(data)); } else { var book = context.Book.Single(b => b.IDName == id); var data = new PackageTemplate(context, book); var serializer = new SerializerBuilder().EmitDefaults().Build(); return(serializer.Serialize(data)); } }
public IEnumerator TestCreatePackage() { var options = new PackageTemplateOptions() { name = "com.unity.my-package", displayName = "My Package", rootNamespace = "Unity.MyPackage" }; var packageFolder = PackageTemplate.CreatePackage(options); AssetDatabase.Refresh(); // Wait for asset db refresh yield return(null); var myPackage = MockPackageInfo.GetAll().Single(p => p.name == options.name); Assert.AreEqual(packageFolder, "Packages/com.unity.my-package"); Assert.AreEqual("com.unity.my-package", myPackage.name); Assert.AreEqual("My Package", myPackage.displayName); Assert.AreEqual("0.0.1", myPackage.version); Assert.AreEqual(PackageSource.Embedded, myPackage.source); }
protected SolutionDeployment(PackageTemplate packageTemplate) { PackageTemplate = packageTemplate; }
public ComplianceDeployment(PackageTemplate packageTemplate) : base(packageTemplate) { _rootBusinessUnit = GetRootBusinessUnit(); }
/// <summary> /// Generates Go code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var codeModel = cm as CodeModelSwift; if (codeModel == null) { throw new Exception("Code model is not a Swift Code Model"); } // unfortunately there is an ordering issue here. during model generation we might // flatten some types (but not all depending on type). then during client generation // the validation codegen needs to know if a type was flattened so it can generate // the correct code, so we need to generate models before clients. //Protocols foreach (CompositeTypeSwift modelType in cm.ModelTypes.Union(codeModel.HeaderTypes)) { var modelProtocolTemplate = new ModelProtocolTemplate { Model = modelType }; await Write(modelProtocolTemplate, Path.Combine("protocols", $"{modelType.Name}Protocol{ImplementationFileExtension}")); } //Models foreach (CompositeTypeSwift modelType in cm.ModelTypes.Union(codeModel.HeaderTypes)) { var modelTemplate = new DataModelTemplate { Model = modelType }; await Write(modelTemplate, Path.Combine("data", $"{modelType.TypeName}{ImplementationFileExtension}")); } //Model Tests foreach (CompositeTypeSwift modelType in cm.ModelTypes.Union(codeModel.HeaderTypes)) { var modelTemplate = new DataModelTestTemplate { Model = modelType }; //await Write(modelTemplate, Path.Combine("tests", $"{modelType.Name}Test{ImplementationFileExtension}")); } // Enums foreach (EnumTypeSwift enumType in cm.EnumTypes) { var enumTemplate = new EnumTemplate { Model = enumType }; await Write(enumTemplate, Path.Combine("data", $"{enumTemplate.Model.Name}Enum{ImplementationFileExtension}")); } // Command foreach (var methodGroup in codeModel.MethodGroups) { if (string.IsNullOrWhiteSpace(methodGroup.Name)) { methodGroup.Name = "Service"; } foreach (var method in methodGroup.Methods) { var methodContextTemplate = new MethodCommandTemplate { Model = (MethodSwift)method }; await Write(methodContextTemplate, Path.Combine("commands", $"{methodGroup.Name + method.Name}{ImplementationFileExtension}")); } } // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, Path.Combine("commands", FormatFileName("DataFactory"))); // Package.swift if (!string.IsNullOrWhiteSpace(CodeModelSwift.FrameworkName)) { var packageTemplate = new PackageTemplate { Model = codeModel }; await Write(packageTemplate, "Package.swift"); } foreach (var methodGroup in codeModel.MethodGroups) { if (string.IsNullOrWhiteSpace(methodGroup.Name)) { methodGroup.Name = "Service"; } var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroup }; await Write(methodGroupTemplate, Path.Combine("commands", FormatFileName(methodGroup.Name))); } }