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)));
}
}
