public DataAdapterCud(DataAdapterRead dataAdapterRead, DatabaseOperations databaseOperations, Dialect dialect, MetadataSrv.Metadata metadataSrv)
{
this.dataAdapterRead = dataAdapterRead;
this.databaseOperations = databaseOperations;
this.dialect = dialect;
this.metadataSrv = metadataSrv;
}
public EntitySet(Type derivedEntityType, Dictionary <string, IEntitySet <IDerivedEntity> > entitySets, MetadataSrv.Metadata metadataSrv)
{
this.derivedEntityType = derivedEntityType;
this.entityTypeName = derivedEntityType.Name;
this.entitySets = entitySets;
this.metadataSrv = metadataSrv;
this.key = metadataSrv.EntityTypes[this.entityTypeName].Key;
this.Items = new List <IDerivedEntity>();
}
public static string FixEntitySetNameCase(string entitySetName, MetadataSrv.Metadata metadataSrv)
{
foreach (var prop in metadataSrv.EntityTypes)
{
if (metadataSrv.EntityTypes[prop.Key].EntitySetName.ToLower() == entitySetName.ToLower())
{
return(metadataSrv.EntityTypes[prop.Key].EntitySetName);
}
}
throw new Exception("Invalid entitySetName");
}
public void Dispose()
{
// se va apela inainte de incetarea utilizarii obiectului
// pentru a evita aparitia de memory leaks si a usura activitatea GC-ului
foreach (var entitySet in this.entitySets)
{
var entitySetValue = entitySet.Value;
entitySetValue.Dispose();
}
this.entitySets = null;
this.metadataSrv = null;
}
public static bool ValidDtoKey(string entityTypeName, Dto dto, MetadataSrv.Metadata metadataSrv)
{
var keyNames = metadataSrv.EntityTypes[entityTypeName].Key;
foreach (var name in keyNames)
{
if (!(dto.ContainsKey(name) || Regex.IsMatch(dto[name].ToString(), @"^\d+$")))
{
return(false);
}
}
return(true);
}
public static bool KeyPresent(string entityTypeName, Dto dto, MetadataSrv.Metadata metadataSrv)
{
var keyNames = metadataSrv.EntityTypes[entityTypeName].Key;
foreach (var keyName in keyNames)
{
if (!dto.ContainsKey(keyName))
{
return(false);
}
}
return(true);
}
public static bool ValidDto(string entityTypeName, Dto key, Dto dto, MetadataSrv.Metadata metadataSrv)
{
var keyNames = metadataSrv.EntityTypes[entityTypeName].Key;
// if dto has key fields, their values should match the key values from query string
foreach (var name in keyNames)
{
if (dto.ContainsKey(name) && dto[name] != key[name])
{
return(false);
}
}
return(true);
}
public static string GetEntityTypeName(string entitySetName, MetadataSrv.Metadata metadataSrv)
{
//var entityType = (from t in metadataSrv.entityTypes where t.Value.entitySetName == entitySetName select t).FirstOrDefault();
//return entityType.Key;
var result = string.Empty;
foreach (var prop in metadataSrv.EntityTypes)
{
if (metadataSrv.EntityTypes[prop.Key].EntitySetName == entitySetName)
{
result = prop.Key;
}
}
return(result);
}
public static bool ValidKeys(string entityTypeName, IEnumerable <Dto> dtos, MetadataSrv.Metadata metadataSrv)
{
if (dtos == null || dtos.Count() == 0)
{
return(false);
}
var keyNames = metadataSrv.EntityTypes[entityTypeName].Key;
foreach (var dto in dtos)
{
if (!ValidDtoKey(entityTypeName, dto, metadataSrv))
{
return(false);
}
}
return(true);
}
public LocalDtoViews(DataContext dataContext, MetadataSrv.Metadata metadataSrv) : base(dataContext, metadataSrv)
{
//this.["Actors"] = new DataViewLocalDto<Actor>(dataContext, metadataSrv);
//this.["Addresses"] = new DataViewLocalDto<Address>(dataContext, metadataSrv);
//this.["Categories"] = new DataViewLocalDto<Category>(dataContext, metadataSrv);
//this.["Cities"] = new DataViewLocalDto<City>(dataContext, metadataSrv);
//this.["Countries"] = new DataViewLocalDto<Country>(dataContext, metadataSrv);
//this.["Customers"] = new DataViewLocalDto<Customer>(dataContext, metadataSrv);
//this.["Films"] = new DataViewLocalDto<Film>(dataContext, metadataSrv);
//this.["FilmActors"] = new DataViewLocalDto<FilmActor>(dataContext, metadataSrv);
//this.["FilmCategories"] = new DataViewLocalDto<FilmCategory>(dataContext, metadataSrv);
//this.["FilmTexts"] = new DataViewLocalDto<FilmText>(dataContext, metadataSrv);
//this.["Inventories"] = new DataViewLocalDto<Inventory>(dataContext, metadataSrv);
//this.["Languages"] = new DataViewLocalDto<Language>(dataContext, metadataSrv);
//this.["Payments"] = new DataViewLocalDto<Payment>(dataContext, metadataSrv);
//this.["Rentals"] = new DataViewLocalDto<Rental>(dataContext, metadataSrv);
//this.["Staffs"] = new DataViewLocalDto<Staff>(dataContext, metadataSrv);
//this.["Stores"] = new DataViewLocalDto<Store>(dataContext, metadataSrv);
}
public static Dialect Dialect(this MetadataSrv.Metadata metadataSrv)
{
// Minimum SQL 2012 because it has improved paging FETCH NEXT ... OFFSET ...
if (metadataSrv.Dialect == "MSSQL11")
{
return(NavyBlueDtos.Dialect.SQL2012);
}
else if (metadataSrv.Dialect == "MSSQL12")
{
return(NavyBlueDtos.Dialect.SQL2014);
}
else if (metadataSrv.Dialect == "MYSQL")
{
return(NavyBlueDtos.Dialect.MYSQL);
}
else
{
throw new ArgumentException("Unsupported database");
}
}
internal static string NavigationBranchToQueryText(string entityTypeName, string entityTypeQuery, List <MetadataSrv.NavigationProperty> navBranch, Dialect dialect, MetadataSrv.Metadata metadataSrv)
{
// A INNER JOIN B ON A.IdDepartament = B.IdDepartament AND A.IdPersoana = B.IdPersoana INNER JOIN C ON ...
var entityTypeNameLocal = entityTypeName;
var navLast = navBranch[navBranch.Count - 1];
var distinct = navLast.Multiplicity == "single" ? "DISTINCT" : string.Empty;
var fields = metadataSrv.EntityTypes[navLast.EntityTypeName].Properties.ToDictionary((it) => it.Key, (it) => it.Value.FieldName);
var result = new StringBuilder(string.Format("SELECT {0} {1} FROM ", distinct, GetSelect(fields, false, dialect)));
var tableName = metadataSrv.EntityTypes[entityTypeName].TableName;
result.Append(!string.IsNullOrEmpty(entityTypeQuery) ? string.Format("({0}) AS {1}", entityTypeQuery, tableName) : tableName);
for (var i = 0; i < navBranch.Count - 1; i++)
{
var nav = navBranch[i];
result.Append(string.Format(" INNER JOIN {0} ON {1}", metadataSrv.EntityTypes[nav.EntityTypeName].TableName, GetJoinCondition(entityTypeNameLocal, false, nav, false, metadataSrv)));
entityTypeNameLocal = nav.EntityTypeName;
}
result.Append(string.Format(" INNER JOIN {0} AS it ON {1}", metadataSrv.EntityTypes[navLast.EntityTypeName].TableName, GetJoinCondition(entityTypeNameLocal, false, navLast, true, metadataSrv)));
return(result.ToString());
}
internal static string GetJoinCondition(string entityTypeName, bool entityTypeTableAlias, MetadataSrv.NavigationProperty navigationProperty, bool navigationTableAlias, MetadataSrv.Metadata metadataSrv)
{
// t1.prop1 = t2.prop1 AND t1.prop2 = t2.prop2
var result = new List <string>();
var entityType = metadataSrv.EntityTypes[entityTypeName];
for (var i = 0; i < navigationProperty.KeyLocal.Length; i++)
{
var entityTypeNav = metadataSrv.EntityTypes[navigationProperty.EntityTypeName];
result.Add((entityTypeTableAlias ? "it" : entityType.TableName) + "." + entityType.Properties[navigationProperty.KeyLocal[i]].FieldName + " = " + (navigationTableAlias ? "it" : entityTypeNav.TableName) + "." + entityTypeNav.Properties[navigationProperty.KeyRemote[i]].FieldName);
}
return(string.Join(" AND ", result));
}
internal static List <QueryResult> GetQueryResult(string entityTypeName, QueryObject queryObject, Dialect dialect, MetadataSrv.Metadata metadataSrv)
{
var result = new List <QueryResult>();
var entityTypeQueries = BuildEntityTypeQueries(entityTypeName, queryObject, dialect, metadataSrv);
var queryRoot = entityTypeQueries.QueryRoot;
result.Add(new QueryResult()
{
EntityTypeName = entityTypeName,
QueryText = entityTypeQueries.QuerySelect
});
if (queryObject.Count != null)
{
result.Add(new QueryResult()
{
EntityTypeName = null,
QueryText = entityTypeQueries.QueryCount
});
}
if (queryObject.Expand != null && queryObject.Expand.Length > 0)
{
var splitExpand = DataUtils.SplitExpand(queryObject.Expand, (el) => el);
foreach (var branch in DataUtils.NavigationBranch(splitExpand))
{
var navs = DataUtils.BranchToNavigation(entityTypeName, branch, metadataSrv);
var entityTypeNameLocal = navs[navs.Count - 1].EntityTypeName;
var foundEntityType = result.FirstOrDefault((it) => it.EntityTypeName == entityTypeNameLocal);
if (foundEntityType == null)
{
result.Add(new QueryResult()
{
EntityTypeName = entityTypeNameLocal,
QueryText = NavigationBranchToQueryText(entityTypeName, queryRoot, navs, dialect, metadataSrv)
});
}
else
{
foundEntityType.QueryText += " UNION " + NavigationBranchToQueryText(entityTypeName, queryRoot, navs, dialect, metadataSrv);
}
}
}
return(result);
}
public DataContext(MetadataSrv.Metadata metadataSrv)
{
this.metadataSrv = metadataSrv;
this.entitySets = new Dictionary <string, IEntitySet <IDerivedEntity> >();
}
public DataViewLocalDto(string entityTypeName, DataContext dataContext, MetadataSrv.Metadata metadataSrv)
{
this.entityTypeName = entityTypeName;
this.dataContext = dataContext;
this.metadataSrv = metadataSrv;
}
public static void FillResultRelatedItems(string entityTypeName, ResultSerialData resultSerialData, string[] expand, DataContext dataContext, MetadataSrv.Metadata metadataSrv)
{
if (expand != null && expand.Length > 0 && resultSerialData.Items != null && resultSerialData.Items.Count() > 0)
{
var splitExpand = DataUtils.SplitExpand(expand, (el) => el);
foreach (var branch in DataUtils.NavigationBranch(splitExpand))
{
var navs = DataUtils.BranchToNavigation(entityTypeName, branch, metadataSrv);
var lastNav = navs[navs.Count - 1];
var rootEntityTypeName = string.Empty;
IEnumerable <Dto> rootItems;
if (branch.Length == 1)
{
rootEntityTypeName = entityTypeName;
rootItems = resultSerialData.Items;
}
else
{
rootEntityTypeName = navs[navs.Count - 2].EntityTypeName;
rootItems = resultSerialData.RelatedItems[rootEntityTypeName];
}
var navigationPropertyName = branch[branch.Length - 1];
var entityTypeNameLocal = lastNav.EntityTypeName;
var relatedEntityItems = dataContext.GetRelatedEntities(rootEntityTypeName, rootItems, navigationPropertyName).ToList();
if (resultSerialData.RelatedItems == null)
{
resultSerialData.RelatedItems = new Dictionary <string, IEnumerable <Dto> >();
}
if (!resultSerialData.RelatedItems.ContainsKey(entityTypeNameLocal))
{
resultSerialData.RelatedItems[entityTypeNameLocal] = relatedEntityItems.Select(it => it.entity.dto);
}
else
{
var items = resultSerialData.RelatedItems[entityTypeNameLocal].ToList();
PushMultiIfNotThere(relatedEntityItems, items);
resultSerialData.RelatedItems[entityTypeNameLocal] = items;
}
}
}
}
public void Dispose()
{
this.DeleteAll();
this.entitySets = null;
this.metadataSrv = null;
}
public ResultSerialUtils(DataViewDto dataViewDto, string apiRouteRoot, MetadataSrv.Metadata metadataSrv)
{
this.dataViewDto = dataViewDto;
this.apiRouteRoot = apiRouteRoot;
this.metadataSrv = metadataSrv;
}
public void Attach(Dictionary <string, IEntitySet <IDerivedEntity> > entitySets, MetadataSrv.Metadata metadataSrv)
{
this.entitySets = entitySets;
this.metadataSrv = metadataSrv;
}
private static string[] GetOrderBy(string entityTypeName, MetadataSrv.Metadata metadataSrv)
{
var keyNames = metadataSrv.EntityTypes[entityTypeName].Key;
return(keyNames.Select((name) => string.Format("{0} DESC", name)).ToArray());
}
public static List <MetadataSrv.NavigationProperty> BranchToNavigation(string entityTypeName, string[] branch, MetadataSrv.Metadata metadataSrv)
{
var navigationPropertyList = new List <MetadataSrv.NavigationProperty>();
var entityTypeNameLocal = entityTypeName;
foreach (var navigationPropertyName in branch)
{
var navigationProperties = metadataSrv.EntityTypes[entityTypeNameLocal].NavigationProperties;
if (navigationProperties.ContainsKey(navigationPropertyName))
{
navigationPropertyList.Add(navigationProperties[navigationPropertyName]);
}
else
{
throw new Exception("invalid navigation property");
}
entityTypeNameLocal = navigationProperties[navigationPropertyName].EntityTypeName;
}
return(navigationPropertyList);
}
public ApiProviderDto(DataViewDto dataViewDto, ResultSerialUtils resultSerialUtils, MetadataSrv.Metadata metadataSrv)
{
this.dataViewDto = dataViewDto;
this.resultSerialUtils = resultSerialUtils;
this.metadataSrv = metadataSrv;
}
public static void FillResultSingleRelatedItems(string entityTypeName, ResultSingleSerialData resultSingleSerialData, string[] expand, DataContext dataContext, MetadataSrv.Metadata metadataSrv)
{
if (resultSingleSerialData.Item != null)
{
var resultSerialData = new ResultSerialData()
{
Items = new List <Dto>()
{
resultSingleSerialData.Item
},
EntityTypeName = entityTypeName,
TotalCount = 0,
RelatedItems = { }
};
FillResultRelatedItems(entityTypeName, resultSerialData, expand, dataContext, metadataSrv);
resultSingleSerialData.RelatedItems = resultSerialData.RelatedItems;
}
}
internal static EntityTypeQueries BuildEntityTypeQueries(string entityTypeName, QueryObject queryObject, Dialect dialect, MetadataSrv.Metadata metadataSrv)
{
var select = "it.*";
var filter = string.Empty;
var filterExpand = new List <string>();
var orderBy = string.Empty;
var skip = string.Empty;
var top = string.Empty;
var entityType = metadataSrv.EntityTypes[entityTypeName];
var fields = entityType.Properties.ToDictionary((it) => it.Key, (it) => it.Value.FieldName);
var selectFields = fields;
var hasCustomSelect = queryObject.Select != null && queryObject.Select.Length > 0;
if (hasCustomSelect)
{
var keyNames = entityType.Key;
selectFields = selectFields.Where((it) => keyNames.Contains(it.Key) || queryObject.Select.Contains(it.Key)).ToDictionary((it) => it.Key, (it) => it.Value);
}
select = GetSelect(selectFields, hasCustomSelect, dialect);
var tableName = !string.IsNullOrEmpty(queryObject.CustomQueryTable) ? string.Format("({0})", queryObject.CustomQueryTable) : metadataSrv.EntityTypes[entityTypeName].TableName;
var entityTypeQuery = new StringBuilder(string.Format("SELECT {0} FROM {1} AS it", "{0}", tableName));
if (queryObject.FilterExpand != null && queryObject.FilterExpand.Count > 0)
{
var splitExpand = DataUtils.SplitExpand(queryObject.FilterExpand.ToArray(), (el) => el.Expand, (el, it, lastInPath) =>
{
// 'process' se executa doar la cea din urma proprietate de navigare
if (lastInPath)
{
it.Filter = el.Filter;
}
});
//DataUtils.ForEachNavigationFilter(entityTypeName, splitExpand, (parentEntityTypeName, nav, filterExp) =>
//{
// var tableNameLocal = metadataSrv.EntityTypes[entityTypeName].TableName;
// var join = GetJoinCondition(parentEntityTypeName, entityTypeName == parentEntityTypeName, nav, false, metadataSrv);
// tableNameLocal = metadataSrv.EntityTypes[nav.EntityTypeName].TableName;
// entityTypeQuery.Append(string.Format(" INNER JOIN {0} ON {1}", tableNameLocal, join));
// if (!string.IsNullOrEmpty(filterExp))
// {
// var childElementFields = metadataSrv.EntityTypes[nav.EntityTypeName].Properties.ToDictionary((it) => it.Key, (it) => it.Value.FieldName);
// filterExpand.Add(string.Format("( {0} )", ReplaceFieldNames(tableNameLocal, filterExp, childElementFields, dialect)));
// }
//}, metadataSrv);
foreach (var navigationResult in DataUtils.NavigationFilter(entityTypeName, splitExpand, metadataSrv))
{
var parentEntityTypeName = navigationResult.EntityTypeName;
var nav = navigationResult.NavigationProperty;
var filterExp = navigationResult.Filter;
var tableNameLocal = metadataSrv.EntityTypes[entityTypeName].TableName;
var join = GetJoinCondition(parentEntityTypeName, entityTypeName == parentEntityTypeName, nav, false, metadataSrv);
tableNameLocal = metadataSrv.EntityTypes[nav.EntityTypeName].TableName;
entityTypeQuery.Append(string.Format(" INNER JOIN {0} ON {1}", tableNameLocal, join));
if (!string.IsNullOrEmpty(filterExp))
{
var childElementFields = metadataSrv.EntityTypes[nav.EntityTypeName].Properties.ToDictionary((it) => it.Key, (it) => it.Value.FieldName);
filterExpand.Add(string.Format("( {0} )", ReplaceFieldNames(tableNameLocal, filterExp, childElementFields, dialect)));
}
}
}
var arrFilter = new List <string>();
if (queryObject.Filter != null)
{
arrFilter.Add(string.Format("( {0} )", ReplaceFieldNames("it", queryObject.Filter, fields, dialect)));
}
if (filterExpand.Count > 0)
{
arrFilter.AddRange(filterExpand);
}
if (arrFilter.Count > 0)
{
filter = " WHERE " + string.Join(" AND ", arrFilter);
}
if (queryObject.OrderBy != null && queryObject.OrderBy.Length > 0)
{
orderBy = " ORDER BY " + string.Join(", ", queryObject.OrderBy);
orderBy = ReplaceFieldNames("it", orderBy, fields, dialect);
}
switch (dialect)
{
case Dialect.SQL2012:
case Dialect.SQL2014:
if (queryObject.Top != null)
{
top = string.Format(" FETCH NEXT {0} ROWS ONLY", queryObject.Top);
}
if (queryObject.Skip != null)
{
skip = string.Format(" OFFSET {0} ROWS", queryObject.Skip);
}
break;
case Dialect.MYSQL:
if (queryObject.Top != null)
{
top = " LIMIT " + queryObject.Top;
}
if (queryObject.Skip != null)
{
skip = " OFFSET " + queryObject.Skip;
}
break;
default:
break;
}
var queryCount = "COUNT(*) AS count";
queryCount = string.Format(entityTypeQuery.ToString() + filter, queryCount);
entityTypeQuery.Append(filter + orderBy + top + skip);
var querySelect = string.Format(entityTypeQuery.ToString(), select);
var queryRoot = string.Format(entityTypeQuery.ToString(), "it.*");
return(new EntityTypeQueries()
{
QuerySelect = querySelect,
QueryCount = queryCount,
QueryRoot = queryRoot
});
}
public static IEntitySet <IDerivedEntity> CreateEntitySet(string entityTypeName, Dictionary <string, IEntitySet <IDerivedEntity> > entitySets, MetadataSrv.Metadata metadataSrv)
{
var currentAssemblyName = Assembly.GetExecutingAssembly().CodeBase; //.Location
var currentAssemblyUri = new Uri(currentAssemblyName);
var path = Path.GetDirectoryName(currentAssemblyUri.LocalPath);
var targetAssemblyName = Path.Combine(path, string.Format("{0}.dll", metadataSrv.Namespace.Split(new char[] { '.' }).FirstOrDefault()));
var targetAssembly = Assembly.LoadFrom(targetAssemblyName);
var derivedEntityType = targetAssembly.GetType(metadataSrv.Namespace + "." + entityTypeName);
//var derivedEntityType = Type.GetType(metadataSrv.Namespace + "." + entityTypeName);
var d1 = typeof(EntitySet <>);
var typeArgs = new Type[] { derivedEntityType };
var constructed = d1.MakeGenericType(typeArgs);
var entitySet = Activator.CreateInstance(constructed, new object[] { derivedEntityType, entitySets, metadataSrv });
return((IEntitySet <IDerivedEntity>)entitySet);
}
public void Detach()
{
this.entitySets = null;
this.metadataSrv = null;
}
public LocalDtoViewsBase(DataContext dataContext, MetadataSrv.Metadata metadataSrv)
{
this.dataContext = dataContext;
this.metadataSrv = metadataSrv;
}
//public static void ForEachNavigationFilter(string parentEntityTypeName, List<NavigationInclude> arr, Action<string, MetadataSrv.NavigationProperty, string> process, MetadataSrv.Metadata metadataSrv)
//{
// foreach (var item in arr)
// {
// var childNavigationProperty = metadataSrv.EntityTypes[parentEntityTypeName].NavigationProperties[item.NavigationProperty];
// process(parentEntityTypeName, childNavigationProperty, item.Filter);
// if (item.Include.Count > 0)
// {
// ForEachNavigationFilter(childNavigationProperty.EntityTypeName, item.Include, process, metadataSrv);
// }
// }
//}
public static IEnumerable <NavigationResult> NavigationFilter(string parentEntityTypeName, List <NavigationInclude> arr, MetadataSrv.Metadata metadataSrv)
{
foreach (var item in arr)
{
var childNavigationProperty = metadataSrv.EntityTypes[parentEntityTypeName].NavigationProperties[item.NavigationProperty];
yield return(new NavigationResult()
{
EntityTypeName = parentEntityTypeName, NavigationProperty = childNavigationProperty, Filter = item.Filter
});
if (item.Include.Count > 0)
{
foreach (var navigationResult in NavigationFilter(childNavigationProperty.EntityTypeName, item.Include, metadataSrv))
{
yield return(navigationResult);
}
}
}
}
public static QueryObject GetQueryObject(string entityTypeName, QueryObject queryObject, int skip, int top, MetadataSrv.Metadata metadataSrv)
{
var queryObjectLocal = JObject.FromObject(queryObject).ToObject <QueryObject>();
if (queryObjectLocal.OrderBy == null || queryObjectLocal.OrderBy.Length == 0)
{
queryObjectLocal.OrderBy = GetOrderBy(entityTypeName, metadataSrv);
}
queryObjectLocal.Count = false;
queryObjectLocal.Skip = skip;
queryObjectLocal.Top = top;
return(queryObjectLocal);
}
