private static void WriteItem <T>(T item, NodeReference node)
{
var entityType = item.GetType();
if (EntityTypeDescriptor.IsSimpleType(entityType))
{
if (item != null)
{
node.Set(item.ToString());
}
}
else if (EntityTypeDescriptor.IsSimpleNullableType(entityType))
{
node.Set(item != null ? item.ToString() : null);
}
else if (EntityTypeDescriptor.IsArrayType(entityType))
{
WriteArray(node, item as Array);
}
else if (EntityTypeDescriptor.IsSupportedEnumerable(entityType))
{
var items = item as IEnumerable;
if (items != null)
{
WriteEnumerable(node, items);
}
}
else
{
WriteComplexEntity(item, node);
}
}
internal static void ValidateDefinitionAndThrow(Type entityType)
{
if (!entityType.IsVisible)
{
throw new EntityValidationException(
string.Format("Class <{0}> must be visible from current assembly. Declare class as public ",
entityType.Name));
}
var typeDescription = EntityTypeDescriptor.GetTypeDescription(entityType);
if (!typeDescription.AllKeys.Any())
{
throw new EntityValidationException(
string.Format(
"Entity <{0}> must declare at least one primary key with <IsPrimaryKey> property of <Column> attribute",
entityType.Name));
}
if (typeDescription.IdentityKeys.Any(k => !IsIdentitySupportedType(k.ColumnInfo.PropertyType)))
{
throw new EntityValidationException(
"Only integral types (short, int or long) supported as DbGenerated column");
}
if (typeDescription.IdentityKeys.Count() > 1)
{
throw new EntityValidationException("Only one DbGenerated column is allowed");
}
if (typeDescription.IdentityKeys.Any() && typeDescription.CustomKeys.Any())
{
throw new EntityValidationException("Either DbGenerated primary key or custom primary keys are allowed");
}
}
private static object ConvertValue(object value, Type columnType)
{
if (value == null)
{
return(null);
}
if (columnType.IsEnum)
{
return(Enum.Parse(columnType, value.ToString()));
}
if (columnType == typeof(DateTime))
{
return(DateTime.Parse(value.ToString()));
}
if (columnType == typeof(DateTimeOffset))
{
return(DateTimeOffset.Parse(value.ToString()));
}
if (EntityTypeDescriptor.IsNullableType(columnType))
{
return(Convert.ChangeType(value, Nullable.GetUnderlyingType(columnType)));
}
return(Convert.ChangeType(value, columnType));
}
private void HookScriptTriggers(Script script)
{
foreach (ScriptTrigger scriptTrigger in script.Triggers)
{
ScriptTrigger triggerCopy = scriptTrigger;
EntityTypeDescriptor entityTypeDescriptor = EntityTypes.Types[scriptTrigger.Object.Type];
EventDescriptor eventDescriptor = entityTypeDescriptor.Events[scriptTrigger.Event];
if (entityTypeDescriptor.Static)
{
Action action = (Action)(() => this.ProcessTrigger(triggerCopy, script));
object obj = eventDescriptor.AddHandler((object)this.services[scriptTrigger.Object.Type], new object[1]
{
(object)action
});
}
else
{
Action <int> action = (Action <int>)(id => this.ProcessTrigger(triggerCopy, script, new int?(id)));
object obj = eventDescriptor.AddHandler((object)this.services[scriptTrigger.Object.Type], new object[1]
{
(object)action
});
}
}
}
private static string SerializeColumnToString <T>(T column)
{
if (column == null)
{
return("null");
}
var columnType = column.GetType();
var result = new StringBuilder();
if (EntityTypeDescriptor.IsSimpleType(columnType) || EntityTypeDescriptor.IsNullableType(columnType))
{
result.Append(column);
}
else if (EntityTypeDescriptor.IsSupportedEnumerable(columnType))
{
var enumerable = column as IEnumerable;
foreach (var item in enumerable)
{
result.AppendFormat("{0},", SerializeColumnToString(item));
}
}
else
{
var typeDescription = EntityTypeDescriptor.GetTypeDescription(columnType);
foreach (var item in typeDescription.Columns)
{
result.AppendFormat("{0}={1}\n", item.ColumnAttribute.Name ?? item.ColumnInfo.Name,
SerializeColumnToString(item.ColumnInfo.GetValue(column, null)));
}
}
return(result.ToString());
}
private static void AppendPrimaryKey <TEntity>(TEntity entity, NodeReference node)
{
var typeDescription = EntityTypeDescriptor.GetTypeDescription(entity.GetType());
var identityKeys = typeDescription.IdentityKeys;
if (identityKeys.Any())
{
//according to the validation rules
var identityKey = identityKeys.Single();
var newSeed = IncrementIdentity(node);
var propertyType = identityKey.ColumnInfo.PropertyType;
propertyType = !EntityTypeDescriptor.IsNullableType(propertyType)
? propertyType
: Nullable.GetUnderlyingType(propertyType);
var correctValue = Convert.ChangeType(newSeed, propertyType);
identityKey.ColumnInfo.SetValue(entity, correctValue, null);
node.AppendSubscript(newSeed);
}
else
{
var hash = PrimaryKeyCalculator.GetPrimaryKey(entity);
if (IsKeyExists(hash, node))
{
throw new GlobalsDbException("Violation of Primary Key constraint. Cannot insert duplicate key");
}
node.SetSubscriptCount(0);
node.AppendSubscript(hash);
}
}
private static void WriteComplexEntity <TEntity>(TEntity entity, NodeReference node)
{
if (entity == null)
{
return;
}
var entityType = entity.GetType();
var underlyingType = EntityTypeDescriptor.IsNullableType(entityType)
? Nullable.GetUnderlyingType(entityType)
: entityType;
var columns = EntityTypeDescriptor.GetTypeDescription(underlyingType).Columns;
foreach (var column in columns)
{
node.AppendSubscript(column.ColumnAttribute.Name ?? column.ColumnInfo.Name);
if (column.IsSimpleColumn)
{
var value = column.ColumnInfo.GetValue(entity, null);
if (value != null)
{
if (column.IsNullableColumn)
{
node.Set(value != null ? value.ToString() : null);
}
else
{
node.Set(value.ToString());
}
}
}
else if (column.IsArrayColumn)
{
var array = column.ColumnInfo.GetValue(entity, null) as Array;
WriteArray(node, array);
}
else if (column.IsEnumerableColumn)
{
var items = column.ColumnInfo.GetValue(entity, null) as IEnumerable;
if (items != null)
{
WriteEnumerable(node, items);
}
}
else
{
WriteComplexEntity(column.ColumnInfo.GetValue(entity, null), node);
}
node.SetSubscriptCount(node.GetSubscriptCount() - 1);
}
}
private static IEnumerable <EntityTypeDescriptor> CollectEntityTypes(
ClientModel model,
IMapperContext context)
{
var entityTypes = new Dictionary <NameString, HashSet <NameString> >();
var descriptions = new Dictionary <NameString, string?>();
foreach (OperationModel operation in model.Operations)
{
foreach (var outputType in operation.OutputTypes.Where(t => !t.IsInterface))
{
INamedType namedType = outputType.Type.NamedType();
descriptions[namedType.Name] = outputType.Description;
if (outputType.Type.NamedType().IsEntity())
{
if (!entityTypes.TryGetValue(
namedType.Name,
out HashSet <NameString>?components))
{
components = new HashSet <NameString>();
entityTypes.Add(namedType.Name, components);
}
components.Add(outputType.Name);
}
}
}
foreach (KeyValuePair <NameString, HashSet <NameString> > entityType in entityTypes)
{
RuntimeTypeInfo runtimeType =
CreateEntityType(entityType.Key, context.Namespace);
descriptions.TryGetValue(entityType.Key, out var description);
var possibleTypes = entityType.Value
.Select(name => context.Types.Single(t => t.RuntimeType.Name.Equals(name)))
.OfType <ComplexTypeDescriptor>()
.ToList();
var entityTypeDescriptor = new EntityTypeDescriptor(
entityType.Key,
runtimeType,
possibleTypes,
description);
foreach (var type in possibleTypes.OfType <ObjectTypeDescriptor>())
{
type.CompleteEntityType(entityTypeDescriptor);
}
yield return(entityTypeDescriptor);
}
}
private DbSet(DataContext context)
{
Context = context;
_dbSetName = typeof(TEntity).Name;
var dbSetAttribute = EntityTypeDescriptor.GetTypeDescription(typeof(TEntity)).DbSetAttribute;
if (dbSetAttribute != null)
{
_dbSetName = dbSetAttribute.Name ?? _dbSetName;
}
}
private static object ReadComplexNode(NodeReference node, Type objectType)
{
var isNullable = EntityTypeDescriptor.IsNullableType(objectType);
if (isNullable && IsNullableComplexColumnEmpty(node))
{
return(null);
}
var underlyingType = !isNullable
? objectType
: Nullable.GetUnderlyingType(objectType);
var typeDescription = EntityTypeDescriptor.GetTypeDescription(underlyingType);
var instance = InstanceCreator.CreateInstance(underlyingType);
foreach (var column in typeDescription.Columns)
{
var subscript = column.ColumnAttribute.Name ?? column.ColumnInfo.Name;
if (column.IsSimpleColumn)
{
node.AppendSubscript(subscript);
var nodeValue = node.GetObject();
column.ColumnInfo.SetValue(instance, ConvertValue(nodeValue, column.ColumnInfo.PropertyType), null);
}
else if (column.IsArrayColumn)
{
node.AppendSubscript(subscript);
column.ColumnInfo.SetValue(instance, ReadArray(node, column.ColumnInfo.PropertyType), null);
}
else if (column.IsEnumerableColumn)
{
node.AppendSubscript(subscript);
column.ColumnInfo.SetValue(instance, ReadEnumerable(node, column.ColumnInfo.PropertyType), null);
}
else if (column.IsComplexColumn)
{
node.AppendSubscript(subscript);
column.ColumnInfo.SetValue(instance,
ReadComplexNode(node, column.ColumnInfo.PropertyType), null);
}
node.SetSubscriptCount(node.GetSubscriptCount() - 1);
}
return(instance);
}
private static object PerformBinaryOperation(object left, Type leftDataType, object right,
Type rightDataType, ExpressionType nodeType)
{
var leftNode = left as NodeReference;
var rightNode = right as NodeReference;
var leftData = (leftNode == null) ? left : DatabaseManager.ReadNode(leftNode, leftDataType);
var rightData = (rightNode == null) ? right : DatabaseManager.ReadNode(rightNode, rightDataType);
if ((EntityTypeDescriptor.IsNullableType(leftDataType) || EntityTypeDescriptor.IsNullableType(rightDataType)) &&
(leftData == null || rightData == null))
{
return(ResolveNullableOperation(leftData, rightData, nodeType));
}
return(BinaryOperationHandler[nodeType](leftData, rightData));
}
public static string GetPrimaryKey <TEntity>(TEntity entity)
{
var typeDescription = EntityTypeDescriptor.GetTypeDescription(entity.GetType());
var identityKeys = typeDescription.IdentityKeys;
if (identityKeys.Any())
{
//according to the validation rules
return(identityKeys.Single().ColumnInfo.GetValue(entity, null).ToString());
}
var primaryKeys = new NameValueCollection();
foreach (var key in typeDescription.CustomKeys)
{
primaryKeys.Add(key.ColumnAttribute.Name ?? key.ColumnInfo.Name, SerializeColumnToString(key.ColumnInfo.GetValue(entity, null)));
}
return(CryptoProvider.CalculatePrimaryKeyHash(primaryKeys));
}
private static Type ResolveParameterType(Type type, Type parentType)
{
if (EntityTypeDescriptor.IsNullableType(type))
{
return(type);
}
if (type == typeof(IQueryable))
{
return(parentType.GetGenericArguments().First());
}
var genericArguments = type.GetGenericArguments();
if (genericArguments.Length == 1)
{
return(genericArguments.Single());
}
return(type);
}
private static object ResolveColumn(ColumnAttribute columnAttribute, MemberExpression expression, IEnumerable <NodeReference> references)
{
if (columnAttribute != null)
{
foreach (var nodeReference in references)
{
nodeReference.AppendSubscript(columnAttribute.Name ?? expression.Member.Name);
}
return(references);
}
if (EntityTypeDescriptor.IsSupportedEnumerable(expression.Expression.Type) && expression.Member.Name == "Count")
{
var result = references.Select(DatabaseManager.GetEnumerableCount).ToList();
return(result);
}
if (EntityTypeDescriptor.IsArrayType(expression.Expression.Type) && expression.Member.Name == "Length")
{
var result = references.Select(DatabaseManager.GetEnumerableCount).ToList();
return(result);
}
if (EntityTypeDescriptor.IsArrayType(expression.Expression.Type) && expression.Member.Name == "LongLength")
{
var result = references.Select(DatabaseManager.GetEnumerableCount).ToList();
return(result);
}
if (EntityTypeDescriptor.IsNullableType(expression.Expression.Type) && expression.Member.Name == "Value")
{
return(references);
}
var parentType = expression.Expression.Type;
var data = DatabaseManager.ReadNodes(references, parentType) as IEnumerable;
return(ProcessLoadedEntityMembers(data, expression));
}
internal static object ReadNode(NodeReference node, Type elementType)
{
object instance;
if (EntityTypeDescriptor.IsSimpleType(elementType) || EntityTypeDescriptor.IsSimpleNullableType(elementType))
{
var nodeValue = node.GetObject();
instance = ConvertValue(nodeValue, elementType);
}
else if (EntityTypeDescriptor.IsArrayType(elementType))
{
instance = ReadArray(node, elementType);
}
else if (EntityTypeDescriptor.IsSupportedEnumerable(elementType))
{
instance = ReadEnumerable(node, elementType);
}
else
{
instance = ReadComplexNode(node, elementType);
}
return(instance);
}
private void ProcessTrigger(ScriptTrigger trigger, Script script, int?id)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: variable of a compiler-generated type
ScriptingHost.\u003C\u003Ec__DisplayClass11 cDisplayClass11 = new ScriptingHost.\u003C\u003Ec__DisplayClass11();
// ISSUE: reference to a compiler-generated field
cDisplayClass11.trigger = trigger;
// ISSUE: reference to a compiler-generated field
cDisplayClass11.script = script;
// ISSUE: reference to a compiler-generated field
cDisplayClass11.\u003C\u003E4__this = this;
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
if (this.GameState.Loading && cDisplayClass11.trigger.Object.Type != "Level" && cDisplayClass11.trigger.Event != "Start" || cDisplayClass11.script.Disabled)
{
return;
}
int?nullable = id;
// ISSUE: reference to a compiler-generated field
int?identifier = cDisplayClass11.trigger.Object.Identifier;
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated method
if ((nullable.GetValueOrDefault() != identifier.GetValueOrDefault() ? 1 : (nullable.HasValue != identifier.HasValue ? 1 : 0)) != 0 || cDisplayClass11.script.Conditions != null && Enumerable.Any <ScriptCondition>((IEnumerable <ScriptCondition>)cDisplayClass11.script.Conditions, (Func <ScriptCondition, bool>)(c => !c.Check(this.services[c.Object.Type]))) || cDisplayClass11.script.OneTime && Enumerable.Any <ActiveScript>((IEnumerable <ActiveScript>) this.activeScripts, new Func <ActiveScript, bool>(cDisplayClass11.\u003CProcessTrigger\u003Eb__a)))
{
return;
}
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
cDisplayClass11.activeScript = new ActiveScript(cDisplayClass11.script, cDisplayClass11.trigger);
// ISSUE: reference to a compiler-generated field
this.activeScripts.Add(cDisplayClass11.activeScript);
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
if (cDisplayClass11.script.IsWinCondition && !this.GameState.SaveData.ThisLevel.FilledConditions.ScriptIds.Contains(cDisplayClass11.script.Id))
{
// ISSUE: reference to a compiler-generated field
this.GameState.SaveData.ThisLevel.FilledConditions.ScriptIds.Add(cDisplayClass11.script.Id);
this.GameState.SaveData.ThisLevel.FilledConditions.ScriptIds.Sort();
}
// ISSUE: reference to a compiler-generated field
foreach (ScriptAction scriptAction in cDisplayClass11.script.Actions)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: variable of a compiler-generated type
ScriptingHost.\u003C\u003Ec__DisplayClass13 cDisplayClass13 = new ScriptingHost.\u003C\u003Ec__DisplayClass13();
// ISSUE: reference to a compiler-generated field
cDisplayClass13.CS\u0024\u003C\u003E8__locals12 = cDisplayClass11;
// ISSUE: reference to a compiler-generated field
cDisplayClass13.runnableAction = new RunnableAction()
{
Action = scriptAction
};
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated method
cDisplayClass13.runnableAction.Invocation = new Func <object>(cDisplayClass13.\u003CProcessTrigger\u003Eb__b);
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
cDisplayClass11.activeScript.EnqueueAction(cDisplayClass13.runnableAction);
}
// ISSUE: reference to a compiler-generated field
if (!cDisplayClass11.script.IgnoreEndTriggers)
{
// ISSUE: reference to a compiler-generated field
foreach (ScriptTrigger scriptTrigger in cDisplayClass11.script.Triggers)
{
EntityTypeDescriptor entityTypeDescriptor = EntityTypes.Types[scriptTrigger.Object.Type];
DynamicMethodDelegate dynamicMethodDelegate = entityTypeDescriptor.Events[scriptTrigger.Event].AddEndTriggerHandler;
if (dynamicMethodDelegate != null)
{
if (entityTypeDescriptor.Static)
{
// ISSUE: reference to a compiler-generated method
Action action = new Action(cDisplayClass11.\u003CProcessTrigger\u003Eb__c);
// ISSUE: reference to a compiler-generated field
object obj = dynamicMethodDelegate((object)this.services[cDisplayClass11.trigger.Object.Type], new object[1]
{
(object)action
});
}
else
{
// ISSUE: reference to a compiler-generated method
Action <int> action = new Action <int>(cDisplayClass11.\u003CProcessTrigger\u003Eb__d);
// ISSUE: reference to a compiler-generated field
object obj = dynamicMethodDelegate((object)this.services[cDisplayClass11.trigger.Object.Type], new object[1]
{
(object)action
});
}
}
}
}
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated method
cDisplayClass11.activeScript.Disposed += new Action(cDisplayClass11.\u003CProcessTrigger\u003Eb__e);
}
internal static object GetDefaultValue(Type instanceType)
{
return(((!instanceType.IsValueType) || (EntityTypeDescriptor.IsNullableType(instanceType)))
? null
: CreateInstance(instanceType));
}
public void CompleteEntityType(EntityTypeDescriptor descriptor)
{
EntityTypeDescriptor = descriptor;
}
