public void DataModel_Template_Test()
{
var template = new DataModelTemplate(new EntityInfo()
{
Id = _entityId
}, ApplicationId, Constants.DataNamespace);
var output = template.TransformText();
Assert.NotNull(output);
Assert.NotEmpty(output);
Assert.Contains($"namespace {ApplicationId}.Backend.{_dataNamespace}", output);
}
private void TransformEntities(SmartAppInfo manifest)
{
var enabledEntities = manifest.DataModel.Entities.Where(e => !e.IsEnum).AsEnumerable();
foreach (var entity in enabledEntities)
{
var template = new DataModelTemplate(entity, manifest.Id, Constants.DataNamespace);
_writingService.WriteFile(Path.Combine(_context.BasePath, template.OutputPath, $"{entity.Id}.g.cs"), template.TransformText());
if (!entity.IsAbstract)
{
var key = entity.AllProperties()?.FirstOrDefault(p => p.IsKey);
if (key != null)
{
var irepositoryTemplate = new IDataRepository(entity, manifest.Id, Constants.Version);
_writingService.WriteFile(Path.Combine(_context.BasePath, irepositoryTemplate.OutputPath, $"I{entity.Id}Repository.g.cs"), irepositoryTemplate.TransformText());
var repositoryTemplate = new DataRepository(entity, manifest.Id, Constants.Version);
_writingService.WriteFile(Path.Combine(_context.BasePath, repositoryTemplate.OutputPath, $"{entity.Id}Repository.g.cs"), repositoryTemplate.TransformText());
}
}
}
}
static void Main(string[] args)
{
Console.WriteLine(ConsoleHelpers.GetSlackerHeaderText());
if (args.Length < 4 || args[0].ToLower() != "export")
{
Console.WriteLine("Invalid command syntax: " + EXPORT_SYNTAX);
Console.Read();
return;
}
// Get Connection String
var connectionString = ConfigurationManager.ConnectionStrings
.Cast <ConnectionStringSettings>().FirstOrDefault(
connStr => connStr.Name == args[1]
)
?.ConnectionString;
// Initialize DataService
var dataService = new GenericDataService <InformationSchemaColumn>(
SqlConnectionService.FromConnectionString(connectionString)
);
// Get Information Schema
var informationSchema = dataService.Select(new QueryProps()
{
WhereSql = "TABLE_CATALOG LIKE @Catalog",
WhereParams = new {
Catalog = args[2]
}
});
if (!informationSchema.Any())
{
Console.WriteLine("Could not find any results matching information schema target.");
Console.Read();
return;
}
// Get Output Directory
var catalogName = DataModelTemplate.GetPropertyName(informationSchema.First().TableCatalog);
var catalogDir = !Path.IsPathRooted(args[3]) ?
Path.Combine(Environment.CurrentDirectory, args[3], catalogName) :
Path.Combine(args[3], catalogName);
// Create Catalog Directory if not exists
if (!Directory.Exists(catalogDir))
{
Directory.CreateDirectory(catalogDir);
}
// Create output schema delegate
void OutputSchema(IGrouping <string, InformationSchemaColumn> schemaGroup)
{
var schemaName = DataModelTemplate.GetPropertyName(schemaGroup.First().TableSchema);
var schemaDir = Path.Combine(catalogDir, schemaName);
// Create Schema Directory if not exists
if (!Directory.Exists(schemaDir))
{
Directory.CreateDirectory(schemaDir);
}
// Create output file delegate
void OutputFile(DataModelTemplate dataModelTemplate)
{
var tableName = DataModelTemplate.GetPropertyName(dataModelTemplate.TableName);
var filePath = Path.Combine(schemaDir, tableName + ".cs");
if (File.Exists(filePath))
{
File.Delete(filePath);
}
Console.WriteLine($"Generating Model: {catalogName}\\{schemaName}\\{tableName}.cs");
File.WriteAllText(filePath, dataModelTemplate.TransformText());
}
// Output files
schemaGroup.GroupBy(
infoSchemaCol => infoSchemaCol.TableName
).Select(
infoSchemaCols => new DataModelTemplate(infoSchemaCols.ToList())
).ToList().ForEach(
OutputFile
);
}
// Build Models
informationSchema.GroupBy(
infoSchemaCol => infoSchemaCol.TableSchema
).ToList().ForEach(OutputSchema);
Console.WriteLine("Done");
Console.Read();
}
public void DataModel_Template_NullParameter_Test()
{
var template = new DataModelTemplate(null, null, null);
Assert.Throws <ArgumentNullException>(() => template.TransformText());
}
/// <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)));
}
}
