public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (DataStructureInfo)conceptInfo;
var orm = info as IOrmDataStructure;
if (orm != null)
{
codeBuilder.InsertCode(SnippetEntityClassMembers(info), DataStructureCodeGenerator.BodyTag, info);
DataStructureCodeGenerator.AddInterfaceAndReference(codeBuilder, string.Format("System.IEquatable<{0}>", info.Name), typeof(System.IEquatable<>), info);
RepositoryHelper.GenerateRepository(info, codeBuilder);
RepositoryHelper.GenerateQueryableRepositoryFunctions(info, codeBuilder, QuerySnippet(info));
codeBuilder.InsertCode(SnippetQueryableFilterById(info), RepositoryHelper.RepositoryMembers, info);
PropertyInfo idProperty = new PropertyInfo { DataStructure = info, Name = "ID" };
PropertyHelper.GenerateCodeForType(idProperty, codeBuilder, "Guid");
DataStructureCodeGenerator.AddInterfaceAndReference(codeBuilder, typeof(IEntity), info);
codeBuilder.InsertCode(
string.Format("public System.Data.Entity.DbSet<Common.Queryable.{0}_{1}> {0}_{1} {{ get; set; }}\r\n ",
info.Module.Name, info.Name),
DomInitializationCodeGenerator.EntityFrameworkContextMembersTag);
codeBuilder.InsertCode(
string.Format("modelBuilder.Ignore<global::{0}.{1}>();\r\n "
+ "modelBuilder.Entity<Common.Queryable.{0}_{1}>().Map(m => {{ m.MapInheritedProperties(); m.ToTable(\"{3}\", \"{2}\"); }});\r\n ",
info.Module.Name, info.Name, orm.GetOrmSchema(), orm.GetOrmDatabaseObject()),
DomInitializationCodeGenerator.EntityFrameworkOnModelCreatingTag);
}
}
private static string DeclarationCodeSnippet(PropertyInfo info, string type, string nameSuffix)
{
return string.Format(@"
" + AttributeTag.Evaluate(info) + @"
public virtual {1} {0}{2} {{ get; set; }}
", info.Name, type, nameSuffix);
}
private static string GetPropertyType(PropertyInfo conceptInfo)
{
return supportedPropertyTypes
.Where(prop => prop.Key.IsAssignableFrom(conceptInfo.GetType()))
.Select(prop => prop.Value)
.FirstOrDefault();
}
private static string GetPropertyName(PropertyInfo property)
{
if (property is ReferencePropertyInfo)
return property.Name + "ID";
else
return property.Name;
}
public static bool IsSupported(PropertyInfo info)
{
if (!(info.DataStructure is IOrmDataStructure))
return false;
return largePropertyTypes.Any(supportedType => supportedType.IsAssignableFrom(info.GetType()));
}
public IEnumerable<IConceptInfo> CreateNewConcepts(IEnumerable<IConceptInfo> existingConcepts)
{
var newConcepts = new List<IConceptInfo>();
CheckSemantics(existingConcepts);
var names = PropertyNames.Split(' ');
if (names.Distinct().Count() != names.Count())
throw new DslSyntaxException(this, "Duplicate property name in index list '" + PropertyNames + "'.");
if (names.Count() == 0)
throw new DslSyntaxException(this, "Empty property list.");
SqlIndexMultiplePropertyInfo lastIndexProperty = null;
for (int i = 0; i < names.Count(); i++)
{
var property = new PropertyInfo { DataStructure = DataStructure, Name = names[i] };
SqlIndexMultiplePropertyInfo indexProperty;
if (i == 0)
indexProperty = new SqlIndexMultiplePropertyInfo { SqlIndex = this, Property = property };
else
indexProperty = new SqlIndexMultipleFollowingPropertyInfo { SqlIndex = this, Property = property, PreviousIndexProperty = lastIndexProperty };
newConcepts.Add(indexProperty);
lastIndexProperty = indexProperty;
}
return newConcepts;
}
private static string GetColumnName(PropertyInfo property)
{
if (property is ReferencePropertyInfo)
return SqlUtility.Identifier(property.Name + "ID");
return SqlUtility.Identifier(property.Name);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
ReferencePropertyInfo info = (ReferencePropertyInfo)conceptInfo;
PropertyHelper.GenerateCodeForType(info, codeBuilder, info.Referenced.Module.Name + "." + info.Referenced.Name, false);
var referenceGuid = new PropertyInfo { DataStructure = info.DataStructure, Name = info.Name + "ID" };
codeBuilder.InsertCode(ReferenceIDSnippet(info, referenceGuid), DataStructureCodeGenerator.BodyTag, info.DataStructure);
codeBuilder.InsertCode("[DataMember]", PropertyHelper.AttributeTag, referenceGuid);
if (info.DataStructure is IWritableOrmDataStructure)
{
codeBuilder.InsertCode(
string.Format(CultureInfo.InvariantCulture,
@" foreach(var item in insertedNew)
if(item.{0}ID != null)
item.{0} = _executionContext.NHibernateSession.Load<{1}.{2}>(item.{0}ID);
foreach(var item in updatedNew)
if(item.{0}ID != null)
item.{0} = _executionContext.NHibernateSession.Load<{1}.{2}>(item.{0}ID);
foreach(var item in deletedIds)
if(item.{0}ID != null)
item.{0} = _executionContext.NHibernateSession.Load<{1}.{2}>(item.{0}ID);
",
info.Name, info.Referenced.Module.Name, info.Referenced.Name),
WritableOrmDataStructureCodeGenerator.InitializationTag.Evaluate(info.DataStructure));
}
}
private static string ReferenceIDSnippet(ReferencePropertyInfo info, PropertyInfo referenceGuid)
{
return string.Format(
@"
{3}
public virtual Guid? {0}ID
{{
get
{{
if ({0} != null)
return {0}.ID;
return null;
}}
set
{{
if(value == null)
{0} = null;
else
{0} = new {1}.{2} {{ ID = value.Value }};
}}
}}
",
info.Name,
info.Referenced.Module.Name,
info.Referenced.Name,
PropertyHelper.AttributeTag.Evaluate(referenceGuid));
}
public static string RemoveColumn(PropertyInfo property, string columnName)
{
return Sql.Format("PropertyDatabaseDefinition_RemoveColumn",
SqlUtility.Identifier(property.DataStructure.Module.Name),
SqlUtility.Identifier(property.DataStructure.Name),
SqlUtility.CheckIdentifier(columnName));
}
public static string RemoveColumn(PropertyInfo property, string columnName)
{
return Sql.Format("PropertyDatabaseDefinition_RemoveColumn",
SqlUtility.Identifier(property.DataStructure.Module.Name),
SqlUtility.Identifier(property.DataStructure.Name),
DslUtility.ValidateIdentifier(columnName, property, "Invalid column name."),
BeforeRemoveTag.Evaluate(property)).Trim();
}
private static string GetPropertyType(PropertyInfo conceptInfo)
{
if (conceptInfo is IntegerPropertyInfo) return "int?";
if (conceptInfo is BinaryPropertyInfo) return "byte[]";
if (conceptInfo is BoolPropertyInfo) return "bool?";
if (conceptInfo is GuidPropertyInfo) return "Guid?";
return null;
}
public static bool SnippetSqlQuoted(PropertyInfo property)
{
return !(property is BoolPropertyInfo
|| property is IntegerPropertyInfo
|| property is DecimalPropertyInfo
|| property is MoneyPropertyInfo
|| property is BinaryPropertyInfo);
}
private static string CreateDefaultes(IDslModel dslModel, PropertyInfo info)
{
bool isAutocode = dslModel.Concepts.OfType<AutoCodePropertyInfo>().Any(
p => p.Property.Name == info.Name && p.Property.DataStructure.Module.Name == info.DataStructure.Module.Name && p.Property.DataStructure.Name == info.DataStructure.Name);
if (isAutocode) return DefaultAutocode;
if (info.Name.ToLower() == "active" && info is BoolPropertyInfo) return DefaultActive;
return "";
}
private static string PropertySnippet(PropertyInfo info, string propertyType)
{
return string.Format(
@"{2}
public {1} {0} {{ get; set; }}
",
info.Name,
propertyType,
AttributeTag.Evaluate(info));
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
ReferencePropertyInfo info = (ReferencePropertyInfo)conceptInfo;
var referenceGuid = new PropertyInfo { DataStructure = info.DataStructure, Name = info.Name + "ID" };
PropertyHelper.GenerateCodeForType(referenceGuid, codeBuilder, "Guid?");
if (DslUtility.IsQueryable(info.DataStructure) && DslUtility.IsQueryable(info.Referenced))
DataStructureQueryableCodeGenerator.AddNavigationPropertyWithBackingField(codeBuilder, info.DataStructure,
csPropertyName: info.Name,
propertyType: "Common.Queryable." + info.Referenced.Module.Name + "_" + info.Referenced.Name,
additionalSetterCode: info.Name + "ID = value != null ? (Guid?)value.ID : null;");
if (info.DataStructure is IOrmDataStructure && info.Referenced is IOrmDataStructure)
codeBuilder.InsertCode(
string.Format("modelBuilder.Entity<Common.Queryable.{0}_{1}>().HasOptional(t => t.{2}).WithMany().HasForeignKey(t => t.{2}ID);\r\n ",
info.DataStructure.Module.Name, info.DataStructure.Name, info.Name),
DomInitializationCodeGenerator.EntityFrameworkOnModelCreatingTag);
else if (info.DataStructure is IOrmDataStructure)
codeBuilder.InsertCode(
string.Format("modelBuilder.Entity<Common.Queryable.{0}_{1}>().Ignore(t => t.{2});\r\n ",
info.DataStructure.Module.Name, info.DataStructure.Name, info.Name),
DomInitializationCodeGenerator.EntityFrameworkOnModelCreatingTag);
if (ReferencePropertyConstraintDatabaseDefinition.IsSupported(info)
&& info.DataStructure is IOrmDataStructure
&& info.Referenced is IOrmDataStructure)
{
var ormDataStructure = (IOrmDataStructure)info.DataStructure;
var referencedOrmDataStructure = (IOrmDataStructure)info.Referenced;
string systemMessage = "DataStructure:" + info.DataStructure + ",Property:" + info.Name + "ID,Referenced:" + info.Referenced;
if (info.DataStructure is IWritableOrmDataStructure)
{
string onEnterInterpretSqlError = @"if (interpretedException is Rhetos.UserException && Rhetos.Utilities.MsSqlUtility.IsReferenceErrorOnInsertUpdate(interpretedException, "
+ CsUtility.QuotedString(referencedOrmDataStructure.GetOrmSchema() + "." + referencedOrmDataStructure.GetOrmDatabaseObject()) + @", "
+ CsUtility.QuotedString("ID") + @", "
+ CsUtility.QuotedString(ReferencePropertyConstraintDatabaseDefinition.GetConstraintName(info)) + @"))
((Rhetos.UserException)interpretedException).SystemMessage = " + CsUtility.QuotedString(systemMessage) + @";
";
codeBuilder.InsertCode(onEnterInterpretSqlError, WritableOrmDataStructureCodeGenerator.OnDatabaseErrorTag, info.DataStructure);
}
if (info.Referenced is IWritableOrmDataStructure)
{
string onDeleteInterpretSqlError = @"if (interpretedException is Rhetos.UserException && Rhetos.Utilities.MsSqlUtility.IsReferenceErrorOnDelete(interpretedException, "
+ CsUtility.QuotedString(ormDataStructure.GetOrmSchema() + "." + ormDataStructure.GetOrmDatabaseObject()) + @", "
+ CsUtility.QuotedString(info.Name + "ID") + @", "
+ CsUtility.QuotedString(ReferencePropertyConstraintDatabaseDefinition.GetConstraintName(info)) + @"))
((Rhetos.UserException)interpretedException).SystemMessage = " + CsUtility.QuotedString(systemMessage) + @";
";
codeBuilder.InsertCode(onDeleteInterpretSqlError, WritableOrmDataStructureCodeGenerator.OnDatabaseErrorTag, info.Referenced);
}
}
}
public static void GenerateCodeForType(PropertyInfo info, ICodeBuilder codeBuilder, string propertyType)
{
codeBuilder.InsertCode(PropertySnippet(info, propertyType), DataStructureCodeGenerator.BodyTag, info.DataStructure);
codeBuilder.InsertCode("[DataMember]", AttributeTag, info);
if (DslUtility.IsQueryable(info.DataStructure))
if (info.Name != "ID")
codeBuilder.InsertCode(
string.Format(",\r\n {0} = item.{0}", info.Name),
RepositoryHelper.AssignSimplePropertyTag, info.DataStructure);
}
public static void CheckIfPropertyBelongsToDataStructure(PropertyInfo property, DataStructureInfo dataStructure, IConceptInfo errorContext)
{
if (property.DataStructure != dataStructure)
throw new Exception(String.Format(
"Invalid use of " + errorContext.GetKeywordOrTypeName() + ": Property {0}.{1}.{2} is not in data structure {3}.{4}.",
property.DataStructure.Module.Name,
property.DataStructure.Name,
property.Name,
dataStructure.Module.Name,
dataStructure.Name));
}
public static string AddColumn(PropertyInfo property, string columnName, string type, string options = "")
{
return Sql.Format("PropertyDatabaseDefinition_AddColumn",
SqlUtility.Identifier(property.DataStructure.Module.Name),
SqlUtility.Identifier(property.DataStructure.Name),
SqlUtility.CheckIdentifier(columnName),
type,
options,
Options1Tag.Evaluate(property),
Options2Tag.Evaluate(property));
}
private static string HideDetailFields(IDslModel dslModel, PropertyInfo info)
{
string entityName = CaptionHelper.RemoveBrowseSufix(info.DataStructure.Name);
bool isDetail = dslModel.Concepts.OfType<ReferenceDetailInfo>().Any(
d => d.Reference.Name == info.Name
&& d.Reference.DataStructure.Name == entityName
&& d.Reference.DataStructure.Module.Name == info.DataStructure.Module.Name);
if (isDetail) return EditModeHidden;
return "";
}
public static string CreateAdditionalAttributes(IDslModel dslModel, PropertyInfo info, string dodatniAtributi)
{
HashSet<string> additionalMvcAttributes = new HashSet<string>();
additionalMvcAttributes.Add(HideLookupFields(dslModel, info));
additionalMvcAttributes.Add(HideDetailFields(dslModel, info));
additionalMvcAttributes.Add(CreateDefaultes(dslModel, info));
additionalMvcAttributes.Add(HideIdFields(dslModel, info));
additionalMvcAttributes.Remove("");
return dodatniAtributi + string.Join("", additionalMvcAttributes);
}
public static string GetPropertyType(PropertyInfo conceptInfo)
{
if (conceptInfo is IntegerPropertyInfo) return "int?";
if (conceptInfo is BinaryPropertyInfo) return "byte[]";
if (conceptInfo is BoolPropertyInfo) return "bool?";
if (conceptInfo is GuidPropertyInfo || conceptInfo is ReferencePropertyInfo) return "Guid?";
if (conceptInfo is ShortStringPropertyInfo) return "string";
if (conceptInfo is LongStringPropertyInfo) return "string";
if (conceptInfo is MoneyPropertyInfo || conceptInfo is DecimalPropertyInfo) return "decimal?";
if (conceptInfo is DatePropertyInfo || conceptInfo is DateTimePropertyInfo) return "DateTime?";
return null;
}
private static string PropertyCodeSnippet(PropertyInfo info, string type, string nameSuffix)
{
return string.Format(
AttributesTag.Evaluate(info) + @"
public virtual {1} {0}{2} {{ get; set; }}
public const string Property{0}{2} = ""{0}{2}"";
",
info.Name,
type,
nameSuffix);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (ComputedInfo)conceptInfo;
PropertyInfo idProperty = new PropertyInfo { DataStructure = info, Name = "ID" };
PropertyHelper.GenerateCodeForType(idProperty, codeBuilder, "Guid", true);
codeBuilder.AddInterfaceAndReference(typeof(IEntity), info);
RepositoryHelper.GenerateRepository(info, codeBuilder);
RepositoryHelper.GenerateQueryableRepositoryFunctions(info, codeBuilder, QueryFunctionBodySnippet(info));
codeBuilder.InsertCode(RepositoryFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info);
}
private static string CodeSnippet(PropertyInfo info)
{
return string.Format(
@" <property {0} {1}>
<column name=""{2}"" length=""{3}"" />
</property>
",
NhUtility.PropertyAndColumnNameMapping(info.Name),
SimplePropertyMappingGenerator.AttributesTag.Evaluate(info),
SqlUtility.Identifier(info.Name),
MaxBlobSize);
}
public void GenerateCode(IConceptInfo conceptInfo, ICodeBuilder codeBuilder)
{
var info = (BrowseDataStructureInfo)conceptInfo;
RepositoryHelper.GenerateRepository(info, codeBuilder);
RepositoryHelper.GenerateQueryableRepositoryFunctions(info, codeBuilder, QuerySnippet(info));
codeBuilder.InsertCode(RepositoryFunctionsSnippet(info), RepositoryHelper.RepositoryMembers, info);
codeBuilder.InsertCode(OrmDataStructureCodeGenerator.SnippetQueryableFilterById(info), RepositoryHelper.RepositoryMembers, info);
PropertyInfo idProperty = new PropertyInfo { DataStructure = info, Name = "ID" };
PropertyHelper.GenerateCodeForType(idProperty, codeBuilder, "Guid");
DataStructureCodeGenerator.AddInterfaceAndReference(codeBuilder, typeof(IEntity), info);
}
public static string AddColumn(ConceptMetadata conceptMetadata, PropertyInfo property, string options = "")
{
string columnName = conceptMetadata.Get(property, ColumnNamesMetadata).Single();
return Sql.Format("PropertyDatabaseDefinition_AddColumn",
SqlUtility.Identifier(property.DataStructure.Module.Name),
SqlUtility.Identifier(property.DataStructure.Name),
DslUtility.ValidateIdentifier(columnName, property, "Invalid column name."),
conceptMetadata.Get(property, ColumnTypesMetadata).Single(),
options,
Options1Tag.Evaluate(property),
Options2Tag.Evaluate(property),
AfterCreateTag.Evaluate(property)).Trim();
}
private static string GetPropertyType(PropertyInfo conceptInfo)
{
if (typeof(IntegerPropertyInfo).IsAssignableFrom(conceptInfo.GetType())) return "int?";
if (typeof(BinaryPropertyInfo).IsAssignableFrom(conceptInfo.GetType())) return "byte[]";
if (typeof(BoolPropertyInfo).IsAssignableFrom(conceptInfo.GetType())) return "bool?";
if (typeof(DatePropertyInfo).IsAssignableFrom(conceptInfo.GetType())
|| typeof(DateTimePropertyInfo).IsAssignableFrom(conceptInfo.GetType())) return "DateTime?";
if (typeof(MoneyPropertyInfo).IsAssignableFrom(conceptInfo.GetType())
|| typeof(DecimalPropertyInfo).IsAssignableFrom(conceptInfo.GetType())) return "decimal?";
if (typeof(GuidPropertyInfo).IsAssignableFrom(conceptInfo.GetType())) return "Guid?";
if (typeof(ShortStringPropertyInfo).IsAssignableFrom(conceptInfo.GetType())
|| typeof(LongStringPropertyInfo).IsAssignableFrom(conceptInfo.GetType())) return "string";
return null;
}
private string LimitStringLengthOnSaveSnippet(PropertyInfo info)
{
return string.Format(@"
{{
var invalidItem = insertedNew.Concat(updatedNew).Where(newItem => newItem.{2} != null && newItem.{2}.Length > {3}).FirstOrDefault();
if (invalidItem != null)
throw new Rhetos.UserException(""Maximum length of property {1}.{2} is {3}."", ""DataStructure:{0}.{1},ID:"" + invalidItem.ID.ToString() + "",Property:{2}"");
}}
",
info.DataStructure.Module.Name,
info.DataStructure.Name,
info.Name,
ShortStringPropertyInfo.MaxLength);
}
private static string GetResourceNameForCursorSelectSnippet(PropertyInfo groupProperty)
{
var resourceName = "AutoCodeForEachDatabaseDefinition_ExtendCursorSelect_" + groupProperty.GetType().Name;
try
{
Sql.Get(resourceName);
}
catch (Exception ex)
{
throw new FrameworkException(
"Group property type '" + groupProperty.GetType().Name +
"' is not supported in AutoCodeForEachDatabaseDefinition. " + ex.Message, ex);
}
return resourceName;
}
