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