public static ParameterTemplate AddParameter(this MethodTemplate methodTemplate, TypeTemplate type, string name, ICodeFragment defaultValue = null)
{
var parameter = new ParameterTemplate(type, name, defaultValue);
methodTemplate.Parameters.Add(parameter);
return(parameter);
}
public ParameterTemplate AddParameter(object value, Column column)
{
string name = _schemaProvider.NameParameter("p" + Interlocked.Increment(ref _number) + _parameterSuffix);
var parameterTemplate = new ParameterTemplate(name, column);
_parameters.Add(parameterTemplate, value);
return parameterTemplate;
}
public CommandTemplate(Func<IDbCommand, IDbParameterFactory> createGetParameterFactoryFunc, string commandText, ParameterTemplate[] parameterNames, Dictionary<string, int> index)
{
_createGetParameterFactoryFunc = createGetParameterFactoryFunc;
_commandText = commandText;
_parameters = parameterNames;
_index = index;
}
public ParameterTemplate AddParameter(string name, DbType dbType, object value)
{
name = _schemaProvider.NameParameter(name + _parameterSuffix);
var parameterTemplate = new ParameterTemplate(name, dbType, 0);
_parameters.Add(parameterTemplate, value);
return parameterTemplate;
}
/// <summary>
/// Определяет, является ли для данного параметра родительская секция табличной (если она не существует, то не является)
/// </summary>
/// <param name="parameterTemplate"></param>
/// <returns></returns>
public static bool IsParentSectionTable(this ParameterTemplate parameterTemplate)
{
var result = false;
if (parameterTemplate.ParentSection != null)
{
result = parameterTemplate.ParentSection.blnGrid;
}
return(result);
}
public ParamGenerator()
{
var assembly = System.Reflection.Assembly.GetExecutingAssembly();
var resourceName = "LogicAppTemplate.Templates.paramTemplate.json";
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
using (StreamReader reader = new StreamReader(stream))
{
paramTemplate = JsonConvert.DeserializeObject <ParameterTemplate>(reader.ReadToEnd());
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
ParameterTemplate template = (ParameterTemplate)fragment;
output.Add(template.Name)
.Add(": ")
.Add(template.Type);
if (template.DefaultValue != null)
{
output.Add(" = ")
.Add(template.DefaultValue);
}
}
public override void Write(ICodeFragment fragment, IOutputCache output)
{
ParameterTemplate template = (ParameterTemplate)fragment;
output.Add(template.Name)
.If(template.IsOptional).Add("?").EndIf()
.Add(": ")
.Add(template.Type);
if (template.DefaultValue != null)
{
output.Add(" = ")
.Add(template.DefaultValue);
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
ParameterTemplate template = (ParameterTemplate)fragment;
template.Attributes.ForEach(x => x.IsInline = true);
output.Add(template.Attributes)
.Add(template.Type)
.Add(" ")
.Add(template.Name);
if (template.DefaultValue != null)
{
output.Add(" = ")
.Add(template.DefaultValue);
}
}
private static void RewriteSqlEqualityToInClause(IDbCommand command, ParameterTemplate parameterTemplate, StringBuilder builder)
{
if (command.CommandText.Contains("!= " + parameterTemplate.Name))
{
command.CommandText = command.CommandText.Replace("!= " + parameterTemplate.Name,
"NOT IN (" +
builder.ToString().Substring(1) +
")");
}
else
{
command.CommandText = command.CommandText.Replace("= " + parameterTemplate.Name,
"IN (" +
builder.ToString().Substring(1) +
")");
}
}
internal FlexLabelItem(ParameterTemplate row, bool isParameterInSection)
: base(row)
{
Height = row.intHeight;
Width = isParameterInSection
? row.intWidth
: row.intLabelSize;
if (Width == 0)
{
Width = row.intWidth;
}
Top = row.intTop;
Left = row.intLeft;
Order = row.intOrder;
FontSize = ReportSettings.DefaultFontSize;
Text = string.IsNullOrEmpty(row.NationalName) ? row.DefaultName : row.NationalName;
}
public void Add
(ParameterTemplate parameterTemplateRow,
ActivityParameter activityParametersRow)
{
Add(parameterTemplateRow, false);
var parametersItem = new FlexLabelItem(parameterTemplateRow, activityParametersRow)
{
IsParameterValue = true
};
var nodeAp = new FlexNodeReport(this, parametersItem);
//нод, который отвечает за контрол, выводится с фиксированной высотой
nodeAp.DataItem.Height = DefaultControlHeight;
if (nodeAp.DataItem.Height > parametersItem.Height)
{
nodeAp.DataItem.Height = parametersItem.Height;
}
ChildList.Add(nodeAp);
}
private static IEnumerable<IDbDataParameter> CreateParameters(IDbCommand command, ParameterTemplate parameterTemplate, object value)
{
var range = value as IRange;
if (range != null)
{
yield return CreateParameter(command, parameterTemplate, range.Start, "_start");
yield return CreateParameter(command, parameterTemplate, range.End, "_end");
CommandBuilder.SetBetweenInCommandText(command, parameterTemplate.Name);
}
else
{
var list = value as IEnumerable;
if (list != null)
{
var builder = new StringBuilder();
var array = list.Cast<object>().ToArray();
for (int i = 0; i < array.Length; i++)
{
builder.AppendFormat(",{0}_{1}", parameterTemplate.Name, i);
yield return CreateParameter(command, parameterTemplate, array[i], "_" + i);
}
if (command.CommandText.Contains("!= " + parameterTemplate.Name))
{
command.CommandText = command.CommandText.Replace("!= " + parameterTemplate.Name,
"NOT IN (" + builder.ToString().Substring(1) +
")");
}
else
{
command.CommandText = command.CommandText.Replace("= " + parameterTemplate.Name,
"IN (" + builder.ToString().Substring(1) + ")");
}
}
else
{
yield return CreateParameter(command, parameterTemplate, value);
}
}
}
public static bool IsParameterInSectionTable(ParameterTemplate parameterTemplate, Template template)
{
//TODO предусмотреть ситуацию, когда имеет место динамический или ressurected параметр
var result = false;
if (parameterTemplate != null)
{
if (parameterTemplate.idfsSection.HasValue)
{
var section = template.SectionTemplatesLookup.FirstOrDefault(c => c.idfsSection == parameterTemplate.idfsSection);
if (section != null)
{
result = section.blnGrid;
}
}
}
else
{
result = true;
}
return(result);
}
private IEnumerable<IDbDataParameter> CreateParameters(IDbCommand command, ParameterTemplate parameterTemplate, object value)
{
if (value == null || TypeHelper.IsKnownType(value.GetType()) || parameterTemplate.DbType == DbType.Binary)
{
yield return CreateParameter(command, parameterTemplate, value);
}
else
{
var range = value as IRange;
if (range != null)
{
yield return CreateParameter(command, parameterTemplate, range.Start, "_start");
yield return CreateParameter(command, parameterTemplate, range.End, "_end");
CommandBuilder.SetBetweenInCommandText(command, parameterTemplate.Name);
}
else
{
var list = value as IEnumerable;
if (list != null)
{
var builder = new StringBuilder();
var array = list.Cast<object>().ToArray();
for (int i = 0; i < array.Length; i++)
{
builder.AppendFormat(",{0}_{1}", parameterTemplate.Name, i);
yield return CreateParameter(command, parameterTemplate, array[i], "_" + i);
}
RewriteSqlEqualityToInClause(command, parameterTemplate, builder);
}
else
{
yield return CreateParameter(command, parameterTemplate, value);
}
}
}
}
public virtual void Write(AngularWriteConfiguration configuration, List <ITransferObject> transferObjects, List <FileTemplate> files)
{
Logger.Trace("Generate angular service for ASP.net controller...");
if (!configuration.Language.IsTypeScript())
{
throw new InvalidOperationException($"Can not generate service for ASP.net Controller for language {configuration.Language?.Name ?? "Empty"}");
}
string httpClient = configuration.Service.HttpClient?.Name ?? "HttpClient";
string httpClientImport = configuration.Service.HttpClient?.Import ?? "@angular/common/http";
foreach (HttpServiceTransferObject controller in transferObjects.OfType <HttpServiceTransferObject>())
{
Dictionary <HttpServiceActionParameterTransferObject, ParameterTemplate> mapping = new Dictionary <HttpServiceActionParameterTransferObject, ParameterTemplate>();
string controllerName = controller.Name.TrimEnd("Controller");
ClassTemplate classTemplate = files.AddFile(configuration.Service.RelativePath, configuration.AddHeader)
.AddNamespace(string.Empty)
.AddClass(configuration.Service.Name ?? controllerName + "Service")
.FormatName(configuration)
.WithUsing(httpClient, httpClientImport)
.WithUsing("Injectable", "@angular/core")
.WithUsing("Observable", "rxjs")
.WithUsing("Subject", "rxjs")
.WithAttribute("Injectable", Code.AnonymousObject().WithProperty("providedIn", Code.String("root")));
FieldTemplate httpField = classTemplate.AddField("http", Code.Type(httpClient)).Readonly().FormatName(configuration);
FieldTemplate serviceUrlField = classTemplate.AddField("serviceUrl", Code.Type("string")).Public().FormatName(configuration).Default(Code.String(string.Empty));
classTemplate.AddConstructor().WithParameter(Code.Type(httpClient), "http")
.WithCode(Code.This().Field(httpField).Assign(Code.Local("http")).Close());
string relativeModelPath = FileSystem.RelativeTo(configuration.Model?.RelativePath ?? ".", configuration.Service.RelativePath);
foreach (HttpServiceActionTransferObject action in controller.Actions)
{
ICodeFragment errorCode = Code.Lambda("error", Code.Local("subject").Method("error", Code.Local("error")));
this.MapType(controller.Language, configuration.Language, action.ReturnType);
TypeTemplate returnType = action.ReturnType.ToTemplate();
this.AddUsing(action.ReturnType, classTemplate, configuration, relativeModelPath);
MethodTemplate methodTemplate = classTemplate.AddMethod(action.Name, Code.Generic("Observable", returnType))
.FormatName(configuration);
foreach (HttpServiceActionParameterTransferObject parameter in action.Parameters)
{
this.MapType(controller.Language, configuration.Language, parameter.Type);
this.AddUsing(parameter.Type, classTemplate, configuration, relativeModelPath);
ParameterTemplate parameterTemplate = methodTemplate.AddParameter(parameter.Type.ToTemplate(), parameter.Name).FormatName(configuration);
mapping.Add(parameter, parameterTemplate);
}
methodTemplate.AddParameter(Code.Type("{}"), "httpOptions?");
TypeTemplate subjectType = Code.Generic("Subject", returnType);
methodTemplate.WithCode(Code.Declare(subjectType, "subject", Code.New(subjectType)));
string uri = ("/" + (controller.Route?.Replace("[controller]", controllerName.ToLower()).TrimEnd('/') ?? controllerName) + "/" + action.Route?.Replace("[action]", action.Name.ToLower())).TrimEnd('/');
List <HttpServiceActionParameterTransferObject> inlineParameters = action.Parameters.Where(x => !x.FromBody && x.Inline).OrderBy(x => x.InlineIndex).ToList();
List <HttpServiceActionParameterTransferObject> urlParameters = action.Parameters.Where(x => !x.FromBody && !x.Inline && x.AppendName).ToList();
List <HttpServiceActionParameterTransferObject> urlDirectParameters = action.Parameters.Where(x => !x.FromBody && !x.Inline && !x.AppendName).ToList();
uri = urlParameters.Count > 0 ? $"{uri}?{urlParameters.First().Name}=" : urlDirectParameters.Count > 0 ? $"{uri}?" : uri;
MultilineCodeFragment code = Code.Multiline();
DeclareTemplate declareTemplate = null;
bool hasReturnType = returnType.Name != "void";
bool isPrimitive = this.IsPrimitive(returnType);
if (returnType.Name == "Array")
{
TypeTemplate type = ((GenericTypeTemplate)returnType).Types[0];
declareTemplate = Code.Declare(returnType, "list", Code.TypeScript("[]")).Constant();
code.AddLine(declareTemplate)
.AddLine(Code.TypeScript("for (const entry of <[]>result)").StartBlock())
.AddLine(Code.Local(declareTemplate).Method("push", isPrimitive ? (ICodeFragment)Code.Cast(type, Code.Local("entry")) : Code.New(type, Code.Local("entry"))).Close())
.AddLine(Code.TypeScript("").EndBlock());
}
else if (hasReturnType)
{
declareTemplate = Code.Declare(returnType, "model", isPrimitive ? (ICodeFragment)Code.Cast(returnType, Code.Local("result")) : Code.New(returnType, Code.Local("result"))).Constant();
code.AddLine(declareTemplate);
}
code.AddLine(Code.Local("subject").Method("next").WithParameter(declareTemplate.ToLocal()).Close())
.AddLine(Code.Local("subject").Method("complete").Close());
ChainedCodeFragment parameterUrl = Code.This().Field(serviceUrlField);
if (inlineParameters.Count == 0)
{
parameterUrl = parameterUrl.Append(Code.String(uri));
}
foreach (HttpServiceActionParameterTransferObject parameter in inlineParameters)
{
string[] chunks = uri.Split(new [] { $"{{{parameter.Name}}}" }, StringSplitOptions.RemoveEmptyEntries);
parameterUrl = parameterUrl.Append(Code.String(chunks[0])).Append(Code.Local(parameter.Name));
uri = chunks.Length == 1 ? string.Empty : chunks[1];
}
bool isFirst = true;
foreach (HttpServiceActionParameterTransferObject parameter in urlDirectParameters)
{
if (isFirst)
{
isFirst = false;
parameterUrl = parameterUrl.Append(Code.Local(parameter.Name));
}
else
{
parameterUrl = parameterUrl.Append(Code.String("&")).Append(Code.Local(parameter.Name));
}
}
foreach (HttpServiceActionParameterTransferObject parameter in urlParameters)
{
if (isFirst)
{
isFirst = false;
parameterUrl = parameterUrl.Append(Code.Local(mapping[parameter]));
}
else
{
parameterUrl = parameterUrl.Append(Code.String($"&{parameter.Name}=")).Append(Code.Local(mapping[parameter]));
}
}
methodTemplate.WithCode(
Code.This()
.Field(httpField)
.Method(action.Type.ToString().ToLowerInvariant(),
parameterUrl,
action.RequireBodyParameter ? Code.Local(action.Parameters.Single(x => x.FromBody).Name) : null,
Code.Local("httpOptions")
)
.Method("subscribe", Code.Lambda(hasReturnType ? "result" : null, code), errorCode).Close()
);
methodTemplate.WithCode(Code.Return(Code.Local("subject")));
}
}
}
public static LambdaTemplate Lambda(this Code _, ParameterTemplate parameter, ICodeFragment code)
{
return(new LambdaTemplate(parameter.Yield(), code));
}
private static IDbDataParameter CreateSingleParameter(IDbParameterFactory parameterFactory, object value, ParameterTemplate template)
{
if (template.Column != null) return CreateSingleParameter(parameterFactory, value, template.Name, template.Column);
var parameter = parameterFactory.CreateParameter(template.Name, template.DbType, template.MaxLength);
parameter.Value = CommandHelper.FixObjectType(value);
return parameter;
}
private static IEnumerable<IDbDataParameter> CreateParameterComplex(IDbParameterFactory parameterFactory, ParameterTemplate template, object value, IDbCommand command)
{
if (template.Column != null && template.Column.IsBinary)
{
yield return CreateSingleParameter(parameterFactory, value, template.Name, template.Column);
}
else
{
var str = value as string;
if (str != null)
{
yield return CreateSingleParameter(parameterFactory, value, template.Name, template.Column);
}
else
{
var range = value as IRange;
if (range != null)
{
yield return
CreateSingleParameter(parameterFactory, range.Start, template.Name + "_start", template.Column);
yield return CreateSingleParameter(parameterFactory, range.End, template.Name + "_end", template.Column);
SetBetweenInCommandText(command, template.Name);
}
else
{
var list = value as IEnumerable;
if (list != null)
{
var builder = new StringBuilder();
var array = list.Cast<object>().ToArray();
for (int i = 0; i < array.Length; i++)
{
builder.AppendFormat(",{0}_{1}", template.Name, i);
yield return
CreateSingleParameter(parameterFactory, array[i], template.Name + "_" + i, template.Column);
}
if (command.CommandText.Contains("!= " + template.Name))
{
command.CommandText = command.CommandText.Replace("!= " + template.Name,
"NOT IN (" +
builder.ToString().Substring(1) + ")");
}
else
{
command.CommandText = command.CommandText.Replace("= " + template.Name,
"IN (" +
builder.ToString().Substring(1) +
")");
}
}
else
{
yield return CreateSingleParameter(parameterFactory, value, template);
}
}
}
}
}
public static ParameterTemplate Optional(this ParameterTemplate template)
{
template.IsOptional = true;
return(template);
}
private static IDbDataParameter CreateParameter(IDbCommand command, ParameterTemplate parameterTemplate, object value, string suffix = "")
{
var parameter = command.CreateParameter();
parameter.ParameterName = parameterTemplate.Name + suffix;
parameter.DbType = parameterTemplate.DbType;
parameter.Value = value;
return parameter;
}
public static LocalVariableTemplate Local(this Code _, ParameterTemplate type)
{
return(new LocalVariableTemplate(type.Name));
}
public virtual void Write(EntityFrameworkWriteConfiguration configuration, List <ITransferObject> transferObjects, List <FileTemplate> files)
{
foreach (EntityFrameworkWriteRepositoryConfiguration repositoryConfiguration in configuration.Repositories)
{
EntityTransferObject entity = transferObjects.OfType <EntityTransferObject>().FirstOrDefault(x => x.Name == repositoryConfiguration.Entity)
.AssertIsNotNull(nameof(repositoryConfiguration.Entity), $"Entity {repositoryConfiguration.Entity} not found. Ensure it is read before.");
ClassTemplate repository = files.AddFile(configuration.RelativePath, configuration.AddHeader)
.AddNamespace(repositoryConfiguration.Namespace ?? configuration.Namespace)
.AddClass(repositoryConfiguration.Name ?? entity.Name + "Repository")
.FormatName(configuration)
.WithUsing("System.Collections.Generic")
.WithUsing("System.Linq");
if (configuration.IsCore)
{
repository.WithUsing("Microsoft.EntityFrameworkCore");
}
else
{
repository.WithUsing("System.Data.Entity");
}
if (!string.IsNullOrEmpty(configuration.Namespace) && !string.IsNullOrEmpty(repositoryConfiguration.Namespace) && configuration.Namespace != repositoryConfiguration.Namespace)
{
repository.AddUsing(configuration.Namespace);
}
configuration.Usings.ForEach(x => repository.AddUsing(x));
repositoryConfiguration.Usings.ForEach(x => repository.AddUsing(x));
TypeTemplate modelType = entity.Model.ToTemplate();
FieldTemplate dataSetField = repository.AddField("dataSet", Code.Generic("DbSet", modelType)).Readonly();
FieldTemplate dataContextField = repository.AddField("dataContext", Code.Type("DataContext")).Readonly();
TypeTemplate dataContextType = Code.Type("DataContext");
ConstructorTemplate constructor = repository.AddConstructor();
ParameterTemplate dataContextParameter = constructor.AddParameter(dataContextType, "dataContext", Code.Null());
constructor.Code.AddLine(Code.This().Field(dataContextField).Assign(Code.NullCoalescing(Code.Local(dataContextParameter), Code.New(dataContextType))).Close())
.AddLine(Code.This().Field(dataSetField).Assign(Code.This().Field(dataContextField).GenericMethod("Set", modelType)).Close());
repository.AddMethod("Get", Code.Generic("IQueryable", modelType))
.Code.AddLine(Code.Return(Code.This().Field(dataSetField)));
repository.AddMethod("Get", modelType)
.WithParameter(Code.Type("params object[]"), "keys")
.Code.AddLine(Code.Return(Code.This().Field(dataSetField).Method("Find", Code.Local("keys"))));
if (configuration.IsCore)
{
repository.AddMethod("Add", modelType)
.WithParameter(modelType, "entity")
.Code.AddLine(Code.Declare(modelType, "result", Code.This().Field(dataSetField).Method("Add", Code.Local("entity")).Property("Entity")))
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close())
.AddLine(Code.Return(Code.Local("result")));
repository.AddMethod("Add", Code.Generic("IEnumerable", modelType))
.WithParameter(Code.Generic("IEnumerable", modelType), "entities")
.Code.AddLine(Code.Declare(Code.Generic("IEnumerable", modelType), "result", Code.Local("entities").Method("Select", Code.Lambda("x", Code.This().Field(dataSetField).Method("Add", Code.Local("x")).Property("Entity"))).Method("ToList")))
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close())
.AddLine(Code.Return(Code.Local("result")));
repository.AddMethod("Update", modelType)
.WithParameter(modelType, "entity")
.Code.AddLine(Code.Declare(modelType, "result", Code.This().Field(dataSetField).Method("Update", Code.Local("entity")).Property("Entity")))
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close())
.AddLine(Code.Return(Code.Local("result")));
repository.AddMethod("Update", Code.Generic("IEnumerable", modelType))
.WithParameter(Code.Generic("IEnumerable", modelType), "entities")
.Code.AddLine(Code.Declare(Code.Generic("IEnumerable", modelType), "result", Code.Local("entities").Method("Select", Code.Lambda("x", Code.This().Field(dataSetField).Method("Update", Code.Local("x")).Property("Entity"))).Method("ToList")))
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close())
.AddLine(Code.Return(Code.Local("result")));
}
else
{
repository.AddMethod("Add", modelType)
.WithParameter(modelType, "entity")
.Code.AddLine(Code.Declare(modelType, "result", Code.This().Field(dataSetField).Method("Add", Code.Local("entity"))))
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close())
.AddLine(Code.Return(Code.Local("result")));
repository.AddMethod("Add", Code.Generic("IEnumerable", modelType))
.WithParameter(Code.Generic("IEnumerable", modelType), "entities")
.Code.AddLine(Code.Declare(Code.Generic("IEnumerable", modelType), "result", Code.Local("entities").Method("Select", Code.Lambda("x", Code.This().Field(dataSetField).Method("Add", Code.Local("x")))).Method("ToList")))
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close())
.AddLine(Code.Return(Code.Local("result")));
repository.WithUsing("System.Data.Entity.Migrations")
.AddMethod("Update", modelType)
.WithParameter(modelType, "entity")
.Code.AddLine(Code.This().Field(dataSetField).Method("AddOrUpdate", Code.Local("entity")).Close())
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close())
.AddLine(Code.Return(Code.Local("entity")));
repository.WithUsing("System.Data.Entity.Migrations")
.AddMethod("Update", Code.Generic("IEnumerable", modelType))
.WithParameter(Code.Generic("IEnumerable", modelType), "entities")
.Code.AddLine(Code.Declare(Code.Generic("List", modelType), "result", Code.Local("entities").Method("ToList")))
.AddLine(Code.Local("result").Method("ForEach", Code.Lambda("x", Code.This().Field(dataSetField).Method("AddOrUpdate", Code.Local("x")))).Close())
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close())
.AddLine(Code.Return(Code.Local("result")));
}
//repository.AddMethod("Update", Code.Void())
// .WithParameter(Code.Generic("Delta", modelType), "delta")
// .WithParameter(Code.Type("object[]"), "keys")
// .Code.AddLine(Code.Declare(modelType, "entity", Code.This().Field(dataSetField).Method("Find", Code.Local("keys"))))
// .AddLine(Code.If(Code.Local("entity").Equals().Null(), x => x.Code.AddLine(Code.Throw(Code.Type("InvalidOperationException"), Code.String("Can not find any element with this keys, Use Add(...) method instead")))))
// .AddLine(Code.Local("delta").Method("Patch", Code.Local("entity")).Close())
// .AddLine(Code.This().Method("Update", Code.Local("entity")).Close())
// .AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close());
repository.AddMethod("Delete", Code.Void())
.WithParameter(modelType, "entity")
.Code.AddLine(Code.This().Field(dataSetField).Method("Remove", Code.Local("entity")).Close())
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close());
repository.AddMethod("Delete", Code.Void())
.WithParameter(Code.Generic("IEnumerable", modelType), "entities")
.Code.AddLine(Code.This().Field(dataSetField).Method("RemoveRange", Code.Local("entities")).Close())
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close());
if (configuration.IsCore)
{
repository.AddMethod("Delete", Code.Void())
.WithParameter(Code.Type("params object[]"), "keys")
.Code.AddLine(Code.This().Field(dataSetField).Method("Remove", Code.This().Field(dataSetField).Method("Find", Code.Local("keys"))).Close())
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close());
}
else
{
repository.AddMethod("Delete", Code.Void())
.WithParameter(Code.Type("params object[]"), "keys")
.Code.AddLine(Code.This().Field(dataSetField).Method("Remove", Code.This().Field(dataSetField).Method("Find", Code.Local("keys"))).Close())
.AddLine(Code.This().Field(dataContextField).Method("SaveChanges").Close());
}
//foreach (string key in entity.Keys)
//{
// PropertyTransferObject property = entity.Model.Properties.First(x => x.Name.Equals(key, StringComparison.InvariantCultureIgnoreCase));
// delete.AddParameter(property.Type.ToTemplate(), property.Name)
// .FormatName(configuration.Language, configuration.FormatNames);
//}
}
}
protected virtual ClassTemplate WriteClass(EntityFrameworkWriteConfiguration configuration, List <ITransferObject> transferObjects, List <FileTemplate> files)
{
ClassTemplate dataContext = files.AddFile(configuration.RelativePath, configuration.AddHeader)
.AddNamespace(configuration.Namespace)
.AddClass("DataContext", Code.Type("DbContext"));
if (configuration.IsCore)
{
dataContext.WithUsing("Microsoft.EntityFrameworkCore");
}
else
{
dataContext.WithUsing("System.Data.Entity");
}
configuration.Usings.ForEach(x => dataContext.AddUsing(x));
PropertyTemplate defaultConnectionProperty = dataContext.AddProperty("DefaultConnection", Code.Type("string")).Static().WithDefaultValue(Code.String("name=DataContext"));
foreach (EntityTransferObject entity in transferObjects.OfType <EntityTransferObject>())
{
dataContext.AddProperty(entity.Name, Code.Generic("DbSet", entity.Model.ToTemplate()))
.FormatName(configuration)
.Virtual();
}
dataContext.AddConstructor()
.WithThisConstructor(Code.Null());
ConstructorTemplate constructor = dataContext.AddConstructor();
ParameterTemplate connectionString = constructor.AddParameter(Code.Type("string"), "connectionString");
if (configuration.IsCore)
{
constructor.WithBaseConstructor(Code.Static(Code.Type("SqlServerDbContextOptionsExtensions")).Method("UseSqlServer", Code.New(Code.Type("DbContextOptionsBuilder")), Code.NullCoalescing(Code.Local(connectionString), Code.Local(defaultConnectionProperty))).Property("Options"))
.Code.AddLine(Code.This().Property("Database").Method("SetCommandTimeout", Code.Number(configuration.DataContext.CommandTimeout)).Close());
}
else
{
constructor.WithBaseConstructor(Code.NullCoalescing(Code.Local("connectionString"), Code.Local(defaultConnectionProperty)))
.Code.AddLine(Code.This().Property("Database").Property("CommandTimeout").Assign(Code.Number(configuration.DataContext.CommandTimeout)).Close());
}
MethodTemplate createMethod = dataContext.AddMethod("OnModelCreating", Code.Void()).Protected().Override();
ParameterTemplate modelBuilder = createMethod.AddParameter(Code.Type(configuration.IsCore ? "ModelBuilder" : "DbModelBuilder"), "modelBuilder");
if (!configuration.IsCore)
{
createMethod.Code.AddLine(Code.Local(modelBuilder).Property("Configurations").Method("AddFromAssembly", Code.This().Method("GetType").Property("Assembly")).Close());
}
foreach (EntityTransferObject entity in transferObjects.OfType <EntityTransferObject>())
{
createMethod.Code.AddLine(Code.Local(modelBuilder).GenericMethod("Entity", entity.Model.ToTemplate()).BreakLine()
.Method("ToTable", Code.String(entity.Table), Code.String(entity.Schema)).BreakLine()
.Method("HasKey", Code.Lambda("x", Code.Csharp("new { " + string.Join(", ", entity.Keys.Select(key => $"x.{key.Name}")) + " }"))).Close());
}
foreach (StoredProcedureTransferObject storedProcedure in transferObjects.OfType <StoredProcedureTransferObject>())
{
dataContext.AddMethod(storedProcedure.Name, storedProcedure.ReturnType.ToTemplate())
.Code.AddLine(Code.This().Property("Database").Method("ExecuteSqlCommand", Code.String($"exec {storedProcedure.Schema}.{storedProcedure.Name}")).Close());
}
return(dataContext);
}
public void Add(ParameterTemplate parameterTemplateRow, bool isParameterInSection)
{
var parameterTemplateItem = new FlexLabelItem(parameterTemplateRow, isParameterInSection);
ChildList.Add(new FlexNodeReport(this, parameterTemplateItem));
}
private IDbDataParameter CreateParameter(IDbCommand command, ParameterTemplate parameterTemplate, object value, string suffix = "")
{
var factory = _createGetParameterFactoryFunc(command);
var parameter = default(IDbDataParameter);
if(parameterTemplate.Column != null)
{
parameter = factory.CreateParameter(parameterTemplate.Name + suffix,
parameterTemplate.Column);
}
else if (parameterTemplate.Type == ParameterType.NameOnly)
{
parameter = factory.CreateParameter(parameterTemplate.Name);
}
else
{
parameter = factory.CreateParameter(parameterTemplate.Name, parameterTemplate.DbType,
parameterTemplate.MaxLength);
}
parameter.Value = FixObjectType(value);
return parameter;
}
public static ParameterTemplate FormatName(this ParameterTemplate parameter, IOptions options, bool force = false)
{
parameter.Name = Formatter.FormatParameter(parameter.Name, options, force);
return(parameter);
}
internal FlexLabelItem
(ParameterTemplate parentRow, ActivityParameter row)
: base(row)
{
if (parentRow.intScheme.Equals((int)FFParameterScheme.Left) ||
parentRow.intScheme.Equals((int)FFParameterScheme.Right))
{
Width = parentRow.intWidth - parentRow.intLabelSize;
Height = parentRow.intHeight;
}
else
{
Width = parentRow.intWidth;
Height = parentRow.intHeight - parentRow.intLabelSize;
}
Top = parentRow.intTop;
Left = parentRow.intLeft;
switch (parentRow.intScheme)
{
case (int)FFParameterScheme.Left:
Left += parentRow.intLabelSize;
break;
case (int)FFParameterScheme.Right:
Left -= parentRow.intLabelSize;
break;
case (int)FFParameterScheme.Top:
Top += parentRow.intLabelSize;
break;
case (int)FFParameterScheme.Bottom:
Top -= parentRow.intLabelSize;
break;
}
FontSize = ReportSettings.DefaultFontSize;
if (row == null)
{
Text = string.Empty;
}
else if (ParameterControlTypeHelper.ConvertToParameterControlType(parentRow.idfsEditor).Equals(FFParameterEditors.CheckBox))
{
long val = (bool)row.varValue ? 10100001 : 10100002; //Yes/No
using (var manager = DbManagerFactory.Factory.Create(ModelUserContext.Instance))
{
Text = BaseReference.Accessor.Instance(null).rftYesNoValue_SelectList(manager).FirstOrDefault(c => c.idfsBaseReference == val, c => String.Empty);
}
}
else if (!string.IsNullOrEmpty(row.strNameValue))
{
Text = row.strNameValue;
}
else if (row.varValue != null)
{
var str = row.varValue.ToString();
if (parentRow.idfsParameterType.Equals((long)FFParameterTypes.Date))
{
var itms = str.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries);
if (itms.Length > 0)
{
Text = itms[0];
}
}
else
{
Text = str;
}
}
}
public static bool IsCorrectDataType(this ParameterTemplate parameterTemplate, object value)
{
return(IsCorrectDataType(parameterTemplate.ParameterType, value));
}
public CommandTemplate(string commandText, ParameterTemplate[] parameterNames, Dictionary<string, int> index)
{
_commandText = commandText;
_parameters = parameterNames;
_index = index;
}
public static MethodTemplate WithParameter(this MethodTemplate methodTemplate, ParameterTemplate parameter)
{
methodTemplate.Parameters.Add(parameter);
return(methodTemplate);
}
private IDbDataParameter CreateParameter(IDbCommand command, ParameterTemplate parameterTemplate, object value, string suffix = "")
{
var factory = _createGetParameterFactoryFunc(command);
var parameter = parameterTemplate.Column != null
? factory.CreateParameter(parameterTemplate.Name + suffix,
parameterTemplate.Column)
: factory.CreateParameter(parameterTemplate.Name, parameterTemplate.DbType,
parameterTemplate.MaxLength);
parameter.Value = FixObjectType(value);
return parameter;
}
private static void RewriteSqlEqualityToInClause(DatabaseSchema schema, IDbCommand command, ParameterTemplate parameterTemplate, StringBuilder builder)
{
if (command.CommandText.Contains("!= " + parameterTemplate.Name))
{
command.CommandText = command.CommandText.Replace("!= " + parameterTemplate.Name,
schema.Operators.NotIn + " (" +
builder.ToString().Substring(1) +
")");
}
else
{
command.CommandText = command.CommandText.Replace("= " + parameterTemplate.Name,
schema.Operators.In + " (" +
builder.ToString().Substring(1) +
")");
}
}
public static LocalVariableTemplate Local(this ChainedCodeFragment template, ParameterTemplate type)
{
return(new LocalVariableTemplate(type.Name).Chain(template));
}
private static IDbDataParameter CreateSingleParameter(IDbParameterFactory parameterFactory, object value, ParameterTemplate template)
{
if (template.Column != null)
{
return CreateSingleParameter(parameterFactory, value, template.Name, template.Column);
}
var parameter = default(IDbDataParameter);
if (template.Type == ParameterType.NameOnly)
{
parameter = parameterFactory.CreateParameter(template.Name);
}
else
{
parameter = parameterFactory.CreateParameter(template.Name, template.DbType, template.MaxLength);
}
parameter.Value = CommandHelper.FixObjectType(value);
return parameter;
}
private static IEnumerable<IDbDataParameter> CreateParameterComplex(ParameterTemplate template, object value, IDbCommand command)
{
var range = value as IRange;
if (range != null)
{
yield return CreateSingleParameter(range.Start, command, template.Name + "_start", template.DbType);
yield return CreateSingleParameter(range.End, command, template.Name + "_end", template.DbType);
SetBetweenInCommandText(command, template.Name);
}
else
{
var list = value as IEnumerable<object>;
if (list != null)
{
var builder = new StringBuilder();
var array = list.ToArray();
for (int i = 0; i < array.Length; i++)
{
builder.AppendFormat(",{0}_{1}", template.Name, i);
yield return CreateSingleParameter(array[i], command, template.Name + "_" + i, template.DbType);
}
if (command.CommandText.Contains("!= " + template.Name))
{
command.CommandText = command.CommandText.Replace("!= " + template.Name,
"NOT IN (" + builder.ToString().Substring(1) + ")");
}
else
{
command.CommandText = command.CommandText.Replace("= " + template.Name,
"IN (" + builder.ToString().Substring(1) + ")");
}
}
else
{
yield return CreateSingleParameter(value, command, template.Name, template.DbType);
}
}
}
public static ParameterTemplate FormatName(this ParameterTemplate parameter, IConfiguration configuration)
{
parameter.Name = Formatter.FormatParameter(parameter.Name, configuration);
return(parameter);
}
public virtual void Write(AspDotNetWriteConfiguration configuration, List <ITransferObject> transferObjects, List <FileTemplate> files)
{
if (!configuration.Language.IsCsharp())
{
throw new InvalidOperationException($"Can not generate ASP.net Controller for language {configuration.Language?.Name ?? "Empty"}. Only Csharp is currently implemented");
}
foreach (AspDotNetWriteEntityControllerConfiguration controllerConfiguration in configuration.Controllers)
{
EntityTransferObject entity = transferObjects.OfType <EntityTransferObject>().FirstOrDefault(x => x.Name == controllerConfiguration.Entity)
.AssertIsNotNull(nameof(controllerConfiguration.Entity), $"Entity {controllerConfiguration.Entity} not found. Ensure it is read before.");
string nameSpace = (controllerConfiguration.Namespace ?? configuration.Namespace).AssertIsNotNull(nameof(configuration.Namespace), "asp writer requires a namespace");
ClassTemplate controller = files.AddFile(configuration.RelativePath, configuration.AddHeader)
.AddNamespace(nameSpace)
.AddClass(controllerConfiguration.Name ?? entity.Name + "Controller", Code.Type(configuration.Template.ControllerBase))
.FormatName(configuration)
.WithAttribute("Route", Code.String(controllerConfiguration.Route ?? "[controller]"));
controller.Usings.AddRange(configuration.Template.Usings);
TypeTemplate modelType = entity.Model.ToTemplate();
configuration.Usings.ForEach(x => controller.AddUsing(x));
controllerConfiguration.Usings.ForEach(x => controller.AddUsing(x));
FieldTemplate repositoryField = controller.AddField("repository", Code.Type(entity.Name + "Repository")).Readonly();
controller.AddConstructor().Code.AddLine(Code.This().Field(repositoryField).Assign(Code.New(repositoryField.Type)).Close());
if (controllerConfiguration.Get != null)
{
controller.AddUsing("System.Linq");
MethodTemplate method = controller.AddMethod("Get", Code.Generic("IEnumerable", modelType));
if (configuration.Template.UseAttributes)
{
method.WithAttribute("HttpGet", Code.String(controllerConfiguration.Get.Name ?? "[action]"));
}
DeclareTemplate queryable = Code.Declare(Code.Generic("IQueryable", modelType), "queryable", Code.This().Field(repositoryField).Method("Get"));
method.Code.AddLine(queryable);
foreach (PropertyTransferObject property in entity.Model.Properties)
{
ParameterTemplate parameter = method.AddParameter(property.Type.ToTemplate(), property.Name, Code.Local("default")).FormatName(configuration);
method.Code.AddLine(Code.If(Code.Local(parameter).NotEquals().Local("default"), x => x.Code.AddLine(Code.Local(queryable).Assign(Code.Local(queryable).Method("Where", Code.Lambda("x", Code.Local("x").Property(property.Name).Equals().Local(parameter)))).Close())));
}
method.Code.AddLine(Code.Return(Code.Local(queryable)));
}
if (controllerConfiguration.Post != null)
{
MethodTemplate method = controller.AddMethod("Post", Code.Void());
if (configuration.Template.UseAttributes)
{
method.WithAttribute("HttpPost", Code.String(controllerConfiguration.Post.Name ?? "[action]"));
}
ParameterTemplate parameter = method.AddParameter(modelType, "entity")
.WithAttribute("FromBody");
method.Code.AddLine(Code.This().Field(repositoryField).Method("Add", Code.Local(parameter)).Close());
}
if (controllerConfiguration.Patch != null)
{
MethodTemplate method = controller.AddMethod("Patch", Code.Void());
if (configuration.Template.UseAttributes)
{
method.WithAttribute("HttpPatch", Code.String(controllerConfiguration.Patch.Name ?? "[action]"));
}
ParameterTemplate parameter = method.AddParameter(modelType, "entity")
.WithAttribute("FromBody");
method.Code.AddLine(Code.This().Field(repositoryField).Method("Update", Code.Local(parameter)).Close());
}
if (controllerConfiguration.Put != null)
{
MethodTemplate method = controller.AddMethod("Put", Code.Void());
if (configuration.Template.UseAttributes)
{
method.WithAttribute("HttpPut", Code.String(controllerConfiguration.Put.Name ?? "[action]"));
}
ParameterTemplate parameter = method.AddParameter(modelType, "entity")
.WithAttribute("FromBody");
method.Code.AddLine(Code.This().Field(repositoryField).Method("Update", Code.Local(parameter)).Close());
}
if (controllerConfiguration.Delete != null)
{
MethodTemplate method = controller.AddMethod("Delete", Code.Void());
if (configuration.Template.UseAttributes)
{
method.WithAttribute("HttpDelete", Code.String(controllerConfiguration.Delete.Name ?? "[action]"));
}
List <ParameterTemplate> parameters = new List <ParameterTemplate>();
foreach (EntityKeyTransferObject key in entity.Keys)
{
PropertyTransferObject property = entity.Model.Properties.First(x => x.Name.Equals(key.Name, StringComparison.InvariantCultureIgnoreCase));
parameters.Add(method.AddParameter(property.Type.ToTemplate(), property.Name)
.FormatName(configuration));
}
method.Code.AddLine(Code.This().Field(repositoryField).Method("Delete", parameters.Select(x => Code.Local(x))).Close());
}
}
}