public static object CreateGenericObject(ManageEntityRequest request, Type entityType)
{
var entity = ConvertDeserializedObjectToStaticType(request.Entity, entityType);
var r = typeof(ManageEntityRequest <>).MakeGenericType(entityType).GetConstructors().First().Invoke(new object[] { entity });
return(r);
}
internal async Task <ActionResult <object> > AddInternal <TEntity>(ManageEntityRequest <TEntity> request)
where TEntity : class
{
try
{
var validationResult = _validator.Validate(request.Entity, ActionTypeEnum.Insert);
if (validationResult?.IsValid == false)
{
return(new BadRequestObjectResult(validationResult));
}
using (var context = GetWriteBusinessDbContext())
{
var set = context.Set <TEntity>();
set.Add(request.Entity);
await context.SaveChangesAsync();
return(request.Entity);
}
}
catch
{
return(new StatusCodeResult(500));
}
}
internal async Task <ActionResult <object> > EditInternal <TEntity>(ManageEntityRequest <TEntity> request)
where TEntity : class
{
try
{
var validationResult = _validator.Validate(request.Entity, ActionTypeEnum.Update);
if (validationResult?.IsValid == false)
{
return(new BadRequestObjectResult(validationResult));
}
using (var context = GetWriteBusinessDbContext())
{
var set = context.Set <TEntity>();
var existing = await set.FindAsync(_entityHelper.GetPrimaryKey(request.Entity));
_entityHelper.CopyPropertyValues(request.Entity, existing);
await context.SaveChangesAsync();
return(existing);
}
}
catch
{
return(new StatusCodeResult(500));
}
}
public async Task <ActionResult <object> > Delete([FromBody] ManageEntityRequest request)
{
if (!_permissionService.IsAllowed(new ActionRequestInfo(HttpContext, _implementationsContainer, request.EntityType, ActionTypeEnum.Delete)))
{
return(Unauthorized());
}
return(await _entityHandler.Delete(request));
}
private async Task <ActionResult <object> > CallMethod(ManageEntityRequest request, string internalMethodName)
{
var entityType = _implementationsContainer.Reflector.GetType(request.EntityType);
var method = _handlerInternal.GetType().GetMethod(internalMethodName, BindingFlags.NonPublic | BindingFlags.Instance).MakeGenericMethod(entityType);
object r = CreateGenericObject(request, entityType);
var awaitable = method.Invoke(_handlerInternal, new object[] { r }) as Task <ActionResult <object> >;
return(await awaitable);
}
private async Task <Result <object> > CallMethod(string internalMethodName
, ManageEntityRequest request, object businessRepository, IActionContextInfo actionContext)
{
var entityType = _implementationsContainer.Reflector.GetType(request.EntityTypeName);
var method = _handlerInternal.GetType().GetMethod(internalMethodName, BindingFlags.NonPublic | BindingFlags.Instance).MakeGenericMethod(entityType);
object r = EntityHelper.CreateGenericObject(request, entityType);
var awaitable = method.Invoke(_handlerInternal, new object[] { r, businessRepository, actionContext }) as Task <Result <object> >;
return(await awaitable);
}
public async Task <Result <object> > Delete(ManageEntityRequest request)
{
using (var repository = _implementations.GetBusinessRepository())
{
var result = await _entityHandler.Delete(request, repository);
await _entityHandler.SaveChanges(repository, request.EntityTypeName);
return(result);
}
}
private object CreateGenericObject(ManageEntityRequest request, Type entityType)
{
var jEntity = request.Entity as JObject;
if (jEntity == null)
{
jEntity = JObject.Parse(JsonConvert.SerializeObject(request.Entity));
}
var toObjectMethod = typeof(JObject).GetMethods(BindingFlags.FlattenHierarchy | BindingFlags.Instance | BindingFlags.Public)
.Single(x => x.Name == nameof(JObject.ToObject) && x.GetGenericArguments().Length == 1 && x.GetParameters().Length == 0);
toObjectMethod = toObjectMethod.MakeGenericMethod(entityType);
var entity = toObjectMethod.Invoke(jEntity, null);
var r = typeof(ManageEntityRequest <>).MakeGenericType(entityType).GetConstructors().First().Invoke(new object[] { entity });
return(r);
}
internal async Task <Result <object> > DeleteInternal <TEntity>(ManageEntityRequest <TEntity> request
, DbContext dbContext, IActionContextInfo actionContext)
where TEntity : class
{
try
{
//var validationResult = _validator.Validate(request.Entity, ActionTypeEnum.Delete, actionContext);
//if (validationResult?.IsValid == false)
//{
// return validationResult;
//}
var set = dbContext.Set <TEntity>();
var entity = await set.FindAsync(_entityHelper.GetPrimaryKey(request.Entity));
set.Remove(entity);
return(request.Entity);
}
catch (Exception ex)
{
return(ex);
}
}
internal async Task <Result <object> > AddInternal <TEntity>(ManageEntityRequest <TEntity> request
, DbContext dbContext, IActionContextInfo actionContext)
where TEntity : class
{
try
{
var validationResult = _validator.Validate(request.Entity, ActionTypeEnum.Insert, actionContext);
if (validationResult?.IsValid == false)
{
return(validationResult);
}
var set = dbContext.Set <TEntity>();
await set.AddAsync(request.Entity);
return(request.Entity);
}
catch (Exception ex)
{
return(ex);
}
}
public async Task <Result <object> > Add(ManageEntityRequest request)
{
using (var repository = _implementations.GetBusinessRepository())
{
var map = new Dictionary <string, object>();
var actionContext = new ActionContextInfo
{
CurrentEntity = request.Entity,
EntityType = _implementations.Metadata[request.EntityTypeName],
Type = ActionContextType.Add
};
var result = await AddRecursive(request, repository, map, "", actionContext);
if (!result.Succeeded)
{
return(result);
}
await _entityHandler.SaveChanges(repository, request.EntityTypeName);
return(map[""]);
}
}
internal async Task <Result <object> > EditInternal <TEntity>(ManageEntityRequest <TEntity> request
, DbContext dbContext, IActionContextInfo actionContext)
where TEntity : class
{
try
{
// var validationResult = _validator.Validate(request.Entity, ActionTypeEnum.Update, actionContext);
//if (validationResult?.IsValid == false)
//{
// return new BadRequestObjectResult(validationResult);
//}
var set = dbContext.Set <TEntity>();
var existing = await set.FindAsync(_entityHelper.GetPrimaryKey(request.Entity));
_entityHelper.CopyPropertyValues(request.Entity, existing);
return(existing);
}
catch (Exception ex)
{
return(ex);
}
}
public async Task <Result <object> > Delete(ManageEntityRequest request, object businessRepository)
{
return(await CallMethod(nameof(EfCoreEntityHandlerInternal.DeleteInternal), request, businessRepository, null));
}
public async Task <Result <object> > Add(ManageEntityRequest request, object businessRepository, IActionContextInfo actionContext)
{
return(await CallMethod(nameof(EfCoreEntityHandlerInternal.AddInternal), request, businessRepository, actionContext));
}
private async Task <Result <object> > AddRecursive(ManageEntityRequest request, IDisposable repository, Dictionary <string, object> map
, string currentObjectPath, ActionContextInfo actionContext)
{
var entityType = _implementations.Metadata[request.EntityTypeName];
object entity;
if (!entityType.NotMapped())
{
foreach (var prop in entityType.GetAllProperties().Where(x => x.DataType == DataTypes.NavigationEntity))
{
if (prop.HideInInsert() || prop.ForeignKey == null)
{
continue;
}
if (actionContext.ExcludedProperties == null)
{
actionContext.ExcludedProperties = new List <string> {
};
}
(actionContext.ExcludedProperties as List <string>).Add(prop.ForeignKey.Name);
}
var result = await _entityHandler.Add(request, repository, actionContext);
if (!result.Succeeded)
{
// TODO: Here, the error messages should be prepended by the path to the current entity
return(result);
}
entity = result.Data;
}
else
{
entity = Activator.CreateInstance(_implementations.Reflector.GetType(request.EntityTypeName));
}
if (map.TryGetValue(currentObjectPath, out var existingValue))
{
existingValue.GetType().GetMethod("Add").Invoke(existingValue, new object[] { entity });
}
if (map.TryGetValue(currentObjectPath, out var list))
{
(list as IList).Add(entity);
}
else
{
map.Add(currentObjectPath, entity);
}
foreach (var pair in map)
{
if (!currentObjectPath.StartsWith(pair.Key))
{
continue;
}
var itemType = pair.Value.GetType();
if (itemType.IsGenericType)
{
itemType = itemType.GetGenericArguments().Single();
}
var typeMetadata = _implementations.Metadata[itemType.Name];
foreach (var property in typeMetadata.GetAllProperties())
{
var path = JoinPath(pair.Key, property.Name);
if (path == currentObjectPath)
{
SetPropertyValue(pair.Value, property, entity);
}
}
}
foreach (var propertyMetadata in entityType.GetAllProperties())
{
var propertyPath = JoinPath(currentObjectPath, propertyMetadata.Name);
if (map.TryGetValue(propertyPath, out var val))
{
SetPropertyValue(entity, propertyMetadata, val);
}
if (propertyMetadata.HideInInsert())
{
continue;
}
var value = (request.Entity as JObject)[propertyMetadata.Name];
//if (propertyMetadata.DataType == DataTypes.NavigationEntity)
//{
// var relatedEntity = await AddRecursive(new ManageEntityRequest
// {
// EntityTypeName = propertyMetadata.EntityTypeName,
// Entity = value
// }, repository, map, propertyPath);
//}
if (propertyMetadata.DataType == DataTypes.NavigationList)
{
map.Add(propertyPath, Activator.CreateInstance(typeof(List <>).MakeGenericType(_implementations.Reflector.GetType(propertyMetadata.EntityTypeName))));
if (!(value is IEnumerable collection))
{
continue;
}
foreach (var item in collection)
{
var childActionContext = new ActionContextInfo
{
CurrentEntity = item,
CurrentList = collection,
EntityType = _implementations.Metadata[propertyMetadata.EntityTypeName],
Masters = actionContext.Masters.Concat(new MasterReference(entity, propertyMetadata)),
Parent = actionContext,
Property = propertyMetadata,
Type = ActionContextType.Add
};
await AddRecursive(new ManageEntityRequest
{
EntityTypeName = propertyMetadata.EntityTypeName,
Entity = item
}, repository, map, propertyPath, childActionContext);
}
}
}
return(map[currentObjectPath]);
}
public async Task <ActionResult <object> > Delete(ManageEntityRequest request)
{
return(await CallMethod(request, nameof(EfCoreEntityHandlerInternal.DeleteInternal)));
}
