public void SqlBulkCopy(IEnumerable <Permission> items)
{
using (var bulkCopy = new SqlBulkCopy(ConnectionString, SqlBulkCopyOptions.KeepIdentity |
SqlBulkCopyOptions.UseInternalTransaction |
SqlBulkCopyOptions.KeepNulls))
{
bulkCopy.BulkCopyTimeout = 0;
bulkCopy.BatchSize = items.Count();
bulkCopy.DestinationTableName = CodeGenerationHelper.GetTableName <Permission>();
var table = new System.Data.DataTable();
table.Columns.Add("CreationDate");
bulkCopy.ColumnMappings.Add("CreationDate", "CreationDate");
table.Columns.Add("CreatedBy");
bulkCopy.ColumnMappings.Add("CreatedBy", "CreatedBy");
table.Columns.Add("ModificationDate");
bulkCopy.ColumnMappings.Add("ModificationDate", "ModificationDate");
table.Columns.Add("ModifiedBy");
bulkCopy.ColumnMappings.Add("ModifiedBy", "ModifiedBy");
table.Columns.Add("Description");
bulkCopy.ColumnMappings.Add("Description", "Description");
table.Columns.Add("ItemName");
bulkCopy.ColumnMappings.Add("ItemName", "ItemName");
table.Columns.Add("Role_Id");
bulkCopy.ColumnMappings.Add("Role_Id", "Role_Id");
foreach (var item in items)
{
table.Rows.Add(new object[] { item.CreationDate, item.CreatedBy, item.ModificationDate, item.ModifiedBy, item.Description, item.ItemName, item.Role == null ? null : item.Role.Id as int? });
}
bulkCopy.WriteToServer(table);
}
}
public override void Render(
StringBuilder builder,
bool isInnerClass,
int level,
CodegenIndent indent)
{
if (LambdaType != null) {
builder.Append("new ");
CodeGenerationHelper.AppendClassName(builder, LambdaType);
builder.Append("(");
}
builder.Append('(');
var delimiter = "";
foreach (var parameter in ParamNames) {
builder.Append(delimiter);
parameter.Render(builder);
delimiter = ",";
}
builder.Append(") => {");
Block.Render(builder, isInnerClass, level + 1, indent);
builder.Append("}");
if (LambdaType != null)
{
builder.Append(")");
}
}
public static void Configure(SqlServerContextBase context, DbModelBuilder modelBuilder)
{
#region CalendarEvent
modelBuilder.Entity <CalendarEvent>()
.ToTable(CodeGenerationHelper.GetTableName <CalendarEvent>());
modelBuilder.Entity <CalendarEvent>()
.HasKey(x => x.Id);
modelBuilder.Entity <CalendarEvent>()
.HasRequired(x => x.Recurrence)
.WithMany();
modelBuilder.Entity <CalendarEvent>()
.HasRequired(x => x.Status)
.WithMany();
#endregion
#region CalendarEventRecurrence
modelBuilder.Entity <CalendarEventRecurrence>()
.ToTable(CodeGenerationHelper.GetTableName <CalendarEventRecurrence>());
modelBuilder.Entity <CalendarEventRecurrence>()
.HasKey(x => x.Id);
#endregion
#region CalendarEventStatus
modelBuilder.Entity <CalendarEventStatus>()
.ToTable(CodeGenerationHelper.GetTableName <CalendarEventStatus>());
modelBuilder.Entity <CalendarEventStatus>()
.HasKey(x => x.Id);
#endregion
}
public void SqlBulkCopyWithId(IEnumerable <Role> items)
{
using (var bulkCopy = new SqlBulkCopy(ConnectionString, SqlBulkCopyOptions.KeepIdentity |
SqlBulkCopyOptions.UseInternalTransaction |
SqlBulkCopyOptions.KeepNulls))
{
bulkCopy.BulkCopyTimeout = 0;
bulkCopy.BatchSize = items.Count();
bulkCopy.DestinationTableName = CodeGenerationHelper.GetTableName <Role>();
var table = new System.Data.DataTable();
table.Columns.Add("Id");
bulkCopy.ColumnMappings.Add("Id", "Id");
table.Columns.Add("CreationDate");
bulkCopy.ColumnMappings.Add("CreationDate", "CreationDate");
table.Columns.Add("CreatedBy");
bulkCopy.ColumnMappings.Add("CreatedBy", "CreatedBy");
table.Columns.Add("ModificationDate");
bulkCopy.ColumnMappings.Add("ModificationDate", "ModificationDate");
table.Columns.Add("ModifiedBy");
bulkCopy.ColumnMappings.Add("ModifiedBy", "ModifiedBy");
table.Columns.Add("CanAccessAllFarms");
bulkCopy.ColumnMappings.Add("CanAccessAllFarms", "CanAccessAllFarms");
table.Columns.Add("Description");
bulkCopy.ColumnMappings.Add("Description", "Description");
table.Columns.Add("IsWebApi");
bulkCopy.ColumnMappings.Add("IsWebApi", "IsWebApi");
table.Columns.Add("Name");
bulkCopy.ColumnMappings.Add("Name", "Name");
foreach (var item in items)
{
table.Rows.Add(new object[] { item.Id, item.CreationDate, item.CreatedBy, item.ModificationDate, item.ModifiedBy, item.CanAccessAllFarms, item.Description, item.IsWebApi, item.Name });
}
bulkCopy.WriteToServer(table);
}
}
public void Generate_AddsConstructorWithBaseCall_PassingQualifiedIPublishedContentParameter()
{
var type = new CodeTypeDeclaration {
Name = "AName"
};
type.BaseTypes.Add("ABaseType");
var generator = new CtorGenerator(null);
generator.Generate(type, new MediaType());
var ns = CodeGenerationHelper.CreateNamespaceWithType(type);
var code = CodeGenerationHelper.GenerateCode(ns);
Assert.AreEqual(
@"namespace ANamespace {
public class AName : ABaseType {
public AName(Umbraco.Core.Models.IPublishedContent content) :
base(content) {
}
}
}
", code.ToString());
}
private static void WriteBody()
{
var indentation = 1;
AppendContent(CodeGenerationHelper.GetLine($"public class {_entityProperty}Definition : ScriptableObject, IEntityDefinition", indentation));
AppendContent(CodeGenerationHelper.GetLine("{", indentation));
indentation++;
AppendContent(CodeGenerationHelper.GetLine($"private const EntityProperty Component = EntityProperty.{_entityProperty};", indentation));
AppendContent(CodeGenerationHelper.GetLine("[SerializeField, ReadOnly]", indentation));
AppendContent(CodeGenerationHelper.GetLine("private EntityType _entityType;", indentation));
AppendContent(CodeGenerationHelper.GetLine("public EntityType EntityType => _entityType;", indentation));
AppendContent(CodeGenerationHelper.GetLine("", indentation));
AppendContent(CodeGenerationHelper.GetLine("// Put in your custom code here ...", indentation));
AppendContent(CodeGenerationHelper.GetLine("", indentation));
AppendContent(CodeGenerationHelper.GetLine("", indentation));
AppendContent(CodeGenerationHelper.GetLine("#if UNITY_EDITOR", 0));
AppendContent(CodeGenerationHelper.GetLine("public void SetEntityType(EntityType type)", indentation));
AppendContent(CodeGenerationHelper.GetLine("{", indentation));
indentation++;
AppendContent(CodeGenerationHelper.GetLine("_entityType = type;", indentation));
indentation--;
AppendContent(CodeGenerationHelper.GetLine("}", indentation));
AppendContent(CodeGenerationHelper.GetLine("#endif", 0));
indentation--;
AppendContent(CodeGenerationHelper.GetLine("}", indentation));
indentation--;
AppendContent(CodeGenerationHelper.GetLine("}", indentation));
}
public void Generate_Body_GetsContentPropertyValueOfType()
{
var property = new GenericProperty {
Alias = "aProperty"
};
var propNode = new CodeMemberProperty {
Type = new CodeTypeReference("String")
};
var generator = new PropertyBodyGenerator(new CodeGeneratorConfiguration().MediaTypes);
generator.Generate(propNode, property);
var ns = CodeGenerationHelper.CreateNamespaceWithTypeAndProperty(propNode);
var builder = CodeGenerationHelper.GenerateCode(ns);
var code = builder.ToString();
var returnIndex = code.IndexOf("return");
var endIndex = code.IndexOf(";", returnIndex);
var body = code.Substring(returnIndex, endIndex - returnIndex + 1);
Assert.AreEqual(
"return Content.GetPropertyValue<String>(\"aProperty\");",
body
);
}
public override void RenderStatement(TextWriter textWriter)
{
CodeGenerationHelper.AppendClassName(textWriter, _clazz, null);
textWriter.Write(" ");
textWriter.Write(_var);
textWriter.Write("=null");
}
public void SqlBulkCopyFor <TItem>(IList <TItem> list) where TItem : class, IPocoBase
{
using (var bulkCopy = new SqlBulkCopy(ConnectionString))
{
bulkCopy.BatchSize = list.Count;
bulkCopy.DestinationTableName = CodeGenerationHelper.GetTableName <TItem>();
var table = new DataTable();
var props = typeof(TItem).GetPrimitiveIncludingPocoBase().ToList();
foreach (var propertyInfo in props)
{
bulkCopy.ColumnMappings.Add(propertyInfo.Name, propertyInfo.Name);
table.Columns.Add(propertyInfo.Name, Nullable.GetUnderlyingType(propertyInfo.PropertyType) ?? propertyInfo.PropertyType);
}
var values = new object[props.Count()];
foreach (var item in list)
{
for (var i = 0; i < values.Length; i++)
{
values[i] = props[i].GetValue(item);
}
table.Rows.Add(values);
}
bulkCopy.WriteToServer(table);
}
}
public void Render(TextWriter textWriter)
{
textWriter.Write("new ");
CodeGenerationHelper.AppendClassName(textWriter, _clazz, null);
textWriter.Write("(");
CodegenExpressionBuilder.RenderExpressions(textWriter, _parameters);
textWriter.Write(")");
}
public void Render(TextWriter textWriter)
{
textWriter.Write("((");
CodeGenerationHelper.AppendClassName(textWriter, _clazz, null);
textWriter.Write(")");
_expression.Render(textWriter);
textWriter.Write(")");
}
public override CodeAttributeDeclaration GetAttributeDeclaration()
{
CodeAttributeDeclaration attribute = new CodeAttributeDeclaration("ValidateCreditCard");
if (this._allowedTypes != CardType.All)
{
ArrayList list = new ArrayList();
if ((_allowedTypes & CardType.MasterCard) != 0)
{
list.Add(GetFieldReferenceForCreditCardEnum(CardType.MasterCard));
}
if ((_allowedTypes & CardType.VISA) != 0)
{
list.Add(GetFieldReferenceForCreditCardEnum(CardType.VISA));
}
if ((_allowedTypes & CardType.Amex) != 0)
{
list.Add(GetFieldReferenceForCreditCardEnum(CardType.Amex));
}
if ((_allowedTypes & CardType.DinersClub) != 0)
{
list.Add(GetFieldReferenceForCreditCardEnum(CardType.DinersClub));
}
if ((_allowedTypes & CardType.enRoute) != 0)
{
list.Add(GetFieldReferenceForCreditCardEnum(CardType.enRoute));
}
if ((_allowedTypes & CardType.Discover) != 0)
{
list.Add(GetFieldReferenceForCreditCardEnum(CardType.Discover));
}
if ((_allowedTypes & CardType.JCB) != 0)
{
list.Add(GetFieldReferenceForCreditCardEnum(CardType.JCB));
}
if ((_allowedTypes & CardType.Unknown) != 0)
{
list.Add(GetFieldReferenceForCreditCardEnum(CardType.Unknown));
}
attribute.Arguments.Add(new CodeAttributeArgument(CodeGenerationHelper.GetBinaryOr(list, 0)));
if (_exceptions != null)
{
// TODO: Add as array initializer
attribute.Arguments.Add(AttributeHelper.GetStringArrayAttributeArgument(_exceptions));
}
}
else if (_exceptions != null)
{
// TODO add as array init. as above :
//attribute.Arguments.Add(GetPrimitiveAttributeArgument("CreditCardValidator.CardType", validator.Exceptions));
}
base.AddAttributeArguments(attribute, ErrorMessagePlacement.UnOrdered);
return(attribute);
}
static void Main(string[] args)
{
var options = new Options();
if (CommandLine.Parser.Default.ParseArguments(args, options))
{
// Values are available here
if (options.Verbose)
{
Console.WriteLine("Reading json schema at : {0}", options.InputFile);
}
if (!File.Exists(options.InputFile))
{
if (options.Verbose)
{
Console.WriteLine("The file does not exists");
}
else
{
throw new FileNotFoundException("The json file does not exists");
}
}
//JsonUtils.Core.Language
JsonUtils.Core.Language Language = (JsonUtils.Core.Language)Enum.Parse(typeof(JsonUtils.Core.Language), options.GenerateLang, true);
if (options.Verbose)
{
Console.WriteLine("Reading the file ...");
}
var jsonInput = File.ReadAllText(options.InputFile).Trim();
if (options.Verbose)
{
Console.WriteLine("Generating the code ...");
}
var output = CodeGenerationHelper.Prepare(jsonInput, options.RootObject, Language, options.NameSpace, false,
"None", (JsonUtils.Core.Language.Java == Language || JsonUtils.Core.Language.PHP == Language) && true);
if (string.IsNullOrEmpty(options.OutputFile))
{
Console.Write(output);
}
else
{
if (options.Verbose)
{
Console.WriteLine("Saving the code");
}
File.WriteAllText(options.OutputFile, output);
if (options.Verbose)
{
Console.WriteLine("Saved to " + options.OutputFile);
}
}
}
}
public override void RenderStatement(TextWriter textWriter)
{
textWriter.Write("if (!(");
textWriter.Write(_var);
textWriter.Write(" is ");
CodeGenerationHelper.AppendClassName(textWriter, _type, null);
textWriter.Write(")) return ");
CodegenExpressionUtil.RenderConstant(textWriter, _constant);
}
public void Render(TextWriter textWriter)
{
CodeGenerationHelper.AppendClassName(textWriter, _target, null);
textWriter.Write(".");
textWriter.Write(_methodName);
textWriter.Write("(");
CodegenExpressionBuilder.RenderExpressions(textWriter, _parameters);
textWriter.Write(")");
}
private void AddRestItemColumns(List <ColumnAndField> whichFields, List <ColumnAndField> whereToAdd, MatchingOptions options, JObject clientPayload)
{
foreach (var item in whichFields)
{
var isAdded = whereToAdd.Where(t =>
t.ColumnName.ToLower().Equals(item.ColumnName.ToLower()) &&
t.TableName.ToLower().Equals(item.TableName.ToLower()) &&
t.EntityFullName.ToLower().Equals(item.EntityFullName.ToLower()) &&
t.EntityPrefix.ToLower().Equals(item.EntityPrefix.ToLower())
).ToList();
if (isAdded.Any())
{
continue;
}
if (item.ColumnName.Equals(BusinessConstant.UpdatedBy))
{
item.Value = options.UserId;
}
if (item.ColumnName.Equals(BusinessConstant.UpdatedDate))
{
item.Value = HelperUtility.GetCurrentUTCDate();
}
if (item.ColumnName.Equals(BusinessConstant.EntityCode))
{
item.Value = options.Context;
}
if (item.ColumnName.Equals(BusinessConstant.EntitySubtype))
{
item.Value = options.EntitySubType;
}
if (item.ColumnName.Equals(BusinessConstant.Active))
{
item.Value = 1;
}
if (item.ColumnName.Equals(BusinessConstant.Name))
{
item.Value = "NotImplemented";
}
if (item.ColumnName.Equals(ItemHelper.ItemTablePrimarykey))
{
item.Value = options.PrimaryId;
}
if (item.ColumnName.Equals(BusinessConstant.TenantId))
{
item.Value = options.TenantId;
}
if (item.ColumnName.Equals(BusinessConstant.AutogeneratedCode))
{
item.Value = CodeGenerationHelper.Generate(ItemHelper.ItemClassName, clientPayload);
}
whereToAdd.Add(item);
}
}
public static void Configure(SqlServerContextBase context, DbModelBuilder modelBuilder)
{
#region NewsItem
modelBuilder.Entity <NewsItem>()
.ToTable(CodeGenerationHelper.GetTableName <NewsItem>());
modelBuilder.Entity <NewsItem>()
.HasKey(x => x.Id);
#endregion
}
public static void Configure(SqlServerContextBase context, DbModelBuilder modelBuilder)
{
#region Permission
modelBuilder.Entity <Permission>()
.ToTable(CodeGenerationHelper.GetTableName <Permission>());
modelBuilder.Entity <Permission>()
.HasKey(x => x.Id);
modelBuilder.Entity <Permission>()
.HasRequired(x => x.Role)
.WithMany(x => x.PermissionList);
#endregion
#region Role
modelBuilder.Entity <Role>()
.ToTable(CodeGenerationHelper.GetTableName <Role>());
modelBuilder.Entity <Role>()
.HasKey(x => x.Id);
modelBuilder.Entity <Role>()
.HasMany(x => x.PermissionList)
.WithRequired(x => x.Role);
modelBuilder.Entity <Role>()
.HasMany(x => x.UserRoleList)
.WithRequired(x => x.Role);
#endregion
#region User
modelBuilder.Entity <User>()
.ToTable(CodeGenerationHelper.GetTableName <User>());
modelBuilder.Entity <User>()
.HasKey(x => x.Id);
modelBuilder.Entity <User>()
.HasMany(x => x.UserRoleList)
.WithRequired(x => x.User);
#endregion
#region UserRole
modelBuilder.Entity <UserRole>()
.ToTable(CodeGenerationHelper.GetTableName <UserRole>());
modelBuilder.Entity <UserRole>()
.HasKey(x => x.Id);
modelBuilder.Entity <UserRole>()
.HasRequired(x => x.Role)
.WithMany(x => x.UserRoleList);
modelBuilder.Entity <UserRole>()
.HasRequired(x => x.User)
.WithMany(x => x.UserRoleList);
#endregion
}
private static string GenerateGetLookupMethod <TIn, Tout>(string methodName, string lookupTableName)
{
var content = "";
AppendContent(CodeGenerationHelper.GetLine($"public static IList<{typeof(Tout).Name}> {methodName}(this {typeof(TIn).Name} key)", 2), ref content);
AppendContent(CodeGenerationHelper.GetLine("{", 2), ref content);
AppendContent(CodeGenerationHelper.GetLine($"if (!{lookupTableName}.TryGetValue(key, out var values)) throw new NotImplementedException($\"The given key '" + "{key}" + "' could not be found\");", 3), ref content);
AppendContent(CodeGenerationHelper.GetLine("return values;", 3), ref content);
AppendContent(CodeGenerationHelper.GetLine("}", 2), ref content);
return(content);
}
public override void RenderStatement(TextWriter textWriter)
{
CodeGenerationHelper.AppendClassName(textWriter, _clazz, null);
textWriter.Write(" s");
textWriter.Write(_streamNum);
textWriter.Write("=(");
CodeGenerationHelper.AppendClassName(textWriter, _clazz, null);
textWriter.Write(")eventsPerStream[");
textWriter.Write(_streamNum);
textWriter.Write("].Underlying");
}
public void Render(TextWriter textWriter)
{
textWriter.Write("((");
CodeGenerationHelper.AppendClassName(textWriter, _clazz, null);
textWriter.Write(")");
_ref.Render(textWriter);
textWriter.Write(".Underlying)");
textWriter.Write("[");
textWriter.Write(_index);
textWriter.Write("]");
}
public void ShouldGenerateField()
{
var codeGenerationHelper = new CodeGenerationHelper();
CodeMemberField codeMemberField = codeGenerationHelper.CreateField(typeof(string), "name");
CodeCompileUnit codeCompileUnit = codeGenerationHelper.GetCodeCompileUnit("someNamespace", "someType");
codeCompileUnit.Namespaces[0].Types[0].Members.Add(codeMemberField);
cSharpCodeProvider.GenerateCodeFromCompileUnit(codeCompileUnit, new StringWriter(stringBuilder),
new CodeGeneratorOptions());
Assert.IsTrue(stringBuilder.ToString().Contains("private string name;"));
}
public void Render(TextWriter textWriter)
{
textWriter.Write("((");
CodeGenerationHelper.AppendClassName(textWriter, _clazz, null);
textWriter.Write(")");
_expression.Render(textWriter);
textWriter.Write(".Underlying).");
textWriter.Write(_method);
textWriter.Write("(");
CodegenExpressionUtil.RenderConstant(textWriter, _constant);
textWriter.Write(")");
}
private static string GenerateHasLookupMethod <Tkey, TType>(string methodName, string lookupTableName)
{
var content = "";
AppendContent(CodeGenerationHelper.GetLine($"public static bool {methodName}(this {typeof(Tkey).Name} key, {typeof(TType)} value)", 2), ref content);
AppendContent(CodeGenerationHelper.GetLine("{", 2), ref content);
AppendContent(CodeGenerationHelper.GetLine($"if (!{lookupTableName}.TryGetValue(key, out var values)) throw new NotImplementedException($\"The given key '" + "{key}" + "' could not be found\");", 3), ref content);
AppendContent(CodeGenerationHelper.GetLine("return values.Any(p => p == value);", 3), ref content);
AppendContent(CodeGenerationHelper.GetLine("}", 2), ref content);
return(content);
}
public void Render(
StringBuilder builder,
bool isInnerClass,
int level,
CodegenIndent indent)
{
builder.Append("new ");
CodeGenerationHelper.AppendClassName(builder, _clazz);
builder.Append("(");
CodegenExpressionBuilder.RenderExpressions(builder, _params, isInnerClass);
builder.Append(")");
}
private static void WriteDisclaimer()
{
AppendContent(CodeGenerationHelper.GetLine("/// <summary>", 1));
AppendContent(CodeGenerationHelper.GetLine("/// This class template has been generated.", 1));
AppendContent(CodeGenerationHelper.GetLine("/// You can add your custom code within the class body.", 1));
AppendContent(CodeGenerationHelper.GetLine("/// As long as the file is present it won't be overwritten", 1));
AppendContent(CodeGenerationHelper.GetLine("", 1));
AppendContent(CodeGenerationHelper.GetLine("/// NOTE: If you want to regenerate this file you have to delete it and press regenerate.", 1));
AppendContent(CodeGenerationHelper.GetLine("/// ----------------------------------------------------------------------------------------------------", 1));
AppendContent(CodeGenerationHelper.GetLine("", 1));
AppendContent(CodeGenerationHelper.GetLine($"///This class template has been generated by '{typeof(EntityDefinitionGenerator).Name}'", 1));
AppendContent(CodeGenerationHelper.GetLine("/// </summary>", 1));
}
public void SqlBulkCopyWithId(IEnumerable <CalendarEvent> items)
{
using (var bulkCopy = new SqlBulkCopy(ConnectionString, SqlBulkCopyOptions.KeepIdentity |
SqlBulkCopyOptions.UseInternalTransaction |
SqlBulkCopyOptions.KeepNulls))
{
bulkCopy.BulkCopyTimeout = 0;
bulkCopy.BatchSize = items.Count();
bulkCopy.DestinationTableName = CodeGenerationHelper.GetTableName <CalendarEvent>();
var table = new System.Data.DataTable();
table.Columns.Add("Id");
bulkCopy.ColumnMappings.Add("Id", "Id");
table.Columns.Add("CreationDate");
bulkCopy.ColumnMappings.Add("CreationDate", "CreationDate");
table.Columns.Add("CreatedBy");
bulkCopy.ColumnMappings.Add("CreatedBy", "CreatedBy");
table.Columns.Add("ModificationDate");
bulkCopy.ColumnMappings.Add("ModificationDate", "ModificationDate");
table.Columns.Add("ModifiedBy");
bulkCopy.ColumnMappings.Add("ModifiedBy", "ModifiedBy");
table.Columns.Add("AppliesTo");
bulkCopy.ColumnMappings.Add("AppliesTo", "AppliesTo");
table.Columns.Add("Comment");
bulkCopy.ColumnMappings.Add("Comment", "Comment");
table.Columns.Add("Description");
bulkCopy.ColumnMappings.Add("Description", "Description");
table.Columns.Add("EndDate");
bulkCopy.ColumnMappings.Add("EndDate", "EndDate");
table.Columns.Add("FileData");
bulkCopy.ColumnMappings.Add("FileData", "FileData");
table.Columns.Add("FileName");
bulkCopy.ColumnMappings.Add("FileName", "FileName");
table.Columns.Add("FileType");
bulkCopy.ColumnMappings.Add("FileType", "FileType");
table.Columns.Add("Owner");
bulkCopy.ColumnMappings.Add("Owner", "Owner");
table.Columns.Add("StartDate");
bulkCopy.ColumnMappings.Add("StartDate", "StartDate");
table.Columns.Add("Title");
bulkCopy.ColumnMappings.Add("Title", "Title");
table.Columns.Add("Recurrence_Id");
bulkCopy.ColumnMappings.Add("Recurrence_Id", "Recurrence_Id");
table.Columns.Add("Status_Id");
bulkCopy.ColumnMappings.Add("Status_Id", "Status_Id");
foreach (var item in items)
{
table.Rows.Add(new object[] { item.Id, item.CreationDate, item.CreatedBy, item.ModificationDate, item.ModifiedBy, item.AppliesTo, item.Comment, item.Description, item.EndDate, item.FileData, item.FileName, item.FileType, item.Owner, item.StartDate, item.Title, item.Recurrence == null ? null : item.Recurrence.Id as int?, item.Status == null ? null : item.Status.Id as int? });
}
bulkCopy.WriteToServer(table);
}
}
public void Render(TextWriter textWriter)
{
int numDimensions = TypeHelper.GetNumberOfDimensions(_component);
Type outermostType = TypeHelper.GetComponentTypeOutermost(_component);
textWriter.Write("new ");
CodeGenerationHelper.AppendClassName(textWriter, outermostType, null);
textWriter.Write("[");
_expression.Render(textWriter);
textWriter.Write("]");
for (int i = 0; i < numDimensions; i++)
{
textWriter.Write("[]");
}
}
private static void Writeheader()
{
AppendContent(CodeGenerationHelper.GetLine("using O.M.A.Games.GDOrganizer.Generated;"));
AppendContent(CodeGenerationHelper.GetLine("using Plugins.O.M.A.Games.GDOrganizer.Runtime.Utils;"));
AppendContent(CodeGenerationHelper.GetLine("using Plugins.O.M.A.Games.GDOrganizer.Runtime.Entity;"));
AppendContent(CodeGenerationHelper.GetLine("using UnityEngine;"));
AppendContent(CodeGenerationHelper.GetLine(""));
AppendContent(CodeGenerationHelper.GetLine($"namespace {GeneratorConstants.DefinitionNamespace}"));
AppendContent(CodeGenerationHelper.GetLine("{"));
}
public void Render(TextWriter textWriter)
{
CodeGenerationHelper.AppendClassName(textWriter, _target, null);
textWriter.Write(".");
textWriter.Write(_methodName);
textWriter.Write("(");
_expression.Render(textWriter);
foreach (object constant in _consts)
{
textWriter.Write(",");
CodegenExpressionUtil.RenderConstant(textWriter, constant);
}
textWriter.Write(")");
}
