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))); }