public void Delete(Intervention request)
{
using (Execute)
{
Execute.Run(ssn =>
{
if (!(request?.Id > 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No Id provided for delete.");
}
var en = DocEntityIntervention.GetIntervention(request?.Id);
if (null == en)
{
throw new HttpError(HttpStatusCode.NotFound, $"No Intervention could be found for Id {request?.Id}.");
}
if (en.IsRemoved)
{
return;
}
if (!DocPermissionFactory.HasPermission(en, currentUser, DocConstantPermission.DELETE))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have DELETE permission for this route.");
}
en.Remove();
DocCacheClient.RemoveSearch(DocConstantModelName.INTERVENTION);
DocCacheClient.RemoveById(request.Id);
});
}
}
private Scope _AssignValues(Scope request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Scope"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Scope ret = null;
request = _InitAssignValues <Scope>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Scope>(DocConstantModelName.SCOPE, nameof(Scope), request);
//First, assign all the variables, do database lookups and conversions
var pApp = DocEntityApp.Get(request.App?.Id, true, Execute) ?? DocEntityApp.Get(request.AppId, true, Execute);
var pBindings = GetVariable <Reference>(request, nameof(request.Bindings), request.Bindings?.ToList(), request.BindingsIds?.ToList());
var pBroadcasts = GetVariable <Reference>(request, nameof(request.Broadcasts), request.Broadcasts?.ToList(), request.BroadcastsIds?.ToList());
var pClient = DocEntityClient.Get(request.Client?.Id, true, Execute) ?? DocEntityClient.Get(request.ClientId, true, Execute);
var pDelete = request.Delete;
var pDocumentSet = DocEntityDocumentSet.Get(request.DocumentSet?.Id, true, Execute) ?? DocEntityDocumentSet.Get(request.DocumentSetId, true, Execute);
var pEdit = request.Edit;
var pHelp = GetVariable <Reference>(request, nameof(request.Help), request.Help?.ToList(), request.HelpIds?.ToList());
var pIsGlobal = request.IsGlobal;
var pScopedComments = GetVariable <Reference>(request, nameof(request.ScopedComments), request.ScopedComments?.ToList(), request.ScopedCommentsIds?.ToList());
var pScopedFiles = GetVariable <Reference>(request, nameof(request.ScopedFiles), request.ScopedFiles?.ToList(), request.ScopedFilesIds?.ToList());
var pScopedTags = GetVariable <Reference>(request, nameof(request.ScopedTags), request.ScopedTags?.ToList(), request.ScopedTagsIds?.ToList());
var pSynonyms = GetVariable <Reference>(request, nameof(request.Synonyms), request.Synonyms?.ToList(), request.SynonymsIds?.ToList());
var pTeam = DocEntityTeam.Get(request.Team?.Id, true, Execute) ?? DocEntityTeam.Get(request.TeamId, true, Execute);
var pType = request.Type;
var pUser = DocEntityUser.Get(request.User?.Id, true, Execute) ?? DocEntityUser.Get(request.UserId, true, Execute);
var pVariableRules = GetVariable <Reference>(request, nameof(request.VariableRules), request.VariableRules?.ToList(), request.VariableRulesIds?.ToList());
var pView = request.View;
var pWorkflows = GetVariable <Reference>(request, nameof(request.Workflows), request.Workflows?.ToList(), request.WorkflowsIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityScope, Scope>(request, permission, session);
if (AllowPatchValue <Scope, bool>(request, DocConstantModelName.SCOPE, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Scope, DocEntityApp>(request, DocConstantModelName.SCOPE, pApp, permission, nameof(request.App), pApp != entity.App))
{
entity.App = pApp;
}
if (AllowPatchValue <Scope, DocEntityClient>(request, DocConstantModelName.SCOPE, pClient, permission, nameof(request.Client), pClient != entity.Client))
{
entity.Client = pClient;
}
if (AllowPatchValue <Scope, bool>(request, DocConstantModelName.SCOPE, pDelete, permission, nameof(request.Delete), pDelete != entity.Delete))
{
entity.Delete = pDelete;
}
if (AllowPatchValue <Scope, DocEntityDocumentSet>(request, DocConstantModelName.SCOPE, pDocumentSet, permission, nameof(request.DocumentSet), pDocumentSet != entity.DocumentSet))
{
entity.DocumentSet = pDocumentSet;
}
if (AllowPatchValue <Scope, bool>(request, DocConstantModelName.SCOPE, pEdit, permission, nameof(request.Edit), pEdit != entity.Edit))
{
entity.Edit = pEdit;
}
if (AllowPatchValue <Scope, bool>(request, DocConstantModelName.SCOPE, pIsGlobal, permission, nameof(request.IsGlobal), pIsGlobal != entity.IsGlobal))
{
entity.IsGlobal = pIsGlobal;
}
if (AllowPatchValue <Scope, DocEntityTeam>(request, DocConstantModelName.SCOPE, pTeam, permission, nameof(request.Team), pTeam != entity.Team))
{
entity.Team = pTeam;
}
if (AllowPatchValue <Scope, ScopeEnm?>(request, DocConstantModelName.SCOPE, pType, permission, nameof(request.Type), pType != entity.Type))
{
if (null != pType)
{
entity.Type = pType.Value;
}
}
if (AllowPatchValue <Scope, DocEntityUser>(request, DocConstantModelName.SCOPE, pUser, permission, nameof(request.User), pUser != entity.User))
{
entity.User = pUser;
}
if (AllowPatchValue <Scope, bool>(request, DocConstantModelName.SCOPE, pView, permission, nameof(request.View), pView != entity.View))
{
entity.View = pView;
}
if (request.Locked && AllowPatchValue <Scope, bool>(request, DocConstantModelName.SCOPE, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <Scope, DocEntityScope, Reference, DocEntityLookupTableBinding>(request, entity, pBindings, permission, nameof(request.Bindings)));
idsToInvalidate.AddRange(PatchCollection <Scope, DocEntityScope, Reference, DocEntityBroadcast>(request, entity, pBroadcasts, permission, nameof(request.Broadcasts)));
idsToInvalidate.AddRange(PatchCollection <Scope, DocEntityScope, Reference, DocEntityHelp>(request, entity, pHelp, permission, nameof(request.Help)));
idsToInvalidate.AddRange(PatchCollection <Scope, DocEntityScope, Reference, DocEntityComment>(request, entity, pScopedComments, permission, nameof(request.ScopedComments)));
idsToInvalidate.AddRange(PatchCollection <Scope, DocEntityScope, Reference, DocEntityFile>(request, entity, pScopedFiles, permission, nameof(request.ScopedFiles)));
idsToInvalidate.AddRange(PatchCollection <Scope, DocEntityScope, Reference, DocEntityTag>(request, entity, pScopedTags, permission, nameof(request.ScopedTags)));
idsToInvalidate.AddRange(PatchCollection <Scope, DocEntityScope, Reference, DocEntityTermSynonym>(request, entity, pSynonyms, permission, nameof(request.Synonyms)));
idsToInvalidate.AddRange(PatchCollection <Scope, DocEntityScope, Reference, DocEntityVariableRule>(request, entity, pVariableRules, permission, nameof(request.VariableRules)));
idsToInvalidate.AddRange(PatchCollection <Scope, DocEntityScope, Reference, DocEntityWorkflow>(request, entity, pWorkflows, permission, nameof(request.Workflows)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.SCOPE);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Scope>(currentUser, nameof(Scope), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.SCOPE);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.SCOPE, cacheExpires);
return(ret);
}
private Intervention _AssignValues(Intervention request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Intervention"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.VisibleFields = request.VisibleFields ?? new List <string>();
Intervention ret = null;
request = _InitAssignValues <Intervention>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Intervention>(DocConstantModelName.INTERVENTION, nameof(Intervention), request);
//First, assign all the variables, do database lookups and conversions
var pDocumentSets = request.DocumentSets?.ToList();
var pName = request.Name;
var pURI = request.URI;
DocEntityIntervention entity = null;
if (permission == DocConstantPermission.ADD)
{
var now = DateTime.UtcNow;
entity = new DocEntityIntervention(session)
{
Created = now,
Updated = now
};
}
else
{
entity = DocEntityIntervention.GetIntervention(request.Id);
if (null == entity)
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
}
//Special case for Archived
var pArchived = true == request.Archived;
if (DocPermissionFactory.IsRequestedHasPermission <bool>(currentUser, request, pArchived, permission, DocConstantModelName.INTERVENTION, nameof(request.Archived)))
{
if (DocPermissionFactory.IsRequested(request, pArchived, entity.Archived, nameof(request.Archived)))
{
if (DocResources.Metadata.IsInsertOnly(DocConstantModelName.INTERVENTION, nameof(request.Archived)) && DocConstantPermission.ADD != permission)
{
throw new HttpError(HttpStatusCode.Forbidden, $"{nameof(request.Archived)} cannot be modified once set.");
}
}
if (DocTools.IsNullOrEmpty(pArchived) && DocResources.Metadata.IsRequired(DocConstantModelName.INTERVENTION, nameof(request.Archived)))
{
throw new HttpError(HttpStatusCode.BadRequest, $"{nameof(request.Archived)} requires a value.");
}
entity.Archived = pArchived;
if (DocPermissionFactory.IsRequested <bool>(request, pArchived, nameof(request.Archived)) && !request.VisibleFields.Matches(nameof(request.Archived), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.Archived));
}
}
if (DocPermissionFactory.IsRequestedHasPermission <string>(currentUser, request, pName, permission, DocConstantModelName.INTERVENTION, nameof(request.Name)))
{
if (DocPermissionFactory.IsRequested(request, pName, entity.Name, nameof(request.Name)))
{
if (DocResources.Metadata.IsInsertOnly(DocConstantModelName.INTERVENTION, nameof(request.Name)) && DocConstantPermission.ADD != permission)
{
throw new HttpError(HttpStatusCode.Forbidden, $"{nameof(request.Name)} cannot be modified once set.");
}
}
if (DocTools.IsNullOrEmpty(pName) && DocResources.Metadata.IsRequired(DocConstantModelName.INTERVENTION, nameof(request.Name)))
{
throw new HttpError(HttpStatusCode.BadRequest, $"{nameof(request.Name)} requires a value.");
}
entity.Name = pName;
if (DocPermissionFactory.IsRequested <string>(request, pName, nameof(request.Name)) && !request.VisibleFields.Matches(nameof(request.Name), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.Name));
}
}
if (DocPermissionFactory.IsRequestedHasPermission <string>(currentUser, request, pURI, permission, DocConstantModelName.INTERVENTION, nameof(request.URI)))
{
if (DocPermissionFactory.IsRequested(request, pURI, entity.URI, nameof(request.URI)))
{
if (DocResources.Metadata.IsInsertOnly(DocConstantModelName.INTERVENTION, nameof(request.URI)) && DocConstantPermission.ADD != permission)
{
throw new HttpError(HttpStatusCode.Forbidden, $"{nameof(request.URI)} cannot be modified once set.");
}
}
if (DocTools.IsNullOrEmpty(pURI) && DocResources.Metadata.IsRequired(DocConstantModelName.INTERVENTION, nameof(request.URI)))
{
throw new HttpError(HttpStatusCode.BadRequest, $"{nameof(request.URI)} requires a value.");
}
entity.URI = pURI;
if (DocPermissionFactory.IsRequested <string>(request, pURI, nameof(request.URI)) && !request.VisibleFields.Matches(nameof(request.URI), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.URI));
}
}
if (request.Locked)
{
entity.Locked = request.Locked;
}
entity.SaveChanges(permission);
if (DocPermissionFactory.IsRequestedHasPermission <List <Reference> >(currentUser, request, pDocumentSets, permission, DocConstantModelName.INTERVENTION, nameof(request.DocumentSets)))
{
if (true == pDocumentSets?.Any())
{
var requestedDocumentSets = pDocumentSets.Select(p => p.Id).Distinct().ToList();
var existsDocumentSets = Execute.SelectAll <DocEntityDocumentSet>().Where(e => e.Id.In(requestedDocumentSets)).Select(e => e.Id).ToList();
if (existsDocumentSets.Count != requestedDocumentSets.Count)
{
var nonExists = requestedDocumentSets.Where(id => existsDocumentSets.All(eId => eId != id));
throw new HttpError(HttpStatusCode.NotFound, $"Cannot patch collection DocumentSets with objects that do not exist. No matching DocumentSets(s) could be found for Ids: {nonExists.ToDelimitedString()}.");
}
var toAdd = requestedDocumentSets.Where(id => entity.DocumentSets.All(e => e.Id != id)).ToList();
toAdd?.ForEach(id =>
{
var target = DocEntityDocumentSet.GetDocumentSet(id);
if (!DocPermissionFactory.HasPermission(entity, currentUser, DocConstantPermission.ADD, targetEntity: target, targetName: nameof(Intervention), columnName: nameof(request.DocumentSets)))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have permission to add {nameof(request.DocumentSets)} to {nameof(Intervention)}");
}
entity.DocumentSets.Add(target);
});
var toRemove = entity.DocumentSets.Where(e => requestedDocumentSets.All(id => e.Id != id)).Select(e => e.Id).ToList();
toRemove.ForEach(id =>
{
var target = DocEntityDocumentSet.GetDocumentSet(id);
if (!DocPermissionFactory.HasPermission(entity, currentUser, DocConstantPermission.REMOVE, targetEntity: target, targetName: nameof(Intervention), columnName: nameof(request.DocumentSets)))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have permission to remove {nameof(request.DocumentSets)} from {nameof(Intervention)}");
}
entity.DocumentSets.Remove(target);
});
}
else
{
var toRemove = entity.DocumentSets.Select(e => e.Id).ToList();
toRemove.ForEach(id =>
{
var target = DocEntityDocumentSet.GetDocumentSet(id);
if (!DocPermissionFactory.HasPermission(entity, currentUser, DocConstantPermission.REMOVE, targetEntity: target, targetName: nameof(Intervention), columnName: nameof(request.DocumentSets)))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have permission to remove {nameof(request.DocumentSets)} from {nameof(Intervention)}");
}
entity.DocumentSets.Remove(target);
});
}
if (DocPermissionFactory.IsRequested <List <Reference> >(request, pDocumentSets, nameof(request.DocumentSets)) && !request.VisibleFields.Matches(nameof(request.DocumentSets), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.DocumentSets));
}
}
DocPermissionFactory.SetVisibleFields <Intervention>(currentUser, nameof(Intervention), request.VisibleFields);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.INTERVENTION);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.INTERVENTION, cacheExpires);
return(ret);
}
private Team _AssignValues(Team request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Team"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Team ret = null;
request = _InitAssignValues <Team>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Team>(DocConstantModelName.TEAM, nameof(Team), request);
//First, assign all the variables, do database lookups and conversions
var pAdminRoles = GetVariable <Reference>(request, nameof(request.AdminRoles), request.AdminRoles?.ToList(), request.AdminRolesIds?.ToList());
var pDescription = request.Description;
var pEmail = request.Email;
var pIsInternal = request.IsInternal;
var pName = request.Name;
var pOwner = DocEntityUser.Get(request.Owner?.Id, true, Execute) ?? DocEntityUser.Get(request.OwnerId, true, Execute);
var pScopes = GetVariable <Reference>(request, nameof(request.Scopes), request.Scopes?.ToList(), request.ScopesIds?.ToList());
var pSettings = (DocTools.IsNullOrEmpty(request.Settings)) ? null : DocSerialize <TeamSettings> .ToString(request.Settings);
var pSlack = request.Slack;
var pUpdates = GetVariable <Reference>(request, nameof(request.Updates), request.Updates?.ToList(), request.UpdatesIds?.ToList());
var pUsers = GetVariable <Reference>(request, nameof(request.Users), request.Users?.ToList(), request.UsersIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityTeam, Team>(request, permission, session);
if (AllowPatchValue <Team, bool>(request, DocConstantModelName.TEAM, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Team, string>(request, DocConstantModelName.TEAM, pDescription, permission, nameof(request.Description), pDescription != entity.Description))
{
entity.Description = pDescription;
}
if (AllowPatchValue <Team, string>(request, DocConstantModelName.TEAM, pEmail, permission, nameof(request.Email), pEmail != entity.Email))
{
entity.Email = pEmail;
}
if (AllowPatchValue <Team, bool>(request, DocConstantModelName.TEAM, pIsInternal, permission, nameof(request.IsInternal), pIsInternal != entity.IsInternal))
{
entity.IsInternal = pIsInternal;
}
if (AllowPatchValue <Team, string>(request, DocConstantModelName.TEAM, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (AllowPatchValue <Team, DocEntityUser>(request, DocConstantModelName.TEAM, pOwner, permission, nameof(request.Owner), pOwner != entity.Owner))
{
entity.Owner = pOwner;
}
if (AllowPatchValue <Team, string>(request, DocConstantModelName.TEAM, pSettings, permission, nameof(request.Settings), pSettings != entity.Settings))
{
entity.Settings = pSettings;
}
if (AllowPatchValue <Team, string>(request, DocConstantModelName.TEAM, pSlack, permission, nameof(request.Slack), pSlack != entity.Slack))
{
entity.Slack = pSlack;
}
if (request.Locked && AllowPatchValue <Team, bool>(request, DocConstantModelName.TEAM, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <Team, DocEntityTeam, Reference, DocEntityRole>(request, entity, pAdminRoles, permission, nameof(request.AdminRoles)));
idsToInvalidate.AddRange(PatchCollection <Team, DocEntityTeam, Reference, DocEntityScope>(request, entity, pScopes, permission, nameof(request.Scopes)));
idsToInvalidate.AddRange(PatchCollection <Team, DocEntityTeam, Reference, DocEntityUpdate>(request, entity, pUpdates, permission, nameof(request.Updates)));
idsToInvalidate.AddRange(PatchCollection <Team, DocEntityTeam, Reference, DocEntityUser>(request, entity, pUsers, permission, nameof(request.Users)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.TEAM);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Team>(currentUser, nameof(Team), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.TEAM);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.TEAM, cacheExpires);
return(ret);
}
private LocaleLookup _AssignValues(LocaleLookup request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "LocaleLookup"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
LocaleLookup ret = null;
request = _InitAssignValues <LocaleLookup>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <LocaleLookup>(DocConstantModelName.LOCALELOOKUP, nameof(LocaleLookup), request);
//First, assign all the variables, do database lookups and conversions
var pData = (DocTools.IsNullOrEmpty(request.Data)) ? null : DocSerialize <IpData> .ToString(request.Data);
var pIpAddress = request.IpAddress;
var pLocale = DocEntityLocale.Get(request.Locale?.Id, true, Execute) ?? DocEntityLocale.Get(request.LocaleId, true, Execute);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityLocaleLookup, LocaleLookup>(request, permission, session);
if (AllowPatchValue <LocaleLookup, bool>(request, DocConstantModelName.LOCALELOOKUP, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <LocaleLookup, string>(request, DocConstantModelName.LOCALELOOKUP, pData, permission, nameof(request.Data), pData != entity.Data))
{
entity.Data = pData;
}
if (AllowPatchValue <LocaleLookup, string>(request, DocConstantModelName.LOCALELOOKUP, pIpAddress, permission, nameof(request.IpAddress), pIpAddress != entity.IpAddress))
{
entity.IpAddress = pIpAddress;
}
if (AllowPatchValue <LocaleLookup, DocEntityLocale>(request, DocConstantModelName.LOCALELOOKUP, pLocale, permission, nameof(request.Locale), pLocale != entity.Locale))
{
entity.Locale = pLocale;
}
if (request.Locked && AllowPatchValue <LocaleLookup, bool>(request, DocConstantModelName.LOCALELOOKUP, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.LOCALELOOKUP);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <LocaleLookup>(currentUser, nameof(LocaleLookup), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.LOCALELOOKUP);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.LOCALELOOKUP, cacheExpires);
return(ret);
}
private UnitOfMeasure _AssignValues(UnitOfMeasure request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "UnitOfMeasure"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
UnitOfMeasure ret = null;
request = _InitAssignValues <UnitOfMeasure>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <UnitOfMeasure>(DocConstantModelName.UNITOFMEASURE, nameof(UnitOfMeasure), request);
//First, assign all the variables, do database lookups and conversions
var pIsSI = request.IsSI;
DocEntityLookupTable pName = GetLookup(DocConstantLookupTable.UOMNAME, request.Name?.Name, request.Name?.Id);
DocEntityLookupTable pType = GetLookup(DocConstantLookupTable.UNITTYPE, request.Type?.Name, request.Type?.Id);
DocEntityLookupTable pUnit = GetLookup(DocConstantLookupTable.UOMUNIT, request.Unit?.Name, request.Unit?.Id);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityUnitOfMeasure, UnitOfMeasure>(request, permission, session);
if (AllowPatchValue <UnitOfMeasure, bool>(request, DocConstantModelName.UNITOFMEASURE, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <UnitOfMeasure, bool>(request, DocConstantModelName.UNITOFMEASURE, pIsSI, permission, nameof(request.IsSI), pIsSI != entity.IsSI))
{
entity.IsSI = pIsSI;
}
if (AllowPatchValue <UnitOfMeasure, DocEntityLookupTable>(request, DocConstantModelName.UNITOFMEASURE, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (AllowPatchValue <UnitOfMeasure, DocEntityLookupTable>(request, DocConstantModelName.UNITOFMEASURE, pType, permission, nameof(request.Type), pType != entity.Type))
{
entity.Type = pType;
}
if (AllowPatchValue <UnitOfMeasure, DocEntityLookupTable>(request, DocConstantModelName.UNITOFMEASURE, pUnit, permission, nameof(request.Unit), pUnit != entity.Unit))
{
entity.Unit = pUnit;
}
if (request.Locked && AllowPatchValue <UnitOfMeasure, bool>(request, DocConstantModelName.UNITOFMEASURE, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.UNITOFMEASURE);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <UnitOfMeasure>(currentUser, nameof(UnitOfMeasure), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.UNITOFMEASURE);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.UNITOFMEASURE, cacheExpires);
return(ret);
}
private Attribute _AssignValues(Attribute request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Attribute"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Attribute ret = null;
request = _InitAssignValues <Attribute>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Attribute>(DocConstantModelName.ATTRIBUTE, nameof(Attribute), request);
//First, assign all the variables, do database lookups and conversions
DocEntityLookupTable pAttributeName = GetLookup(DocConstantLookupTable.ATTRIBUTENAME, request.AttributeName?.Name, request.AttributeName?.Id);
DocEntityLookupTable pAttributeType = GetLookup(DocConstantLookupTable.ATTRIBUTETYPE, request.AttributeType?.Name, request.AttributeType?.Id);
var pInterval = DocEntityAttributeInterval.Get(request.Interval?.Id, true, Execute) ?? DocEntityAttributeInterval.Get(request.IntervalId, true, Execute);
var pIsCharacteristic = request.IsCharacteristic;
var pIsOutcome = request.IsOutcome;
var pIsPositive = request.IsPositive;
var pUniqueKey = request.UniqueKey;
var pValueType = DocEntityValueType.Get(request.ValueType);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityAttribute, Attribute>(request, permission, session);
if (AllowPatchValue <Attribute, bool>(request, DocConstantModelName.ATTRIBUTE, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Attribute, DocEntityLookupTable>(request, DocConstantModelName.ATTRIBUTE, pAttributeName, permission, nameof(request.AttributeName), pAttributeName != entity.AttributeName))
{
entity.AttributeName = pAttributeName;
}
if (AllowPatchValue <Attribute, DocEntityLookupTable>(request, DocConstantModelName.ATTRIBUTE, pAttributeType, permission, nameof(request.AttributeType), pAttributeType != entity.AttributeType))
{
entity.AttributeType = pAttributeType;
}
if (AllowPatchValue <Attribute, DocEntityAttributeInterval>(request, DocConstantModelName.ATTRIBUTE, pInterval, permission, nameof(request.Interval), pInterval != entity.Interval))
{
entity.Interval = pInterval;
}
if (AllowPatchValue <Attribute, bool>(request, DocConstantModelName.ATTRIBUTE, pIsCharacteristic, permission, nameof(request.IsCharacteristic), pIsCharacteristic != entity.IsCharacteristic))
{
entity.IsCharacteristic = pIsCharacteristic;
}
if (AllowPatchValue <Attribute, bool>(request, DocConstantModelName.ATTRIBUTE, pIsOutcome, permission, nameof(request.IsOutcome), pIsOutcome != entity.IsOutcome))
{
entity.IsOutcome = pIsOutcome;
}
if (AllowPatchValue <Attribute, bool?>(request, DocConstantModelName.ATTRIBUTE, pIsPositive, permission, nameof(request.IsPositive), pIsPositive != entity.IsPositive))
{
entity.IsPositive = pIsPositive;
}
if (AllowPatchValue <Attribute, string>(request, DocConstantModelName.ATTRIBUTE, pUniqueKey, permission, nameof(request.UniqueKey), pUniqueKey != entity.UniqueKey))
{
entity.UniqueKey = pUniqueKey;
}
if (AllowPatchValue <Attribute, DocEntityValueType>(request, DocConstantModelName.ATTRIBUTE, pValueType, permission, nameof(request.ValueType), pValueType != entity.ValueType))
{
entity.ValueType = pValueType;
}
if (request.Locked && AllowPatchValue <Attribute, bool>(request, DocConstantModelName.ATTRIBUTE, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.ATTRIBUTE);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Attribute>(currentUser, nameof(Attribute), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.ATTRIBUTE);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.ATTRIBUTE, cacheExpires);
return(ret);
}
public override void FlushCache()
{
base.FlushCache();
DocCacheClient.RemoveById(Id);
}
private LookupTable _AssignValues(LookupTable request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "LookupTable"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
LookupTable ret = null;
request = _InitAssignValues <LookupTable>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <LookupTable>(DocConstantModelName.LOOKUPTABLE, nameof(LookupTable), request);
//First, assign all the variables, do database lookups and conversions
var pBindings = GetVariable <Reference>(request, nameof(request.Bindings), request.Bindings?.ToList(), request.BindingsIds?.ToList());
var pCategories = GetVariable <Reference>(request, nameof(request.Categories), request.Categories?.ToList(), request.CategoriesIds?.ToList());
var pDocuments = GetVariable <Reference>(request, nameof(request.Documents), request.Documents?.ToList(), request.DocumentsIds?.ToList());
var pEnum = DocEntityLookupTableEnum.Get(request.Enum);
var pName = request.Name;
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityLookupTable, LookupTable>(request, permission, session);
if (AllowPatchValue <LookupTable, bool>(request, DocConstantModelName.LOOKUPTABLE, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <LookupTable, DocEntityLookupTableEnum>(request, DocConstantModelName.LOOKUPTABLE, pEnum, permission, nameof(request.Enum), pEnum != entity.Enum))
{
entity.Enum = pEnum;
}
if (AllowPatchValue <LookupTable, string>(request, DocConstantModelName.LOOKUPTABLE, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (request.Locked && AllowPatchValue <LookupTable, bool>(request, DocConstantModelName.LOOKUPTABLE, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <LookupTable, DocEntityLookupTable, Reference, DocEntityLookupTableBinding>(request, entity, pBindings, permission, nameof(request.Bindings)));
idsToInvalidate.AddRange(PatchCollection <LookupTable, DocEntityLookupTable, Reference, DocEntityLookupCategory>(request, entity, pCategories, permission, nameof(request.Categories)));
idsToInvalidate.AddRange(PatchCollection <LookupTable, DocEntityLookupTable, Reference, DocEntityDocument>(request, entity, pDocuments, permission, nameof(request.Documents)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.LOOKUPTABLE);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <LookupTable>(currentUser, nameof(LookupTable), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.LOOKUPTABLE);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.LOOKUPTABLE, cacheExpires);
return(ret);
}
private BackgroundTask _AssignValues(BackgroundTask request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "BackgroundTask"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
BackgroundTask ret = null;
request = _InitAssignValues <BackgroundTask>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <BackgroundTask>(DocConstantModelName.BACKGROUNDTASK, nameof(BackgroundTask), request);
//First, assign all the variables, do database lookups and conversions
var pApp = DocEntityApp.Get(request.App?.Id, true, Execute) ?? DocEntityApp.Get(request.AppId, true, Execute);
var pChannel = DocEntityQueueChannel.Get(request.Channel?.Id, true, Execute) ?? DocEntityQueueChannel.Get(request.ChannelId, true, Execute);
var pDescription = request.Description;
var pEnabled = request.Enabled;
var pFrequency = request.Frequency;
var pHistoryRetention = request.HistoryRetention;
var pItems = GetVariable <Reference>(request, nameof(request.Items), request.Items?.ToList(), request.ItemsIds?.ToList());
var pKeepHistory = request.KeepHistory;
var pLastRunVersion = request.LastRunVersion;
var pLogError = request.LogError;
var pLogInfo = request.LogInfo;
var pName = request.Name;
var pRowsToProcessPerIteration = request.RowsToProcessPerIteration;
var pRunNow = request.RunNow;
var pStartAt = request.StartAt;
var pTaskHistory = GetVariable <Reference>(request, nameof(request.TaskHistory), request.TaskHistory?.ToList(), request.TaskHistoryIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityBackgroundTask, BackgroundTask>(request, permission, session);
if (AllowPatchValue <BackgroundTask, bool>(request, DocConstantModelName.BACKGROUNDTASK, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <BackgroundTask, DocEntityApp>(request, DocConstantModelName.BACKGROUNDTASK, pApp, permission, nameof(request.App), pApp != entity.App))
{
entity.App = pApp;
}
if (AllowPatchValue <BackgroundTask, DocEntityQueueChannel>(request, DocConstantModelName.BACKGROUNDTASK, pChannel, permission, nameof(request.Channel), pChannel != entity.Channel))
{
entity.Channel = pChannel;
}
if (AllowPatchValue <BackgroundTask, string>(request, DocConstantModelName.BACKGROUNDTASK, pDescription, permission, nameof(request.Description), pDescription != entity.Description))
{
entity.Description = pDescription;
}
if (AllowPatchValue <BackgroundTask, bool>(request, DocConstantModelName.BACKGROUNDTASK, pEnabled, permission, nameof(request.Enabled), pEnabled != entity.Enabled))
{
entity.Enabled = pEnabled;
}
if (AllowPatchValue <BackgroundTask, int?>(request, DocConstantModelName.BACKGROUNDTASK, pFrequency, permission, nameof(request.Frequency), pFrequency != entity.Frequency))
{
if (null != pFrequency)
{
entity.Frequency = (int)pFrequency;
}
}
if (AllowPatchValue <BackgroundTask, int?>(request, DocConstantModelName.BACKGROUNDTASK, pHistoryRetention, permission, nameof(request.HistoryRetention), pHistoryRetention != entity.HistoryRetention))
{
entity.HistoryRetention = pHistoryRetention;
}
if (AllowPatchValue <BackgroundTask, bool>(request, DocConstantModelName.BACKGROUNDTASK, pKeepHistory, permission, nameof(request.KeepHistory), pKeepHistory != entity.KeepHistory))
{
entity.KeepHistory = pKeepHistory;
}
if (AllowPatchValue <BackgroundTask, string>(request, DocConstantModelName.BACKGROUNDTASK, pLastRunVersion, permission, nameof(request.LastRunVersion), pLastRunVersion != entity.LastRunVersion))
{
entity.LastRunVersion = pLastRunVersion;
}
if (AllowPatchValue <BackgroundTask, bool>(request, DocConstantModelName.BACKGROUNDTASK, pLogError, permission, nameof(request.LogError), pLogError != entity.LogError))
{
entity.LogError = pLogError;
}
if (AllowPatchValue <BackgroundTask, bool>(request, DocConstantModelName.BACKGROUNDTASK, pLogInfo, permission, nameof(request.LogInfo), pLogInfo != entity.LogInfo))
{
entity.LogInfo = pLogInfo;
}
if (AllowPatchValue <BackgroundTask, string>(request, DocConstantModelName.BACKGROUNDTASK, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (AllowPatchValue <BackgroundTask, int?>(request, DocConstantModelName.BACKGROUNDTASK, pRowsToProcessPerIteration, permission, nameof(request.RowsToProcessPerIteration), pRowsToProcessPerIteration != entity.RowsToProcessPerIteration))
{
if (null != pRowsToProcessPerIteration)
{
entity.RowsToProcessPerIteration = (int)pRowsToProcessPerIteration;
}
}
if (AllowPatchValue <BackgroundTask, bool>(request, DocConstantModelName.BACKGROUNDTASK, pRunNow, permission, nameof(request.RunNow), pRunNow != entity.RunNow))
{
entity.RunNow = pRunNow;
}
if (AllowPatchValue <BackgroundTask, string>(request, DocConstantModelName.BACKGROUNDTASK, pStartAt, permission, nameof(request.StartAt), pStartAt != entity.StartAt))
{
entity.StartAt = pStartAt;
}
if (request.Locked && AllowPatchValue <BackgroundTask, bool>(request, DocConstantModelName.BACKGROUNDTASK, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <BackgroundTask, DocEntityBackgroundTask, Reference, DocEntityBackgroundTaskItem>(request, entity, pItems, permission, nameof(request.Items)));
idsToInvalidate.AddRange(PatchCollection <BackgroundTask, DocEntityBackgroundTask, Reference, DocEntityBackgroundTaskHistory>(request, entity, pTaskHistory, permission, nameof(request.TaskHistory)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.BACKGROUNDTASK);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <BackgroundTask>(currentUser, nameof(BackgroundTask), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.BACKGROUNDTASK);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.BACKGROUNDTASK, cacheExpires);
return(ret);
}
private ReleaseStatus _AssignValues(ReleaseStatus request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "ReleaseStatus"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.VisibleFields = request.VisibleFields ?? new List <string>();
ReleaseStatus ret = null;
request = _InitAssignValues <ReleaseStatus>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <ReleaseStatus>(DocConstantModelName.RELEASESTATUS, nameof(ReleaseStatus), request);
//First, assign all the variables, do database lookups and conversions
var pBranch = request.Branch;
var pRelease = request.Release;
var pServer = request.Server;
var pURL = request.URL;
var pVersion = request.Version;
DocEntityReleaseStatus entity = null;
if (permission == DocConstantPermission.ADD)
{
var now = DateTime.UtcNow;
entity = new DocEntityReleaseStatus(session)
{
Created = now,
Updated = now
};
}
else
{
entity = DocEntityReleaseStatus.GetReleaseStatus(request.Id);
if (null == entity)
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
}
//Special case for Archived
var pArchived = true == request.Archived;
if (DocPermissionFactory.IsRequestedHasPermission <bool>(currentUser, request, pArchived, permission, DocConstantModelName.RELEASESTATUS, nameof(request.Archived)))
{
if (DocPermissionFactory.IsRequested(request, pArchived, entity.Archived, nameof(request.Archived)))
{
if (DocResources.Metadata.IsInsertOnly(DocConstantModelName.RELEASESTATUS, nameof(request.Archived)) && DocConstantPermission.ADD != permission)
{
throw new HttpError(HttpStatusCode.Forbidden, $"{nameof(request.Archived)} cannot be modified once set.");
}
}
if (DocTools.IsNullOrEmpty(pArchived) && DocResources.Metadata.IsRequired(DocConstantModelName.RELEASESTATUS, nameof(request.Archived)))
{
throw new HttpError(HttpStatusCode.BadRequest, $"{nameof(request.Archived)} requires a value.");
}
entity.Archived = pArchived;
if (DocPermissionFactory.IsRequested <bool>(request, pArchived, nameof(request.Archived)) && !request.VisibleFields.Matches(nameof(request.Archived), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.Archived));
}
}
if (DocPermissionFactory.IsRequestedHasPermission <string>(currentUser, request, pBranch, permission, DocConstantModelName.RELEASESTATUS, nameof(request.Branch)))
{
if (DocPermissionFactory.IsRequested(request, pBranch, entity.Branch, nameof(request.Branch)))
{
if (DocResources.Metadata.IsInsertOnly(DocConstantModelName.RELEASESTATUS, nameof(request.Branch)) && DocConstantPermission.ADD != permission)
{
throw new HttpError(HttpStatusCode.Forbidden, $"{nameof(request.Branch)} cannot be modified once set.");
}
}
if (DocTools.IsNullOrEmpty(pBranch) && DocResources.Metadata.IsRequired(DocConstantModelName.RELEASESTATUS, nameof(request.Branch)))
{
throw new HttpError(HttpStatusCode.BadRequest, $"{nameof(request.Branch)} requires a value.");
}
entity.Branch = pBranch;
if (DocPermissionFactory.IsRequested <string>(request, pBranch, nameof(request.Branch)) && !request.VisibleFields.Matches(nameof(request.Branch), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.Branch));
}
}
if (DocPermissionFactory.IsRequestedHasPermission <string>(currentUser, request, pRelease, permission, DocConstantModelName.RELEASESTATUS, nameof(request.Release)))
{
if (DocPermissionFactory.IsRequested(request, pRelease, entity.Release, nameof(request.Release)))
{
if (DocResources.Metadata.IsInsertOnly(DocConstantModelName.RELEASESTATUS, nameof(request.Release)) && DocConstantPermission.ADD != permission)
{
throw new HttpError(HttpStatusCode.Forbidden, $"{nameof(request.Release)} cannot be modified once set.");
}
}
if (DocTools.IsNullOrEmpty(pRelease) && DocResources.Metadata.IsRequired(DocConstantModelName.RELEASESTATUS, nameof(request.Release)))
{
throw new HttpError(HttpStatusCode.BadRequest, $"{nameof(request.Release)} requires a value.");
}
entity.Release = pRelease;
if (DocPermissionFactory.IsRequested <string>(request, pRelease, nameof(request.Release)) && !request.VisibleFields.Matches(nameof(request.Release), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.Release));
}
}
if (DocPermissionFactory.IsRequestedHasPermission <string>(currentUser, request, pServer, permission, DocConstantModelName.RELEASESTATUS, nameof(request.Server)))
{
if (DocPermissionFactory.IsRequested(request, pServer, entity.Server, nameof(request.Server)))
{
if (DocResources.Metadata.IsInsertOnly(DocConstantModelName.RELEASESTATUS, nameof(request.Server)) && DocConstantPermission.ADD != permission)
{
throw new HttpError(HttpStatusCode.Forbidden, $"{nameof(request.Server)} cannot be modified once set.");
}
}
if (DocTools.IsNullOrEmpty(pServer) && DocResources.Metadata.IsRequired(DocConstantModelName.RELEASESTATUS, nameof(request.Server)))
{
throw new HttpError(HttpStatusCode.BadRequest, $"{nameof(request.Server)} requires a value.");
}
entity.Server = pServer;
if (DocPermissionFactory.IsRequested <string>(request, pServer, nameof(request.Server)) && !request.VisibleFields.Matches(nameof(request.Server), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.Server));
}
}
if (DocPermissionFactory.IsRequestedHasPermission <string>(currentUser, request, pURL, permission, DocConstantModelName.RELEASESTATUS, nameof(request.URL)))
{
if (DocPermissionFactory.IsRequested(request, pURL, entity.URL, nameof(request.URL)))
{
if (DocResources.Metadata.IsInsertOnly(DocConstantModelName.RELEASESTATUS, nameof(request.URL)) && DocConstantPermission.ADD != permission)
{
throw new HttpError(HttpStatusCode.Forbidden, $"{nameof(request.URL)} cannot be modified once set.");
}
}
if (DocTools.IsNullOrEmpty(pURL) && DocResources.Metadata.IsRequired(DocConstantModelName.RELEASESTATUS, nameof(request.URL)))
{
throw new HttpError(HttpStatusCode.BadRequest, $"{nameof(request.URL)} requires a value.");
}
entity.URL = pURL;
if (DocPermissionFactory.IsRequested <string>(request, pURL, nameof(request.URL)) && !request.VisibleFields.Matches(nameof(request.URL), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.URL));
}
}
if (DocPermissionFactory.IsRequestedHasPermission <string>(currentUser, request, pVersion, permission, DocConstantModelName.RELEASESTATUS, nameof(request.Version)))
{
if (DocPermissionFactory.IsRequested(request, pVersion, entity.Version, nameof(request.Version)))
{
if (DocResources.Metadata.IsInsertOnly(DocConstantModelName.RELEASESTATUS, nameof(request.Version)) && DocConstantPermission.ADD != permission)
{
throw new HttpError(HttpStatusCode.Forbidden, $"{nameof(request.Version)} cannot be modified once set.");
}
}
if (DocTools.IsNullOrEmpty(pVersion) && DocResources.Metadata.IsRequired(DocConstantModelName.RELEASESTATUS, nameof(request.Version)))
{
throw new HttpError(HttpStatusCode.BadRequest, $"{nameof(request.Version)} requires a value.");
}
entity.Version = pVersion;
if (DocPermissionFactory.IsRequested <string>(request, pVersion, nameof(request.Version)) && !request.VisibleFields.Matches(nameof(request.Version), ignoreSpaces: true))
{
request.VisibleFields.Add(nameof(request.Version));
}
}
if (request.Locked)
{
entity.Locked = request.Locked;
}
entity.SaveChanges(permission);
DocPermissionFactory.SetVisibleFields <ReleaseStatus>(currentUser, nameof(ReleaseStatus), request.VisibleFields);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.RELEASESTATUS);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.RELEASESTATUS, cacheExpires);
return(ret);
}
private Project _AssignValues(Project request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Project"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Project ret = null;
request = _InitAssignValues <Project>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Project>(DocConstantModelName.PROJECT, nameof(Project), request);
//First, assign all the variables, do database lookups and conversions
var pChildren = GetVariable <Reference>(request, nameof(request.Children), request.Children?.ToList(), request.ChildrenIds?.ToList());
var pClient = DocEntityClient.Get(request.Client?.Id, true, Execute) ?? DocEntityClient.Get(request.ClientId, true, Execute);
var pDatabaseDeadline = request.DatabaseDeadline;
var pDatabaseName = request.DatabaseName;
var pDataset = DocEntityDataSet.Get(request.Dataset?.Id, true, Execute) ?? DocEntityDataSet.Get(request.DatasetId, true, Execute);
var pDeliverableDeadline = request.DeliverableDeadline;
var pFqId = request.FqId;
var pFqWorkflow = DocEntityWorkflow.Get(request.FqWorkflow?.Id, true, Execute) ?? DocEntityWorkflow.Get(request.FqWorkflowId, true, Execute);
var pLegacyPackageId = request.LegacyPackageId;
var pLibrary = DocEntityLibrarySet.Get(request.Library?.Id, true, Execute) ?? DocEntityLibrarySet.Get(request.LibraryId, true, Execute);
var pLibraryPackageId = request.LibraryPackageId;
var pLibraryPackageName = request.LibraryPackageName;
var pNumber = request.Number;
var pOperationsDeliverable = request.OperationsDeliverable;
var pOpportunityId = request.OpportunityId;
var pOpportunityName = request.OpportunityName;
var pParent = DocEntityProject.Get(request.Parent?.Id, true, Execute) ?? DocEntityProject.Get(request.ParentId, true, Execute);
var pPICO = request.PICO;
var pProjectId = request.ProjectId;
var pProjectName = request.ProjectName;
var pStatus = request.Status;
var pTimeCards = GetVariable <Reference>(request, nameof(request.TimeCards), request.TimeCards?.ToList(), request.TimeCardsIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityProject, Project>(request, permission, session);
if (AllowPatchValue <Project, bool>(request, DocConstantModelName.PROJECT, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Project, DocEntityClient>(request, DocConstantModelName.PROJECT, pClient, permission, nameof(request.Client), pClient != entity.Client))
{
entity.Client = pClient;
}
if (AllowPatchValue <Project, DateTime?>(request, DocConstantModelName.PROJECT, pDatabaseDeadline, permission, nameof(request.DatabaseDeadline), pDatabaseDeadline != entity.DatabaseDeadline))
{
entity.DatabaseDeadline = pDatabaseDeadline;
}
if (AllowPatchValue <Project, string>(request, DocConstantModelName.PROJECT, pDatabaseName, permission, nameof(request.DatabaseName), pDatabaseName != entity.DatabaseName))
{
entity.DatabaseName = pDatabaseName;
}
if (AllowPatchValue <Project, DocEntityDataSet>(request, DocConstantModelName.PROJECT, pDataset, permission, nameof(request.Dataset), pDataset != entity.Dataset))
{
entity.Dataset = pDataset;
}
if (AllowPatchValue <Project, DateTime?>(request, DocConstantModelName.PROJECT, pDeliverableDeadline, permission, nameof(request.DeliverableDeadline), pDeliverableDeadline != entity.DeliverableDeadline))
{
entity.DeliverableDeadline = pDeliverableDeadline;
}
if (AllowPatchValue <Project, int?>(request, DocConstantModelName.PROJECT, pFqId, permission, nameof(request.FqId), pFqId != entity.FqId))
{
entity.FqId = pFqId;
}
if (AllowPatchValue <Project, DocEntityWorkflow>(request, DocConstantModelName.PROJECT, pFqWorkflow, permission, nameof(request.FqWorkflow), pFqWorkflow != entity.FqWorkflow))
{
entity.FqWorkflow = pFqWorkflow;
}
if (AllowPatchValue <Project, int?>(request, DocConstantModelName.PROJECT, pLegacyPackageId, permission, nameof(request.LegacyPackageId), pLegacyPackageId != entity.LegacyPackageId))
{
entity.LegacyPackageId = pLegacyPackageId;
}
if (AllowPatchValue <Project, DocEntityLibrarySet>(request, DocConstantModelName.PROJECT, pLibrary, permission, nameof(request.Library), pLibrary != entity.Library))
{
entity.Library = pLibrary;
}
if (AllowPatchValue <Project, int?>(request, DocConstantModelName.PROJECT, pLibraryPackageId, permission, nameof(request.LibraryPackageId), pLibraryPackageId != entity.LibraryPackageId))
{
entity.LibraryPackageId = pLibraryPackageId;
}
if (AllowPatchValue <Project, string>(request, DocConstantModelName.PROJECT, pLibraryPackageName, permission, nameof(request.LibraryPackageName), pLibraryPackageName != entity.LibraryPackageName))
{
entity.LibraryPackageName = pLibraryPackageName;
}
if (AllowPatchValue <Project, string>(request, DocConstantModelName.PROJECT, pNumber, permission, nameof(request.Number), pNumber != entity.Number))
{
entity.Number = pNumber;
}
if (AllowPatchValue <Project, string>(request, DocConstantModelName.PROJECT, pOperationsDeliverable, permission, nameof(request.OperationsDeliverable), pOperationsDeliverable != entity.OperationsDeliverable))
{
entity.OperationsDeliverable = pOperationsDeliverable;
}
if (AllowPatchValue <Project, string>(request, DocConstantModelName.PROJECT, pOpportunityId, permission, nameof(request.OpportunityId), pOpportunityId != entity.OpportunityId))
{
entity.OpportunityId = pOpportunityId;
}
if (AllowPatchValue <Project, string>(request, DocConstantModelName.PROJECT, pOpportunityName, permission, nameof(request.OpportunityName), pOpportunityName != entity.OpportunityName))
{
entity.OpportunityName = pOpportunityName;
}
if (AllowPatchValue <Project, DocEntityProject>(request, DocConstantModelName.PROJECT, pParent, permission, nameof(request.Parent), pParent != entity.Parent))
{
entity.Parent = pParent;
}
if (AllowPatchValue <Project, string>(request, DocConstantModelName.PROJECT, pPICO, permission, nameof(request.PICO), pPICO != entity.PICO))
{
entity.PICO = pPICO;
}
if (AllowPatchValue <Project, string>(request, DocConstantModelName.PROJECT, pProjectId, permission, nameof(request.ProjectId), pProjectId != entity.ProjectId))
{
entity.ProjectId = pProjectId;
}
if (AllowPatchValue <Project, string>(request, DocConstantModelName.PROJECT, pProjectName, permission, nameof(request.ProjectName), pProjectName != entity.ProjectName))
{
entity.ProjectName = pProjectName;
}
if (AllowPatchValue <Project, ForeignKeyStatusEnm?>(request, DocConstantModelName.PROJECT, pStatus, permission, nameof(request.Status), pStatus != entity.Status))
{
entity.Status = pStatus;
}
if (request.Locked && AllowPatchValue <Project, bool>(request, DocConstantModelName.PROJECT, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <Project, DocEntityProject, Reference, DocEntityProject>(request, entity, pChildren, permission, nameof(request.Children)));
idsToInvalidate.AddRange(PatchCollection <Project, DocEntityProject, Reference, DocEntityTimeCard>(request, entity, pTimeCards, permission, nameof(request.TimeCards)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.PROJECT);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Project>(currentUser, nameof(Project), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.PROJECT);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.PROJECT, cacheExpires);
return(ret);
}
private Interval _AssignValues(Interval request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Interval"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Interval ret = null;
request = _InitAssignValues <Interval>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Interval>(DocConstantModelName.INTERVAL, nameof(Interval), request);
//First, assign all the variables, do database lookups and conversions
var pCalendarDateEnd = DocEntityDateTime.Get(request.CalendarDateEnd?.Id, true, Execute) ?? DocEntityDateTime.Get(request.CalendarDateEndId, true, Execute);
var pCalendarDateStart = DocEntityDateTime.Get(request.CalendarDateStart?.Id, true, Execute) ?? DocEntityDateTime.Get(request.CalendarDateStartId, true, Execute);
var pCalendarType = request.CalendarType;
var pFollowUp = DocEntityTimePoint.Get(request.FollowUp?.Id, true, Execute) ?? DocEntityTimePoint.Get(request.FollowUpId, true, Execute);
var pTimeOfDay = DocEntityTimePoint.Get(request.TimeOfDay?.Id, true, Execute) ?? DocEntityTimePoint.Get(request.TimeOfDayId, true, Execute);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityInterval, Interval>(request, permission, session);
if (AllowPatchValue <Interval, bool>(request, DocConstantModelName.INTERVAL, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Interval, DocEntityDateTime>(request, DocConstantModelName.INTERVAL, pCalendarDateEnd, permission, nameof(request.CalendarDateEnd), pCalendarDateEnd != entity.CalendarDateEnd))
{
entity.CalendarDateEnd = pCalendarDateEnd;
}
if (AllowPatchValue <Interval, DocEntityDateTime>(request, DocConstantModelName.INTERVAL, pCalendarDateStart, permission, nameof(request.CalendarDateStart), pCalendarDateStart != entity.CalendarDateStart))
{
entity.CalendarDateStart = pCalendarDateStart;
}
if (AllowPatchValue <Interval, string>(request, DocConstantModelName.INTERVAL, pCalendarType, permission, nameof(request.CalendarType), pCalendarType != entity.CalendarType))
{
entity.CalendarType = pCalendarType;
}
if (AllowPatchValue <Interval, DocEntityTimePoint>(request, DocConstantModelName.INTERVAL, pFollowUp, permission, nameof(request.FollowUp), pFollowUp != entity.FollowUp))
{
entity.FollowUp = pFollowUp;
}
if (AllowPatchValue <Interval, DocEntityTimePoint>(request, DocConstantModelName.INTERVAL, pTimeOfDay, permission, nameof(request.TimeOfDay), pTimeOfDay != entity.TimeOfDay))
{
entity.TimeOfDay = pTimeOfDay;
}
if (request.Locked && AllowPatchValue <Interval, bool>(request, DocConstantModelName.INTERVAL, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.INTERVAL);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Interval>(currentUser, nameof(Interval), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.INTERVAL);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.INTERVAL, cacheExpires);
return(ret);
}
private Junction _AssignValues(Junction request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Junction"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Junction ret = null;
request = _InitAssignValues <Junction>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Junction>(DocConstantModelName.JUNCTION, nameof(Junction), request);
//First, assign all the variables, do database lookups and conversions
var pChildren = GetVariable <Reference>(request, nameof(request.Children), request.Children?.ToList(), request.ChildrenIds?.ToList());
var pData = request.Data;
var pOwnerId = request.OwnerId;
var pOwnerType = request.OwnerType;
var pParent = DocEntityJunction.Get(request.Parent?.Id, true, Execute) ?? DocEntityJunction.Get(request.ParentId, true, Execute);
var pTargetId = request.TargetId;
var pTargetType = request.TargetType;
DocEntityLookupTable pType = GetLookup(DocConstantLookupTable.JUNCTIONTYPE, request.Type?.Name, request.Type?.Id);
var pUser = DocEntityUser.Get(request.User?.Id, true, Execute) ?? DocEntityUser.Get(request.UserId, true, Execute);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityJunction, Junction>(request, permission, session);
if (AllowPatchValue <Junction, bool>(request, DocConstantModelName.JUNCTION, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Junction, string>(request, DocConstantModelName.JUNCTION, pData, permission, nameof(request.Data), pData != entity.Data))
{
entity.Data = pData;
}
if (AllowPatchValue <Junction, int?>(request, DocConstantModelName.JUNCTION, pOwnerId, permission, nameof(request.OwnerId), pOwnerId != entity.OwnerId))
{
entity.OwnerId = pOwnerId;
}
if (AllowPatchValue <Junction, string>(request, DocConstantModelName.JUNCTION, pOwnerType, permission, nameof(request.OwnerType), pOwnerType != entity.OwnerType))
{
entity.OwnerType = pOwnerType;
}
if (AllowPatchValue <Junction, DocEntityJunction>(request, DocConstantModelName.JUNCTION, pParent, permission, nameof(request.Parent), pParent != entity.Parent))
{
entity.Parent = pParent;
}
if (AllowPatchValue <Junction, int?>(request, DocConstantModelName.JUNCTION, pTargetId, permission, nameof(request.TargetId), pTargetId != entity.TargetId))
{
entity.TargetId = pTargetId;
}
if (AllowPatchValue <Junction, string>(request, DocConstantModelName.JUNCTION, pTargetType, permission, nameof(request.TargetType), pTargetType != entity.TargetType))
{
entity.TargetType = pTargetType;
}
if (AllowPatchValue <Junction, DocEntityLookupTable>(request, DocConstantModelName.JUNCTION, pType, permission, nameof(request.Type), pType != entity.Type))
{
entity.Type = pType;
}
if (AllowPatchValue <Junction, DocEntityUser>(request, DocConstantModelName.JUNCTION, pUser, permission, nameof(request.User), pUser != entity.User))
{
entity.User = pUser;
}
if (request.Locked && AllowPatchValue <Junction, bool>(request, DocConstantModelName.JUNCTION, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <Junction, DocEntityJunction, Reference, DocEntityJunction>(request, entity, pChildren, permission, nameof(request.Children)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.JUNCTION);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Junction>(currentUser, nameof(Junction), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.JUNCTION);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.JUNCTION, cacheExpires);
return(ret);
}
private Favorite _AssignValues(Favorite request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Favorite"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Favorite ret = null;
request = _InitAssignValues <Favorite>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Favorite>(DocConstantModelName.FAVORITE, nameof(Favorite), request);
//First, assign all the variables, do database lookups and conversions
var pScope = DocEntityScope.Get(request.Scope?.Id, true, Execute) ?? DocEntityScope.Get(request.ScopeId, true, Execute);
var pOwner = DocEntityBase.Get(request.Owner?.Id, true, Execute) ?? DocEntityBase.Get(request.OwnerId, true, Execute);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityFavorite, Favorite>(request, permission, session);
if (AllowPatchValue <Favorite, bool>(request, DocConstantModelName.FAVORITE, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Favorite, DocEntityScope>(request, DocConstantModelName.FAVORITE, pScope, permission, nameof(request.Scope), pScope != entity.Scope))
{
entity.Scope = pScope;
}
if (AllowPatchValue <Favorite, DocEntityBase>(request, DocConstantModelName.FAVORITE, pOwner, permission, nameof(request.Owner), pOwner != entity.Owner))
{
entity.Owner = pOwner;
}
if (request.Locked && AllowPatchValue <Favorite, bool>(request, DocConstantModelName.FAVORITE, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.FAVORITE);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Favorite>(currentUser, nameof(Favorite), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.FAVORITE);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.FAVORITE, cacheExpires);
return(ret);
}
private VariableInstance _AssignValues(VariableInstance request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "VariableInstance"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
VariableInstance ret = null;
request = _InitAssignValues <VariableInstance>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <VariableInstance>(DocConstantModelName.VARIABLEINSTANCE, nameof(VariableInstance), request);
//First, assign all the variables, do database lookups and conversions
var pData = request.Data;
var pDocument = DocEntityDocument.Get(request.Document?.Id, true, Execute) ?? DocEntityDocument.Get(request.DocumentId, true, Execute);
var pRule = DocEntityVariableRule.Get(request.Rule?.Id, true, Execute) ?? DocEntityVariableRule.Get(request.RuleId, true, Execute);
var pWorkflows = GetVariable <Reference>(request, nameof(request.Workflows), request.Workflows?.ToList(), request.WorkflowsIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityVariableInstance, VariableInstance>(request, permission, session);
if (AllowPatchValue <VariableInstance, bool>(request, DocConstantModelName.VARIABLEINSTANCE, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <VariableInstance, string>(request, DocConstantModelName.VARIABLEINSTANCE, pData, permission, nameof(request.Data), pData != entity.Data))
{
entity.Data = pData;
}
if (AllowPatchValue <VariableInstance, DocEntityDocument>(request, DocConstantModelName.VARIABLEINSTANCE, pDocument, permission, nameof(request.Document), pDocument != entity.Document))
{
entity.Document = pDocument;
}
if (AllowPatchValue <VariableInstance, DocEntityVariableRule>(request, DocConstantModelName.VARIABLEINSTANCE, pRule, permission, nameof(request.Rule), pRule != entity.Rule))
{
entity.Rule = pRule;
}
if (request.Locked && AllowPatchValue <VariableInstance, bool>(request, DocConstantModelName.VARIABLEINSTANCE, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <VariableInstance, DocEntityVariableInstance, Reference, DocEntityWorkflow>(request, entity, pWorkflows, permission, nameof(request.Workflows)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.VARIABLEINSTANCE);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <VariableInstance>(currentUser, nameof(VariableInstance), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.VARIABLEINSTANCE);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.VARIABLEINSTANCE, cacheExpires);
return(ret);
}
private AuditDelta _AssignValues(AuditDelta request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "AuditDelta"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
AuditDelta ret = null;
request = _InitAssignValues <AuditDelta>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <AuditDelta>(DocConstantModelName.AUDITDELTA, nameof(AuditDelta), request);
//First, assign all the variables, do database lookups and conversions
var pAudit = DocEntityAuditRecord.Get(request.Audit?.Id, true, Execute) ?? DocEntityAuditRecord.Get(request.AuditId, true, Execute);
var pDelta = request.Delta;
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityAuditDelta, AuditDelta>(request, permission, session);
if (AllowPatchValue <AuditDelta, bool>(request, DocConstantModelName.AUDITDELTA, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <AuditDelta, DocEntityAuditRecord>(request, DocConstantModelName.AUDITDELTA, pAudit, permission, nameof(request.Audit), pAudit != entity.Audit))
{
entity.Audit = pAudit;
}
if (AllowPatchValue <AuditDelta, string>(request, DocConstantModelName.AUDITDELTA, pDelta, permission, nameof(request.Delta), pDelta != entity.Delta))
{
entity.Delta = pDelta;
}
if (request.Locked && AllowPatchValue <AuditDelta, bool>(request, DocConstantModelName.AUDITDELTA, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.AUDITDELTA);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <AuditDelta>(currentUser, nameof(AuditDelta), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.AUDITDELTA);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.AUDITDELTA, cacheExpires);
return(ret);
}
private DataProperty _AssignValues(DataProperty request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "DataProperty"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
DataProperty ret = null;
request = _InitAssignValues <DataProperty>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <DataProperty>(DocConstantModelName.DATAPROPERTY, nameof(DataProperty), request);
//First, assign all the variables, do database lookups and conversions
var pAutoCreateMissing = request.AutoCreateMissing;
var pChildren = GetVariable <Reference>(request, nameof(request.Children), request.Children?.ToList(), request.ChildrenIds?.ToList());
var pClass = DocEntityDataClass.Get(request.Class?.Id, true, Execute) ?? DocEntityDataClass.Get(request.ClassId, true, Execute);
var pDescription = request.Description;
var pDisplayName = request.DisplayName;
var pIsAllowAddInForm = request.IsAllowAddInForm;
var pIsAllowCreateInForm = request.IsAllowCreateInForm;
var pIsAllowEditInForm = request.IsAllowEditInForm;
var pIsAllowFreeText = request.IsAllowFreeText;
var pIsAllowRemoveInForm = request.IsAllowRemoveInForm;
var pIsAudited = request.IsAudited;
var pIsCompressed = request.IsCompressed;
var pIsDisplayInForm = request.IsDisplayInForm;
var pIsDisplayInGrid = request.IsDisplayInGrid;
var pIsEditColumn = request.IsEditColumn;
var pIsInsertOnly = request.IsInsertOnly;
var pIsJSON = request.IsJSON;
var pIsLazy = request.IsLazy;
var pIsNullOnUpgrade = request.IsNullOnUpgrade;
var pIsReadOnly = request.IsReadOnly;
var pIsRelationship = request.IsRelationship;
var pIsRequired = request.IsRequired;
var pIsRequiredInForm = request.IsRequiredInForm;
var pIsVirtual = request.IsVirtual;
var pJsonType = request.JsonType;
var pLookupTableEnum = DocEntityLookupTableEnum.Get(request.LookupTableEnum);
var pName = request.Name;
var pOrder = request.Order;
var pOwner = DocEntityDataProperty.Get(request.Owner?.Id, true, Execute) ?? DocEntityDataProperty.Get(request.OwnerId, true, Execute);
var pPrecision = request.Precision;
var pRelationshipOnOwnerRemove = request.RelationshipOnOwnerRemove;
var pRelationshipOnTargetRemove = request.RelationshipOnTargetRemove;
var pRelationshipPairTo = DocEntityDataProperty.Get(request.RelationshipPairTo?.Id, true, Execute) ?? DocEntityDataProperty.Get(request.RelationshipPairToId, true, Execute);
var pScale = request.Scale;
var pSetDefaultValue = request.SetDefaultValue;
var pTab = DocEntityDataTab.Get(request.Tab?.Id, true, Execute) ?? DocEntityDataTab.Get(request.TabId, true, Execute);
var pTarget = DocEntityDataClass.Get(request.Target?.Id, true, Execute) ?? DocEntityDataClass.Get(request.TargetId, true, Execute);
var pTargetAlias = request.TargetAlias;
var pType = request.Type;
var pUIType = request.UIType;
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityDataProperty, DataProperty>(request, permission, session);
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pAutoCreateMissing, permission, nameof(request.AutoCreateMissing), pAutoCreateMissing != entity.AutoCreateMissing))
{
entity.AutoCreateMissing = pAutoCreateMissing;
}
if (AllowPatchValue <DataProperty, DocEntityDataClass>(request, DocConstantModelName.DATAPROPERTY, pClass, permission, nameof(request.Class), pClass != entity.Class))
{
entity.Class = pClass;
}
if (AllowPatchValue <DataProperty, string>(request, DocConstantModelName.DATAPROPERTY, pDescription, permission, nameof(request.Description), pDescription != entity.Description))
{
entity.Description = pDescription;
}
if (AllowPatchValue <DataProperty, string>(request, DocConstantModelName.DATAPROPERTY, pDisplayName, permission, nameof(request.DisplayName), pDisplayName != entity.DisplayName))
{
entity.DisplayName = pDisplayName;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsAllowAddInForm, permission, nameof(request.IsAllowAddInForm), pIsAllowAddInForm != entity.IsAllowAddInForm))
{
entity.IsAllowAddInForm = pIsAllowAddInForm;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsAllowCreateInForm, permission, nameof(request.IsAllowCreateInForm), pIsAllowCreateInForm != entity.IsAllowCreateInForm))
{
entity.IsAllowCreateInForm = pIsAllowCreateInForm;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsAllowEditInForm, permission, nameof(request.IsAllowEditInForm), pIsAllowEditInForm != entity.IsAllowEditInForm))
{
entity.IsAllowEditInForm = pIsAllowEditInForm;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsAllowFreeText, permission, nameof(request.IsAllowFreeText), pIsAllowFreeText != entity.IsAllowFreeText))
{
entity.IsAllowFreeText = pIsAllowFreeText;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsAllowRemoveInForm, permission, nameof(request.IsAllowRemoveInForm), pIsAllowRemoveInForm != entity.IsAllowRemoveInForm))
{
entity.IsAllowRemoveInForm = pIsAllowRemoveInForm;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsAudited, permission, nameof(request.IsAudited), pIsAudited != entity.IsAudited))
{
entity.IsAudited = pIsAudited;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsCompressed, permission, nameof(request.IsCompressed), pIsCompressed != entity.IsCompressed))
{
entity.IsCompressed = pIsCompressed;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsDisplayInForm, permission, nameof(request.IsDisplayInForm), pIsDisplayInForm != entity.IsDisplayInForm))
{
entity.IsDisplayInForm = pIsDisplayInForm;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsDisplayInGrid, permission, nameof(request.IsDisplayInGrid), pIsDisplayInGrid != entity.IsDisplayInGrid))
{
entity.IsDisplayInGrid = pIsDisplayInGrid;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsEditColumn, permission, nameof(request.IsEditColumn), pIsEditColumn != entity.IsEditColumn))
{
entity.IsEditColumn = pIsEditColumn;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsInsertOnly, permission, nameof(request.IsInsertOnly), pIsInsertOnly != entity.IsInsertOnly))
{
entity.IsInsertOnly = pIsInsertOnly;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsJSON, permission, nameof(request.IsJSON), pIsJSON != entity.IsJSON))
{
entity.IsJSON = pIsJSON;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsLazy, permission, nameof(request.IsLazy), pIsLazy != entity.IsLazy))
{
entity.IsLazy = pIsLazy;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsNullOnUpgrade, permission, nameof(request.IsNullOnUpgrade), pIsNullOnUpgrade != entity.IsNullOnUpgrade))
{
entity.IsNullOnUpgrade = pIsNullOnUpgrade;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsReadOnly, permission, nameof(request.IsReadOnly), pIsReadOnly != entity.IsReadOnly))
{
entity.IsReadOnly = pIsReadOnly;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsRelationship, permission, nameof(request.IsRelationship), pIsRelationship != entity.IsRelationship))
{
entity.IsRelationship = pIsRelationship;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsRequired, permission, nameof(request.IsRequired), pIsRequired != entity.IsRequired))
{
entity.IsRequired = pIsRequired;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsRequiredInForm, permission, nameof(request.IsRequiredInForm), pIsRequiredInForm != entity.IsRequiredInForm))
{
entity.IsRequiredInForm = pIsRequiredInForm;
}
if (AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pIsVirtual, permission, nameof(request.IsVirtual), pIsVirtual != entity.IsVirtual))
{
entity.IsVirtual = pIsVirtual;
}
if (AllowPatchValue <DataProperty, string>(request, DocConstantModelName.DATAPROPERTY, pJsonType, permission, nameof(request.JsonType), pJsonType != entity.JsonType))
{
entity.JsonType = pJsonType;
}
if (AllowPatchValue <DataProperty, DocEntityLookupTableEnum>(request, DocConstantModelName.DATAPROPERTY, pLookupTableEnum, permission, nameof(request.LookupTableEnum), pLookupTableEnum != entity.LookupTableEnum))
{
entity.LookupTableEnum = pLookupTableEnum;
}
if (AllowPatchValue <DataProperty, string>(request, DocConstantModelName.DATAPROPERTY, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (AllowPatchValue <DataProperty, int?>(request, DocConstantModelName.DATAPROPERTY, pOrder, permission, nameof(request.Order), pOrder != entity.Order))
{
if (null != pOrder)
{
entity.Order = (int)pOrder;
}
}
if (AllowPatchValue <DataProperty, DocEntityDataProperty>(request, DocConstantModelName.DATAPROPERTY, pOwner, permission, nameof(request.Owner), pOwner != entity.Owner))
{
entity.Owner = pOwner;
}
if (AllowPatchValue <DataProperty, int?>(request, DocConstantModelName.DATAPROPERTY, pPrecision, permission, nameof(request.Precision), pPrecision != entity.Precision))
{
entity.Precision = pPrecision;
}
if (AllowPatchValue <DataProperty, OnRemoveAction?>(request, DocConstantModelName.DATAPROPERTY, pRelationshipOnOwnerRemove, permission, nameof(request.RelationshipOnOwnerRemove), pRelationshipOnOwnerRemove != entity.RelationshipOnOwnerRemove))
{
entity.RelationshipOnOwnerRemove = pRelationshipOnOwnerRemove;
}
if (AllowPatchValue <DataProperty, OnRemoveAction?>(request, DocConstantModelName.DATAPROPERTY, pRelationshipOnTargetRemove, permission, nameof(request.RelationshipOnTargetRemove), pRelationshipOnTargetRemove != entity.RelationshipOnTargetRemove))
{
entity.RelationshipOnTargetRemove = pRelationshipOnTargetRemove;
}
if (AllowPatchValue <DataProperty, DocEntityDataProperty>(request, DocConstantModelName.DATAPROPERTY, pRelationshipPairTo, permission, nameof(request.RelationshipPairTo), pRelationshipPairTo != entity.RelationshipPairTo))
{
entity.RelationshipPairTo = pRelationshipPairTo;
}
if (AllowPatchValue <DataProperty, int?>(request, DocConstantModelName.DATAPROPERTY, pScale, permission, nameof(request.Scale), pScale != entity.Scale))
{
entity.Scale = pScale;
}
if (AllowPatchValue <DataProperty, string>(request, DocConstantModelName.DATAPROPERTY, pSetDefaultValue, permission, nameof(request.SetDefaultValue), pSetDefaultValue != entity.SetDefaultValue))
{
entity.SetDefaultValue = pSetDefaultValue;
}
if (AllowPatchValue <DataProperty, DocEntityDataTab>(request, DocConstantModelName.DATAPROPERTY, pTab, permission, nameof(request.Tab), pTab != entity.Tab))
{
entity.Tab = pTab;
}
if (AllowPatchValue <DataProperty, DocEntityDataClass>(request, DocConstantModelName.DATAPROPERTY, pTarget, permission, nameof(request.Target), pTarget != entity.Target))
{
entity.Target = pTarget;
}
if (AllowPatchValue <DataProperty, string>(request, DocConstantModelName.DATAPROPERTY, pTargetAlias, permission, nameof(request.TargetAlias), pTargetAlias != entity.TargetAlias))
{
entity.TargetAlias = pTargetAlias;
}
if (AllowPatchValue <DataProperty, DataType?>(request, DocConstantModelName.DATAPROPERTY, pType, permission, nameof(request.Type), pType != entity.Type))
{
if (null != pType)
{
entity.Type = pType.Value;
}
}
if (AllowPatchValue <DataProperty, UiType?>(request, DocConstantModelName.DATAPROPERTY, pUIType, permission, nameof(request.UIType), pUIType != entity.UIType))
{
entity.UIType = pUIType;
}
if (request.Locked && AllowPatchValue <DataProperty, bool>(request, DocConstantModelName.DATAPROPERTY, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <DataProperty, DocEntityDataProperty, Reference, DocEntityDataProperty>(request, entity, pChildren, permission, nameof(request.Children)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.DATAPROPERTY);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <DataProperty>(currentUser, nameof(DataProperty), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.DATAPROPERTY);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.DATAPROPERTY, cacheExpires);
return(ret);
}
private Glossary _AssignValues(Glossary request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Glossary"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Glossary ret = null;
request = _InitAssignValues <Glossary>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Glossary>(DocConstantModelName.GLOSSARY, nameof(Glossary), request);
//First, assign all the variables, do database lookups and conversions
var pDefinition = request.Definition;
var pEnum = DocEntityLookupTableEnum.Get(request.Enum);
var pIcon = request.Icon;
var pPage = DocEntityPage.Get(request.Page?.Id, true, Execute) ?? DocEntityPage.Get(request.PageId, true, Execute);
var pTerm = DocEntityTermMaster.Get(request.Term?.Id, true, Execute) ?? DocEntityTermMaster.Get(request.TermId, true, Execute);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityGlossary, Glossary>(request, permission, session);
if (AllowPatchValue <Glossary, bool>(request, DocConstantModelName.GLOSSARY, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Glossary, string>(request, DocConstantModelName.GLOSSARY, pDefinition, permission, nameof(request.Definition), pDefinition != entity.Definition))
{
entity.Definition = pDefinition;
}
if (AllowPatchValue <Glossary, DocEntityLookupTableEnum>(request, DocConstantModelName.GLOSSARY, pEnum, permission, nameof(request.Enum), pEnum != entity.Enum))
{
entity.Enum = pEnum;
}
if (AllowPatchValue <Glossary, string>(request, DocConstantModelName.GLOSSARY, pIcon, permission, nameof(request.Icon), pIcon != entity.Icon))
{
entity.Icon = pIcon;
}
if (AllowPatchValue <Glossary, DocEntityPage>(request, DocConstantModelName.GLOSSARY, pPage, permission, nameof(request.Page), pPage != entity.Page))
{
entity.Page = pPage;
}
if (AllowPatchValue <Glossary, DocEntityTermMaster>(request, DocConstantModelName.GLOSSARY, pTerm, permission, nameof(request.Term), pTerm != entity.Term))
{
entity.Term = pTerm;
}
if (request.Locked && AllowPatchValue <Glossary, bool>(request, DocConstantModelName.GLOSSARY, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.GLOSSARY);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Glossary>(currentUser, nameof(Glossary), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.GLOSSARY);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.GLOSSARY, cacheExpires);
return(ret);
}
private Rating _AssignValues(Rating request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Rating"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Rating ret = null;
request = _InitAssignValues <Rating>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Rating>(DocConstantModelName.RATING, nameof(Rating), request);
//First, assign all the variables, do database lookups and conversions
var pAssignee = DocEntityUser.Get(request.Assignee?.Id, true, Execute) ?? DocEntityUser.Get(request.AssigneeId, true, Execute);
var pData = request.Data;
var pDescription = request.Description;
var pDocument = DocEntityDocument.Get(request.Document?.Id, true, Execute) ?? DocEntityDocument.Get(request.DocumentId, true, Execute);
var pDueDate = request.DueDate;
var pRating = request.Rating;
var pReasonRejected = request.ReasonRejected;
var pReporter = DocEntityUser.Get(request.Reporter?.Id, true, Execute) ?? DocEntityUser.Get(request.ReporterId, true, Execute);
var pType = request.Type;
var pWorkflow = DocEntityWorkflow.Get(request.Workflow?.Id, true, Execute) ?? DocEntityWorkflow.Get(request.WorkflowId, true, Execute);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityRating, Rating>(request, permission, session);
if (AllowPatchValue <Rating, bool>(request, DocConstantModelName.RATING, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Rating, DocEntityUser>(request, DocConstantModelName.RATING, pAssignee, permission, nameof(request.Assignee), pAssignee != entity.Assignee))
{
entity.Assignee = pAssignee;
}
if (AllowPatchValue <Rating, string>(request, DocConstantModelName.RATING, pData, permission, nameof(request.Data), pData != entity.Data))
{
entity.Data = pData;
}
if (AllowPatchValue <Rating, string>(request, DocConstantModelName.RATING, pDescription, permission, nameof(request.Description), pDescription != entity.Description))
{
entity.Description = pDescription;
}
if (AllowPatchValue <Rating, DocEntityDocument>(request, DocConstantModelName.RATING, pDocument, permission, nameof(request.Document), pDocument != entity.Document))
{
entity.Document = pDocument;
}
if (AllowPatchValue <Rating, DateTime?>(request, DocConstantModelName.RATING, pDueDate, permission, nameof(request.DueDate), pDueDate != entity.DueDate))
{
entity.DueDate = pDueDate;
}
if (AllowPatchValue <Rating, RatingEnm?>(request, DocConstantModelName.RATING, pRating, permission, nameof(request.Rating), pRating != entity.Rating))
{
if (null != pRating)
{
entity.Rating = pRating.Value;
}
}
if (AllowPatchValue <Rating, ReasonRejectedEnm?>(request, DocConstantModelName.RATING, pReasonRejected, permission, nameof(request.ReasonRejected), pReasonRejected != entity.ReasonRejected))
{
entity.ReasonRejected = pReasonRejected;
}
if (AllowPatchValue <Rating, DocEntityUser>(request, DocConstantModelName.RATING, pReporter, permission, nameof(request.Reporter), pReporter != entity.Reporter))
{
entity.Reporter = pReporter;
}
if (AllowPatchValue <Rating, TaskTypeEnm?>(request, DocConstantModelName.RATING, pType, permission, nameof(request.Type), pType != entity.Type))
{
if (null != pType)
{
entity.Type = pType.Value;
}
}
if (AllowPatchValue <Rating, DocEntityWorkflow>(request, DocConstantModelName.RATING, pWorkflow, permission, nameof(request.Workflow), pWorkflow != entity.Workflow))
{
entity.Workflow = pWorkflow;
}
if (request.Locked && AllowPatchValue <Rating, bool>(request, DocConstantModelName.RATING, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.RATING);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Rating>(currentUser, nameof(Rating), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.RATING);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.RATING, cacheExpires);
return(ret);
}
private ImportData _AssignValues(ImportData request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "ImportData"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
ImportData ret = null;
request = _InitAssignValues <ImportData>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <ImportData>(DocConstantModelName.IMPORTDATA, nameof(ImportData), request);
//First, assign all the variables, do database lookups and conversions
var pCompletedOn = request.CompletedOn;
var pDataSets = GetVariable <Reference>(request, nameof(request.DataSets), request.DataSets?.ToList(), request.DataSetsIds?.ToList());
var pDocument = DocEntityDocument.Get(request.Document?.Id, true, Execute) ?? DocEntityDocument.Get(request.DocumentId, true, Execute);
var pErrorData = request.ErrorData;
var pExtractUrl = request.ExtractUrl;
var pHighPriority = request.HighPriority;
var pImportFr = request.ImportFr;
DocEntityLookupTable pImportLocation = GetLookup(DocConstantLookupTable.STUDYIMPORTLOCATION, request.ImportLocation?.Name, request.ImportLocation?.Id);
var pImportNewName = request.ImportNewName;
var pImportTable = request.ImportTable;
var pImportText = request.ImportText;
DocEntityLookupTable pImportType = GetLookup(DocConstantLookupTable.STUDYIMPORTTYPE, request.ImportType?.Name, request.ImportType?.Id);
var pIsLegacy = request.IsLegacy;
var pOrder = request.Order;
var pReferenceId = request.ReferenceId;
var pRequestedBy = DocEntityUser.Get(request.RequestedBy?.Id, true, Execute) ?? DocEntityUser.Get(request.RequestedById, true, Execute);
var pRequestedOn = request.RequestedOn;
var pStartedOn = request.StartedOn;
DocEntityLookupTable pStatus = GetLookup(DocConstantLookupTable.IMPORTSTATUS, request.Status?.Name, request.Status?.Id);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityImportData, ImportData>(request, permission, session);
if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <ImportData, DateTime?>(request, DocConstantModelName.IMPORTDATA, pCompletedOn, permission, nameof(request.CompletedOn), pCompletedOn != entity.CompletedOn))
{
entity.CompletedOn = pCompletedOn;
}
if (AllowPatchValue <ImportData, DocEntityDocument>(request, DocConstantModelName.IMPORTDATA, pDocument, permission, nameof(request.Document), pDocument != entity.Document))
{
entity.Document = pDocument;
}
if (AllowPatchValue <ImportData, string>(request, DocConstantModelName.IMPORTDATA, pErrorData, permission, nameof(request.ErrorData), pErrorData != entity.ErrorData))
{
entity.ErrorData = pErrorData;
}
if (AllowPatchValue <ImportData, string>(request, DocConstantModelName.IMPORTDATA, pExtractUrl, permission, nameof(request.ExtractUrl), pExtractUrl != entity.ExtractUrl))
{
entity.ExtractUrl = pExtractUrl;
}
if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pHighPriority, permission, nameof(request.HighPriority), pHighPriority != entity.HighPriority))
{
entity.HighPriority = pHighPriority;
}
if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pImportFr, permission, nameof(request.ImportFr), pImportFr != entity.ImportFr))
{
entity.ImportFr = pImportFr;
}
if (AllowPatchValue <ImportData, DocEntityLookupTable>(request, DocConstantModelName.IMPORTDATA, pImportLocation, permission, nameof(request.ImportLocation), pImportLocation != entity.ImportLocation))
{
entity.ImportLocation = pImportLocation;
}
if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pImportNewName, permission, nameof(request.ImportNewName), pImportNewName != entity.ImportNewName))
{
entity.ImportNewName = pImportNewName;
}
if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pImportTable, permission, nameof(request.ImportTable), pImportTable != entity.ImportTable))
{
entity.ImportTable = pImportTable;
}
if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pImportText, permission, nameof(request.ImportText), pImportText != entity.ImportText))
{
entity.ImportText = pImportText;
}
if (AllowPatchValue <ImportData, DocEntityLookupTable>(request, DocConstantModelName.IMPORTDATA, pImportType, permission, nameof(request.ImportType), pImportType != entity.ImportType))
{
entity.ImportType = pImportType;
}
if (AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pIsLegacy, permission, nameof(request.IsLegacy), pIsLegacy != entity.IsLegacy))
{
entity.IsLegacy = pIsLegacy;
}
if (AllowPatchValue <ImportData, int?>(request, DocConstantModelName.IMPORTDATA, pOrder, permission, nameof(request.Order), pOrder != entity.Order))
{
entity.Order = pOrder;
}
if (AllowPatchValue <ImportData, int?>(request, DocConstantModelName.IMPORTDATA, pReferenceId, permission, nameof(request.ReferenceId), pReferenceId != entity.ReferenceId))
{
if (null != pReferenceId)
{
entity.ReferenceId = (int)pReferenceId;
}
}
if (AllowPatchValue <ImportData, DocEntityUser>(request, DocConstantModelName.IMPORTDATA, pRequestedBy, permission, nameof(request.RequestedBy), pRequestedBy != entity.RequestedBy))
{
entity.RequestedBy = pRequestedBy;
}
if (AllowPatchValue <ImportData, DateTime?>(request, DocConstantModelName.IMPORTDATA, pRequestedOn, permission, nameof(request.RequestedOn), pRequestedOn != entity.RequestedOn))
{
entity.RequestedOn = pRequestedOn;
}
if (AllowPatchValue <ImportData, DateTime?>(request, DocConstantModelName.IMPORTDATA, pStartedOn, permission, nameof(request.StartedOn), pStartedOn != entity.StartedOn))
{
entity.StartedOn = pStartedOn;
}
if (AllowPatchValue <ImportData, DocEntityLookupTable>(request, DocConstantModelName.IMPORTDATA, pStatus, permission, nameof(request.Status), pStatus != entity.Status))
{
entity.Status = pStatus;
}
if (request.Locked && AllowPatchValue <ImportData, bool>(request, DocConstantModelName.IMPORTDATA, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <ImportData, DocEntityImportData, Reference, DocEntityDataSet>(request, entity, pDataSets, permission, nameof(request.DataSets)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.IMPORTDATA);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <ImportData>(currentUser, nameof(ImportData), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.IMPORTDATA);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.IMPORTDATA, cacheExpires);
return(ret);
}
private Workflow _AssignValues(Workflow request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Workflow"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Workflow ret = null;
request = _InitAssignValues <Workflow>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Workflow>(DocConstantModelName.WORKFLOW, nameof(Workflow), request);
//First, assign all the variables, do database lookups and conversions
var pBindings = GetVariable <Reference>(request, nameof(request.Bindings), request.Bindings?.ToList(), request.BindingsIds?.ToList());
var pData = request.Data;
var pDescription = request.Description;
var pDocuments = GetVariable <Reference>(request, nameof(request.Documents), request.Documents?.ToList(), request.DocumentsIds?.ToList());
var pDocumentSet = DocEntityDocumentSet.Get(request.DocumentSet?.Id, true, Execute) ?? DocEntityDocumentSet.Get(request.DocumentSetId, true, Execute);
var pName = request.Name;
var pOwner = DocEntityWorkflow.Get(request.Owner?.Id, true, Execute) ?? DocEntityWorkflow.Get(request.OwnerId, true, Execute);
var pScopes = GetVariable <Reference>(request, nameof(request.Scopes), request.Scopes?.ToList(), request.ScopesIds?.ToList());
var pStatus = request.Status;
var pTasks = GetVariable <Reference>(request, nameof(request.Tasks), request.Tasks?.ToList(), request.TasksIds?.ToList());
var pType = request.Type;
var pUser = DocEntityUser.Get(request.User?.Id, true, Execute) ?? DocEntityUser.Get(request.UserId, true, Execute);
var pVariables = GetVariable <Reference>(request, nameof(request.Variables), request.Variables?.ToList(), request.VariablesIds?.ToList());
var pWorkflows = GetVariable <Reference>(request, nameof(request.Workflows), request.Workflows?.ToList(), request.WorkflowsIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityWorkflow, Workflow>(request, permission, session);
if (AllowPatchValue <Workflow, bool>(request, DocConstantModelName.WORKFLOW, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Workflow, string>(request, DocConstantModelName.WORKFLOW, pData, permission, nameof(request.Data), pData != entity.Data))
{
entity.Data = pData;
}
if (AllowPatchValue <Workflow, string>(request, DocConstantModelName.WORKFLOW, pDescription, permission, nameof(request.Description), pDescription != entity.Description))
{
entity.Description = pDescription;
}
if (AllowPatchValue <Workflow, DocEntityDocumentSet>(request, DocConstantModelName.WORKFLOW, pDocumentSet, permission, nameof(request.DocumentSet), pDocumentSet != entity.DocumentSet))
{
entity.DocumentSet = pDocumentSet;
}
if (AllowPatchValue <Workflow, string>(request, DocConstantModelName.WORKFLOW, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (AllowPatchValue <Workflow, DocEntityWorkflow>(request, DocConstantModelName.WORKFLOW, pOwner, permission, nameof(request.Owner), pOwner != entity.Owner))
{
entity.Owner = pOwner;
}
if (AllowPatchValue <Workflow, WorkflowStatusEnm?>(request, DocConstantModelName.WORKFLOW, pStatus, permission, nameof(request.Status), pStatus != entity.Status))
{
entity.Status = pStatus;
}
if (AllowPatchValue <Workflow, WorkflowEnm?>(request, DocConstantModelName.WORKFLOW, pType, permission, nameof(request.Type), pType != entity.Type))
{
if (null != pType)
{
entity.Type = pType.Value;
}
}
if (AllowPatchValue <Workflow, DocEntityUser>(request, DocConstantModelName.WORKFLOW, pUser, permission, nameof(request.User), pUser != entity.User))
{
entity.User = pUser;
}
if (request.Locked && AllowPatchValue <Workflow, bool>(request, DocConstantModelName.WORKFLOW, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <Workflow, DocEntityWorkflow, Reference, DocEntityLookupTableBinding>(request, entity, pBindings, permission, nameof(request.Bindings)));
idsToInvalidate.AddRange(PatchCollection <Workflow, DocEntityWorkflow, Reference, DocEntityDocument>(request, entity, pDocuments, permission, nameof(request.Documents)));
idsToInvalidate.AddRange(PatchCollection <Workflow, DocEntityWorkflow, Reference, DocEntityScope>(request, entity, pScopes, permission, nameof(request.Scopes)));
idsToInvalidate.AddRange(PatchCollection <Workflow, DocEntityWorkflow, Reference, DocEntityTask>(request, entity, pTasks, permission, nameof(request.Tasks)));
idsToInvalidate.AddRange(PatchCollection <Workflow, DocEntityWorkflow, Reference, DocEntityVariableInstance>(request, entity, pVariables, permission, nameof(request.Variables)));
idsToInvalidate.AddRange(PatchCollection <Workflow, DocEntityWorkflow, Reference, DocEntityWorkflow>(request, entity, pWorkflows, permission, nameof(request.Workflows)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.WORKFLOW);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Workflow>(currentUser, nameof(Workflow), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.WORKFLOW);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.WORKFLOW, cacheExpires);
return(ret);
}
private Division _AssignValues(Division request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Division"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Division ret = null;
request = _InitAssignValues <Division>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Division>(DocConstantModelName.DIVISION, nameof(Division), request);
//First, assign all the variables, do database lookups and conversions
var pClient = DocEntityClient.Get(request.Client?.Id, true, Execute) ?? DocEntityClient.Get(request.ClientId, true, Execute);
var pDefaultLocale = DocEntityLocale.Get(request.DefaultLocale?.Id, true, Execute) ?? DocEntityLocale.Get(request.DefaultLocaleId, true, Execute);
var pDocumentSets = GetVariable <Reference>(request, nameof(request.DocumentSets), request.DocumentSets?.ToList(), request.DocumentSetsIds?.ToList());
var pName = request.Name;
var pRole = DocEntityRole.Get(request.Role?.Id, true, Execute) ?? DocEntityRole.Get(request.RoleId, true, Execute);
var pSettings = (DocTools.IsNullOrEmpty(request.Settings)) ? null : DocSerialize <DivisionSettings> .ToString(request.Settings);
var pUsers = GetVariable <Reference>(request, nameof(request.Users), request.Users?.ToList(), request.UsersIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityDivision, Division>(request, permission, session);
if (AllowPatchValue <Division, bool>(request, DocConstantModelName.DIVISION, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Division, DocEntityClient>(request, DocConstantModelName.DIVISION, pClient, permission, nameof(request.Client), pClient != entity.Client))
{
entity.Client = pClient;
}
if (AllowPatchValue <Division, DocEntityLocale>(request, DocConstantModelName.DIVISION, pDefaultLocale, permission, nameof(request.DefaultLocale), pDefaultLocale != entity.DefaultLocale))
{
entity.DefaultLocale = pDefaultLocale;
}
if (AllowPatchValue <Division, string>(request, DocConstantModelName.DIVISION, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (AllowPatchValue <Division, DocEntityRole>(request, DocConstantModelName.DIVISION, pRole, permission, nameof(request.Role), pRole != entity.Role))
{
entity.Role = pRole;
}
if (AllowPatchValue <Division, string>(request, DocConstantModelName.DIVISION, pSettings, permission, nameof(request.Settings), pSettings != entity.Settings))
{
entity.Settings = pSettings;
}
if (request.Locked && AllowPatchValue <Division, bool>(request, DocConstantModelName.DIVISION, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <Division, DocEntityDivision, Reference, DocEntityDocumentSet>(request, entity, pDocumentSets, permission, nameof(request.DocumentSets)));
idsToInvalidate.AddRange(PatchCollection <Division, DocEntityDivision, Reference, DocEntityUser>(request, entity, pUsers, permission, nameof(request.Users)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.DIVISION);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Division>(currentUser, nameof(Division), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.DIVISION);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.DIVISION, cacheExpires);
return(ret);
}
private Page _AssignValues(Page request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Page"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Page ret = null;
request = _InitAssignValues <Page>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Page>(DocConstantModelName.PAGE, nameof(Page), request);
//First, assign all the variables, do database lookups and conversions
var pApps = GetVariable <Reference>(request, nameof(request.Apps), request.Apps?.ToList(), request.AppsIds?.ToList());
var pDescription = request.Description;
var pGlossary = GetVariable <Reference>(request, nameof(request.Glossary), request.Glossary?.ToList(), request.GlossaryIds?.ToList());
var pHelp = GetVariable <Reference>(request, nameof(request.Help), request.Help?.ToList(), request.HelpIds?.ToList());
var pName = request.Name;
var pRoles = GetVariable <Reference>(request, nameof(request.Roles), request.Roles?.ToList(), request.RolesIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityPage, Page>(request, permission, session);
if (AllowPatchValue <Page, bool>(request, DocConstantModelName.PAGE, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Page, string>(request, DocConstantModelName.PAGE, pDescription, permission, nameof(request.Description), pDescription != entity.Description))
{
entity.Description = pDescription;
}
if (AllowPatchValue <Page, string>(request, DocConstantModelName.PAGE, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (request.Locked && AllowPatchValue <Page, bool>(request, DocConstantModelName.PAGE, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <Page, DocEntityPage, Reference, DocEntityApp>(request, entity, pApps, permission, nameof(request.Apps)));
idsToInvalidate.AddRange(PatchCollection <Page, DocEntityPage, Reference, DocEntityGlossary>(request, entity, pGlossary, permission, nameof(request.Glossary)));
idsToInvalidate.AddRange(PatchCollection <Page, DocEntityPage, Reference, DocEntityHelp>(request, entity, pHelp, permission, nameof(request.Help)));
idsToInvalidate.AddRange(PatchCollection <Page, DocEntityPage, Reference, DocEntityRole>(request, entity, pRoles, permission, nameof(request.Roles)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.PAGE);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Page>(currentUser, nameof(Page), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.PAGE);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.PAGE, cacheExpires);
return(ret);
}
private DateTimeDto _AssignValues(DateTimeDto request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "DateTime"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
DateTimeDto ret = null;
request = _InitAssignValues <DateTimeDto>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <DateTimeDto>(DocConstantModelName.DATETIME, nameof(DateTimeDto), request);
//First, assign all the variables, do database lookups and conversions
var pDateDay = request.DateDay;
var pDateMonth = request.DateMonth;
var pDateTime = request.DateTime;
var pDateYear = request.DateYear;
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityDateTime, DateTimeDto>(request, permission, session);
if (AllowPatchValue <DateTimeDto, bool>(request, DocConstantModelName.DATETIME, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <DateTimeDto, int?>(request, DocConstantModelName.DATETIME, pDateDay, permission, nameof(request.DateDay), pDateDay != entity.DateDay))
{
entity.DateDay = pDateDay;
}
if (AllowPatchValue <DateTimeDto, int?>(request, DocConstantModelName.DATETIME, pDateMonth, permission, nameof(request.DateMonth), pDateMonth != entity.DateMonth))
{
entity.DateMonth = pDateMonth;
}
if (AllowPatchValue <DateTimeDto, DateTime?>(request, DocConstantModelName.DATETIME, pDateTime, permission, nameof(request.DateTime), pDateTime != entity.DateTime))
{
entity.DateTime = pDateTime;
}
if (AllowPatchValue <DateTimeDto, int?>(request, DocConstantModelName.DATETIME, pDateYear, permission, nameof(request.DateYear), pDateYear != entity.DateYear))
{
entity.DateYear = pDateYear;
}
if (request.Locked && AllowPatchValue <DateTimeDto, bool>(request, DocConstantModelName.DATETIME, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.DATETIME);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <DateTimeDto>(currentUser, nameof(DateTimeDto), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.DATETIME);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.DATETIME, cacheExpires);
return(ret);
}
private Role _AssignValues(Role request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "Role"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Role ret = null;
request = _InitAssignValues <Role>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <Role>(DocConstantModelName.ROLE, nameof(Role), request);
//First, assign all the variables, do database lookups and conversions
var pAdminTeam = DocEntityTeam.Get(request.AdminTeam?.Id, true, Execute) ?? DocEntityTeam.Get(request.AdminTeamId, true, Execute);
var pApps = GetVariable <Reference>(request, nameof(request.Apps), request.Apps?.ToList(), request.AppsIds?.ToList());
var pDescription = request.Description;
var pFeatures = request.Features;
var pFeatureSets = GetVariable <Reference>(request, nameof(request.FeatureSets), request.FeatureSets?.ToList(), request.FeatureSetsIds?.ToList());
var pIsInternal = request.IsInternal;
var pIsSuperAdmin = request.IsSuperAdmin;
var pName = request.Name;
var pPages = GetVariable <Reference>(request, nameof(request.Pages), request.Pages?.ToList(), request.PagesIds?.ToList());
var pPermissions = request.Permissions;
var pUsers = GetVariable <Reference>(request, nameof(request.Users), request.Users?.ToList(), request.UsersIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityRole, Role>(request, permission, session);
if (AllowPatchValue <Role, bool>(request, DocConstantModelName.ROLE, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Role, DocEntityTeam>(request, DocConstantModelName.ROLE, pAdminTeam, permission, nameof(request.AdminTeam), pAdminTeam != entity.AdminTeam))
{
entity.AdminTeam = pAdminTeam;
}
if (AllowPatchValue <Role, string>(request, DocConstantModelName.ROLE, pDescription, permission, nameof(request.Description), pDescription != entity.Description))
{
entity.Description = pDescription;
}
if (AllowPatchValue <Role, string>(request, DocConstantModelName.ROLE, pFeatures, permission, nameof(request.Features), pFeatures != entity.Features))
{
entity.Features = pFeatures;
}
if (AllowPatchValue <Role, bool>(request, DocConstantModelName.ROLE, pIsInternal, permission, nameof(request.IsInternal), pIsInternal != entity.IsInternal))
{
entity.IsInternal = pIsInternal;
}
if (AllowPatchValue <Role, string>(request, DocConstantModelName.ROLE, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (AllowPatchValue <Role, string>(request, DocConstantModelName.ROLE, pPermissions, permission, nameof(request.Permissions), pPermissions != entity.Permissions))
{
entity.Permissions = pPermissions;
}
if (request.Locked && AllowPatchValue <Role, bool>(request, DocConstantModelName.ROLE, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <Role, DocEntityRole, Reference, DocEntityApp>(request, entity, pApps, permission, nameof(request.Apps)));
idsToInvalidate.AddRange(PatchCollection <Role, DocEntityRole, Reference, DocEntityFeatureSet>(request, entity, pFeatureSets, permission, nameof(request.FeatureSets)));
idsToInvalidate.AddRange(PatchCollection <Role, DocEntityRole, Reference, DocEntityPage>(request, entity, pPages, permission, nameof(request.Pages)));
idsToInvalidate.AddRange(PatchCollection <Role, DocEntityRole, Reference, DocEntityUser>(request, entity, pUsers, permission, nameof(request.Users)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.ROLE);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Role>(currentUser, nameof(Role), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.ROLE);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.ROLE, cacheExpires);
return(ret);
}
private TimeCard _AssignValues(TimeCard request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "TimeCard"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
TimeCard ret = null;
request = _InitAssignValues <TimeCard>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <TimeCard>(DocConstantModelName.TIMECARD, nameof(TimeCard), request);
//First, assign all the variables, do database lookups and conversions
var pDescription = request.Description;
var pDocument = DocEntityDocument.Get(request.Document?.Id, true, Execute) ?? DocEntityDocument.Get(request.DocumentId, true, Execute);
var pEnd = request.End;
var pProject = DocEntityProject.Get(request.Project?.Id, true, Execute) ?? DocEntityProject.Get(request.ProjectId, true, Execute);
var pReferenceId = request.ReferenceId;
var pStart = request.Start;
DocEntityLookupTable pStatus = GetLookup(DocConstantLookupTable.TIMECARDSTATUS, request.Status?.Name, request.Status?.Id);
var pUser = DocEntityUser.Get(request.User?.Id, true, Execute) ?? DocEntityUser.Get(request.UserId, true, Execute);
DocEntityLookupTable pWorkType = GetLookup(DocConstantLookupTable.WORKTYPE, request.WorkType?.Name, request.WorkType?.Id);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityTimeCard, TimeCard>(request, permission, session);
if (AllowPatchValue <TimeCard, bool>(request, DocConstantModelName.TIMECARD, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <TimeCard, string>(request, DocConstantModelName.TIMECARD, pDescription, permission, nameof(request.Description), pDescription != entity.Description))
{
entity.Description = pDescription;
}
if (AllowPatchValue <TimeCard, DocEntityDocument>(request, DocConstantModelName.TIMECARD, pDocument, permission, nameof(request.Document), pDocument != entity.Document))
{
entity.Document = pDocument;
}
if (AllowPatchValue <TimeCard, DateTime?>(request, DocConstantModelName.TIMECARD, pEnd, permission, nameof(request.End), pEnd != entity.End))
{
if (null != pEnd)
{
entity.End = (DateTime)pEnd;
}
}
if (AllowPatchValue <TimeCard, DocEntityProject>(request, DocConstantModelName.TIMECARD, pProject, permission, nameof(request.Project), pProject != entity.Project))
{
entity.Project = pProject;
}
if (AllowPatchValue <TimeCard, int?>(request, DocConstantModelName.TIMECARD, pReferenceId, permission, nameof(request.ReferenceId), pReferenceId != entity.ReferenceId))
{
entity.ReferenceId = pReferenceId;
}
if (AllowPatchValue <TimeCard, DateTime?>(request, DocConstantModelName.TIMECARD, pStart, permission, nameof(request.Start), pStart != entity.Start))
{
if (null != pStart)
{
entity.Start = (DateTime)pStart;
}
}
if (AllowPatchValue <TimeCard, DocEntityLookupTable>(request, DocConstantModelName.TIMECARD, pStatus, permission, nameof(request.Status), pStatus != entity.Status))
{
entity.Status = pStatus;
}
if (AllowPatchValue <TimeCard, DocEntityUser>(request, DocConstantModelName.TIMECARD, pUser, permission, nameof(request.User), pUser != entity.User))
{
entity.User = pUser;
}
if (AllowPatchValue <TimeCard, DocEntityLookupTable>(request, DocConstantModelName.TIMECARD, pWorkType, permission, nameof(request.WorkType), pWorkType != entity.WorkType))
{
entity.WorkType = pWorkType;
}
if (request.Locked && AllowPatchValue <TimeCard, bool>(request, DocConstantModelName.TIMECARD, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.TIMECARD);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <TimeCard>(currentUser, nameof(TimeCard), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.TIMECARD);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.TIMECARD, cacheExpires);
return(ret);
}
private DiseaseStateSet _AssignValues(DiseaseStateSet request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "DiseaseStateSet"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
DiseaseStateSet ret = null;
request = _InitAssignValues <DiseaseStateSet>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <DiseaseStateSet>(DocConstantModelName.DISEASESTATESET, nameof(DiseaseStateSet), request);
//First, assign all the variables, do database lookups and conversions
var pClients = GetVariable <Reference>(request, nameof(request.Clients), request.Clients?.ToList(), request.ClientsIds?.ToList());
var pConfidential = request.Confidential;
var pDivisions = GetVariable <Reference>(request, nameof(request.Divisions), request.Divisions?.ToList(), request.DivisionsIds?.ToList());
var pDocuments = GetVariable <Reference>(request, nameof(request.Documents), request.Documents?.ToList(), request.DocumentsIds?.ToList());
var pDocumentSets = GetVariable <Reference>(request, nameof(request.DocumentSets), request.DocumentSets?.ToList(), request.DocumentSetsIds?.ToList());
var pHistories = GetVariable <Reference>(request, nameof(request.Histories), request.Histories?.ToList(), request.HistoriesIds?.ToList());
var pLegacyDocumentSetId = request.LegacyDocumentSetId;
var pName = request.Name;
var pOwner = DocEntityDocumentSet.Get(request.Owner?.Id, true, Execute) ?? DocEntityDocumentSet.Get(request.OwnerId, true, Execute);
var pProjectTeam = DocEntityTeam.Get(request.ProjectTeam?.Id, true, Execute) ?? DocEntityTeam.Get(request.ProjectTeamId, true, Execute);
var pScopes = GetVariable <Reference>(request, nameof(request.Scopes), request.Scopes?.ToList(), request.ScopesIds?.ToList());
var pSettings = request.Settings;
var pStats = GetVariable <Reference>(request, nameof(request.Stats), request.Stats?.ToList(), request.StatsIds?.ToList());
var pType = request.Type;
var pUsers = GetVariable <Reference>(request, nameof(request.Users), request.Users?.ToList(), request.UsersIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityDiseaseStateSet, DiseaseStateSet>(request, permission, session);
if (AllowPatchValue <DiseaseStateSet, bool>(request, DocConstantModelName.DISEASESTATESET, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <DiseaseStateSet, bool>(request, DocConstantModelName.DISEASESTATESET, pConfidential, permission, nameof(request.Confidential), pConfidential != entity.Confidential))
{
entity.Confidential = pConfidential;
}
if (AllowPatchValue <DiseaseStateSet, int?>(request, DocConstantModelName.DISEASESTATESET, pLegacyDocumentSetId, permission, nameof(request.LegacyDocumentSetId), pLegacyDocumentSetId != entity.LegacyDocumentSetId))
{
entity.LegacyDocumentSetId = pLegacyDocumentSetId;
}
if (AllowPatchValue <DiseaseStateSet, string>(request, DocConstantModelName.DISEASESTATESET, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (AllowPatchValue <DiseaseStateSet, DocEntityDocumentSet>(request, DocConstantModelName.DISEASESTATESET, pOwner, permission, nameof(request.Owner), pOwner != entity.Owner))
{
entity.Owner = pOwner;
}
if (AllowPatchValue <DiseaseStateSet, DocEntityTeam>(request, DocConstantModelName.DISEASESTATESET, pProjectTeam, permission, nameof(request.ProjectTeam), pProjectTeam != entity.ProjectTeam))
{
entity.ProjectTeam = pProjectTeam;
}
if (AllowPatchValue <DiseaseStateSet, string>(request, DocConstantModelName.DISEASESTATESET, pSettings, permission, nameof(request.Settings), pSettings != entity.Settings))
{
entity.Settings = pSettings;
}
if (AllowPatchValue <DiseaseStateSet, DocumentSetTypeEnm?>(request, DocConstantModelName.DISEASESTATESET, pType, permission, nameof(request.Type), pType != entity.Type))
{
if (null != pType)
{
entity.Type = pType.Value;
}
}
if (request.Locked && AllowPatchValue <DiseaseStateSet, bool>(request, DocConstantModelName.DISEASESTATESET, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <DiseaseStateSet, DocEntityDiseaseStateSet, Reference, DocEntityClient>(request, entity, pClients, permission, nameof(request.Clients)));
idsToInvalidate.AddRange(PatchCollection <DiseaseStateSet, DocEntityDiseaseStateSet, Reference, DocEntityDivision>(request, entity, pDivisions, permission, nameof(request.Divisions)));
idsToInvalidate.AddRange(PatchCollection <DiseaseStateSet, DocEntityDiseaseStateSet, Reference, DocEntityDocument>(request, entity, pDocuments, permission, nameof(request.Documents)));
idsToInvalidate.AddRange(PatchCollection <DiseaseStateSet, DocEntityDiseaseStateSet, Reference, DocEntityDocumentSet>(request, entity, pDocumentSets, permission, nameof(request.DocumentSets)));
idsToInvalidate.AddRange(PatchCollection <DiseaseStateSet, DocEntityDiseaseStateSet, Reference, DocEntityDocumentSetHistory>(request, entity, pHistories, permission, nameof(request.Histories)));
idsToInvalidate.AddRange(PatchCollection <DiseaseStateSet, DocEntityDiseaseStateSet, Reference, DocEntityScope>(request, entity, pScopes, permission, nameof(request.Scopes)));
idsToInvalidate.AddRange(PatchCollection <DiseaseStateSet, DocEntityDiseaseStateSet, Reference, DocEntityStatsStudySet>(request, entity, pStats, permission, nameof(request.Stats)));
idsToInvalidate.AddRange(PatchCollection <DiseaseStateSet, DocEntityDiseaseStateSet, Reference, DocEntityUser>(request, entity, pUsers, permission, nameof(request.Users)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.DISEASESTATESET);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <DiseaseStateSet>(currentUser, nameof(DiseaseStateSet), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.DISEASESTATESET);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.DISEASESTATESET, cacheExpires);
return(ret);
}
private LookupTableBinding _AssignValues(LookupTableBinding request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "LookupTableBinding"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
LookupTableBinding ret = null;
request = _InitAssignValues <LookupTableBinding>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <LookupTableBinding>(DocConstantModelName.LOOKUPTABLEBINDING, nameof(LookupTableBinding), request);
//First, assign all the variables, do database lookups and conversions
var pBinding = (DocTools.IsNullOrEmpty(request.Binding)) ? null : DocSerialize <Bindings> .ToString(request.Binding);
var pBoundName = request.BoundName;
DocEntityLookupTable pLookupTable = GetLookup(DocConstantLookupTable.ATTRIBUTENAME, request.LookupTable?.Name, request.LookupTable?.Id);
var pScope = DocEntityScope.Get(request.Scope?.Id, true, Execute) ?? DocEntityScope.Get(request.ScopeId, true, Execute);
var pSynonyms = GetVariable <Reference>(request, nameof(request.Synonyms), request.Synonyms?.ToList(), request.SynonymsIds?.ToList());
var pWorkflows = GetVariable <Reference>(request, nameof(request.Workflows), request.Workflows?.ToList(), request.WorkflowsIds?.ToList());
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityLookupTableBinding, LookupTableBinding>(request, permission, session);
if (AllowPatchValue <LookupTableBinding, bool>(request, DocConstantModelName.LOOKUPTABLEBINDING, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <LookupTableBinding, string>(request, DocConstantModelName.LOOKUPTABLEBINDING, pBinding, permission, nameof(request.Binding), pBinding != entity.Binding))
{
entity.Binding = pBinding;
}
if (AllowPatchValue <LookupTableBinding, string>(request, DocConstantModelName.LOOKUPTABLEBINDING, pBoundName, permission, nameof(request.BoundName), pBoundName != entity.BoundName))
{
entity.BoundName = pBoundName;
}
if (AllowPatchValue <LookupTableBinding, DocEntityLookupTable>(request, DocConstantModelName.LOOKUPTABLEBINDING, pLookupTable, permission, nameof(request.LookupTable), pLookupTable != entity.LookupTable))
{
entity.LookupTable = pLookupTable;
}
if (AllowPatchValue <LookupTableBinding, DocEntityScope>(request, DocConstantModelName.LOOKUPTABLEBINDING, pScope, permission, nameof(request.Scope), pScope != entity.Scope))
{
entity.Scope = pScope;
}
if (request.Locked && AllowPatchValue <LookupTableBinding, bool>(request, DocConstantModelName.LOOKUPTABLEBINDING, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <LookupTableBinding, DocEntityLookupTableBinding, Reference, DocEntityTermSynonym>(request, entity, pSynonyms, permission, nameof(request.Synonyms)));
idsToInvalidate.AddRange(PatchCollection <LookupTableBinding, DocEntityLookupTableBinding, Reference, DocEntityWorkflow>(request, entity, pWorkflows, permission, nameof(request.Workflows)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.LOOKUPTABLEBINDING);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <LookupTableBinding>(currentUser, nameof(LookupTableBinding), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.LOOKUPTABLEBINDING);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.LOOKUPTABLEBINDING, cacheExpires);
return(ret);
}
private QueueChannel _AssignValues(QueueChannel request, DocConstantPermission permission, Session session)
{
if (permission != DocConstantPermission.ADD && (request == null || request.Id <= 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No record");
}
if (permission == DocConstantPermission.ADD && !DocPermissionFactory.HasPermissionTryAdd(currentUser, "QueueChannel"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
QueueChannel ret = null;
request = _InitAssignValues <QueueChannel>(request, permission, session);
//In case init assign handles create for us, return it
if (permission == DocConstantPermission.ADD && request.Id > 0)
{
return(request);
}
var cacheKey = GetApiCacheKey <QueueChannel>(DocConstantModelName.QUEUECHANNEL, nameof(QueueChannel), request);
//First, assign all the variables, do database lookups and conversions
var pAutoDelete = request.AutoDelete;
var pBackgroundTask = DocEntityBackgroundTask.Get(request.BackgroundTask?.Id, true, Execute) ?? DocEntityBackgroundTask.Get(request.BackgroundTaskId, true, Execute);
var pDescription = request.Description;
var pDurable = request.Durable;
var pEnabled = request.Enabled;
var pExclusive = request.Exclusive;
var pName = request.Name;
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityQueueChannel, QueueChannel>(request, permission, session);
if (AllowPatchValue <QueueChannel, bool>(request, DocConstantModelName.QUEUECHANNEL, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <QueueChannel, bool>(request, DocConstantModelName.QUEUECHANNEL, pAutoDelete, permission, nameof(request.AutoDelete), pAutoDelete != entity.AutoDelete))
{
entity.AutoDelete = pAutoDelete;
}
if (AllowPatchValue <QueueChannel, DocEntityBackgroundTask>(request, DocConstantModelName.QUEUECHANNEL, pBackgroundTask, permission, nameof(request.BackgroundTask), pBackgroundTask != entity.BackgroundTask))
{
entity.BackgroundTask = pBackgroundTask;
}
if (AllowPatchValue <QueueChannel, string>(request, DocConstantModelName.QUEUECHANNEL, pDescription, permission, nameof(request.Description), pDescription != entity.Description))
{
entity.Description = pDescription;
}
if (AllowPatchValue <QueueChannel, bool>(request, DocConstantModelName.QUEUECHANNEL, pDurable, permission, nameof(request.Durable), pDurable != entity.Durable))
{
entity.Durable = pDurable;
}
if (AllowPatchValue <QueueChannel, bool>(request, DocConstantModelName.QUEUECHANNEL, pEnabled, permission, nameof(request.Enabled), pEnabled != entity.Enabled))
{
entity.Enabled = pEnabled;
}
if (AllowPatchValue <QueueChannel, bool>(request, DocConstantModelName.QUEUECHANNEL, pExclusive, permission, nameof(request.Exclusive), pExclusive != entity.Exclusive))
{
entity.Exclusive = pExclusive;
}
if (AllowPatchValue <QueueChannel, string>(request, DocConstantModelName.QUEUECHANNEL, pName, permission, nameof(request.Name), pName != entity.Name))
{
entity.Name = pName;
}
if (request.Locked && AllowPatchValue <QueueChannel, bool>(request, DocConstantModelName.QUEUECHANNEL, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.QUEUECHANNEL);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <QueueChannel>(currentUser, nameof(QueueChannel), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.QUEUECHANNEL);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.QUEUECHANNEL, cacheExpires);
return(ret);
}
