public HttpResponseMessage <JsonQueryResult> Get( [FromUri(Name = "designmode")] bool isInDesignMode = false, string id = null, string ns = null, string alias = null ) { using (Profiler.Measure("FormController.Get")) { // Get the entityRef EntityRef formRef = WebApiHelpers.MakeEntityRef(id, ns, alias); long formId; try { formId = formRef.Id; } catch (ArgumentException) { throw new FormNotFoundException(); } EntityData formEntityData = _formControllerRequestHandler.GetFormAsEntityData(formId, isInDesignMode); var context = new EntityPackage(); context.AddEntityData(formEntityData, "formEntity"); return(new HttpResponseMessage <JsonQueryResult>(context.GetQueryResult())); } }
protected EntityPackage SetLikeNew(EntityPackage package) { package.Entity.id = 0; package.Values.ForEach(x => x.id = 0); package.Relations.ForEach(x => x.id = 0); return(package); }
public bool CanUser(long userId, string action, EntityPackage package) { return(CanUser(new Requester() { userId = userId }, action, package)); }
//public static ILogger Logger = null; /// <summary> /// Write an entire entity wrapper as-is, setting all associated ids. /// </summary> /// <param name="provider"></param> /// <param name="entity"></param> /// <returns></returns> public static async Task WriteAsync(this IEntityProvider provider, EntityPackage entity) { var allWrite = new List <EntityBase>(); allWrite.AddRange(entity.Values); allWrite.AddRange(entity.Relations); if (entity.Entity.id > 0) { //If this is an update entity, it's easy. Just save everything all //at once, making the whole dang thing atomic allWrite.Add(entity.Entity); await provider.WriteAsync(allWrite.ToArray()); } else { //If this is a NEW entity, try to write it first then update the values and relations. //If something goes wrong with the values/relations, delete the entity we added. await provider.WriteAsync(entity.Entity); try { entity.Values.ForEach(x => x.entityId = entity.Entity.id); entity.Relations.ForEach(x => x.entityId2 = entity.Entity.id); //Assume relations are all parents. a user has perms ON this entity, a category OWNS this entity, etc. await provider.WriteAsync(allWrite.ToArray()); } catch { await provider.DeleteAsync(entity.Entity); throw; } } }
public static List <EntityBase> FlattenPackage(this EntityPackage package) { var result = new List <EntityBase>(); FlattenPackage(package, result); return(result); }
public void FullUpdate() //Lots of tests with updating { var package = SimplePackage(); var originaPackageCopy = new EntityPackage(package); service.InsertWithHistoryAsync(package, 1).Wait(); var firstInsertedPackage = new EntityPackage(package); package.Relations.First().value = "Something NEW"; package.Values.First().value = "aha MORE"; service.UpdateWithHistoryAsync(package, 1).Wait(); //This shouldn't be "new", it should be the same as before Assert.Equal(firstInsertedPackage.Entity.id, package.Entity.id); var revisions = service.GetRevisionIdsAsync(package.Entity.id).Result; Assert.Single(revisions); Assert.NotEqual(package.Entity.id, revisions.First()); //Ensure the CURRENT package we pulled out is EXACTLY the same (minus date kind) var currentPackage = provider.FindByIdAsync(package.Entity.id).Result; Assert.Equal(package, currentPackage); //Ensure the package from history is EXACTLY the same as the one before sans ids (set all to 0) var revisionPackage = provider.FindByIdAsync(revisions.First()).Result; var likeUpdate = service.ConvertHistoryToUpdate(revisionPackage); Assert.Equal(firstInsertedPackage, likeUpdate); }
public async Task InsertWithHistoryAsync(EntityPackage newData, long user, Action <EntityPackage> modifyBeforeCreate = null) { if (newData.Entity.id > 0) { throw new InvalidOperationException("'New' package has non-zero id!"); } var mainEntity = newData.Entity; await provider.WriteAsync(mainEntity); try { newData.Relink(); modifyBeforeCreate?.Invoke(newData); var writes = new List <EntityBase>(); //Must write everything else at the same time. We only wrote the first thing to get the ID writes.AddRange(newData.Values); writes.AddRange(newData.Relations); writes.Add(activityService.MakeActivity(newData.Entity, user, Keys.CreateAction)); await provider.WriteAsync(writes.ToArray()); } catch { logger.LogError("Failure during historic insert, trying to undo... Exception bubbling"); await provider.DeleteAsync(mainEntity); throw; } }
public bool CanUser(Requester requester, string action, EntityPackage package) { //Inefficient in compute but easier for me, the programmer, to use a single source of truth. return(PermissionWhere(package.Relations.Select(x => new EntityGroup() { permission = x }).AsQueryable(), requester, action).Any()); }
public void ApplyFromValueView(IValueView view, EntityPackage package, string type) { FromViewValues(view.values).ForEach(x => { x.entityId = view.id; package.Add(x); }); }
/// <summary> /// Create a "new" copy of the given entity /// </summary> /// <param name="entity"></param> public static EntityPackage NewCopy(this EntityPackage entity) { var newEntity = new EntityPackage(entity); newEntity.Entity.id = 0; newEntity.Values.ForEach(x => x.id = 0); newEntity.Relations.ForEach(x => x.id = 0); return(newEntity); }
public override async Task <FileView> CleanViewUpdateAsync(FileView view, EntityPackage existing, Requester requester) { var result = await base.CleanViewGeneralAsync(view, requester); //Always restore the filetype, you can't change uploaded files anyway. result.fileType = existing.Entity.content; return(result); }
public void ApplyToPermissionView(EntityPackage package, IPermissionView view) { if (package.HasRelation(Keys.ParentRelation)) { view.parentId = package.GetRelation(Keys.ParentRelation).entityId1; } view.permissions = ToPerms(package.Relations); }
public static Task DeleteAsync(this IEntityProvider provider, EntityPackage package) { var deletes = new List <EntityBase>(); deletes.Add(package.Entity); deletes.AddRange(package.Values); deletes.AddRange(package.Relations); return(provider.DeleteAsync(deletes.ToArray())); }
public HttpResponseMessage <JsonQueryResult> GetNavigationTree() { EntityPackage context; context = new EntityPackage(); EntityData tree = ConsoleTreeRepository.GetTree(); context.AddEntityData(tree, "navItems"); return(new HttpResponseMessage <JsonQueryResult>(context.GetQueryResult())); }
/// <summary> /// Given a type, get the generated form for it. /// </summary> /// <param name="entityType">Type of the entity.</param> /// <param name="isInDesignMode">if set to <c>true</c> [is in design mode].</param> /// <returns> /// A response containing entity data for the form /// </returns> public static HttpResponseMessage <JsonQueryResult> GetGeneratedFormForType(EntityRef entityType, bool isInDesignMode) { EntityData formEntityData = EditFormHelper.GenerateDefaultFormForResourceType(entityType, isInDesignMode); var entityBatch = new EntityPackage( ); entityBatch.AddEntityData(formEntityData, "formEntity"); return(new HttpResponseMessage <JsonQueryResult>(entityBatch.GetQueryResult( ))); }
// Edit vview applications public void ApplyToEditView(EntityPackage package, IEditView view) { ApplyToBaseView(package.Entity, view); //History has a creator and an editor. The create date comes from base var creatorRelation = package.GetRelation(Keys.CreatorRelation); view.editDate = (DateTime)creatorRelation.createDateProper(); view.createUserId = creatorRelation.entityId1; view.editUserId = long.Parse(creatorRelation.value); }
private static List <string> PopulateEntityList(EntityPackage package) { var items = new List <string>(); for (var i = 0; i < package.loadedObjects_.Count; i++) { items.Add(package.loadedObjectNames_[i]); } return(items); }
/// <summary> /// Get a value from an entity package /// </summary> /// <param name="entity"></param> /// <param name="key"></param> /// <returns></returns> public static EntityValue GetValue(this EntityPackage entity, string key) { var values = FindValues(entity, key); if (values.Count() != 1) { throw new InvalidOperationException($"Not a single value for key: {key}"); } return(values.First()); }
/// <summary> /// Get a relation from an entity package /// </summary> /// <param name="entity"></param> /// <param name="key"></param> /// <returns></returns> public static EntityRelation GetRelation(this EntityPackage entity, string type) { var relations = FindRelations(entity, type); if (relations.Count() != 1) { throw new InvalidOperationException($"Not a single relation for type: {type}"); } return(relations.First()); }
/// <summary> /// Allow "fake" deletion of ANY historic entity (of any type) /// </summary> /// <param name="entityId"></param> /// <returns></returns> public async Task DeleteWithHistoryAsync(EntityPackage package, long user) { var historicPart = package.Entity; MakeHistoric(historicPart); //Notice it is a WRITe and not a delete. The activity extra will include the title. await provider.WriteAsync <EntityBase>( historicPart, activityService.MakeActivity(historicPart, user, Keys.DeleteAction, package.Entity.name)); }
public EntityPackage NewPackage() { var package = new EntityPackage() { Entity = NewEntity() }; var value = NewValue(); var relation = NewRelation(); package.Add(value); package.Add(relation); return(package); }
/// <summary> /// Clean the view specifically for updates, run AFTER general /// </summary> /// <param name="view"></param> /// <param name="existing"></param> /// <returns></returns> public virtual Task <V> CleanViewUpdateAsync(V view, EntityPackage existing, Requester requester) { //FORCE these to be what they were before. view.createDate = (DateTime)existing.Entity.createDateProper(); view.createUserId = existing.GetRelation(Keys.CreatorRelation).entityId1; //Don't allow posting over some other entity! THIS IS SUUUUPER IMPORTANT!!! if (!existing.Entity.type.StartsWith(EntityType)) { throw new BadRequestException($"No entity of proper type with id {view.id}"); } return(Task.FromResult(view)); }
/// <summary> /// Packages the form data response. /// </summary> /// <param name="entityData">The entity data.</param> /// <param name="initiallyHiddenControls">The initially hidden controls.</param> /// <returns></returns> private FormDataResponse PackageFormDataResponse(EntityData entityData, ISet <long> initiallyHiddenControls) { var context = new EntityPackage(); context.AddEntityData(entityData, "entity"); var response = new FormDataResponse { FormDataEntity = context.GetQueryResult(), InitiallyHiddenControls = initiallyHiddenControls }; return(response); }
public override async Task <FileView> CleanViewUpdateAsync(FileView view, EntityPackage existing, Requester requester) { var result = await base.CleanViewUpdateAsync(view, existing, requester); var existingView = converter.ToView(existing); //Always restore the filetype, you can't change uploaded files anyway. if (!requester.system) { result.fileType = existingView.fileType; //.Entity.content; result.quantization = existingView.quantization; //.GetValue(); } return(result); }
public override CategoryView ToView(EntityPackage package) { var view = new CategoryView(); this.ApplyToStandard(package, view); view.name = package.Entity.name; view.description = package.Entity.content; foreach (var v in package.Relations.Where(x => x.type == Keys.SuperRelation)) { view.localSupers.Add(v.entityId1); } return(view); }
public static void SetGenericValue(this EntityPackage package, string key, string value) { if (package.HasValue(key)) { package.GetValue(key).value = value; } else { package.Add(new EntityValue() { key = key, value = value, createDate = null }); } }
public override ContentView ToView(EntityPackage package) { var view = new ContentView(); this.ApplyToStandard(package, view); view.name = package.Entity.name; view.content = package.Entity.content; view.type = package.Entity.type.Substring(Keys.ContentType.Length); foreach (var keyword in package.Values.Where(x => x.key == Keys.KeywordKey)) { view.keywords.Add(keyword.value); } return(view); }
public void ApplyFromEditView(IEditView view, EntityPackage package, string type) { ApplyFromBaseView(view, package.Entity); package.Entity.type = type; var relation = new EntityRelation() { entityId1 = view.createUserId, entityId2 = view.id, type = Keys.CreatorRelation, value = view.editUserId.ToString(), createDate = view.editDate }; package.Add(relation); }
/// <summary> /// Given a type, get the default form for it. /// </summary> /// <param name="entityType">Type of the entity.</param> /// <param name="isInDesignMode">if set to <c>true</c> [is in design mode].</param> /// <param name="forceGenerate">Force a generated form to be used</param> /// <returns> /// A response containing entity data for the form /// </returns> public static HttpResponseMessage <JsonQueryResult> GetDefaultFormForType(EntityType entityType, bool isInDesignMode, bool forceGenerate) { CustomEditForm formRef = entityType.DefaultEditForm; if (formRef != null && !forceGenerate) { var entityBatch = new EntityPackage( ); EntityData formEntityData = EditFormHelper.GetFormAsEntityData(formRef); entityBatch.AddEntityData(formEntityData, "formEntity"); return(new HttpResponseMessage <JsonQueryResult>(entityBatch.GetQueryResult( ))); } //TODO: return something to indicate that there is no form return(GetGeneratedFormForType(entityType, isInDesignMode)); }
/// <summary> /// Update the given existing entity with the new entity, preserving the history for the original. /// </summary> /// <param name="updateData"></param> /// <param name="originalData"></param> /// <returns></returns> public async Task UpdateWithHistoryAsync(EntityPackage updateData, long user, EntityPackage originalData = null) { logger.LogTrace($"WriteHistoric called for entity {updateData.Entity.id}"); //The original isn't necessary; we can find it using the id from our apparently updated data if (originalData == null) { originalData = await provider.FindByIdAsync(updateData.Entity.id); } var history = await CreateHistoricCopyAsync(originalData.Entity); try { //Bring all the existing over to this historic entity history.Relink(originalData.Values, originalData.Relations); //WE have to link the new stuff to US because we want to write everything all at once originalData.Entity.Relink(updateData.Values, updateData.Relations); //Add the historic link back to the history copy from the originalData.Relations.Add(NewHistoryLink(updateData.Entity, history)); //A special thing: the values and relations need to be NEW for the update data updateData.Relations.ForEach(x => x.id = 0); updateData.Values.ForEach(x => x.id = 0); //We're writing the entirety of the "update" data. var writes = updateData.FlattenPackage(); //Also writing the relinked original stuff. writes.AddRange(originalData.Values); writes.AddRange(originalData.Relations); writes.Add(activityService.MakeActivity(updateData.Entity, user, Keys.UpdateAction, history.id.ToString())); await provider.WriteAsync(writes.ToArray()); } catch { logger.LogError("Failure during historic update, trying to undo... Exception bubbling..."); await provider.DeleteAsync(history); throw; } }