private void ddlGroupStageCreation_SelectedIndexChanged(object sender, EventArgs e)
{
EnumEntity entity = (EnumEntity)ddlGroupStageCreation.SelectedItem;
if (entity != null)
{
_CurrentSoundEntry.StageCreationGroupID = entity.Value;
}
else
{
_CurrentSoundEntry.StageCreationGroupID = -1;
}
}
private void ddlSoundIconID_SelectedIndexChanged(object sender, EventArgs e)
{
EnumEntity entity = (EnumEntity)ddlSoundIconID.SelectedItem;
if (entity != null)
{
_CurrentSoundEntry.IconID = entity.Value;
}
else
{
_CurrentSoundEntry.IconID = -1;
}
}
internal static List <TypeEntity> GenerateSchemaTypes()
{
var list = (from tab in Schema.Current.Tables.Values
let type = EnumEntity.Extract(tab.Type) ?? tab.Type
select new TypeEntity
{
FullClassName = type.FullName,
TableName = tab.Name.Name,
CleanName = Reflector.CleanTypeName(type)
}).ToList();
return(list);
}
static Reflector()
{
DescriptionManager.CleanTypeName = CleanTypeName; //To allow MyEntityEntity
DescriptionManager.CleanType = t => EnumEntity.Extract(t) ?? t.CleanType(); //To allow Lite<T>
DescriptionManager.DefaultDescriptionOptions += DescriptionManager_IsEnumsInEntities;
DescriptionManager.DefaultDescriptionOptions += DescriptionManager_IsQuery;
DescriptionManager.DefaultDescriptionOptions += DescriptionManager_IsSymbolContainer;
DescriptionManager.DefaultDescriptionOptions += DescriptionManager_IsIEntity;
DescriptionManager.ShouldLocalizeMemeber += DescriptionManager_ShouldLocalizeMemeber;
DescriptionManager.Invalidate();
}
private void btnOK_Click(object sender, EventArgs e)
{
if (dataGridViewEnum.SelectedRows.Count == 0)
{
this.SelectedEnumEntity = null;
}
else
{
EnumEntity enumEntity = (EnumEntity)dataGridViewEnum.SelectedRows[0].DataBoundItem;
this.SelectedEnumEntity = enumEntity;
}
this.DialogResult = DialogResult.OK;
this.Close();
}
private static string GetSchemaName(Table table)
{
Type type = EnumEntity.Extract(table.Type) ?? table.Type;
if (type == typeof(ColumnOptionsMode) || type == typeof(FilterOperation) || type == typeof(PaginationMode) || type == typeof(OrderType))
{
type = typeof(UserQueryEntity);
}
if (type == typeof(SmtpDeliveryFormat) || type == typeof(SmtpDeliveryMethod))
{
type = typeof(EmailMessageEntity);
}
if (type == typeof(DayOfWeek))
{
type = typeof(ScheduledTaskEntity);
}
if (type.Assembly == typeof(ApplicationConfigurationEntity).Assembly)
{
return(null);
}
if (type.Assembly == typeof(DashboardEntity).Assembly)
{
var name = type.Namespace.Replace("Signum.Entities.", "");
name = (name.TryBefore('.') ?? name);
if (name == "SMS")
{
return("sms");
}
if (name == "Authorization")
{
return("auth");
}
return(name.FirstLower());
}
if (type.Assembly == typeof(Entity).Assembly)
{
return("framework");
}
throw new InvalidOperationException("Impossible to determine SchemaName for {0}".FormatWith(type.FullName));
}
public static OperationMapInfo GetOperationMapInfo(Type type)
{
var operations = OperationLogic.TypeOperationsAndConstructors(type);
var stateTypes = operations.Select(a => a.StateType).Distinct().NotNull().PreAnd(typeof(DefaultState)).ToList();
Dictionary <Type, LambdaExpression> expressions = stateTypes
.ToDictionary(t => t, t => type == typeof(DefaultState) ? null : giGetGraphGetter.GetInvoker(type, t)());
Dictionary <Type, Dictionary <Enum, int> > counts = expressions.SelectDictionary(t => t.UnNullify(), exp =>
exp == null ? giCount.GetInvoker(type)() :
giCountGroupBy.GetInvoker(type, exp.Body.Type)(exp));
Dictionary <Type, string> tokens = expressions.SelectDictionary(t => t.UnNullify(), exp => exp == null ? null : GetToken(exp));
var symbols = operations.Select(a => a.OperationSymbol).ToList();
var operationCounts = Database.Query <OperationLogEntity>()
.Where(log => symbols.Contains(log.Operation))
.GroupBy(log => log.Operation)
.Select(a => KVP.Create(a.Key, a.Count()))
.ToDictionary();
return(new OperationMapInfo
{
states = (from t in stateTypes
from e in Enum.GetValues(t.UnNullify()).Cast <Enum>()
let ignored = e.GetType().GetField(e.ToString(), BindingFlags.Static | BindingFlags.Public).HasAttribute <IgnoreAttribute>()
select new MapState
{
count = counts.GetOrThrow(e.GetType()).TryGet(e, 0),
ignored = ignored,
key = e.ToString(),
niceName = e.NiceToString(),
isSpecial = t == typeof(DefaultState),
color = Engine.Chart.ChartColorLogic.ColorFor(EnumEntity.FromEnumUntyped(e)).TryToHtml(),
token = tokens.GetOrThrow(e.GetType()),
}).ToList(),
operations = (from o in operations
select new MapOperation
{
niceName = o.OperationSymbol.NiceToString(),
key = o.OperationSymbol.Key,
count = operationCounts.TryGet(o.OperationSymbol, 0),
fromStates = WithDefaultStateArray(o.UntypedFromStates, DefaultState.Start).Select(a => a.ToString()).ToArray(),
toStates = WithDefaultStateArray(o.UntypedToStates, DefaultState.End).Select(a => a.ToString()).ToArray(),
}).ToList()
});
}
public static bool EnumChoose(out EnumEntity enumEntity)
{
bool result = false;
enumEntity = null;
using (FormEnumChoose view = new FormEnumChoose())
{
if (view.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
enumEntity = view.SelectedEnumEntity;
result = true;
}
}
return(result);
}
public TypeCaches(Schema current)
{
TypeToEntity = EnumerableExtensions.JoinRelaxed(
Database.RetrieveAll <TypeEntity>(),
current.Tables.Keys,
t => t.FullClassName,
t => (EnumEntity.Extract(t) ?? t).FullName,
(typeEntity, type) => new { typeEntity, type },
"caching {0}".FormatWith(current.Table(typeof(TypeEntity)).Name)
).ToDictionary(a => a.type, a => a.typeEntity);
EntityToType = TypeToEntity.Inverse();
TypeToId = TypeToEntity.SelectDictionary(k => k, v => v.Id);
IdToType = TypeToId.Inverse();
}
static Type GetEntityType(string typeStr, Type objectType)
{
var type = ReflectionServer.TypesByName.Value.GetOrThrow(typeStr);
if (type.IsEnum)
{
type = EnumEntity.Generate(type);
}
if (!objectType.IsAssignableFrom(type))
{
throw new JsonSerializationException($"Type '{type.Name}' is not assignable to '{objectType.TypeName()}'");
}
return(type);
}
/// <summary>
/// 获取枚举列表
/// </summary>
/// <returns></returns>
public List <EnumEntity> GetEnumEntityList()
{
XElement[] entityElements = _indexXml.XPathSelectElements(XPATH_Index_Dictionary_Entity).ToArray();
List <EnumEntity> list = new List <EnumEntity>();
foreach (XElement element in entityElements)
{
EnumEntity entity = GetEnumEntity(element.Attribute("Id").Value);
if (entity != null)
{
list.Add(entity);
}
}
return(list);
}
public TypeHelpTS GetTypeHelp(string typeName, TypeHelpMode mode)
{
Type type = TypeLogic.TryGetType(typeName);
if (type == null)
{
return(null);
}
var isEnum = EnumEntity.IsEnumEntity(type);
var members = new List <TypeMemberHelpTS>();
if (isEnum)
{
var enumType = EnumEntity.Extract(type);
var values = EnumEntity.GetValues(enumType).ToList();
members.AddRange(values.Select(ev => new TypeMemberHelpTS(ev)));
}
else
{
var routes = PropertyRoute.GenerateRoutes(type);
var root = TreeHelper.ToTreeC(routes, a => a.Parent).SingleEx();
members = root.Children
.Where(a => mode == TypeHelpMode.CSharp || ReflectionServer.InTypeScript(a.Value))
.Select(pr => new TypeMemberHelpTS(pr, mode)).ToList();
if (mode == TypeHelpMode.CSharp)
{
var expressions = DynamicQueryManager.Current.RegisteredExtensions.GetValue(type);
members.AddRange(expressions.Values.Select(ex => new TypeMemberHelpTS(ex)));
}
}
return(new TypeHelpTS
{
type = (isEnum ? EnumEntity.Extract(type).Name : type.Name),
cleanTypeName = typeName,
isEnum = isEnum,
members = members
});
}
public TypeMemberHelpTS(Node <PropertyRoute> node, TypeHelpMode mode)
{
var pr = node.Value;
this.propertyString = pr.PropertyString();
this.name = mode == TypeHelpMode.Typescript ?
pr.PropertyInfo?.Name.FirstLower() :
pr.PropertyInfo?.Name;
this.type = mode == TypeHelpMode.Typescript && ReflectionServer.IsId(pr) ?
PrimaryKey.Type(pr.RootType).Nullify().TypeName():
pr.Type.TypeName();
this.isExpression = false;
this.isEnum = pr.Type.UnNullify().IsEnum;
this.cleanTypeName = GetCleanTypeName(pr.Type.UnNullify().IsEnum ? EnumEntity.Generate(pr.Type.UnNullify()) : pr.Type);
this.subMembers = node.Children.Select(a => new TypeMemberHelpTS(a, mode)).ToList();
}
public virtual string GenerateMListFieldName(PropertyRoute route, KindOfField kindOfField)
{
Type type = Lite.Extract(route.Type) ?? route.Type;
switch (kindOfField)
{
case KindOfField.Value:
case KindOfField.Embedded:
return(type.Name.FirstUpper());
case KindOfField.Enum:
case KindOfField.Reference:
return((EnumEntity.Extract(type)?.Name ?? Reflector.CleanTypeName(type)) + "ID");
default:
throw new InvalidOperationException("No field name for type {0} defined".FormatWith(type));
}
}
protected virtual FieldEnum GenerateFieldEnum(ITable table, PropertyRoute route, NameSequence name, bool forceNull)
{
var att = Settings.FieldAttribute <SqlDbTypeAttribute>(route);
Type cleanEnum = route.Type.UnNullify();
var referenceTable = Include(EnumEntity.Generate(cleanEnum), route);
return(new FieldEnum(route.Type)
{
Name = name.ToString(),
Nullable = Settings.IsNullable(route, forceNull),
IsLite = false,
ReferenceTable = referenceTable,
AvoidForeignKey = Settings.FieldAttribute <AvoidForeignKeyAttribute>(route) != null,
Default = att?.Default,
}.Do(f => f.UniqueIndex = f.GenerateUniqueIndex(table, Settings.FieldAttribute <UniqueIndexAttribute>(route))));
}
public void SerializeDateTime()
{
// Verify that Enum values with the [Flags] attribute serialize correctly.
var converter = new JsonDataConverter();
byte[] contents;
string json;
var enumValue = new EnumEntity()
{
Gender = Gender.Male
};
contents = converter.ToData(enumValue);
json = Encoding.UTF8.GetString(contents);
Assert.Equal("{\"Gender\":\"male\"}", json);
}
//public static string ToEnumDesc(this string Name,Type type)
//{
// return ((Enum)Enum.Parse(type.GetType(), Name)).ToDescription();
//}
/// <summary>
/// 将枚举转换成list
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static List <EnumEntity> EnumToList <T>()
{
List <EnumEntity> list = new List <EnumEntity>();
foreach (var e in Enum.GetValues(typeof(T)))
{
EnumEntity m = new EnumEntity();
object[] objArr = e.GetType().GetField(e.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), true);
if (objArr != null && objArr.Length > 0)
{
DescriptionAttribute da = objArr[0] as DescriptionAttribute;
m.Description = da.Description;
}
m.EnumValue = Convert.ToInt32(e);
m.EnumName = e.ToString();
list.Add(m);
}
return(list);
}
private string EnumToString(EnumEntity entity, int tableNum)
{
StringBuilder sb = new StringBuilder();
sb.NewLine(tableNum);
sb.AppendFormat("public enum {0}", entity.Name.Value);
sb.NewLine(tableNum).Append('{');
foreach (var field in entity.Fields)
{
sb.NewLine(tableNum + 1).Append(field.Name.Value);
if (field.Value != null)
{
sb.Append(" = ").Append(field.Value.Value);
}
sb.Append(',');
}
sb.NewLine(tableNum).Append('}');
sb.NewLine();
return(sb.ToString());
}
public System.Web.WebPages.HelperResult ColorLink(TypeContext tc, Type type)
{
#line default
#line hidden
return(new System.Web.WebPages.HelperResult(__razor_helper_writer => {
#line 15 "..\..\Chart\Views\ChartColumn.cshtml"
var identType = type.IsEnum ? EnumEntity.Generate(type) : type;
#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, " <div");
WriteLiteralTo(__razor_helper_writer, " class=\"col-sm-4\"");
WriteLiteralTo(__razor_helper_writer, ">\r\n");
WriteLiteralTo(__razor_helper_writer, " ");
#line 18 "..\..\Chart\Views\ChartColumn.cshtml"
WriteTo(__razor_helper_writer, Html.FormGroup(tc, null, ChartMessage.ColorsFor0.NiceToString().FormatWith(type.NiceName()),
Html.ActionLink(Signum.Engine.Chart.ChartColorLogic.Colors.Value.ContainsKey(identType) ? ChartMessage.ViewPalette.NiceToString() : ChartMessage.CreatePalette.NiceToString(),
(ColorChartController cc) => cc.Colors(Navigator.ResolveWebTypeName(identType)), new { @class = "form-control" })));
#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "\r\n </div>\r\n");
#line 22 "..\..\Chart\Views\ChartColumn.cshtml"
#line default
#line hidden
}));
#line 22 "..\..\Chart\Views\ChartColumn.cshtml"
}
protected virtual ValueTuple[]? SugestedValues(QueryToken queryToken)
{
var ft = QueryUtils.GetFilterType(queryToken.Type);
switch (ft)
{
case FilterType.Integer:
case FilterType.Decimal: return(new[] { new ValueTuple {
Value = Activator.CreateInstance(queryToken.Type.UnNullify()), Match = null
} });
case FilterType.String: return(new[] { new ValueTuple {
Value = "", Match = null
} });
case FilterType.DateTime: return(new[] { new ValueTuple {
Value = DateTime.Today, Match = null
} });
case FilterType.Time: return(new[] { new ValueTuple {
Value = TimeSpan.Zero, Match = null
} });
case FilterType.Lite:
case FilterType.Embedded: break;
case FilterType.Boolean: return(new[] { new ValueTuple {
Value = true, Match = null
}, new ValueTuple {
Value = false, Match = null
} });
case FilterType.Enum: return(EnumEntity.GetValues(queryToken.Type.UnNullify()).Select(e => new ValueTuple {
Value = e, Match = null
}).ToArray());
case FilterType.Guid: break;
}
return(null);
}
public ForeignKeyException(Exception inner) : base(null, inner)
{
Match m = indexRegex.Match(inner.Message);
if (m.Success)
{
var parts = m.Groups["parts"].Value.Split("_");
for (int i = 1; i < parts.Length; i++)
{
TableName = parts.Take(i).ToString("_");
ColumnName = parts.Skip(i).ToString("_");
TableType = Schema.Current.Tables
.Where(kvp => kvp.Value.Name.Name == TableName)
.Select(p => p.Key)
.SingleOrDefaultEx();
if (TableType != null)
{
break;
}
}
}
if (inner.Message.Contains("INSERT") || inner.Message.Contains("UPDATE"))
{
IsInsert = true;
Match m2 = referedTable.Match(inner.Message);
if (m2.Success)
{
ReferedTableName = m2.Groups["referedTable"].Value.Split('.').Last();
ReferedTableType = Schema.Current.Tables
.Where(kvp => kvp.Value.Name.Name == ReferedTableName)
.Select(p => p.Key)
.SingleOrDefaultEx();
ReferedTableType = ReferedTableType == null ? null : EnumEntity.Extract(ReferedTableType) ?? ReferedTableType;
}
}
}
public virtual Type ResolveType(string typeStr, Type objectType)
{
if (objectType.Name == typeStr || Reflector.CleanTypeName(objectType) == typeStr)
{
return(objectType);
}
var type = TypeLogic.GetType(typeStr);
if (type.IsEnum)
{
type = EnumEntity.Generate(type);
}
if (!objectType.IsAssignableFrom(type))
{
throw new JsonException($"Type '{type.Name}' is not assignable to '{objectType.TypeName()}'");
}
return(type);
}
/// <summary>
/// 枚举转List
/// </summary>
/// <typeparam name="T">枚举对象</typeparam>
/// <returns></returns>
public List <EnumEntity> EnumToList <T>()
{
var list = new List <EnumEntity>();
foreach (var e in Enum.GetValues(typeof(T)))
{
var model = new EnumEntity();
var objArr = e.GetType().GetField(e.ToString()).GetCustomAttributes(typeof(DescriptionAttribute), true);
if (objArr.Length > 0)
{
var da = objArr[0] as DescriptionAttribute;
if (da != null)
{
model.Description = da.Description;
}
}
model.EnumValue = Convert.ToInt32(e);
model.EnumName = e.ToString();
list.Add(model);
}
return(list);
}
public static IEnumerable<EnumEntity> GetList(Type enumType)
{
if (enumType.IsGenericType && enumType.GetGenericTypeDefinition() == typeof(Nullable<>))
enumType = Nullable.GetUnderlyingType(enumType);
var list = new List<EnumEntity>();
FieldInfo[] fields = enumType.GetFields();
foreach (FieldInfo field in fields)
{
if (!field.FieldType.IsEnum)
continue; ;
var disply = field.GetCustomAttributes(true).OfType<DisplayAttribute>().FirstOrDefault();
var enumText = field.GetValue(null).ToString();
int key = Convert.ToInt32(Enum.Parse(enumType, enumText, true));
if (disply != null)
{
enumText = disply.Name;
}
var entity = new EnumEntity() { Value = key, Name = field.Name, Text = enumText };
list.Add(entity);
}
return list;
}
public void CheckEventHappen()
{
var check = new EnumEntity();
var result1 = check.CheckEventHappen(new DateTime(2018, 5, 14), "1,3");
var result2 = check.CheckEventHappen(new DateTime(2018, 5, 15), "3,4");
var result3 = check.CheckEventHappen(new DateTime(2018, 5, 16), "1,2,3");
var result4 = check.CheckEventHappen(new DateTime(2018, 5, 17), "1,2,3");
var result5 = check.CheckEventHappen(new DateTime(2018, 5, 18), "1,3");
var result6 = check.CheckEventHappen(new DateTime(2018, 5, 19), "4,5");
var result0 = check.CheckEventHappen(new DateTime(2018, 5, 20), "4,0");
var result7 = check.CheckEventHappen(new DateTime(2018, 5, 21), "1");
var result8 = check.CheckEventHappen(new DateTime(2018, 5, 20), "");
Assert.IsTrue(result0);
Assert.IsTrue(result1);
Assert.IsTrue(!result2);
Assert.IsTrue(result3);
Assert.IsTrue(result7);
Assert.IsTrue(result8);
Assert.IsTrue(!result4);
Assert.IsTrue(!result5);
Assert.IsTrue(!result6);
}
internal protected virtual Table Include(Type type, PropertyRoute route)
{
if (schema.Tables.TryGetValue(type, out Table result))
{
return(result);
}
using (HeavyProfiler.LogNoStackTrace("Include", () => type.TypeName()))
{
if (type.IsAbstract)
{
throw new InvalidOperationException(route?.Let(r => "Error on field {0}: ".FormatWith(r)) + "Impossible to include in the Schema the type {0} because is abstract".FormatWith(type));
}
if (!Reflector.IsEntity(type))
{
throw new InvalidOperationException(route?.Let(r => "Error on field {0}: ".FormatWith(r)) + "Impossible to include in the Schema the type {0} because is not and Entity".FormatWith(type));
}
foreach (var t in type.Follow(a => a.BaseType))
{
if (!t.IsSerializable)
{
throw new InvalidOperationException("Type {0} is not marked as serializable".FormatWith(t.TypeName()));
}
}
string name = schema.Settings.desambiguatedNames?.TryGetC(type) ?? Reflector.CleanTypeName(EnumEntity.Extract(type) ?? type);
if (schema.NameToType.ContainsKey(name))
{
throw new InvalidOperationException(route?.Let(r => "Error on field {0}: ".FormatWith(r)) + "Two types have the same cleanName, desambiguate using Schema.Current.Settings.Desambiguate method: \r\n {0}\r\n {1}".FormatWith(schema.NameToType[name].FullName, type.FullName));
}
try
{
result = new Table(type);
schema.Tables.Add(type, result);
schema.NameToType[name] = type;
schema.TypeToName[type] = name;
Complete(result);
return(result);
}
catch (Exception) //Avoid half-cooked tables
{
schema.Tables.Remove(type);
schema.NameToType.Remove(name);
schema.TypeToName.Remove(type);
throw;
}
}
}
public static string GetKey(object queryName)
{
return(queryName is Type t?Reflector.CleanTypeName(EnumEntity.Extract(t) ?? t) :
queryName.ToString() !);
}
static SqlPreCommand SynchronizeEnumsScript(Replacements replacements)
{
Schema schema = Schema.Current;
List <SqlPreCommand> commands = new List <SqlPreCommand>();
foreach (var table in schema.Tables.Values)
{
Type enumType = EnumEntity.Extract(table.Type);
if (enumType != null)
{
IEnumerable <Entity> should = EnumEntity.GetEntities(enumType);
Dictionary <string, Entity> shouldByName = should.ToDictionary(a => a.ToString());
List <Entity> current = Administrator.TryRetrieveAll(table.Type, replacements);
Dictionary <string, Entity> currentByName = current.ToDictionaryEx(a => a.toStr, table.Name.Name);
string key = Replacements.KeyEnumsForTable(table.Name.Name);
replacements.AskForReplacements(currentByName.Keys.ToHashSet(), shouldByName.Keys.ToHashSet(), key);
currentByName = replacements.ApplyReplacementsToOld(currentByName, key);
var mix = shouldByName.JoinDictionary(currentByName, (n, s, c) => new { s, c }).Where(a => a.Value.s.id != a.Value.c.id).ToDictionary();
HashSet <PrimaryKey> usedIds = current.Select(a => a.Id).ToHashSet();
Dictionary <string, Entity> middleByName = mix.Where(kvp => usedIds.Contains(kvp.Value.s.Id)).ToDictionary(kvp => kvp.Key, kvp => Clone(kvp.Value.c));
if (middleByName.Any())
{
var moveToAux = SyncEnums(schema, table,
currentByName.Where(a => middleByName.ContainsKey(a.Key)).ToDictionary(),
middleByName);
if (moveToAux != null)
{
commands.Add(moveToAux);
}
}
var com = SyncEnums(schema, table,
currentByName.Where(a => !middleByName.ContainsKey(a.Key)).ToDictionary(),
shouldByName.Where(a => !middleByName.ContainsKey(a.Key)).ToDictionary());
if (com != null)
{
commands.Add(com);
}
if (middleByName.Any())
{
var backFromAux = SyncEnums(schema, table,
middleByName,
shouldByName.Where(a => middleByName.ContainsKey(a.Key)).ToDictionary());
if (backFromAux != null)
{
commands.Add(backFromAux);
}
}
}
}
return(SqlPreCommand.Combine(Spacing.Double, commands.ToArray()));
}
public override EnumItemEntity CreateEnumItemEntity(EnumEntity owner)
{
return(new EnumItemEntityDev(owner));
}
public static void ShowEntity(this EntityComponent entityComponent, int serialId, EnumEntity enumEntity, Type logicType, object userData = null)
{
entityComponent.ShowEntity(serialId, (int)enumEntity, logicType, userData);
}
public static Control GetValueControl(QueryToken token, string bindingPath)
{
Type type = token.Type;
if (type.IsLite())
{
Implementations implementations = token.GetImplementations().Value;
Type cleanType = Lite.Extract(type);
if (EntityKindCache.IsLowPopulation(cleanType) && !implementations.IsByAll)
{
EntityCombo ec = new EntityCombo
{
Type = type,
Implementations = implementations,
};
ec.SetBinding(EntityCombo.EntityProperty, new Binding
{
Path = new PropertyPath(bindingPath),
NotifyOnValidationError = true,
ValidatesOnDataErrors = true,
ValidatesOnExceptions = true,
});
return(ec);
}
else
{
EntityLine el = new EntityLine
{
Type = type,
Create = false,
Implementations = implementations,
};
el.SetBinding(EntityLine.EntityProperty, new Binding
{
Path = new PropertyPath(bindingPath),
NotifyOnValidationError = true,
ValidatesOnDataErrors = true,
ValidatesOnExceptions = true
});
return(el);
}
}
else if (type.IsEmbeddedEntity())
{
EntityLine el = new EntityLine
{
Type = type,
Create = false,
Autocomplete = false,
Find = false,
Implementations = null,
};
el.SetBinding(EntityLine.EntityProperty, new Binding
{
Path = new PropertyPath(bindingPath),
NotifyOnValidationError = true,
ValidatesOnDataErrors = true,
ValidatesOnExceptions = true
});
return(el);
}
else
{
ValueLine vl = new ValueLine()
{
Type = type,
Format = token.Format,
UnitText = token.Unit,
};
if (type.UnNullify().IsEnum)
{
vl.ItemSource = EnumEntity.GetValues(type.UnNullify()).PreAndNull(type.IsNullable()).ToObservableCollection();
}
vl.SetBinding(ValueLine.ValueProperty, new Binding
{
Path = new PropertyPath(bindingPath), //odd
NotifyOnValidationError = true,
ValidatesOnDataErrors = true,
ValidatesOnExceptions = true,
Converter = Reflector.IsNumber(type) ? Converters.Identity : null,
});
return(vl);
}
}
