private Scope GetScope(Scope request)
{
var id = request?.Id;
Scope ret = null;
var query = DocQuery.ActiveQuery ?? Execute;
DocPermissionFactory.SetSelect <Scope>(currentUser, "Scope", request.Select);
DocEntityScope entity = null;
if (id.HasValue)
{
entity = DocEntityScope.Get(id.Value);
}
if (null == entity)
{
throw new HttpError(HttpStatusCode.NotFound, $"No Scope found for Id {id.Value}");
}
if (!DocPermissionFactory.HasPermission(entity, currentUser, DocConstantPermission.VIEW))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have VIEW permission for this route.");
}
ret = entity?.ToDto();
return(ret);
}
public void Delete(Scope request)
{
using (Execute)
{
Execute.Run(ssn =>
{
if (!(request?.Id > 0))
{
throw new HttpError(HttpStatusCode.NotFound, $"No Id provided for delete.");
}
var en = DocEntityScope.Get(request?.Id);
if (null == en)
{
throw new HttpError(HttpStatusCode.NotFound, $"No Scope 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.SCOPE);
DocCacheClient.RemoveById(request.Id);
});
}
}
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 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);
}
public Scope Post(ScopeCopy request)
{
Scope ret = null;
using (Execute)
{
Execute.Run(ssn =>
{
var entity = DocEntityScope.Get(request?.Id);
if (null == entity)
{
throw new HttpError(HttpStatusCode.NoContent, "The COPY request did not succeed.");
}
if (!DocPermissionFactory.HasPermission(entity, currentUser, DocConstantPermission.ADD))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
var pApp = entity.App;
var pBindings = entity.Bindings.ToList();
var pBroadcasts = entity.Broadcasts.ToList();
var pClient = entity.Client;
var pDelete = entity.Delete;
var pDocumentSet = entity.DocumentSet;
var pEdit = entity.Edit;
var pHelp = entity.Help.ToList();
var pIsGlobal = entity.IsGlobal;
var pScopedComments = entity.ScopedComments.ToList();
var pScopedFiles = entity.ScopedFiles.ToList();
var pScopedTags = entity.ScopedTags.ToList();
var pSynonyms = entity.Synonyms.ToList();
var pTeam = entity.Team;
var pType = entity.Type;
var pUser = entity.User;
var pVariableRules = entity.VariableRules.ToList();
var pView = entity.View;
var pWorkflows = entity.Workflows.ToList();
var copy = new DocEntityScope(ssn)
{
Hash = Guid.NewGuid()
, App = pApp
, Client = pClient
, Delete = pDelete
, DocumentSet = pDocumentSet
, Edit = pEdit
, IsGlobal = pIsGlobal
, Team = pTeam
, Type = pType
, User = pUser
, View = pView
};
foreach (var item in pBindings)
{
entity.Bindings.Add(item);
}
foreach (var item in pBroadcasts)
{
entity.Broadcasts.Add(item);
}
foreach (var item in pHelp)
{
entity.Help.Add(item);
}
foreach (var item in pScopedComments)
{
entity.ScopedComments.Add(item);
}
foreach (var item in pScopedFiles)
{
entity.ScopedFiles.Add(item);
}
foreach (var item in pScopedTags)
{
entity.ScopedTags.Add(item);
}
foreach (var item in pSynonyms)
{
entity.Synonyms.Add(item);
}
foreach (var item in pVariableRules)
{
entity.VariableRules.Add(item);
}
foreach (var item in pWorkflows)
{
entity.Workflows.Add(item);
}
copy.SaveChanges(DocConstantPermission.ADD);
ret = copy.ToDto();
});
}
return(ret);
}
private TermSynonym _AssignValues(TermSynonym 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, "TermSynonym"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
TermSynonym ret = null;
request = _InitAssignValues <TermSynonym>(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 <TermSynonym>(DocConstantModelName.TERMSYNONYM, nameof(TermSynonym), request);
//First, assign all the variables, do database lookups and conversions
var pApproved = request.Approved;
var pBindings = GetVariable <Reference>(request, nameof(request.Bindings), request.Bindings?.ToList(), request.BindingsIds?.ToList());
var pMaster = DocEntityTermMaster.Get(request.Master?.Id, true, Execute) ?? DocEntityTermMaster.Get(request.MasterId, true, Execute);
var pPreferred = request.Preferred;
var pScope = DocEntityScope.Get(request.Scope?.Id, true, Execute) ?? DocEntityScope.Get(request.ScopeId, true, Execute);
var pSynonym = request.Synonym;
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityTermSynonym, TermSynonym>(request, permission, session);
if (AllowPatchValue <TermSynonym, bool>(request, DocConstantModelName.TERMSYNONYM, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <TermSynonym, bool>(request, DocConstantModelName.TERMSYNONYM, pApproved, permission, nameof(request.Approved), pApproved != entity.Approved))
{
entity.Approved = pApproved;
}
if (AllowPatchValue <TermSynonym, DocEntityTermMaster>(request, DocConstantModelName.TERMSYNONYM, pMaster, permission, nameof(request.Master), pMaster != entity.Master))
{
entity.Master = pMaster;
}
if (AllowPatchValue <TermSynonym, bool>(request, DocConstantModelName.TERMSYNONYM, pPreferred, permission, nameof(request.Preferred), pPreferred != entity.Preferred))
{
entity.Preferred = pPreferred;
}
if (AllowPatchValue <TermSynonym, DocEntityScope>(request, DocConstantModelName.TERMSYNONYM, pScope, permission, nameof(request.Scope), pScope != entity.Scope))
{
entity.Scope = pScope;
}
if (AllowPatchValue <TermSynonym, string>(request, DocConstantModelName.TERMSYNONYM, pSynonym, permission, nameof(request.Synonym), pSynonym != entity.Synonym))
{
entity.Synonym = pSynonym;
}
if (request.Locked && AllowPatchValue <TermSynonym, bool>(request, DocConstantModelName.TERMSYNONYM, pArchived, permission, nameof(request.Locked), pLocked != entity.Locked))
{
entity.Archived = pArchived;
}
entity.SaveChanges(permission);
var idsToInvalidate = new List <int>();
idsToInvalidate.AddRange(PatchCollection <TermSynonym, DocEntityTermSynonym, Reference, DocEntityLookupTableBinding>(request, entity, pBindings, permission, nameof(request.Bindings)));
if (idsToInvalidate.Any())
{
idsToInvalidate.Add(entity.Id);
DocCacheClient.RemoveByEntityIds(idsToInvalidate);
DocCacheClient.RemoveSearch(DocConstantModelName.TERMSYNONYM);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <TermSynonym>(currentUser, nameof(TermSynonym), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.TERMSYNONYM);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.TERMSYNONYM, cacheExpires);
return(ret);
}
private Default _AssignValues(Default 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, "Default"))
{
throw new HttpError(HttpStatusCode.Forbidden, "You do not have ADD permission for this route.");
}
request.Select = request.Select ?? new List <string>();
Default ret = null;
request = _InitAssignValues <Default>(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 <Default>(DocConstantModelName.DEFAULT, nameof(Default), request);
//First, assign all the variables, do database lookups and conversions
var pDiseaseState = DocEntityDiseaseStateSet.Get(request.DiseaseState?.Id, true, Execute) ?? DocEntityDiseaseStateSet.Get(request.DiseaseStateId, true, Execute);
var pRole = DocEntityRole.Get(request.Role?.Id, true, Execute) ?? DocEntityRole.Get(request.RoleId, true, Execute);
var pScope = DocEntityScope.Get(request.Scope?.Id, true, Execute) ?? DocEntityScope.Get(request.ScopeId, true, Execute);
var pTherapeuticArea = DocEntityTherapeuticAreaSet.Get(request.TherapeuticArea?.Id, true, Execute) ?? DocEntityTherapeuticAreaSet.Get(request.TherapeuticAreaId, true, Execute);
var pArchived = true == request.Archived;
var pLocked = request.Locked;
var entity = InitEntity <DocEntityDefault, Default>(request, permission, session);
if (AllowPatchValue <Default, bool>(request, DocConstantModelName.DEFAULT, pArchived, permission, nameof(request.Archived), pArchived != entity.Archived))
{
entity.Archived = pArchived;
}
if (AllowPatchValue <Default, DocEntityDiseaseStateSet>(request, DocConstantModelName.DEFAULT, pDiseaseState, permission, nameof(request.DiseaseState), pDiseaseState != entity.DiseaseState))
{
entity.DiseaseState = pDiseaseState;
}
if (AllowPatchValue <Default, DocEntityRole>(request, DocConstantModelName.DEFAULT, pRole, permission, nameof(request.Role), pRole != entity.Role))
{
entity.Role = pRole;
}
if (AllowPatchValue <Default, DocEntityScope>(request, DocConstantModelName.DEFAULT, pScope, permission, nameof(request.Scope), pScope != entity.Scope))
{
entity.Scope = pScope;
}
if (AllowPatchValue <Default, DocEntityTherapeuticAreaSet>(request, DocConstantModelName.DEFAULT, pTherapeuticArea, permission, nameof(request.TherapeuticArea), pTherapeuticArea != entity.TherapeuticArea))
{
entity.TherapeuticArea = pTherapeuticArea;
}
if (request.Locked && AllowPatchValue <Default, bool>(request, DocConstantModelName.DEFAULT, 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.DEFAULT);
}
entity.SaveChanges(permission);
DocPermissionFactory.SetSelect <Default>(currentUser, nameof(Default), request.Select);
ret = entity.ToDto();
var cacheExpires = DocResources.Metadata.GetCacheExpiration(DocConstantModelName.DEFAULT);
DocCacheClient.Set(key: cacheKey, value: ret, entityId: request.Id, entityType: DocConstantModelName.DEFAULT, cacheExpires);
return(ret);
}
