public async Task Invoke(CRUDContext <TService> ctx)
{
IAuthorizer <TService> authorizer = ctx.ServiceContainer.GetAuthorizer();
RunTimeMetadata metadata = ctx.Service.GetMetadata();
foreach (DbSet dbSet in ctx.Request.dbSets)
{
//methods on domain service which are attempted to be executed by client (SaveChanges triggers their execution)
Dictionary <string, MethodInfoData> domainServiceMethods = new Dictionary <string, MethodInfoData>();
DbSetInfo dbInfo = metadata.DbSets[dbSet.dbSetName];
dbSet.rows.Aggregate <RowInfo, Dictionary <string, MethodInfoData> >(domainServiceMethods, (dict, rowInfo) =>
{
MethodInfoData method = rowInfo.GetCRUDMethodInfo(metadata, dbInfo.dbSetName);
if (method == null)
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_REC_CHANGETYPE_INVALID,
dbInfo.GetEntityType().Name, rowInfo.changeType));
}
string dicKey = string.Format("{0}:{1}", method.OwnerType.FullName, method.MethodInfo.Name);
if (!dict.ContainsKey(dicKey))
{
dict.Add(dicKey, method);
}
return(dict);
});
await authorizer.CheckUserRightsToExecute(domainServiceMethods.Values);
}
await _next(ctx);
}
public async Task UpdateEntity(RunTimeMetadata metadata, RowInfo rowInfo)
{
DbSetInfo dbSetInfo = rowInfo.GetDbSetInfo();
if (rowInfo.changeType != ChangeType.Updated)
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_REC_CHANGETYPE_INVALID,
dbSetInfo.GetEntityType().Name, rowInfo.changeType));
}
MethodInfoData methodData = metadata.GetOperationMethodInfo(dbSetInfo.dbSetName, MethodType.Update);
if (methodData == null)
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_DB_UPDATE_NOT_IMPLEMENTED,
dbSetInfo.GetEntityType().Name, GetType().Name));
}
object dbEntity = Activator.CreateInstance(dbSetInfo.GetEntityType());
UpdateEntityFromRowInfo(dbEntity, rowInfo, false);
object original = GetOriginalEntity(dbEntity, rowInfo);
rowInfo.GetChangeState().Entity = dbEntity;
rowInfo.GetChangeState().OriginalEntity = original;
object instance = GetMethodOwner(methodData);
//apply this changes to entity that is in the database (this is done in user domain service method)
object res = methodData.MethodInfo.Invoke(instance, new[] { dbEntity });
if (res is Task)
{
await(res as Task);
}
}
public void ApplyValues(object entity, RowInfo rowInfo, string path, ValueChange[] values, bool isOriginal)
{
DbSetInfo dbSetInfo = rowInfo.GetDbSetInfo();
Array.ForEach(values, val =>
{
string fullName = path + val.fieldName;
Field fieldInfo = _dataHelper.GetFieldInfo(dbSetInfo, fullName);
if (!fieldInfo.GetIsIncludeInResult())
{
return;
}
//Server Side calculated fields are never set on entities from updates
if (fieldInfo.fieldType == FieldType.ServerCalculated)
{
return;
}
if (fieldInfo.fieldType == FieldType.Object && val.nested != null)
{
ApplyValues(entity, rowInfo, fullName + '.', val.nested.ToArray(), isOriginal);
}
else
{
ApplyValue(entity, rowInfo, fullName, fieldInfo, val, isOriginal);
}
});
}
public async Task DeleteEntity(RunTimeMetadata metadata, RowInfo rowInfo)
{
DbSetInfo dbSetInfo = rowInfo.GetDbSetInfo();
if (rowInfo.changeType != ChangeType.Deleted)
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_REC_CHANGETYPE_INVALID,
dbSetInfo.GetEntityType().Name, rowInfo.changeType));
}
MethodInfoData methodData = metadata.GetOperationMethodInfo(dbSetInfo.dbSetName, MethodType.Delete);
if (methodData == null)
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_DB_DELETE_NOT_IMPLEMENTED,
dbSetInfo.GetEntityType().Name, GetType().Name));
}
object dbEntity = Activator.CreateInstance(dbSetInfo.GetEntityType());
UpdateEntityFromRowInfo(dbEntity, rowInfo, true);
rowInfo.GetChangeState().Entity = dbEntity;
rowInfo.GetChangeState().OriginalEntity = dbEntity;
object instance = GetMethodOwner(methodData);
object res = methodData.MethodInfo.Invoke(instance, new[] { dbEntity });
if (res is Task)
{
await(res as Task);
}
}
protected override DesignTimeMetadata GetDesignTimeMetadata(bool isDraft)
{
DesignTimeMetadata metadata = new DesignTimeMetadata();
IModel dbModel = DB.Model;
IEntityType[] allEntities = dbModel.GetEntityTypes().ToArray();
IEntityType[] plainEntities = allEntities.Where(t => !t.IsOwned()).ToArray();
Dictionary <string, IEntityType> ownedTypesMap = allEntities.Where(t => t.IsOwned()).ToDictionary(t => t.Name);
foreach (IEntityType entityInfo in plainEntities)
{
IEnumerable <IProperty> edmProps = entityInfo.GetProperties().Where(p => !p.IsShadowProperty()).ToArray();
// IEnumerable<string> edmProps1 = entityInfo.GetNavigations().Select(n => n.ForeignKey.DeclaringEntityType.Name).ToArray();
IEnumerable <INavigation> ownedTypes = entityInfo.GetNavigations().Where(n => ownedTypesMap.ContainsKey(n.ForeignKey.DeclaringEntityType.Name)).ToArray();
DbSetInfo dbSetInfo = new DbSetInfo
{
dbSetName = entityInfo.ClrType.Name
};
dbSetInfo.SetEntityType(entityInfo.ClrType);
metadata.DbSets.Add(dbSetInfo);
GenerateFieldInfos(metadata, entityInfo, dbSetInfo, edmProps, ownedTypes, ownedTypesMap);
GenerateAssociations(metadata, entityInfo, dbSetInfo);
}
return(metadata);
}
public void CheckValuesChanges(RowInfo rowInfo, string path, ValueChange[] values)
{
DbSetInfo dbSetInfo = rowInfo.GetDbSetInfo();
Array.ForEach(values, val =>
{
string fullName = path + val.fieldName;
Field fieldInfo = _dataHelper.GetFieldInfo(dbSetInfo, fullName);
if (!fieldInfo.GetIsIncludeInResult())
{
return;
}
if (fieldInfo.fieldType == FieldType.Object && val.nested != null)
{
CheckValuesChanges(rowInfo, fullName + '.', val.nested.ToArray());
}
else
{
if (isEntityValueChanged(rowInfo, fullName, fieldInfo, out string newVal))
{
val.val = newVal;
val.flags = val.flags | ValueFlags.Refreshed;
}
}
});
}
/// <summary>
/// Refresh Customer's custom ServerCalculated field 'AddressCount' on insert or delete
/// </summary>
/// <param name="changeSet"></param>
/// <param name="refreshResult"></param>
/// <returns></returns>
public override async Task AfterChangeSetCommited(ChangeSetRequest changeSet, SubResultList refreshResult)
{
DbSetInfo custAddrDbSet = this.GetSetInfosByEntityType(typeof(CustomerAddress)).Single();
DbSetInfo customerDbSet = this.GetSetInfosByEntityType(typeof(Customer)).Single();
DbSet dbCustAddr = changeSet.dbSets.FirstOrDefault(d => d.dbSetName == custAddrDbSet.dbSetName);
if (dbCustAddr != null)
{
int[] custIDs = dbCustAddr.rows.Where(r => r.changeType == ChangeType.Deleted || r.changeType == ChangeType.Added).Select(r => r.values.First(v => v.fieldName == "CustomerId").val).Select(id => int.Parse(id)).ToArray();
System.Collections.Generic.List <Customer> customersList = await DB.Customer.AsNoTracking().Where(c => custIDs.Contains(c.CustomerId)).ToListAsync();
System.Collections.Generic.List <int> customerAddress = await DB.CustomerAddress.AsNoTracking().Where(ca => custIDs.Contains(ca.CustomerId)).Select(ca => ca.CustomerId).ToListAsync();
customersList.ForEach(customer =>
{
customer.AddressCount = customerAddress.Count(id => id == customer.CustomerId);
});
SubResult subResult = new SubResult
{
dbSetName = customerDbSet.dbSetName,
Result = customersList
};
refreshResult.Add(subResult);
}
}
public async Task <bool> Handle(RefreshRequest message, IOutputPort <RefreshResponse> outputPort)
{
RefreshResponse response = new RefreshResponse {
rowInfo = message.rowInfo, dbSetName = message.dbSetName
};
try
{
Metadata.RunTimeMetadata metadata = _service.GetMetadata();
DbSetInfo dbSetInfo = metadata.DbSets.Get(message.dbSetName) ?? throw new InvalidOperationException($"The DbSet {message.dbSetName} was not found in metadata");
message.SetDbSetInfo(dbSetInfo);
message.rowInfo.SetDbSetInfo(dbSetInfo);
RefreshContext <TService> context = new RefreshContext <TService>(message,
response,
(TService)_service,
_serviceContainer);
await _pipeline(context);
}
catch (Exception ex)
{
if (ex is System.Reflection.TargetInvocationException)
{
ex = ex.InnerException;
}
string err = _onError(ex);
response.error = new ErrorInfo(err, ex.GetType().Name);
}
outputPort.Handle(response);
return(true);
}
public static void Initialize(this DbSetInfo dbSetInfo, Type serviceType)
{
var fbo = dbSetInfo.GetFieldByOrdinal();
var fbn = dbSetInfo.GetFieldByNames();
dbSetInfo.InitMethods(serviceType);
}
public async Task Invoke(RefreshContext <TService> ctx)
{
DbSetInfo dbSetInfo = ctx.Request.GetDbSetInfo() ?? throw new InvalidOperationException($"Could not get the DbSet for {ctx.Request.dbSetName}");
IServiceOperationsHelper <TService> serviceHelper = ctx.ServiceContainer.GetServiceHelper();
RunTimeMetadata metadata = ctx.Service.GetMetadata();
RequestContext req = RefreshContext <TService> .CreateRequestContext(ctx.Service, ctx.Request.rowInfo);
using (RequestCallContext callContext = new RequestCallContext(req))
{
MethodInfoData methodData = metadata.GetOperationMethodInfo(ctx.Request.dbSetName, MethodType.Refresh);
object instance = serviceHelper.GetMethodOwner(methodData);
object invokeRes = methodData.MethodInfo.Invoke(instance, new object[] { ctx.Request });
object dbEntity = await serviceHelper.GetMethodResult(invokeRes);
if (dbEntity != null)
{
serviceHelper.UpdateRowInfoFromEntity(dbEntity, ctx.Request.rowInfo);
}
else
{
throw new InvalidOperationException($"Refresh Operation for {ctx.Request.dbSetName} did not return a result");
}
}
await _next(ctx);
}
private string createCalcFields(DbSetInfo dbSetInfo)
{
var entityType = GetEntityTypeName(dbSetInfo.dbSetName);
var entityInterfaceName = GetEntityInterfaceName(dbSetInfo.dbSetName);
var dataHelper = _serviceContainer.DataHelper;
var sb = new StringBuilder(256);
dbSetInfo.fieldInfos.ForEach(fieldInfo =>
{
dataHelper.ForEachFieldInfo("", fieldInfo, (fullName, f) =>
{
if (f.fieldType == FieldType.Calculated)
{
sb.AppendFormat("\tdefine{0}Field(getFunc: (item: {1}) => {2})", fullName.Replace('.', '_'),
entityInterfaceName, GetFieldDataType(f));
sb.Append(" { ");
sb.AppendFormat("this._defineCalculatedField('{0}', getFunc);", fullName);
sb.Append(" }");
sb.AppendLine();
}
});
});
return(TrimEnd(sb.ToString()));
}
public SubsetList CreateSubsets(IEnumerable <SubResult> subResults)
{
SubsetList result = new SubsetList();
if (subResults == null)
{
return(result);
}
foreach (SubResult subResult in subResults)
{
DbSetInfo dbSetInfo = _metadata.DbSets[subResult.dbSetName];
if (result.Any(r => r.dbSetName == subResult.dbSetName))
{
throw new DomainServiceException(string.Format("The included sub results already have DbSet {0} entities", dbSetInfo.dbSetName));
}
RowGenerator rowGenerator = new RowGenerator(dbSetInfo, subResult.Result, _dataHelper);
Subset current = new Subset
{
dbSetName = dbSetInfo.dbSetName,
rows = rowGenerator.CreateDistinctRows(),
names = dbSetInfo.GetNames()
};
result.Add(current);
}
return(result);
}
public int?GetTotalCount <T>(IQueryable <T> entities, FilterInfo filter, DbSetInfo dbSetInfo)
where T : class
{
IQueryable filtered_entities = this.PerformFilter <T>(entities, filter, dbSetInfo);
return(filtered_entities.Count());
}
private static string createDbSetMethods(DbSetInfo dbSetInfo, string tableName)
{
var sb = new StringBuilder(512);
sb.AppendLine(string.Format("#region {0}", dbSetInfo.dbSetName));
sb.AppendLine("[Query]");
sb.AppendFormat("public QueryResult<{0}> Read{1}()", dbSetInfo.EntityType.Name, dbSetInfo.dbSetName);
sb.AppendLine("");
sb.AppendLine("{");
sb.AppendLine("\tint? totalCount = null;");
sb.AppendLine(string.Format("\tvar res = this.PerformQuery(this.DB.{0}, ref totalCount).AsEnumerable();", tableName));
sb.AppendLine(string.Format("\treturn new QueryResult<{0}>(res, totalCount);", dbSetInfo.EntityType.Name));
sb.AppendLine("}");
sb.AppendLine("");
sb.AppendLine("[Insert]");
sb.AppendFormat("public void Insert{1}({0} {2})", dbSetInfo.EntityType.Name, dbSetInfo.dbSetName, dbSetInfo.dbSetName.ToLower());
sb.AppendLine("");
sb.AppendLine("{");
sb.AppendLine(string.Format("\tif (({0}.EntityState != EntityState.Detached))", dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t{");
sb.AppendLine(string.Format("\t\tthis.DB.ObjectStateManager.ChangeObjectState({0}, EntityState.Added);", dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t}");
sb.AppendLine("\telse");
sb.AppendLine("\t{");
sb.AppendLine(string.Format("\t\tthis.DB.{0}.AddObject({1});", tableName, dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t}");
sb.AppendLine("}");
sb.AppendLine("");
sb.AppendLine("[Update]");
sb.AppendFormat("public void Update{1}({0} {2})", dbSetInfo.EntityType.Name, dbSetInfo.dbSetName, dbSetInfo.dbSetName.ToLower());
sb.AppendLine("");
sb.AppendLine("{");
sb.AppendLine(string.Format("\t{0} orig = this.GetOriginal<{0}>();", dbSetInfo.EntityType.Name));
sb.AppendLine(string.Format("\tthis.DB.{0}.Attach({1});", tableName, dbSetInfo.dbSetName.ToLower()));
sb.AppendLine(string.Format("\tthis.DB.{0}.ApplyOriginalValues(orig);", tableName));
sb.AppendLine("}");
sb.AppendLine("");
sb.AppendLine("[Delete]");
sb.AppendFormat("public void Delete{1}({0} {2})", dbSetInfo.EntityType.Name, dbSetInfo.dbSetName, dbSetInfo.dbSetName.ToLower());
sb.AppendLine("");
sb.AppendLine("{");
sb.AppendLine(string.Format("\tif (({0}.EntityState != EntityState.Detached))", dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t{");
sb.AppendLine(string.Format("\t\tthis.DB.ObjectStateManager.ChangeObjectState({0}, EntityState.Deleted);", dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t}");
sb.AppendLine("\telse");
sb.AppendLine("\t{");
sb.AppendLine(string.Format("\t\tthis.DB.{0}.Attach({1});", tableName, dbSetInfo.dbSetName.ToLower()));
sb.AppendLine(string.Format("\t\tthis.DB.{0}.DeleteObject({1});", tableName, dbSetInfo.dbSetName.ToLower()));
sb.AppendLine("\t}");
sb.AppendLine("}");
sb.AppendLine("");
sb.AppendLine("#endregion");
return(sb.ToString());
}
public RowGenerator(DbSetInfo dbSetInfo, IEnumerable <object> dataSource, IDataHelper dataHelper)
{
_dbSetInfo = dbSetInfo ?? throw new ArgumentNullException(nameof(dbSetInfo));
_dataSource = dataSource ?? throw new ArgumentNullException(nameof(dataSource));
_dataHelper = dataHelper ?? throw new ArgumentNullException(nameof(dataHelper));
fieldInfos = _dbSetInfo.GetInResultFields();
pkInfos = _dbSetInfo.GetPKFields();
}
public static int?GetTotalCount <T>(this IServicesProvider dataService, IQueryable <T> entities,
FilterInfo filter, DbSetInfo dbSetInfo)
where T : class
{
IQueryable filtered_entities = PerformFilter(dataService, entities, filter, dbSetInfo);
return(filtered_entities.Count());
}
private void GenerateFieldInfos(DbSetInfo dbSetInfo, string[] keys, EdmProperty[] edmProps)
{
short pkNum = 0;
Array.ForEach(edmProps, (edmProp) =>
{
Field fieldInfo = new Field()
{
fieldName = edmProp.Name
};
if (keys.Contains(fieldInfo.fieldName))
{
++pkNum;
fieldInfo.isPrimaryKey = pkNum;
fieldInfo.isReadOnly = true;
}
bool isComputed = this.isComputed(edmProp);
fieldInfo.isAutoGenerated = isAutoGenerated(edmProp);
fieldInfo.isNullable = edmProp.Nullable;
fieldInfo.isReadOnly = fieldInfo.isAutoGenerated;
bool isArray = false;
string propType = edmProp.TypeUsage.EdmType.Name;
try
{
fieldInfo.dataType = DataTypeFromType(propType, out isArray);
ReadOnlyMetadataCollection <Facet> facets = edmProp.TypeUsage.Facets;
Facet maxLenFacet = facets.Where(f => f.Name == "MaxLength").FirstOrDefault();
if (maxLenFacet != null)
{
try
{
fieldInfo.maxLength = (short)Convert.ChangeType(maxLenFacet.Value, typeof(short));
}
catch
{
}
}
//gess that the property is rowversion
fieldInfo.fieldType = (isComputed && fieldInfo.dataType == DataType.Binary) ? FieldType.RowTimeStamp : FieldType.None;
}
catch (UnSupportedTypeException)
{
BuiltInTypeKind typeKind = edmProp.TypeUsage.EdmType.BuiltInTypeKind;
if (typeKind == BuiltInTypeKind.ComplexType)
{
fieldInfo.dataType = DataType.None;
fieldInfo.fieldType = FieldType.Object;
}
else
{
throw;
}
}
dbSetInfo.fieldInfos.Add(fieldInfo);
});
}
public RowGenerator(DbSetInfo dbSetInfo, IEnumerable <object> dataSource, IDataHelper dataHelper)
{
_dbSetInfo = dbSetInfo;
_dataSource = dataSource;
_dataHelper = dataHelper;
fieldInfos = _dbSetInfo.GetInResultFields();
fieldCnt = fieldInfos.Length;
pkInfos = _dbSetInfo.GetPKFields();
}
public void UpdateDbSetInfo(DbSetInfo dbSetInfo, Type entityType, Type contextType)
{
var tableAttribute = entityType.GetTypeInfo().GetCustomAttribute <TableAttribute>();
if (tableAttribute == null || _ignoreTableAttribute)
{
dbSetInfo.TableName = _prefix + dbSetInfo.TableName;
}
}
public object GetTypedValue(Type entityType, DbSetInfo dbSetInfo)
{
FieldInfo fi = dbSetInfo.GetFieldByNames()[this.fieldName];
PropertyInfo pinfo = entityType.GetProperty(fi.fieldName);
if (pinfo == null)
throw new Exception(string.Format(ErrorStrings.ERR_PROPERTY_IS_MISSING, entityType.Name, fi.fieldName));
Type propType = pinfo.PropertyType;
return DataHelper.ConvertToTyped(propType, fi.dataType, fi.dateConversion, this.val);
}
public void UpdateDbSetInfo(DbSetInfo dbSetInfo, Type entityType, Type contextType, IShamanLogger logger)
{
var tableAttribute = entityType.GetTypeInfo().GetCustomAttribute <TableAttribute>();
if (tableAttribute == null)
{
dbSetInfo.TableName = entityType.Name;
}
// todo log
}
public void UpdateRowInfoFromEntity(object entity, RowInfo rowInfo)
{
DbSetInfo dbSetInfo = rowInfo.GetDbSetInfo();
UpdateValuesFromEntity(entity, "", dbSetInfo, rowInfo.values.ToArray());
if (rowInfo.changeType == ChangeType.Added)
{
rowInfo.serverKey = rowInfo.GetRowKeyAsString();
}
}
protected override Metadata GetMetadata()
{
MethodInfo[] methList = this.GetType().GetMethods();
LinkedList <DbSetInfo> dbsets = new LinkedList <DbSetInfo>();
Array.ForEach(methList, (methodInfo) =>
{
Type entityType = null;
if (methodInfo.IsDefined(typeof(QueryAttribute), false))
{
Type[] genArgs = methodInfo.ReturnType.GetGenericArguments();
if (genArgs.Length == 1)
{
entityType = genArgs[0];
}
else
{
return;
}
DbSetInfo dbSetInfo = new DbSetInfo()
{
dbSetName = entityType.Name
};
dbsets.AddLast(dbSetInfo);
PropertyInfo[] props = entityType.GetProperties();
short pkNum = 0;
Array.ForEach(props, (propInfo) => {
if (propInfo.IsDefined(typeof(ColumnAttribute), false))
{
ColumnAttribute colAttr = (ColumnAttribute)propInfo.GetCustomAttributes(typeof(ColumnAttribute), false).First();
FieldInfo fldInfo = new FieldInfo()
{
isAutoGenerated = colAttr.IsDbGenerated
};
if (colAttr.IsPrimaryKey)
{
fldInfo.isPrimaryKey = ++pkNum;
}
bool isArray = false;
fldInfo.dataType = DataHelper.DataTypeFromType(propInfo.PropertyType, out isArray);
fldInfo.isNullable = DataHelper.IsNullableType(propInfo.PropertyType) || colAttr.CanBeNull;
fldInfo.isRowTimeStamp = colAttr.IsVersion;
fldInfo.isNeedOriginal = colAttr.UpdateCheck != UpdateCheck.Never;
fldInfo.isReadOnly = !propInfo.CanWrite;
dbSetInfo.fieldInfos.Add(fldInfo);
}
});
}
});
Metadata metadata = new Metadata();
metadata.DbSets.AddRange(dbsets);
return(metadata);
}
private void CreateSubset(DbSetInfo dbSetInfo, IEnumerable <object> inputEntities, string propertyName,
string[] nextParts, Dictionary <string, Subset> visited)
{
var metadata = MetadataHelper.GetInitializedMetadata(_domainService);
var isChildProperty = false;
DbSetInfo nextDbSetInfo = null;
var assoc = metadata.associations.Values.Where(
a => a.parentDbSetName == dbSetInfo.dbSetName && a.parentToChildrenName == propertyName)
.FirstOrDefault();
if (assoc != null)
{
isChildProperty = true;
nextDbSetInfo = metadata.dbSets[assoc.childDbSetName];
}
else
{
assoc = metadata.associations.Values.Where(
a => a.childDbSetName == dbSetInfo.dbSetName && a.childToParentName == propertyName)
.FirstOrDefault();
if (assoc == null)
{
throw new DomainServiceException(string.Format(ErrorStrings.ERR_INCL_NAVIG_INVALID,
propertyName + (nextParts.Length > 0 ? "." + string.Join(".", nextParts) : "")));
}
nextDbSetInfo = metadata.dbSets[assoc.parentDbSetName];
}
if (visited.ContainsKey(nextDbSetInfo.dbSetName + "." + propertyName))
{
return;
}
var resultEntities = this.GetResultEntities(inputEntities, propertyName, isChildProperty);
//create temporary result without rows
//fills rows at the end of the method
var current = new Subset
{
dbSetName = nextDbSetInfo.dbSetName,
rows = new Row[0],
names = nextDbSetInfo.GetNames()
};
visited.Add(nextDbSetInfo.dbSetName + "." + propertyName, current);
if (nextParts.Length > 0)
{
CreateSubset(nextDbSetInfo, resultEntities, nextParts[0], nextParts.Skip(1).ToArray(), visited);
}
var rowGenerator = new RowGenerator(nextDbSetInfo, resultEntities, _dataHelper);
current.rows = rowGenerator.CreateDistinctRows();
}
public void UpdateDbSetInfo(DbSetInfo dbSetInfo, Type entityType, Type contextType, IShamanLogger logger)
{
var tableAttribute = entityType.GetTypeInfo().GetCustomAttribute <TableAttribute>();
if (tableAttribute == null || _ignoreTableAttribute)
{
dbSetInfo.TableName = _prefix + dbSetInfo.TableName;
logger.Log(typeof(PrefixedTableNameService), nameof(UpdateDbSetInfo),
$"Set TableName='{dbSetInfo.TableName}', prefix='{_prefix}')");
}
}
private SqlServerDirectSaver(DbSetInfo dbSetInfo)
{
_info = dbSetInfo;
_identityColumn = _info.Properites.SingleOrDefault(a => a.IsIdentity);
_sqlColumns = _info.Properites.Where(a => !a.IsNotMapped && !a.IsNavigationProperty).ToArray();
_pkColumns = _sqlColumns.Where(a => a.IsInPrimaryKey).ToArray();
if (_pkColumns.Length == 0)
{
throw new Exception("DBset has no primary key columns");
}
}
public static Dictionary <int, FieldInfo> GetFieldByOrdinal(this DbSetInfo dbSetInfo)
{
System.Threading.LazyInitializer.EnsureInitialized <Dictionary <int, FieldInfo> >(ref dbSetInfo._fieldsByOrdinal, () =>
{
int i = 0, cnt = dbSetInfo.fieldInfos.Count();
for (i = 0; i < cnt; ++i)
{
dbSetInfo.fieldInfos[i]._ordinal = i;
}
return(dbSetInfo.fieldInfos.ToDictionary(f => f._ordinal));
});
return(dbSetInfo._fieldsByOrdinal);
}
public static FieldName[] GetNames(this DbSetInfo dbSetInfo)
{
return
(dbSetInfo.GetInResultFields()
.Select(
fi =>
new FieldName
{
n = fi.fieldName,
p = fi.fieldType == FieldType.Object ? fi.GetNames() : null
})
.ToArray());
}
private string CreateDbSetType(EntityDefinition entityDef, DbSetInfo dbSetInfo, DotNet2TS dotNet2TS)
{
StringBuilder sb = new StringBuilder(512);
string dbSetType = GetDbSetTypeName(dbSetInfo.dbSetName);
List <Association> childAssoc = _associations.Where(assoc => assoc.childDbSetName == dbSetInfo.dbSetName).ToList();
List <Association> parentAssoc = _associations.Where(assoc => assoc.parentDbSetName == dbSetInfo.dbSetName).ToList();
FieldsList fieldInfos = dbSetInfo.fieldInfos;
Field[] pkFields = dbSetInfo.GetPKFields();
string pkVals = "";
foreach (Field pkField in pkFields)
{
if (!string.IsNullOrEmpty(pkVals))
{
pkVals += ", ";
}
pkVals += pkField.fieldName.ToCamelCase() + ": " + GetFieldDataType(pkField);
}
Dictionary <string, Func <TemplateParser.Context, string> > dic = new Dictionary <string, Func <TemplateParser.Context, string> >
{
{ "DBSET_NAME", (context) => dbSetInfo.dbSetName },
{ "DBSET_TYPE", (context) => dbSetType },
{ "ENTITY_NAME", (context) => entityDef.entityName },
{ "ASPECT_NAME", (context) => entityDef.aspectName },
{ "INTERFACE_NAME", (context) => entityDef.interfaceName },
{ "VALS_NAME", (context) => entityDef.valsName },
{
"DBSET_INFO",
(context) =>
{
//we are making copy of the object, in order that we don't change original object
//while it can be accessed by other threads
//we change our own copy, making it threadsafe
DbSetInfo copy = dbSetInfo.ShallowCopy();
copy.SetFieldInfos(new FieldsList()); //serialze with empty field infos
return(_serializer.Serialize(copy));
}
},
{ "FIELD_INFOS", (context) => _serializer.Serialize(dbSetInfo.fieldInfos) },
{ "CHILD_ASSOC", (context) => _serializer.Serialize(childAssoc) },
{ "PARENT_ASSOC", (context) => _serializer.Serialize(parentAssoc) },
{ "QUERIES", (context) => CreateDbSetQueries(dbSetInfo, dotNet2TS) },
{ "CALC_FIELDS", (context) => CreateCalcFields(dbSetInfo) },
{ "PK_VALS", (context) => pkVals }
};
return(_dbSetTemplate.ToString(dic));
}
public void UpdateDbSetInfo(DbSetInfo dbSetInfo, Type entityType, Type contextType)
{
var ta = entityType.GetTypeInfo().GetCustomAttribute <TableAttribute>();
if (ta == null)
{
return;
}
dbSetInfo.TableName = ta.Name;
if (!string.IsNullOrEmpty(ta.Schema))
{
dbSetInfo.Schema = ta.Schema;
}
}
private void GenerateFieldInfos(Metadata metadata, Type[] dbSetTypes, DbSetInfo dbSetInfo, string[] keys,
PropertyInfo[] edmProps)
{
short pkNum = 0;
Array.ForEach(edmProps, edmProp =>
{
var fieldInfo = new Field {
fieldName = edmProp.Name
};
var isArray = false;
try
{
fieldInfo.dataType = ValueConverter.DataTypeFromTypeCore(edmProp.PropertyType, out isArray);
}
catch (UnsupportedTypeException)
{
//if it is a relational property - child entity references parent entity
if (dbSetTypes.Contains(edmProp.PropertyType))
{
GenerateAssociation(metadata, dbSetInfo, edmProp);
return;
}
//if it is a relational property - parent entity references child entities (most often a collection)
if (edmProp.PropertyType.IsGenericType &&
dbSetTypes.Contains(edmProp.PropertyType.GetGenericArguments().First()))
{
return;
}
//Complex Type field
GenerateNestedFieldInfos(fieldInfo, edmProp.PropertyType);
}
if (fieldInfo.fieldType != FieldType.Object)
{
if (keys.Contains(fieldInfo.fieldName))
{
++pkNum;
fieldInfo.isPrimaryKey = pkNum;
fieldInfo.isReadOnly = true;
}
UpdateFieldInfo(fieldInfo, edmProp);
}
dbSetInfo.fieldInfos.Add(fieldInfo);
});
}
public static DbSetPermit GetDbSetPermissions(DbSetInfo dbInfo, IAuthorizer authorizer)
{
MethodInfo methInfo = null;
DbSetPermit permit = new DbSetPermit();
methInfo = dbInfo.getOperationMethodInfo(OperationNames.CREATE);
permit.canAddRow = methInfo != null && CanAccessMethod(methInfo,authorizer);
methInfo = dbInfo.getOperationMethodInfo(OperationNames.UPDATE);
permit.canEditRow = methInfo != null && CanAccessMethod(methInfo, authorizer);
methInfo = dbInfo.getOperationMethodInfo(OperationNames.DELETE);
permit.canDeleteRow = methInfo != null && CanAccessMethod(methInfo, authorizer);
methInfo = dbInfo.getOperationMethodInfo(OperationNames.REFRESH);
permit.canRefreshRow = methInfo != null && CanAccessMethod(methInfo, authorizer);
return permit;
}
public static MethodInfo GetCRUDMethodInfo(DbSetInfo dbInfo, RowInfo rowInfo)
{
MethodInfo methInfo = null;
switch (rowInfo.changeType)
{
case ChangeType.Added:
methInfo = dbInfo.getOperationMethodInfo(OperationNames.CREATE);
break;
case ChangeType.Deleted:
methInfo = dbInfo.getOperationMethodInfo(OperationNames.DELETE);
break;
case ChangeType.Updated:
methInfo = dbInfo.getOperationMethodInfo(OperationNames.UPDATE);
break;
default:
throw new DomainServiceException(string.Format(ErrorStrings.ERR_REC_CHANGETYPE_INVALID, dbInfo.EntityType.Name, rowInfo.changeType));
}
return methInfo;
}
public string GetRowKeyAsString(DbSetInfo dbSetInfo)
{
FieldInfo[] finfos = DataHelper.GetPKFieldInfos(dbSetInfo);
string[] vals = new string[finfos.Length];
for (int i = 0; i < finfos.Length; ++i)
{
ValueChange fv =this.GetValue(finfos[i].fieldName);
vals[i] = fv.val;
}
return string.Join(";", vals);
}
