public QueryComposerRequestInterrogator(DTO.QueryComposer.QueryComposerRequestDTO request)
{
_request = request;
if (_request.Select == null)
{
_request.Select = new DTO.QueryComposer.QueryComposerSelectDTO
{
Fields = Enumerable.Empty <DTO.QueryComposer.QueryComposerFieldDTO>()
};
}
if (_request.Select.Fields == null)
{
_request.Select.Fields = Enumerable.Empty <DTO.QueryComposer.QueryComposerFieldDTO>();
}
_selectFields = _request.Select.Fields;
if (_request.Where.Criteria == null)
{
_request.Where.Criteria = Enumerable.Empty <DTO.QueryComposer.QueryComposerCriteriaDTO>();
}
_primaryCriteria = _request.Where.Criteria.FirstOrDefault();
if (_primaryCriteria != null)
{
_primaryObservationPeriodTerm = _primaryCriteria.Terms.FirstOrDefault(t => t.Type == ModelTermsFactory.ObservationPeriodID);
}
}
public void UpdateRequestJson()
{
string json = System.IO.File.ReadAllText("../Requests/Samples/ModularProgramRequest.json");
DTO.QueryComposer.QueryComposerRequestDTO requestDTO = Newtonsoft.Json.JsonConvert.DeserializeObject <DTO.QueryComposer.QueryComposerRequestDTO>(json);
var modularTerm = requestDTO.Where.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == Lpp.QueryComposer.ModelTermsFactory.ModularProgramID)).FirstOrDefault();
var termValues = Newtonsoft.Json.JsonConvert.DeserializeObject <ModularProgramTermValues>(((JObject)modularTerm.Values["Values"]).ToString());
//foreach(var x in termValues.Documents)
//{
// Console.WriteLine(x.RevisionSetID);
//}
//add new revisionset values to update the request.json
termValues.Documents.Add(new ModularProgramTermValues.Document {
RevisionSetID = Guid.NewGuid()
});
termValues.Documents.Add(new ModularProgramTermValues.Document {
RevisionSetID = Guid.NewGuid()
});
termValues.Documents.Add(new ModularProgramTermValues.Document {
RevisionSetID = Guid.NewGuid()
});
modularTerm.Values["Values"] = Newtonsoft.Json.JsonConvert.SerializeObject(termValues);
string json2 = Newtonsoft.Json.JsonConvert.SerializeObject(requestDTO);
Console.WriteLine(json2);
System.Diagnostics.Debugger.Break();
}
/// <summary>
/// Parses the query json of a request and up-converts to the multi-query structure if required.
/// </summary>
/// <param name="requestID"></param>
/// <param name="requestName"></param>
/// <param name="dueDate"></param>
/// <param name="priority"></param>
/// <param name="queryJSON"></param>
/// <returns></returns>
public static DTO.QueryComposer.QueryComposerRequestDTO ParseRequestJSON(Guid requestID, string requestName, DateTime?dueDate, Dns.DTO.Enums.Priorities priority, string queryJSON)
{
if (string.IsNullOrWhiteSpace(queryJSON))
{
return(null);
}
var jsonObj = Newtonsoft.Json.Linq.JObject.Parse(queryJSON);
if (jsonObj.ContainsKey("SchemaVersion"))
{
return(jsonObj.ToObject <DTO.QueryComposer.QueryComposerRequestDTO>());
}
var requestDTO = new DTO.QueryComposer.QueryComposerRequestDTO
{
Header = new DTO.QueryComposer.QueryComposerRequestHeaderDTO
{
ID = requestID,
Name = requestName,
DueDate = dueDate,
Priority = priority
},
Queries = new[] { jsonObj.ToObject <DTO.QueryComposer.QueryComposerQueryDTO>() }
};
return(requestDTO);
}
protected override SummaryRequestModel ConvertToModel(DTO.QueryComposer.QueryComposerRequestDTO request)
{
var criteria = request.Where.Criteria.First();
SummaryRequestModel model = new SummaryRequestModel();
//var observationPeriodTerm = criteria.Terms.FirstOrDefault(t => t.Type == ModelTermsFactory.YearID);
var observationPeriodTerm = GetAllCriteriaTerms(criteria, ModelTermsFactory.YearID).FirstOrDefault();
if (observationPeriodTerm != null)
{
model.StartPeriod = observationPeriodTerm.GetStringValue("StartYear");
model.EndPeriod = observationPeriodTerm.GetStringValue("EndYear");
model.Period = string.Join(",", QueryAdapter.ExpandYears(model).Select(y => "'" + y + "'"));//used in query
}
//var codeTerms = criteria.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == ModelTermsFactory.ICD9DiagnosisCodes3digitID)).Concat(criteria.Terms.Where(t => t.Type == ModelTermsFactory.ICD9DiagnosisCodes3digitID));
var codeTerms = GetAllCriteriaTerms(criteria, ModelTermsFactory.ICD9DiagnosisCodes3digitID);
IEnumerable <string> codeTermValues = from t in codeTerms
from v in t.GetCodeStringCollection()
where !string.IsNullOrWhiteSpace(v)
select v.Trim();
model.Codes = string.Join(",", codeTermValues.Distinct());
model.CodeNames = null;//this is a collection of the full names of the codes selected, original query used in the crossjoin for the name of the code, pulling from db now
DTO.Enums.Settings settingValue;
var setting = GetAllCriteriaTerms(criteria, ModelTermsFactory.SettingID).FirstOrDefault();
if (setting.GetEnumValue("Setting", out settingValue))
{
model.Setting = settingValue.ToString();
}
//These values are pulled from the stratification section of the request json
var ageStratification = request.Select.Fields.Where(f => f.Type == ModelTermsFactory.AgeRangeID).FirstOrDefault();
if (ageStratification != null)
{
QueryAdapter.SetAgeStratification(model, ageStratification);
}
//var sexTerm = criteria.Criteria.Select(y => y.Terms.Where( z => z.Type == ModelTermsFactory.SexID).FirstOrDefault());
var sexStratification = GetAllCriteriaTerms(criteria, ModelTermsFactory.SexID).FirstOrDefault();
if (sexStratification != null)
{
QueryAdapter.SetSexStratification(model, sexStratification);
}
model.Coverage = null; //not applicable to this query
model.MetricType = "0"; //not applicable to this query
model.OutputCriteria = "0"; //not applicable to this query
model.StartQuarter = null; //not applicable to this query
model.EndQuarter = null; //not applicable to this query
model.SubtypeId = 0; //value never gets set in ui of v5 summary query composer
return(model);
}
protected override SummaryRequestModel ConvertToModel(DTO.QueryComposer.QueryComposerRequestDTO request)
{
var criteria = request.Where.Criteria.First();
SummaryRequestModel model = new SummaryRequestModel();
var observationPeriodTerm = GetAllCriteriaTerms(criteria, ModelTermsFactory.YearID).FirstOrDefault();
if (observationPeriodTerm != null)
{
model.StartPeriod = observationPeriodTerm.GetStringValue("StartYear");
model.EndPeriod = observationPeriodTerm.GetStringValue("EndYear");
model.Period = string.Join(",", QueryAdapter.ExpandYears(model).Select(y => "'" + y + "'"));//used in query
}
IEnumerable <DTO.QueryComposer.QueryComposerTermDTO> codeTerms = criteria.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == TermID)).Concat(criteria.Terms.Where(t => t.Type == TermID));
var codeTermValues = (from t in codeTerms
let v = t.GetCodeSelectorValues()
from c in v
where c != null && !string.IsNullOrWhiteSpace(c.Code)
select c).GroupBy(k => k.Code.Trim()).Select(k => new { Code = k.Key, Name = k.Select(c => c.Name).FirstOrDefault() ?? k.Key }).ToArray();
model.Codes = string.Join(",", codeTermValues.Select(c => c.Code));
model.CodeNames = codeTermValues.Select(c => c.Name).ToArray();
DTO.Enums.Settings settingValue;
var set = GetAllCriteriaTerms(criteria, ModelTermsFactory.SettingID).FirstOrDefault();
if (set.GetEnumValue("Setting", out settingValue))
{
model.Setting = settingValue.ToString();
}
//These values are pulled from the stratification section of the request json
var ageStratification = request.Select.Fields.Where(f => f.Type == ModelTermsFactory.AgeRangeID).FirstOrDefault();
if (ageStratification != null)
{
QueryAdapter.SetAgeStratification(model, ageStratification);
}
var sexStratification = GetAllCriteriaTerms(criteria, ModelTermsFactory.SexID).FirstOrDefault();
if (sexStratification != null)
{
QueryAdapter.SetSexStratification(model, sexStratification);
}
model.Coverage = null; //not applicable to this query
model.MetricType = "0"; //not applicable to this query
model.OutputCriteria = "0"; //not applicable to this query
model.StartQuarter = null; //not applicable to this query
model.EndQuarter = null; //not applicable to this query
model.SubtypeId = 0; //value never gets set in ui of v5 summary query composer
return(model);
}
protected override SummaryRequestModel ConvertToModel(DTO.QueryComposer.QueryComposerRequestDTO request)
{
SummaryRequestModel model = new SummaryRequestModel();
var criteria = request.Where.Criteria.First();
var observationPeriodTerm = GetAllCriteriaTerms(criteria, ModelTermsFactory.QuarterYearID).FirstOrDefault();
if (observationPeriodTerm != null)
{
model.StartPeriod = observationPeriodTerm.GetStringValue("StartYear");
model.EndPeriod = observationPeriodTerm.GetStringValue("EndYear");
model.Period = string.Join(",", QueryAdapter.ExpandYears(model).Select(y => "'" + y + "'"));//used in query
}
DTO.Enums.DispensingMetric metricValue;
var dispensing = GetAllCriteriaTerms(criteria, ModelTermsFactory.DispensingMetricID).FirstOrDefault();
if (dispensing.GetEnumValue("Metric", out metricValue))
{
model.MetricType = metricValue.ToString("D");
}
DTO.Enums.OutputCriteria outputValue;
var cri = GetAllCriteriaTerms(criteria, ModelTermsFactory.CriteriaID).FirstOrDefault();
if (cri.GetEnumValue("Criteria", out outputValue))
{
model.OutputCriteria = outputValue.ToString("D");
}
var ageStratification = request.Select.Fields.Where(f => f.Type == ModelTermsFactory.AgeRangeID).FirstOrDefault();
if (ageStratification != null)
{
QueryAdapter.SetAgeStratification(model, ageStratification);
}
var sexStratification = GetAllCriteriaTerms(criteria, ModelTermsFactory.SexID).FirstOrDefault();
if (sexStratification != null)
{
QueryAdapter.SetSexStratification(model, sexStratification);
}
model.Setting = null;
model.Codes = null; //not applicable to this query
model.CodeNames = null; //not applicable to this query
model.Coverage = null; //not applicable to this query
model.StartQuarter = null; //not applicable to this query
model.EndQuarter = null; //not applicable to this query
model.SubtypeId = 0; //value never gets set in ui of v5 summary query composer
return(model);
}
public override DTO.QueryComposer.QueryComposerResponseDTO Execute(DTO.QueryComposer.QueryComposerRequestDTO request, bool viewSQL)
{
IQueryAdapter queryAdapter = null;
if (request.Where.Criteria.First().Terms.Any(t => t.Type == Lpp.QueryComposer.ModelTermsFactory.SqlDistributionID))
{
logger.Debug("Sql Distribution term found, creating SummarySqlQueryAdapter.");
SummarySqlQueryAdapter sql = new SummarySqlQueryAdapter();
var result = sql.Execute(request, _settings, viewSQL);
_currentResponse = result;
return(result);
}
if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.ICD9DiagnosisCodes3digitID))
{
logger.Debug("ICD-9 Diagnoses Codes term found, creating IncidenceICD9DiagnosisQueryAdapter.");
queryAdapter = new IncidenceICD9DiagnosisQueryAdapter(_settings);
}
else if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.DrugNameID) || request.Select.Fields.Any(t => t.Type == ModelTermsFactory.DrugClassID))
{
if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.DrugNameID))
{
logger.Debug("Pharmacy dispensing generic drug name term found, creating IncidencePharmaDispensingQueryAdapter.");
}
else
{
logger.Debug("Pharmacy dispensing drug class term found, creating IncidencePharmaDispensingQueryAdapter.");
}
queryAdapter = new IncidencePharmaDispensingQueryAdapter(_settings);
}
if (queryAdapter == null)
{
throw new InvalidOperationException("Unable to determine the query adapter to use based on the primary criteria terms.");
}
using (queryAdapter)
{
var qcResponseDTO = queryAdapter.Execute(request, viewSQL);
qcResponseDTO.LowCellThrehold = _lowThresholdValue;
_currentResponse = qcResponseDTO;
return(qcResponseDTO);
}
}
protected override SummaryRequestModel ConvertToModel(DTO.QueryComposer.QueryComposerRequestDTO request)
{
var criteria = request.Where.Criteria.First();
SummaryRequestModel model = new SummaryRequestModel();
var observationPeriodTerm = GetAllCriteriaTerms(criteria, ModelTermsFactory.YearID).FirstOrDefault();
if (observationPeriodTerm != null)
{
model.StartPeriod = observationPeriodTerm.GetStringValue("StartYear");
model.EndPeriod = observationPeriodTerm.GetStringValue("EndYear");
model.Period = string.Join(",", QueryAdapter.ExpandYears(model).Select(y => "'" + y + "'"));//used in query
}
DTO.Enums.Coverages coverage;
var cov = GetAllCriteriaTerms(criteria, ModelTermsFactory.CoverageID).FirstOrDefault();
if (cov.GetEnumValue("Coverage", out coverage))
{
model.Coverage = coverage;
}
//These values are pulled from the stratification section of the request json
var ageStratification = GetAgeField(request.Select.Fields.Where(f => f.Type == ModelTermsFactory.AgeRangeID));
if (ageStratification != null)
{
QueryAdapter.SetAgeStratification(model, ageStratification);
}
var sexStratification = GetAllCriteriaTerms(criteria, ModelTermsFactory.SexID).FirstOrDefault();
if (sexStratification != null)
{
QueryAdapter.SetSexStratification(model, sexStratification);
}
model.Codes = null; //not applicable to this query
model.CodeNames = null; //not applicable to this query
model.Setting = null; //not applicable to this query
model.MetricType = "0"; //not applicable to this query
model.OutputCriteria = "0"; //not applicable to this query
model.StartQuarter = null; //not applicable to this query
model.EndQuarter = null; //not applicable to this query
model.SubtypeId = 0; //value never gets set in ui of v5 summary query composer
return(model);
}
public virtual DTO.QueryComposer.QueryComposerResponseDTO Execute(DTO.QueryComposer.QueryComposerRequestDTO request, bool viewSQL)
{
SummaryRequestModel args = ConvertToModel(request);
IEnumerable <string> queries = BuildQueries(args);
List <DTO.QueryComposer.QueryComposerResponseErrorDTO> errors = new List <DTO.QueryComposer.QueryComposerResponseErrorDTO>();
List <Dictionary <string, object> > resultSets = new List <Dictionary <string, object> >(500);
foreach (var query in queries)
{
IEnumerable <Dictionary <string, object> > resultSet = ExecuteQuery(query, errors, viewSQL);
if (resultSet != null)
{
resultSets.AddRange(resultSet);
}
if (errors.Count > 0)
{
break;
}
}
var response = new DTO.QueryComposer.QueryComposerResponseDTO
{
Errors = errors,
RequestID = request.ID.HasValue ? request.ID.Value : default(Guid),
ResponseDateTime = DateTime.UtcNow,
Results = new[] { resultSets }
};
response.Properties = GetResponsePropertyDefinitions();
if (_lowThresholdValue.HasValue)
{
response.Properties = response.Properties.Concat(new[] { new DTO.QueryComposer.QueryComposerResponsePropertyDefinitionDTO {
Name = LowThresholdColumnName, As = LowThresholdColumnName, Type = "System.Boolean"
} });
}
response.Aggregation = GetResponseAggregationDefinition();
return(response);
}
/// <summary>
/// Deserializes a request, it will convert a previous schema version to the current RequestDTO.
/// </summary>
/// <param name="json">The json to deserialize to a <see cref="DTO.QueryComposer.QueryComposerRequestDTO"/>.</param>
/// <returns></returns>
public static DTO.QueryComposer.QueryComposerRequestDTO DeserializeRequest(string json)
{
Newtonsoft.Json.Linq.JObject obj = Newtonsoft.Json.Linq.JObject.Parse(json.Trim());
var serializationSettings = new Newtonsoft.Json.JsonSerializerSettings();
serializationSettings.Converters.Add(new DTO.QueryComposer.QueryComposerResponsePropertyDefinitionConverter());
serializationSettings.DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.IgnoreAndPopulate;
Newtonsoft.Json.JsonSerializer serializer = Newtonsoft.Json.JsonSerializer.Create(serializationSettings);
if (obj.ContainsKey("SchemaVersion"))
{
return(obj.ToObject <DTO.QueryComposer.QueryComposerRequestDTO>(serializer));
}
var query = obj.ToObject <DTO.QueryComposer.QueryComposerQueryDTO>(serializer);
var requestDTO = new DTO.QueryComposer.QueryComposerRequestDTO
{
Header = new DTO.QueryComposer.QueryComposerRequestHeaderDTO
{
ID = query.Header.ID,
Name = query.Header.Name,
Description = query.Header.Description,
DueDate = query.Header.DueDate,
Priority = query.Header.Priority,
SubmittedOn = query.Header.SubmittedOn,
ViewUrl = query.Header.ViewUrl
},
Queries = new[] {
query
}
};
return(requestDTO);
}
public override DTO.QueryComposer.QueryComposerResponseDTO Execute(DTO.QueryComposer.QueryComposerRequestDTO request, bool viewSQL)
{
throw new NotSupportedException("This model adapter does not support processing a QueryComposerRequestDTO, execute the adapter by calling StartRequest.");
}
protected override SummaryRequestModel ConvertToModel(DTO.QueryComposer.QueryComposerRequestDTO request)
{
var criteria = request.Where.Criteria.First();
SummaryRequestModel model = new SummaryRequestModel();
//var observationPeriodTerm = criteria.Terms.FirstOrDefault(t => t.Type == ModelTermsFactory.QuarterYearID);
var observationPeriodTerm = GetAllCriteriaTerms(criteria, ModelTermsFactory.QuarterYearID).FirstOrDefault();
if (observationPeriodTerm != null)
{
model.StartPeriod = observationPeriodTerm.GetStringValue("StartYear");
model.EndPeriod = observationPeriodTerm.GetStringValue("EndYear");
model.Period = string.Join(",", QueryAdapter.ExpandYears(model).Select(y => "'" + y + "'"));//used in query
}
IEnumerable <DTO.QueryComposer.QueryComposerTermDTO> codeTerms = criteria.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == ModelTermsFactory.DrugClassID || t.Type == ModelTermsFactory.DrugNameID)).Concat(criteria.Terms.Where(t => t.Type == ModelTermsFactory.DrugClassID || t.Type == ModelTermsFactory.DrugNameID)).ToArray();
if (codeTerms.Any(t => t.Type == ModelTermsFactory.DrugNameID))
{
_queryType = IncidencePharmaDispensingQueryType.DrugName;
}
else if (codeTerms.Any(t => t.Type == ModelTermsFactory.DrugClassID))
{
_queryType = IncidencePharmaDispensingQueryType.DrugClass;
}
else
{
throw new InvalidOperationException("Either a Drug Name term or a Drug Class term is required for the query.");
}
IEnumerable <string> codeTermValues = from t in codeTerms
from v in t.GetCodeStringCollection()
where !string.IsNullOrWhiteSpace(v)
select v.Trim();
model.Codes = string.Join(",", codeTermValues.Distinct().Select(c => System.Net.WebUtility.HtmlEncode(c).Replace(",", ",")));
model.CodeNames = null;//not applicable to this query
//These values are pulled from the stratification section of the request json
var ageStratification = request.Select.Fields.Where(f => f.Type == ModelTermsFactory.AgeRangeID).FirstOrDefault();
if (ageStratification != null)
{
QueryAdapter.SetAgeStratification(model, ageStratification);
}
var sexStratification = GetAllCriteriaTerms(criteria, ModelTermsFactory.SexID).FirstOrDefault();
if (sexStratification != null)
{
QueryAdapter.SetSexStratification(model, sexStratification);
}
model.Setting = null; //not applicable to this query
model.Coverage = null; //not applicable to this query
model.MetricType = "0"; //not applicable to this query
model.OutputCriteria = "0"; //not applicable to this query
model.StartQuarter = null; //not applicable to this query
model.EndQuarter = null; //not applicable to this query
model.SubtypeId = 0; //value never gets set in ui of v5 summary query composer
return(model);
}
public override async Task <CompletionResult> Complete(string data, Guid?activityResultID)
{
if (!activityResultID.HasValue)
{
throw new ArgumentNullException(CommonMessages.ActivityResultIDRequired);
}
if (activityResultID.Value != TerminateResultID &&
activityResultID.Value != SubmitResultID &&
activityResultID.Value != SaveResultID)
{
throw new NotSupportedException(CommonMessages.ActivityResultNotSupported);
}
var task = await PmnTask.GetActiveTaskForRequestActivityAsync(_entity.ID, ID, db);
await db.Entry(_entity).ReloadAsync();
if (activityResultID.Value == TerminateResultID)
{
_entity.CancelledByID = _workflow.Identity.ID;
_entity.CancelledOn = DateTime.UtcNow;
task.Status = DTO.Enums.TaskStatuses.Cancelled;
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = TerminateResultID
});
}
if (activityResultID.Value == SubmitResultID)
{
await db.LoadCollection(_entity, (r) => r.DataMarts);
if (!_entity.DataMarts.Any())
{
throw new Exception("At least one routing needs to be specified when submitting a requests.");
}
//prepare the request documents, save created documents same as legacy
IList <Guid> documentRevisionSets = Newtonsoft.Json.JsonConvert.DeserializeObject <IList <Guid> >(data);
IEnumerable <Document> documents = await(from d in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => documentRevisionSets.Contains(dd.RevisionSetID.Value))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on d.ID equals x
orderby d.ItemID descending, d.RevisionSetID descending, d.CreatedOn descending
select d).ToArrayAsync();
await db.Entry(_entity).Reference(r => r.Activity).LoadAsync();
await db.Entry(_entity).Reference(r => r.RequestType).LoadAsync();
string submitterEmail = await db.Users.Where(u => u.ID == _workflow.Identity.ID).Select(u => u.Email).SingleAsync();
string xmlContent = SerializeModularProgramsToXML(documents, submitterEmail);
string htmlContent = SerializeModularProgramsToHTML(documents, submitterEmail);
Document existingDocument = await(from d in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => dd.ItemID == task.ID && dd.FileName == "ModularProgramRequest.xml")
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on d.ID equals x
orderby d.ItemID descending, d.RevisionSetID descending, d.CreatedOn descending
select d).FirstOrDefaultAsync();
Document xmlRequestDoc = db.Documents.Add(new Document
{
Name = "ModularProgramRequest.xml",
FileName = "ModularProgramRequest.xml",
ItemID = task.ID,
Kind = DTO.Enums.DocumentKind.SystemGeneratedNoLog,
MimeType = "application/xml",
Viewable = false,
UploadedByID = _workflow.Identity.ID,
Length = System.Text.UTF8Encoding.UTF8.GetByteCount(xmlContent)
});
db.ActionReferences.Add(new TaskReference {
TaskID = task.ID, ItemID = xmlRequestDoc.ID, Type = DTO.Enums.TaskItemTypes.ActivityDataDocument
});
if (existingDocument == null)
{
xmlRequestDoc.RevisionSetID = xmlRequestDoc.ID;
}
else
{
xmlRequestDoc.ParentDocumentID = existingDocument.ID;
xmlRequestDoc.Name = existingDocument.Name;
xmlRequestDoc.Description = existingDocument.Description;
xmlRequestDoc.RevisionSetID = existingDocument.RevisionSetID;
xmlRequestDoc.MajorVersion = existingDocument.MajorVersion;
xmlRequestDoc.MinorVersion = existingDocument.MinorVersion;
xmlRequestDoc.BuildVersion = existingDocument.BuildVersion;
xmlRequestDoc.RevisionVersion = existingDocument.RevisionVersion + 1;
}
existingDocument = await(from d in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => dd.ItemID == task.ID && dd.FileName == "ModularProgramRequest.html")
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on d.ID equals x
orderby d.ItemID descending, d.RevisionSetID descending, d.CreatedOn descending
select d).FirstOrDefaultAsync();
Document htmlRequestDoc = db.Documents.Add(new Document
{
Name = "ModularProgramRequest.html",
FileName = "ModularProgramRequest.html",
ItemID = task.ID,
Kind = DTO.Enums.DocumentKind.SystemGeneratedNoLog,
MimeType = "text/html",
Viewable = true,
UploadedByID = _workflow.Identity.ID,
Length = System.Text.UTF8Encoding.UTF8.GetByteCount(htmlContent)
});
db.ActionReferences.Add(new TaskReference {
TaskID = task.ID, ItemID = htmlRequestDoc.ID, Type = DTO.Enums.TaskItemTypes.ActivityDataDocument
});
if (existingDocument == null)
{
htmlRequestDoc.RevisionSetID = htmlRequestDoc.ID;
}
else
{
htmlRequestDoc.ParentDocumentID = existingDocument.ID;
htmlRequestDoc.Name = existingDocument.Name;
htmlRequestDoc.Description = existingDocument.Description;
htmlRequestDoc.RevisionSetID = existingDocument.RevisionSetID;
htmlRequestDoc.MajorVersion = existingDocument.MajorVersion;
htmlRequestDoc.MinorVersion = existingDocument.MinorVersion;
htmlRequestDoc.BuildVersion = existingDocument.BuildVersion;
htmlRequestDoc.RevisionVersion = existingDocument.RevisionVersion + 1;
}
//save the document metadata
await db.SaveChangesAsync();
//push the document bytes
xmlRequestDoc.SetData(db, System.Text.Encoding.UTF8.GetBytes(xmlContent));
htmlRequestDoc.SetData(db, System.Text.Encoding.UTF8.GetBytes(htmlContent));
//add the system generated documents revisionsetIDs to the collection of request documents to be submitted to the data partners.
documentRevisionSets.Add(xmlRequestDoc.RevisionSetID.Value);
documentRevisionSets.Add(htmlRequestDoc.RevisionSetID.Value);
//update the request
_entity.SubmittedByID = _workflow.Identity.ID;
_entity.SubmittedOn = DateTime.UtcNow;
_entity.AdapterPackageVersion = System.Diagnostics.FileVersionInfo.GetVersionInfo(this.GetType().Assembly.Location).FileVersion;
_entity.RejectedByID = null;
_entity.RejectedOn = null;
_entity.Private = false;
//save the changes to the request now since the trigger for routings will change the status invalidating the object before save
await db.SaveChangesAsync();
var originalStatus = _entity.Status;
await SetRequestStatus(DTO.Enums.RequestStatuses.Submitted, false);
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
foreach (var dm in _entity.DataMarts.Where(dm => dm.Status == 0 || dm.Status == DTO.Enums.RoutingStatus.AwaitingRequestApproval || dm.Status == DTO.Enums.RoutingStatus.Draft))
{
dm.Status = DTO.Enums.RoutingStatus.Submitted;
var currentResponse = db.Responses.Include(rsp => rsp.RequestDocument).FirstOrDefault(r => r.RequestDataMartID == dm.ID && r.Count == r.RequestDataMart.Responses.Max(rr => rr.Count));
if (currentResponse == null)
{
currentResponse = db.Responses.Add(new Response {
RequestDataMartID = dm.ID
});
}
currentResponse.SubmittedByID = _workflow.Identity.ID;
currentResponse.SubmittedOn = DateTime.UtcNow;
//add the request document associations
for (int i = 0; i < documentRevisionSets.Count; i++)
{
if (!currentResponse.RequestDocument.Any(rd => rd.RevisionSetID == documentRevisionSets[i]))
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = documentRevisionSets[i], ResponseID = currentResponse.ID, DocumentType = DTO.Enums.RequestDocumentType.Input
});
}
}
foreach (var attachment in attachments)
{
if (!currentResponse.RequestDocument.Any(rd => rd.RevisionSetID == attachment.RevisionSetID.Value))
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = currentResponse.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
}
await db.SaveChangesAsync();
//reload the request since altering the routings triggers a change of the request status in the db by a trigger.
await db.Entry(_entity).ReloadAsync();
DTO.QueryComposer.QueryComposerRequestDTO qcRequestDTO = Newtonsoft.Json.JsonConvert.DeserializeObject <DTO.QueryComposer.QueryComposerRequestDTO>(_entity.Query);
var modularTerm = qcRequestDTO.Where.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == SimpleModularProgramWorkflowConfiguration.ModularProgramTermID)).FirstOrDefault();
var termValues = Newtonsoft.Json.JsonConvert.DeserializeObject <ModularProgramTermValues>(modularTerm.Values["Values"].ToString());
//update the request.json term value to include system generated documents revisionsetIDs
termValues.Documents.Clear();
for (int i = 0; i < documentRevisionSets.Count; i++)
{
termValues.Documents.Add(new ModularProgramTermValues.Document {
RevisionSetID = documentRevisionSets[i]
});
}
modularTerm.Values["Values"] = termValues;
_entity.Query = Newtonsoft.Json.JsonConvert.SerializeObject(qcRequestDTO);
await db.SaveChangesAsync();
await MarkTaskComplete(task);
}
return(new CompletionResult
{
ResultID = activityResultID.Value
});
}
public override async Task <CompletionResult> Complete(string data, Guid?activityResultID)
{
if (!activityResultID.HasValue)
{
throw new ArgumentNullException(CommonMessages.ActivityResultIDRequired);
}
var task = await PmnTask.GetActiveTaskForRequestActivityAsync(_workflow.Entity.ID, ID, db);
if (task == null)
{
task = db.Actions.Add(PmnTask.CreateForWorkflowActivity(_workflow.Entity.ID, ID, _workflow.ID, db));
}
if (activityResultID.Value == SaveResultID)
{
return(new CompletionResult
{
ResultID = SaveResultID
});
}
if (activityResultID.Value == EditRoutingStatusResultID)
{
var dataMarts = Newtonsoft.Json.JsonConvert.DeserializeObject <IEnumerable <RoutingChangeRequestModel> >(data);
await UpdateDataMartRoutingStatus(dataMarts);
return(new CompletionResult
{
ResultID = EditRoutingStatusResultID
});
}
else if (activityResultID.Value == RoutingsBulkEditID)
{
return(new CompletionResult
{
ResultID = RoutingsBulkEditID
});
}
else if (activityResultID.Value == RemoveDataMartsResultID)
{
Guid[] guids = data.Split(',').Select(s => Guid.Parse(s)).ToArray();
var routings = await db.RequestDataMarts.Where(dm => guids.Contains(dm.ID)).ToArrayAsync();
foreach (var routing in routings)
{
routing.Status = DTO.Enums.RoutingStatus.Canceled;
}
await LogTaskModified();
await db.SaveChangesAsync();
var originalStatus = _entity.Status;
await db.SaveChangesAsync();
await db.Entry(_entity).ReloadAsync();
if (originalStatus != DTO.Enums.RequestStatuses.Complete && _entity.Status == DTO.Enums.RequestStatuses.Complete)
{
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.Complete);
}
}
else if (activityResultID.Value == AddDataMartsResultID)
{
DTO.QueryComposer.QueryComposerRequestDTO requestDTO = Newtonsoft.Json.JsonConvert.DeserializeObject <DTO.QueryComposer.QueryComposerRequestDTO>(_entity.Query);
var modularTerm = requestDTO.Where.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == SimpleModularProgramWorkflowConfiguration.ModularProgramTermID)).FirstOrDefault();
var termValues = Newtonsoft.Json.JsonConvert.DeserializeObject <ModularProgramTermValues>(modularTerm.Values["Values"].ToString());
string[] datamartIDs = data.Split(',');
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
foreach (var guid in datamartIDs)
{
Guid dmGuid = new Guid(guid);
var dm = RequestDataMart.Create(_entity.ID, dmGuid, _workflow.Identity.ID);
dm.Status = DTO.Enums.RoutingStatus.Submitted;
dm.DueDate = _entity.DueDate;
dm.Priority = _entity.Priority;
_entity.DataMarts.Add(dm);
Response rsp = dm.Responses.OrderByDescending(r => r.Count).FirstOrDefault();
//add the request document associations
foreach (var revisionSetID in termValues.Documents.Select(d => d.RevisionSetID))
{
db.RequestDocuments.Add(new RequestDocument {
DocumentType = DTO.Enums.RequestDocumentType.Input, ResponseID = rsp.ID, RevisionSetID = revisionSetID
});
}
foreach (var attachment in attachments)
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = rsp.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
await LogTaskModified();
await db.SaveChangesAsync();
}
//Grouping
if (activityResultID.Value == GroupResultID)
{
GroupingRequestModel model = Newtonsoft.Json.JsonConvert.DeserializeObject <GroupingRequestModel>(data);
var responses = await db.Responses.Include(r => r.RequestDataMart).Where(r => model.Responses.Any(x => x == r.ID)).ToArrayAsync();
if (responses.Select(r => r.RequestDataMart.RequestID).Distinct().Count() > 1)
{
throw new ArgumentException("Cannot group responses that come from different requests.");
}
Guid[] requestDataMartIDs = responses.Select(rsp => rsp.RequestDataMartID).Distinct().ToArray();
var pq = (from rdm in db.RequestDataMarts
let permissionID = PermissionIdentifiers.DataMartInProject.GroupResponses.ID
let identityID = _workflow.Identity.ID
let acls = db.GlobalAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID)).Select(a => a.Allowed)
.Concat(db.ProjectAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
.Concat(db.DataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.ProjectDataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.OrganizationAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Organization.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
where requestDataMartIDs.Contains(rdm.ID) &&
acls.Any() && acls.All(a => a == true)
select rdm.ID);
var allowedResponses = await pq.ToArrayAsync();
if (allowedResponses.Length != requestDataMartIDs.Length)
{
throw new SecurityException("Insufficient permission to group one or more of the specified responses.");
}
if (string.IsNullOrWhiteSpace(model.GroupName))
{
model.GroupName = string.Join(", ", db.Responses.Where(r => model.Responses.Any(x => x == r.ID)).Select(r => r.RequestDataMart.DataMart.Name).Distinct());
}
ResponseGroup grouping = db.ResponseGroups.Add(new ResponseGroup(model.GroupName));
foreach (var response in responses)
{
grouping.Responses.Add(response);
response.RequestDataMart.ResultsGrouped = true;
}
await LogTaskModified("Grouped results.");
await db.SaveChangesAsync();
}
//Un-grouping
if (activityResultID.Value == UngroupResultID)
{
IEnumerable <Guid> groupID = (from r in data.Split(',')
where !string.IsNullOrWhiteSpace(r)
select Guid.Parse(r.Trim())).ToArray();
List <Guid> requestDataMartIDs = await db.ResponseGroups.Include(g => g.Responses).Where(g => groupID.Contains(g.ID)).SelectMany(g => g.Responses.Select(r => r.RequestDataMartID)).ToListAsync();
var pq = (from rdm in db.RequestDataMarts
let permissionID = PermissionIdentifiers.DataMartInProject.GroupResponses.ID
let identityID = _workflow.Identity.ID
let acls = db.GlobalAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID)).Select(a => a.Allowed)
.Concat(db.ProjectAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
.Concat(db.DataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.ProjectDataMartAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Project.Requests.Any(r => r.ID == rdm.RequestID) && a.DataMartID == rdm.DataMartID).Select(a => a.Allowed))
.Concat(db.OrganizationAcls.Where(a => a.PermissionID == permissionID && a.SecurityGroup.Users.Any(sgu => sgu.UserID == identityID) && a.Organization.Requests.Any(r => r.ID == rdm.RequestID)).Select(a => a.Allowed))
where requestDataMartIDs.Contains(rdm.ID) &&
acls.Any() && acls.All(a => a == true)
select rdm.ID);
var allowedResponses = await pq.ToArrayAsync();
if (allowedResponses.Length != requestDataMartIDs.Count)
{
throw new SecurityException("Insufficient permission to ungroup routings for the specified request.");
}
var groups = await db.ResponseGroups.Include(g => g.Responses).Where(g => groupID.Contains(g.ID)).ToArrayAsync();
foreach (var group in groups)
{
requestDataMartIDs.AddRange(group.Responses.Select(r => r.RequestDataMartID));
group.Responses.Clear();
db.ResponseGroups.Remove(group);
}
var routings = await db.RequestDataMarts.Where(dm => requestDataMartIDs.Contains(dm.ID)).ToArrayAsync();
foreach (var routing in routings)
{
routing.ResultsGrouped = false;
}
await LogTaskModified("Ungrouped results.");
await db.SaveChangesAsync();
}
if (activityResultID.Value == TerminateResultID)
{
_workflow.Entity.CancelledByID = _workflow.Identity.ID;
_workflow.Entity.CancelledOn = DateTime.UtcNow;
task.Status = DTO.Enums.TaskStatuses.Cancelled;
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = TerminateResultID
});
}
if (activityResultID.Value == RedistributeResultID)
{
if (!await db.HasPermissions <Project>(_workflow.Identity, _entity.ProjectID, Lpp.Dns.DTO.Security.PermissionIdentifiers.Project.ResubmitRequests))
{
throw new System.Security.SecurityException(CommonMessages.RequirePermissionToResubmitRequest, Lpp.Dns.DTO.Security.PermissionIdentifiers.Project.ResubmitRequests.GetType());
}
//TODO: is this applicable in workflow?
//bool canSkipSubmissionApproval = await db.HasPermissions<Request>(Workflow.Identity, Request.ID, Lpp.Dns.DTO.Security.PermissionIdentifiers.Request.SkipSubmissionApproval);
//data will contain a list of routings to resubmit, the ID may also be for a group
ResubmitRoutingsModel resubmitModel = Newtonsoft.Json.JsonConvert.DeserializeObject <ResubmitRoutingsModel>(data);
var datamarts = await(
from dm in db.RequestDataMarts.Include(dm => dm.Responses)
where dm.RequestID == _entity.ID &&
dm.Responses.Any(r => resubmitModel.Responses.Contains(r.ID) || (r.ResponseGroupID.HasValue && resubmitModel.Responses.Contains(r.ResponseGroupID.Value)))
select dm
).ToArrayAsync();
//get the previously submitted input RequestDocument links
var previousInputRequestDocuments = await(from rd in db.RequestDocuments
where rd.DocumentType == DTO.Enums.RequestDocumentType.Input &&
resubmitModel.Responses.Contains(rd.ResponseID)
select new { RequestDataMartID = rd.Response.RequestDataMartID, RevisionSetID = rd.RevisionSetID }).ToArrayAsync();
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
//attachments are associated to the task they were uploaded on, any existing attachment should be included with the routing
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
DateTime reSubmittedOn = DateTime.UtcNow;
foreach (var dm in datamarts)
{
var response = dm.AddResponse(_workflow.Identity.ID);
response.SubmittedOn = reSubmittedOn;
response.SubmitMessage = resubmitModel.ResubmissionMessage;
dm.Status = DTO.Enums.RoutingStatus.Resubmitted;
foreach (var requestDoc in previousInputRequestDocuments.Where(rd => rd.RequestDataMartID == dm.ID))
{
db.RequestDocuments.Add(new RequestDocument {
ResponseID = response.ID, RevisionSetID = requestDoc.RevisionSetID, DocumentType = DTO.Enums.RequestDocumentType.Input
});
}
foreach (var attachment in attachments)
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = response.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
await SetRequestStatus(DTO.Enums.RequestStatuses.Submitted);
await LogTaskModified();
await MarkTaskComplete(task);
}
else if (activityResultID.Value == CompleteResultID)
{
var originalStatus = _entity.Status;
await SetRequestStatus(DTO.Enums.RequestStatuses.PendingDraftReport);
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.PendingDraftReport);
await MarkTaskComplete(task);
}
else if (activityResultID.Value == CompleteWorkflowResultID)
{
var originalStatus = _entity.Status;
if (originalStatus != DTO.Enums.RequestStatuses.Complete && originalStatus != DTO.Enums.RequestStatuses.CompleteWithReport)
{
await SetRequestStatus(DTO.Enums.RequestStatuses.Complete);
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.Complete);
}
await MarkTaskComplete(task);
}
return(new CompletionResult
{
ResultID = activityResultID.Value
});
}
public override DTO.QueryComposer.QueryComposerResponseDTO Execute(DTO.QueryComposer.QueryComposerRequestDTO request, bool viewSQL)
{
IQueryAdapter queryAdapter = null;
if (request.Where.Criteria.First().Terms.Any(t => t.Type == Lpp.QueryComposer.ModelTermsFactory.SqlDistributionID))
{
logger.Debug("Sql Distribution term found, creating SummarySqlQueryAdapter.");
SummarySqlQueryAdapter sql = new SummarySqlQueryAdapter();
var result = sql.Execute(request, _settings, viewSQL);
_currentResponse = result;
return(result);
}
if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.DrugNameID) || request.Select.Fields.Any(t => t.Type == ModelTermsFactory.DrugClassID))
{
if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.DrugNameID))
{
logger.Debug("Pharmacy dispensing generic drug name term found, creating PrevalencePharmaDispensingQueryAdapter.");
}
else
{
logger.Debug("Pharmacy dispensing drug class term found, creating PrevalencePharmaDispensingQueryAdapter.");
}
queryAdapter = new PrevalencePharmaDispensingQueryAdapter(_settings);
}
else if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.CoverageID))
{
logger.Debug("Coverage term found, creating PrevalenceEnrollmentQueryAdapter.");
queryAdapter = new PrevalenceEnrollmentQueryAdapter(_settings);
}
else if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.HCPCSProcedureCodesID))
{
logger.Debug("HCPCS procedure codes term found, creating PrevalenceHCPCSProceduresQueryAdapter.");
queryAdapter = new PrevalenceHCPCSProceduresQueryAdapter(_settings);
}
else if (request.Select.Fields.Any(f => CodeQueryTermIDs.Contains(f.Type)))
{
Guid termID = Guid.Empty;
if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.ICD9ProcedureCodes3digitID))
{
termID = ModelTermsFactory.ICD9ProcedureCodes3digitID;
logger.Debug("ICD9 Procedure Codes (3 digit) term found, creating PrevalenceICD9QueryAdapter.");
}
else if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.ICD9ProcedureCodes4digitID))
{
termID = ModelTermsFactory.ICD9ProcedureCodes4digitID;
logger.Debug("ICD9 Procedure Codes (4 digit) term found, creating PrevalenceICD9QueryAdapter.");
}
else if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.ICD9DiagnosisCodes3digitID))
{
termID = ModelTermsFactory.ICD9DiagnosisCodes3digitID;
logger.Debug("ICD9 Diagnosis Codes (3 digit) term found, creating PrevalenceICD9QueryAdapter.");
}
else if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.ICD9DiagnosisCodes4digitID))
{
termID = ModelTermsFactory.ICD9DiagnosisCodes4digitID;
logger.Debug("ICD9 Diagnosis Codes (4 digit) term found, creating PrevalenceICD9QueryAdapter.");
}
else if (request.Select.Fields.Any(t => t.Type == ModelTermsFactory.ICD9DiagnosisCodes5digitID))
{
termID = ModelTermsFactory.ICD9DiagnosisCodes5digitID;
logger.Debug("ICD9 Diagnosis Codes (5 digit) term found, creating PrevalenceICD9QueryAdapter.");
}
queryAdapter = new PrevalenceICD9QueryAdapter(_settings, termID);
}
if (queryAdapter == null)
{
throw new InvalidOperationException("Unable to determine the query adapter to use based on the primary criteria terms.");
}
using (queryAdapter)
{
var qcResponseDTO = queryAdapter.Execute(request, viewSQL);
qcResponseDTO.LowCellThrehold = _lowThresholdValue;
_currentResponse = qcResponseDTO;
return(qcResponseDTO);
}
}
public override DTO.QueryComposer.QueryComposerResponseDTO Execute(DTO.QueryComposer.QueryComposerRequestDTO request, bool viewSQL)
{
//modular program doesn't actually upload anything.
throw new NotImplementedException();
}
public virtual void GeneratePatientIdentifierLists(DTO.QueryComposer.QueryComposerRequestDTO request, IDictionary <Guid, string> outputSettings, string format)
{
throw new NotSupportedException("Generating Patient Identifier Lists is not supported by this adapter.");
}
protected IEnumerable <DTO.QueryComposer.QueryComposerTermDTO> GetAllTerms(Guid termTypeID, DTO.QueryComposer.QueryComposerRequestDTO requestDTO)
{
return(Data.QueryComposer.Helpers.GetAllTerms(termTypeID, requestDTO.Queries.SelectMany(q => q.Where.Criteria)));
}
/// <summary>
/// The Method to do what the User decieded
/// </summary>
/// <param name="data">The Data payload passed by the User</param>
/// <param name="activityResultID">The Result ID Passed by the User to indicate which step to proceed to.</param>
/// <returns></returns>
public override async Task <CompletionResult> Complete(string data, Guid?activityResultID)
{
if (!activityResultID.HasValue)
{
activityResultID = SaveResultID;
}
var task = PmnTask.GetActiveTaskForRequestActivity(_entity.ID, ID, db);
if (activityResultID == SaveResultID)
{
await task.LogAsModifiedAsync(_workflow.Identity, db);
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = SaveResultID
});
}
else if (activityResultID == RedistributeResultID)
{
if (!await db.HasPermissions <Project>(_workflow.Identity, _entity.ProjectID, Lpp.Dns.DTO.Security.PermissionIdentifiers.Project.ResubmitRequests))
{
throw new System.Security.SecurityException(CommonMessages.RequirePermissionToResubmitRequest, Lpp.Dns.DTO.Security.PermissionIdentifiers.Project.ResubmitRequests.GetType());
}
ResubmitRoutingsModel resubmitModel = Newtonsoft.Json.JsonConvert.DeserializeObject <ResubmitRoutingsModel>(data);
var datamarts = await(
from dm in db.RequestDataMarts.Include(dm => dm.Responses)
where dm.RequestID == _entity.ID &&
dm.Responses.Any(r => resubmitModel.Responses.Contains(r.ID) || (r.ResponseGroupID.HasValue && resubmitModel.Responses.Contains(r.ResponseGroupID.Value)))
select dm
).ToArrayAsync();
//for the last completed routing from the AC
//look for the file_list.csv document, if does not exist use all files
//if file_list.csv exists, only use the documents it specifies
List <Guid> documentRevisionSetIDs = new List <Guid>();
var previousInputRequestDocuments = await(from d in db.Documents.AsNoTracking()
join reqDoc in (from rd in db.RequestDocuments
where rd.DocumentType == DTO.Enums.RequestDocumentType.Output &&
rd.Response.RequestDataMart.RoutingType == DTO.Enums.RoutingType.AnalysisCenter &&
rd.Response.Count == rd.Response.RequestDataMart.Responses.Where(rsp => rsp.RespondedByID.HasValue).Max(rsp => rsp.Count) &&
rd.Response.RequestDataMart.RequestID == _entity.ID
select rd) on d.RevisionSetID equals reqDoc.RevisionSetID
where d.ID == db.Documents.Where(dd => dd.RevisionSetID == d.RevisionSetID).OrderByDescending(dd => dd.MajorVersion).ThenByDescending(dd => dd.MinorVersion).ThenByDescending(dd => dd.BuildVersion).ThenByDescending(dd => dd.RevisionVersion).Select(dd => dd.ID).FirstOrDefault()
select d).ToArrayAsync();
// look for the first document with kind == "DistributedRegression.FileList".
Document fileListDocument = previousInputRequestDocuments.Where(d => !string.IsNullOrEmpty(d.Kind) && string.Equals("DistributedRegression.FileList", d.Kind, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (fileListDocument != null)
{
//only include the files indicated in the manifest
byte[] fileListBytes = fileListDocument.GetData(db);
using (var ms = new System.IO.MemoryStream(fileListBytes))
using (var reader = new System.IO.StreamReader(ms))
{
//read the header line
reader.ReadLine();
string line, filename;
bool includeInDistribution = false;
while (!reader.EndOfStream)
{
line = reader.ReadLine();
string[] split = line.Split(',');
if (split.Length > 0)
{
filename = split[0].Trim();
if (split.Length > 1)
{
includeInDistribution = string.Equals(split[1].Trim(), "1");
}
else
{
includeInDistribution = false;
}
if (includeInDistribution == false)
{
continue;
}
if (!string.IsNullOrEmpty(filename))
{
Guid?revisionSetID = previousInputRequestDocuments.Where(d => string.Equals(d.FileName, filename, StringComparison.OrdinalIgnoreCase)).Select(d => d.RevisionSetID).FirstOrDefault();
if (revisionSetID.HasValue)
{
documentRevisionSetIDs.Add(revisionSetID.Value);
}
}
}
}
reader.Close();
}
}
else
{
//include all documents
documentRevisionSetIDs.AddRange(previousInputRequestDocuments.Select(d => d.RevisionSetID.Value).Distinct());
}
DateTime reSubmittedOn = DateTime.UtcNow;
foreach (var dm in datamarts)
{
var response = dm.AddResponse(_workflow.Identity.ID);
response.SubmittedOn = reSubmittedOn;
response.SubmitMessage = resubmitModel.ResubmissionMessage;
dm.Status = DTO.Enums.RoutingStatus.Resubmitted;
foreach (var revisionSetID in documentRevisionSetIDs)
{
db.RequestDocuments.Add(new RequestDocument {
ResponseID = response.ID, RevisionSetID = revisionSetID, DocumentType = DTO.Enums.RequestDocumentType.Input
});
}
}
await SetRequestStatus(DTO.Enums.RequestStatuses.Submitted);
await task.LogAsModifiedAsync(_workflow.Identity, db);
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = RedistributeResultID
});
}
else if (activityResultID == BulkEditResultID)
{
await task.LogAsModifiedAsync(_workflow.Identity, db);
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = BulkEditResultID
});
}
else if (activityResultID == AddDatamartsResultID)
{
DTO.QueryComposer.QueryComposerRequestDTO requestDTO = Newtonsoft.Json.JsonConvert.DeserializeObject <DTO.QueryComposer.QueryComposerRequestDTO>(_entity.Query);
var modularTerm = requestDTO.Where.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == DistributedRegressionConfiguration.ModularProgramTermID)).FirstOrDefault();
var termValues = Newtonsoft.Json.JsonConvert.DeserializeObject <ModularProgramTermValues>(modularTerm.Values["Values"].ToString());
string[] datamartIDs = data.Split(',');
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
foreach (var guid in datamartIDs)
{
Guid dmGuid = new Guid(guid);
var dm = RequestDataMart.Create(_entity.ID, dmGuid, _workflow.Identity.ID);
dm.Status = DTO.Enums.RoutingStatus.Submitted;
dm.DueDate = _entity.DueDate;
dm.Priority = _entity.Priority;
dm.RoutingType = DTO.Enums.RoutingType.DataPartner;
_entity.DataMarts.Add(dm);
Response rsp = dm.Responses.OrderByDescending(r => r.Count).FirstOrDefault();
//add the request document associations
foreach (var revisionSetID in termValues.Documents.Select(d => d.RevisionSetID))
{
db.RequestDocuments.Add(new RequestDocument {
DocumentType = DTO.Enums.RequestDocumentType.Input, ResponseID = rsp.ID, RevisionSetID = revisionSetID
});
}
foreach (var attachment in attachments)
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = rsp.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
await task.LogAsModifiedAsync(_workflow.Identity, db);
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = AddDatamartsResultID
});
}
else if (activityResultID == RemoveDatamartsResultID)
{
Guid[] guids = data.Split(',').Select(s => Guid.Parse(s)).ToArray();
var routings = await db.RequestDataMarts.Where(dm => guids.Contains(dm.ID)).ToArrayAsync();
foreach (var routing in routings)
{
routing.Status = DTO.Enums.RoutingStatus.Canceled;
}
await task.LogAsModifiedAsync(_workflow.Identity, db);
await db.SaveChangesAsync();
var originalStatus = _entity.Status;
await db.SaveChangesAsync();
await db.Entry(_entity).ReloadAsync();
if (originalStatus != DTO.Enums.RequestStatuses.Complete && _entity.Status == DTO.Enums.RequestStatuses.Complete)
{
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.Complete);
}
return(new CompletionResult
{
ResultID = RemoveDatamartsResultID
});
}
else if (activityResultID == CompleteRoutingResultID)
{
var uiResponse = Newtonsoft.Json.JsonConvert.DeserializeObject <WebResponseModel>(data);
var routing = await db.RequestDataMarts.Include("Request").SingleOrDefaultAsync(dm => dm.ID == uiResponse.RequestDM && dm.RequestID == _entity.ID);
var response = await db.Responses.SingleOrDefaultAsync(res => res.ID == uiResponse.Response && res.RequestDataMartID == uiResponse.RequestDM);
response.ResponseTime = DateTime.UtcNow;
response.RespondedByID = _workflow.Identity.ID;
response.ResponseMessage = uiResponse.Comment;
var originalRequestStatus = routing.Request.Status;
var originalStatus = routing.Status;
//We should only update the routing status if it is not already complete or modified.
if (originalStatus != DTO.Enums.RoutingStatus.Completed && originalStatus != DTO.Enums.RoutingStatus.ResultsModified)
{
routing.Status = DTO.Enums.RoutingStatus.Completed;
}
if (routing.Status == DTO.Enums.RoutingStatus.Completed || routing.Status == DTO.Enums.RoutingStatus.ResultsModified)
{
try
{
var trackingTableProcessor = new DistributedRegressionTrackingTableProcessor(db);
await trackingTableProcessor.Process(response);
}
catch (Exception ex)
{
//should not block if fails
}
}
await db.SaveChangesAsync();
await db.Entry <RequestDataMart>(routing).ReloadAsync();
await db.Entry <Request>(_entity).ReloadAsync();
var completeStatuses = new[] {
Lpp.Dns.DTO.Enums.RoutingStatus.Completed,
Lpp.Dns.DTO.Enums.RoutingStatus.ResultsModified,
Lpp.Dns.DTO.Enums.RoutingStatus.RequestRejected,
Lpp.Dns.DTO.Enums.RoutingStatus.ResponseRejectedBeforeUpload,
Lpp.Dns.DTO.Enums.RoutingStatus.ResponseRejectedAfterUpload,
Lpp.Dns.DTO.Enums.RoutingStatus.AwaitingResponseApproval
};
var incompletedRoutings = await db.RequestDataMarts.Where(dm => dm.RequestID == _entity.ID &&
dm.RoutingType != DTO.Enums.RoutingType.AnalysisCenter &&
!completeStatuses.Contains(dm.Status)).CountAsync();
if (incompletedRoutings == 0)
{
try
{
var routingProcessor = new DistributedRegressionRoutingProcessor(db, _workflow.Identity.ID);
await routingProcessor.Process(routing);
return(new CompletionResult
{
ResultID = CompleteRoutingResultToAC
});
}
catch (Exception ex)
{
throw;
}
}
else
{
await task.LogAsModifiedAsync(_workflow.Identity, db);
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = CompleteRoutingResultID
});
}
}
else if (activityResultID == TerminateResultID)
{
db.Requests.Remove(_entity);
if (task != null)
{
db.Actions.Remove(task);
}
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = TerminateResultID
});
}
else
{
throw new NotSupportedException(CommonMessages.ActivityResultNotSupported);
}
}
protected override SummaryRequestModel ConvertToModel(DTO.QueryComposer.QueryComposerRequestDTO request)
{
var criteria = request.Where.Criteria.First();
SummaryRequestModel model = new SummaryRequestModel();
var observationPeriodTerm = GetAllCriteriaTerms(criteria, ModelTermsFactory.QuarterYearID).FirstOrDefault();
if (observationPeriodTerm != null)
{
model.StartPeriod = observationPeriodTerm.GetStringValue("StartYear");
model.EndPeriod = observationPeriodTerm.GetStringValue("EndYear");
if (string.Equals(observationPeriodTerm.GetStringValue("ByYearsOrQuarters"), "ByQuarters", StringComparison.OrdinalIgnoreCase))
{
model.StartQuarter = observationPeriodTerm.GetStringValue("StartQuarter");
model.EndQuarter = observationPeriodTerm.GetStringValue("EndQuarter");
model.Period = string.Join(",", QueryAdapter.ExpandYearsWithQuarters(Convert.ToInt32(model.StartPeriod), Convert.ToInt32(model.StartQuarter[1].ToString()), Convert.ToInt32(model.EndPeriod), Convert.ToInt32(model.EndQuarter[1].ToString())).Select(y => "'" + y + "'"));//used in query
}
else
{
model.StartQuarter = null;
model.EndQuarter = null;
model.Period = string.Join(",", QueryAdapter.ExpandYears(model).Select(y => "'" + y + "'"));//used in query
}
}
IEnumerable <DTO.QueryComposer.QueryComposerTermDTO> codeTerms = criteria.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == ModelTermsFactory.DrugNameID || t.Type == ModelTermsFactory.DrugClassID)).Concat(criteria.Terms.Where(t => t.Type == ModelTermsFactory.DrugNameID || t.Type == ModelTermsFactory.DrugClassID));
if (codeTerms.Any(t => t.Type == ModelTermsFactory.DrugNameID))
{
_queryType = IncidencePharmaDispensingQueryType.DrugName;
}
else if (codeTerms.Any(t => t.Type == ModelTermsFactory.DrugClassID))
{
_queryType = IncidencePharmaDispensingQueryType.DrugClass;
}
else
{
throw new InvalidOperationException("Either a Drug Name term or a Drug Class term is required for the query.");
}
var codeTermValues = (from t in codeTerms
let v = t.GetCodeSelectorValues()
from c in v
where c != null && !string.IsNullOrWhiteSpace(c.Code)
select c).GroupBy(k => k.Code.Trim()).Select(k => new { Code = k.Key, Name = k.Select(c => c.Name).FirstOrDefault() ?? k.Key }).ToArray();
model.Codes = string.Join(",", codeTermValues.Select(c => System.Net.WebUtility.HtmlEncode(c.Code).Replace(",", ",")));
model.CodeNames = codeTermValues.Select(c => c.Name).ToArray();
//These values are pulled from the stratification section of the request json
var ageStratification = GetAgeField(request.Select.Fields.Where(f => f.Type == ModelTermsFactory.AgeRangeID));
if (ageStratification != null)
{
QueryAdapter.SetAgeStratification(model, ageStratification);
}
var sexStratification = GetAllCriteriaTerms(criteria, ModelTermsFactory.SexID).FirstOrDefault();
if (sexStratification != null)
{
QueryAdapter.SetSexStratification(model, sexStratification);
}
model.Setting = null; //not applicable to this query
model.Coverage = null; //not applicable to this query
model.MetricType = "0"; //not applicable to this query
model.OutputCriteria = "0"; //not applicable to this query
model.SubtypeId = 0; //value never gets set in ui of v5 summary query composer
return(model);
}
protected bool HasTermInAnyCriteria(Guid termTypeID, DTO.QueryComposer.QueryComposerRequestDTO requestDTO)
{
return(Data.QueryComposer.Helpers.HasTermInAnyCriteria(termTypeID, requestDTO));
}
/// <summary> /// Converts the request dto into a SummaryRequestModel that the query translator can use. /// </summary> /// <param name="request"></param> /// <returns></returns> protected abstract SummaryRequestModel ConvertToModel(DTO.QueryComposer.QueryComposerRequestDTO request);
public QueryComposerResponseDTO Execute(DTO.QueryComposer.QueryComposerRequestDTO request, IDictionary <string, object> settings, bool viewSQL)
{
QueryComposerResponseDTO response = new QueryComposerResponseDTO
{
ResponseDateTime = DateTime.UtcNow,
Errors = Array.Empty <QueryComposerResponseErrorDTO>()
};
var allTerms = request.Where.Criteria.SelectMany(c => c.Criteria.SelectMany(cc => cc.Terms)).Concat(request.Where.Criteria.SelectMany(c => c.Terms)).ToArray();
if (allTerms.Any(t => t.Type != ModelTermsFactory.SqlDistributionID))
{
//error: cannot mix sql distribution with any other term
throw new NotSupportedException("Only a single Sql Distribution term can be specified per request. The term cannot be mixed with other terms.");
}
if (allTerms.Length > 1)
{
//limit to a single sql dist request
throw new NotSupportedException("Only a single Sql Distribution term can be specified per request.");
}
string sql = allTerms[0].GetStringValue("Sql");
if (viewSQL)
{
response.Results = new[] {
new [] {
new Dictionary <string, object>()
{
{ "SQL", sql }
}
}
};
response.Properties = new[] {
new QueryComposerResponsePropertyDefinitionDTO {
Name = "SQL",
Type = "System.String"
}
};
return(response);
}
List <DTO.QueryComposer.QueryComposerResponsePropertyDefinitionDTO> columnProperties = new List <QueryComposerResponsePropertyDefinitionDTO>();
List <Dictionary <string, object> > queryResults = new List <Dictionary <string, object> >();
using (var conn = Utilities.OpenConnection(settings, logger))
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = sql;
using (var reader = cmd.ExecuteReader(CommandBehavior.KeyInfo))
{
int noNameIndex = 1;
DataTable schemaTable = reader.GetSchemaTable();
foreach (DataRow row in schemaTable.Rows)
{
foreach (DataColumn column in schemaTable.Columns)
{
if (column.ColumnName == "ColumnName")
{
string columnName = row[column].ToString();
if (string.IsNullOrWhiteSpace(columnName))
{
columnName = "NoColumnName" + noNameIndex;
noNameIndex++;
}
columnProperties.Add(new DTO.QueryComposer.QueryComposerResponsePropertyDefinitionDTO {
Name = columnName, Type = column.DataType.FullName
});
}
}
}
while (reader.Read())
{
Dictionary <string, object> row = new Dictionary <string, object>();
//have to enumerate over the record using ordinal index since there may not be a column name in the reader
for (int i = 0; i < columnProperties.Count; i++)
{
row.Add(columnProperties[i].Name, reader.GetValue(i));
}
queryResults.Add(row);
}
reader.Close();
}
}
if (request.ID.HasValue)
{
response.RequestID = request.ID.Value;
}
response.ResponseDateTime = DateTime.UtcNow;
response.Results = new[] { queryResults };
response.Properties = columnProperties;
return(response);
}
/// <summary>
/// The Method to do what the User decieded
/// </summary>
/// <param name="data">The Data payload passed by the User</param>
/// <param name="activityResultID">The Result ID Passed by the User to indicate which step to proceed to.</param>
/// <returns></returns>
public override async Task <CompletionResult> Complete(string data, Guid?activityResultID)
{
if (!activityResultID.HasValue)
{
activityResultID = SaveResultID;
}
var task = PmnTask.GetActiveTaskForRequestActivity(_entity.ID, ID, db);
if (activityResultID == SaveResultID)
{
await task.LogAsModifiedAsync(_workflow.Identity, db);
await db.Entry(_entity).ReloadAsync();
_entity.Private = false;
await db.SaveChangesAsync();
//Do nothing, it was already saved.
return(new CompletionResult
{
ResultID = SaveResultID
});
}
else if (activityResultID == SubmitResultID)
{
await db.LoadCollection(_entity, (r) => r.DataMarts);
if (!_entity.DataMarts.Any())
{
throw new Exception("At least one routing needs to be specified when submitting a requests.");
}
IList <Guid> documentRevisionSets = Newtonsoft.Json.JsonConvert.DeserializeObject <IList <Guid> >(data);
IEnumerable <Document> documents = await(from d in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => documentRevisionSets.Contains(dd.RevisionSetID.Value))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on d.ID equals x
orderby d.ItemID descending, d.RevisionSetID descending, d.CreatedOn descending
select d).ToArrayAsync();
//reload the request since altering the routings triggers a change of the request status in the db by a trigger.
await db.Entry(_entity).ReloadAsync();
//update the request
_entity.SubmittedByID = _workflow.Identity.ID;
_entity.SubmittedOn = DateTime.UtcNow;
_entity.AdapterPackageVersion = System.Diagnostics.FileVersionInfo.GetVersionInfo(this.GetType().Assembly.Location).FileVersion;
_entity.RejectedByID = null;
_entity.RejectedOn = null;
_entity.Private = false;
//save the changes to the request now since the trigger for routings will change the status invalidating the object before save
await db.SaveChangesAsync();
var originalStatus = _entity.Status;
await SetRequestStatus(DTO.Enums.RequestStatuses.Submitted, false);
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
foreach (var dm in _entity.DataMarts.Where(dm => dm.Status == 0 || dm.Status == DTO.Enums.RoutingStatus.AwaitingRequestApproval || dm.Status == DTO.Enums.RoutingStatus.Draft))
{
if (dm.RoutingType != DTO.Enums.RoutingType.AnalysisCenter)
{
dm.Status = DTO.Enums.RoutingStatus.Submitted;
}
else
{
dm.Status = DTO.Enums.RoutingStatus.Draft;
}
var currentResponse = db.Responses.Include(rsp => rsp.RequestDocument).FirstOrDefault(r => r.RequestDataMartID == dm.ID && r.Count == r.RequestDataMart.Responses.Max(rr => rr.Count));
if (currentResponse == null && dm.RoutingType != DTO.Enums.RoutingType.AnalysisCenter)
{
currentResponse = db.Responses.Add(new Response {
RequestDataMartID = dm.ID
});
}
if (dm.RoutingType != DTO.Enums.RoutingType.AnalysisCenter)
{
currentResponse.SubmittedByID = _workflow.Identity.ID;
currentResponse.SubmittedOn = DateTime.UtcNow;
//add the request document associations
for (int i = 0; i < documentRevisionSets.Count; i++)
{
if (!currentResponse.RequestDocument.Any(rd => rd.RevisionSetID == documentRevisionSets[i]))
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = documentRevisionSets[i], ResponseID = currentResponse.ID, DocumentType = DTO.Enums.RequestDocumentType.Input
});
}
}
foreach (var attachment in attachments)
{
if (!currentResponse.RequestDocument.Any(rd => rd.RevisionSetID == attachment.RevisionSetID.Value))
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = currentResponse.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
}
}
await db.SaveChangesAsync();
//reload the request since altering the routings triggers a change of the request status in the db by a trigger.
await db.Entry(_entity).ReloadAsync();
DTO.QueryComposer.QueryComposerRequestDTO qcRequestDTO = Newtonsoft.Json.JsonConvert.DeserializeObject <DTO.QueryComposer.QueryComposerRequestDTO>(_entity.Query);
var modularTerm = qcRequestDTO.Where.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == DistributedRegressionConfiguration.ModularProgramTermID)).FirstOrDefault();
var termValues = Newtonsoft.Json.JsonConvert.DeserializeObject <ModularProgramTermValues>(modularTerm.Values["Values"].ToString());
//update the request.json term value to include system generated documents revisionsetIDs
termValues.Documents.Clear();
for (int i = 0; i < documentRevisionSets.Count; i++)
{
termValues.Documents.Add(new ModularProgramTermValues.Document {
RevisionSetID = documentRevisionSets[i]
});
}
modularTerm.Values["Values"] = termValues;
_entity.Query = Newtonsoft.Json.JsonConvert.SerializeObject(qcRequestDTO);
await db.SaveChangesAsync();
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.Submitted);
await MarkTaskComplete(task);
return(new CompletionResult
{
ResultID = SubmitResultID
});
}
else if (activityResultID == CopyResultID)
{
return(new CompletionResult
{
ResultID = CopyResultID
});
}
else if (activityResultID == TerminateResultID)
{
db.Requests.Remove(_entity);
if (task != null)
{
db.Actions.Remove(task);
}
await db.SaveChangesAsync();
return(new CompletionResult
{
ResultID = TerminateResultID
});
}
else
{
throw new NotSupportedException(CommonMessages.ActivityResultNotSupported);
}
}
/// <summary>
/// Returns all terms used within request of the specified type.
/// </summary>
/// <param name="termTypeID"></param>
/// <param name="requestDTO"></param>
/// <returns></returns>
public static IEnumerable <DTO.QueryComposer.QueryComposerTermDTO> GetAllTerms(Guid termTypeID, DTO.QueryComposer.QueryComposerRequestDTO requestDTO)
{
return(GetAllTerms(termTypeID, requestDTO.Queries.SelectMany(q => q.Where.Criteria)));
}
public void Initialize(Guid modelID, Model.DocumentWithStream[] documents)
{
ModelID = modelID;
modelMetadata.SetModel(ModelID);
if (documents != null && documents.Any())
{
_requestDocuments = documents.Select(d => d.Document).ToArray();
IEnumerable <DocumentWithStream> requestDocuments = documents.Where(d => string.Equals(d.Document.Kind, DTO.Enums.DocumentKind.Request, StringComparison.OrdinalIgnoreCase)).ToArray();
_desiredDocuments = requestDocuments.Select(d => d.Document).ToArray();
DocumentWithStream requestJson = documents.Where(d => string.Equals(d.Document.Kind, DTO.Enums.DocumentKind.Request, StringComparison.OrdinalIgnoreCase) && string.Equals(d.Document.Filename, "request.json", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (requestJson != null)
{
try
{
using (StreamReader reader = new StreamReader(requestJson.Stream))
{
string query = reader.ReadToEnd();
log.Debug("Request json:" + Environment.NewLine + query);
Newtonsoft.Json.JsonSerializerSettings jsonSettings = new Newtonsoft.Json.JsonSerializerSettings();
jsonSettings.DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.IgnoreAndPopulate;
_request = Newtonsoft.Json.JsonConvert.DeserializeObject <Lpp.Dns.DTO.QueryComposer.QueryComposerRequestDTO>(query, jsonSettings);
}
}
catch (Exception ex)
{
log.Debug(ex.Message, ex);
status.Code = RequestStatus.StatusCode.Error;
status.Message = ex.Message;
throw ex;
}
//inspect for modular or file dist. terms to determine type of request regardless of specified model for datamart
var allTerms = _request.Where.Criteria.SelectMany(c => c.Criteria.SelectMany(cc => cc.Terms.Where(t => t.Type == ModelTermsFactory.ModularProgramID || t.Type == ModelTermsFactory.FileUploadID))).Concat(_request.Where.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == ModelTermsFactory.ModularProgramID || t.Type == ModelTermsFactory.FileUploadID))).ToArray();
if (allTerms.Any())
{
IsFileDistributionRequest = true;
ModelID = QueryComposerModelMetadata.ModularProgramModelID;
}
}
else
{
log.Debug("No request.json found, assuming the request is for Modular Program/File Distribution.");
IsFileDistributionRequest = true;
}
}
using (QueryComposer.IModelAdapter adapter = GetModelAdapter())
{
log.Debug(string.Format("Updating processor metadata based on the selected model adapter: CanViewSQL = {0}, CanRunAndUpload = {1}, CanUploadWithoutRun = {2}, AddFiles = {3}", adapter.CanViewSQL, adapter.CanRunAndUpload, adapter.CanUploadWithoutRun, adapter.CanAddResponseFiles));
modelMetadata.Capabilities["CanViewSQL"] = adapter.CanViewSQL;
modelMetadata.Capabilities["CanRunAndUpload"] = adapter.CanRunAndUpload;
modelMetadata.Capabilities["CanUploadWithoutRun"] = adapter.CanUploadWithoutRun;
modelMetadata.Capabilities["AddFiles"] = adapter.CanAddResponseFiles;
}
}
/// <summary>
/// Determines if the term exists in any query within the request.
/// </summary>
/// <param name="termTypeID">The ID of the term type.</param>
/// <param name="requestDTO">The QueryComposer request dto.</param>
/// <returns></returns>
public static bool HasTermInAnyCriteria(Guid termTypeID, DTO.QueryComposer.QueryComposerRequestDTO requestDTO)
{
var terms = GetAllTerms(termTypeID, requestDTO);
return(terms.Any());
}
public void Initialize(Guid modelID, Model.DocumentWithStream[] documents)
{
ModelID = modelID;
modelMetadata.SetModel(ModelID);
if (modelID == QueryComposerModelMetadata.DistributedRegressionID)
{
_drDocuments = documents;
IsDistributedRegressionRequest = true;
ModelID = QueryComposerModelMetadata.DistributedRegressionID;
}
else if (documents != null && documents.Any())
{
_requestDocuments = documents.Select(d => d.Document).ToArray();
IEnumerable <DocumentWithStream> requestDocuments = documents.Where(d => string.Equals(d.Document.Kind, DTO.Enums.DocumentKind.Request, StringComparison.OrdinalIgnoreCase)).ToArray();
_desiredDocuments = requestDocuments.Select(d => d.Document).ToArray();
DocumentWithStream requestJson = documents.Where(d => string.Equals(d.Document.Kind, DTO.Enums.DocumentKind.Request, StringComparison.OrdinalIgnoreCase) && string.Equals(d.Document.Filename, "request.json", StringComparison.OrdinalIgnoreCase)).FirstOrDefault();
if (requestJson != null)
{
try
{
using (StreamReader reader = new StreamReader(requestJson.Stream))
{
string json = reader.ReadToEnd();
log.Debug("Request json:" + Environment.NewLine + json);
_request = Lpp.Dns.DTO.QueryComposer.QueryComposerDTOHelpers.DeserializeRequest(json);
}
}
catch (Exception ex)
{
log.Debug(ex.Message, ex);
status.Code = RequestStatus.StatusCode.Error;
status.Message = ex.Message;
throw ex;
}
//inspect for modular or file dist. terms to determine type of request regardless of specified model for datamart
var allTerms = Lpp.Dns.DTO.QueryComposer.QueryComposerDTOHelpers.FlattenToTerms(_request).Where(t => t != null && (t.Type == ModelTermsFactory.ModularProgramID || t.Type == ModelTermsFactory.FileUploadID));
if (allTerms.Any())
{
IsFileDistributionRequest = true;
ModelID = QueryComposerModelMetadata.ModularProgramModelID;
}
}
else
{
log.Debug("No request.json found, assuming the request is for Modular Program/File Distribution.");
IsFileDistributionRequest = true;
}
}
else
{
IsFileDistributionRequest = true;
}
//the criteria is only required to determine the sub adapter type based on the query type. The ability to run and view sql is true by default for the model adapters.
using (QueryComposer.IModelAdapter adapter = GetModelAdapter(null))
{
log.Debug(string.Format("Updating processor metadata based on the selected model adapter: CanViewSQL = {0}, CanRunAndUpload = {1}, CanUploadWithoutRun = {2}, AddFiles = {3}", adapter.CanViewSQL, adapter.CanRunAndUpload, adapter.CanUploadWithoutRun, adapter.CanAddResponseFiles));
modelMetadata.Capabilities["CanViewSQL"] = adapter.CanViewSQL;
modelMetadata.Capabilities["CanRunAndUpload"] = adapter.CanRunAndUpload;
modelMetadata.Capabilities["CanUploadWithoutRun"] = adapter.CanUploadWithoutRun;
modelMetadata.Capabilities["AddFiles"] = adapter.CanAddResponseFiles;
modelMetadata.Capabilities["IsFileDistributionRequest"] = IsFileDistributionRequest;
modelMetadata.Capabilities["IsDistributedRegressionRequest"] = IsDistributedRegressionRequest;
modelMetadata.Capabilities["CanGeneratePatientIdentifierLists"] = adapter.CanGeneratePatientIdentifierLists;
}
}
public override async Task <CompletionResult> Complete(string data, Guid?activityResultID)
{
//default to SaveResultID if resultID not specified
if (!activityResultID.HasValue)
{
activityResultID = SaveResultID;
}
await db.Entry(_entity).ReloadAsync();
var task = PmnTask.GetActiveTaskForRequestActivity(_entity.ID, ID, db);
if (activityResultID.Value == SubmitResultID) //Submit
{
await db.LoadCollection(_entity, (r) => r.DataMarts);
var filters = new ExtendedQuery
{
Projects = (a) => a.ProjectID == _entity.ProjectID,
ProjectOrganizations = a => a.ProjectID == _entity.ProjectID && a.OrganizationID == _entity.OrganizationID,
Organizations = a => a.OrganizationID == _entity.OrganizationID,
Users = a => a.UserID == _entity.CreatedByID
};
var permissions = await db.HasGrantedPermissions <Request>(_workflow.Identity, _entity, filters, PermissionIdentifiers.Request.SkipSubmissionApproval);
await db.Entry(_entity).ReloadAsync();
if (Newtonsoft.Json.JsonConvert.DeserializeObject <Lpp.Dns.DTO.QueryComposer.QueryComposerRequestDTO>(_entity.Query).Where.Criteria.Any(c => c.Terms.Any(t => t.Type.ToString().ToUpper() == "2F60504D-9B2F-4DB1-A961-6390117D3CAC") || c.Criteria.Any(ic => ic.Terms.Any(t => t.Type.ToString().ToUpper() == "2F60504D-9B2F-4DB1-A961-6390117D3CAC"))))
{
if (!permissions.Contains(PermissionIdentifiers.Request.SkipSubmissionApproval))
{
//file distribution never requires review before submission, add the permission if the user does not have it.
permissions = new[] { PermissionIdentifiers.Request.SkipSubmissionApproval };
}
await db.LoadCollection(_entity, (r) => r.DataMarts);
if (!_entity.DataMarts.Any())
{
throw new Exception("At least one routing needs to be specified when submitting a requests.");
}
//prepare the request documents, save created documents same as legacy
IList <Guid> documentRevisionSets = Newtonsoft.Json.JsonConvert.DeserializeObject <IList <Guid> >(data);
IEnumerable <Document> documents = await(from d in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => documentRevisionSets.Contains(dd.RevisionSetID.Value))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on d.ID equals x
orderby d.ItemID descending, d.RevisionSetID descending, d.CreatedOn descending
select d).ToArrayAsync();
await db.Entry(_entity).Reference(r => r.Activity).LoadAsync();
await db.Entry(_entity).Reference(r => r.RequestType).LoadAsync();
string submitterEmail = await db.Users.Where(u => u.ID == _workflow.Identity.ID).Select(u => u.Email).SingleAsync();
//update the request
_entity.SubmittedByID = _workflow.Identity.ID;
_entity.SubmittedOn = DateTime.UtcNow;
_entity.AdapterPackageVersion = System.Diagnostics.FileVersionInfo.GetVersionInfo(this.GetType().Assembly.Location).FileVersion;
_entity.RejectedByID = null;
_entity.RejectedOn = null;
_entity.Private = false;
//save the changes to the request now since the trigger for routings will change the status invalidating the object before save
await db.SaveChangesAsync();
await db.Entry(_entity).ReloadAsync();
var originalStatus = _entity.Status;
await SetRequestStatus(DTO.Enums.RequestStatuses.Submitted, false);
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
foreach (var dm in _entity.DataMarts.Where(dm => dm.Status == 0 || dm.Status == DTO.Enums.RoutingStatus.AwaitingRequestApproval || dm.Status == DTO.Enums.RoutingStatus.Draft))
{
dm.Status = DTO.Enums.RoutingStatus.Submitted;
var currentResponse = db.Responses.Include(rsp => rsp.RequestDocument).FirstOrDefault(r => r.RequestDataMartID == dm.ID && r.Count == r.RequestDataMart.Responses.Max(rr => rr.Count));
if (currentResponse == null)
{
currentResponse = db.Responses.Add(new Response {
RequestDataMartID = dm.ID
});
}
currentResponse.SubmittedByID = _workflow.Identity.ID;
currentResponse.SubmittedOn = DateTime.UtcNow;
//add the request document associations
for (int i = 0; i < documentRevisionSets.Count; i++)
{
if (!currentResponse.RequestDocument.Any(rd => rd.RevisionSetID == documentRevisionSets[i]))
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = documentRevisionSets[i], ResponseID = currentResponse.ID, DocumentType = DTO.Enums.RequestDocumentType.Input
});
}
}
foreach (var attachment in attachments)
{
if (!currentResponse.RequestDocument.Any(rd => rd.RevisionSetID == attachment.RevisionSetID.Value))
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = currentResponse.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
}
await db.SaveChangesAsync();
//reload the request since altering the routings triggers a change of the request status in the db by a trigger.
await db.Entry(_entity).ReloadAsync();
DTO.QueryComposer.QueryComposerRequestDTO qcRequestDTO = Newtonsoft.Json.JsonConvert.DeserializeObject <DTO.QueryComposer.QueryComposerRequestDTO>(_entity.Query);
var fileUploadTerm = qcRequestDTO.Where.Criteria.SelectMany(c => c.Terms.Where(t => t.Type == FileUploadTermID)).FirstOrDefault();
var termValues = Newtonsoft.Json.JsonConvert.DeserializeObject <FileUploadValues>(fileUploadTerm.Values["Values"].ToString());
//update the request.json term value to include system generated documents revisionsetIDs
termValues.Documents.Clear();
for (int i = 0; i < documentRevisionSets.Count; i++)
{
termValues.Documents.Add(new FileUploadValues.Document {
RevisionSetID = documentRevisionSets[i]
});
}
fileUploadTerm.Values["Values"] = termValues;
_entity.Query = Newtonsoft.Json.JsonConvert.SerializeObject(qcRequestDTO);
await db.SaveChangesAsync();
await NotifyRequestStatusChanged(originalStatus, DTO.Enums.RequestStatuses.Submitted);
}
else
{
await db.LoadCollection(_entity, (r) => r.DataMarts);
var parentDocument = db.Documents.FirstOrDefault(d => d.ItemID == _entity.ID && d.Kind == DocumentKind && d.ParentDocumentID == null);
byte[] documentContent = System.Text.UTF8Encoding.UTF8.GetBytes(_entity.Query ?? string.Empty);
var document = new Document
{
Name = "Request Criteria",
MajorVersion = parentDocument == null ? 1 : parentDocument.MajorVersion,
MinorVersion = parentDocument == null ? 0 : parentDocument.MinorVersion,
RevisionVersion = parentDocument == null ? 0 : parentDocument.RevisionVersion,
MimeType = "application/json",
Viewable = false,
UploadedByID = _workflow.Identity.ID,
FileName = "request.json",
CreatedOn = DateTime.UtcNow,
BuildVersion = parentDocument == null ? 0 : parentDocument.BuildVersion,
ParentDocumentID = parentDocument == null ? (Guid?)null : parentDocument.ID,
ItemID = task.ID,
Length = documentContent.LongLength,
Kind = Dns.DTO.Enums.DocumentKind.Request
};
db.Documents.Add(document);
document.RevisionSetID = document.ID;
await db.SaveChangesAsync();
document.SetData(db, documentContent);
_entity.AdapterPackageVersion = System.Diagnostics.FileVersionInfo.GetVersionInfo(this.GetType().Assembly.Location).FileVersion;
//Reset reject for resubmit.
_entity.RejectedByID = null;
_entity.RejectedOn = null;
_entity.Private = false;
await db.SaveChangesAsync();
DTO.Enums.RequestStatuses newRequestStatus = DTO.Enums.RequestStatuses.AwaitingRequestApproval;
if (permissions.Contains(PermissionIdentifiers.Request.SkipSubmissionApproval))
{
_entity.SubmittedByID = _workflow.Identity.ID;
_entity.SubmittedOn = DateTime.UtcNow;
await db.SaveChangesAsync();
var allTasks = await db.ActionReferences.Where(tr => tr.ItemID == _entity.ID &&
tr.Type == DTO.Enums.TaskItemTypes.Request &&
tr.Task.Type == DTO.Enums.TaskTypes.Task
)
.Select(tr => tr.Task.ID).ToArrayAsync();
var attachments = await(from doc in db.Documents.AsNoTracking()
join x in (
db.Documents.Where(dd => allTasks.Contains(dd.ItemID))
.GroupBy(k => k.RevisionSetID)
.Select(k => k.OrderByDescending(d => d.MajorVersion).ThenByDescending(d => d.MinorVersion).ThenByDescending(d => d.BuildVersion).ThenByDescending(d => d.RevisionVersion).Select(y => y.ID).Distinct().FirstOrDefault())
) on doc.ID equals x
where allTasks.Contains(doc.ItemID) && doc.Kind == "Attachment.Input"
orderby doc.ItemID descending, doc.RevisionSetID descending, doc.CreatedOn descending
select doc).ToArrayAsync();
_entity.Status = DTO.Enums.RequestStatuses.Submitted;
foreach (var dm in _entity.DataMarts)
{
dm.Status = DTO.Enums.RoutingStatus.Submitted;
var currentResponse = db.Responses.Include(rsp => rsp.RequestDocument).FirstOrDefault(r => r.RequestDataMartID == dm.ID && r.Count == r.RequestDataMart.Responses.Max(rr => rr.Count));
if (currentResponse == null)
{
currentResponse = db.Responses.Add(new Response {
RequestDataMartID = dm.ID
});
}
currentResponse.SubmittedByID = _workflow.Identity.ID;
currentResponse.SubmittedOn = DateTime.UtcNow;
if (!currentResponse.RequestDocument.Any(rd => rd.RevisionSetID == document.RevisionSetID.Value))
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = document.RevisionSetID.Value, ResponseID = currentResponse.ID, DocumentType = DTO.Enums.RequestDocumentType.Input
});
}
foreach (var attachment in attachments)
{
if (!currentResponse.RequestDocument.Any(rd => rd.RevisionSetID == attachment.RevisionSetID.Value))
{
db.RequestDocuments.Add(new RequestDocument {
RevisionSetID = attachment.RevisionSetID.Value, ResponseID = currentResponse.ID, DocumentType = DTO.Enums.RequestDocumentType.AttachmentInput
});
}
}
}
}
else
{
_entity.Status = DTO.Enums.RequestStatuses.AwaitingRequestApproval;
foreach (var dm in _entity.DataMarts)
{
dm.Status = DTO.Enums.RoutingStatus.AwaitingRequestApproval;
}
}
await db.SaveChangesAsync();
await db.Entry(_entity).ReloadAsync();
await SetRequestStatus(newRequestStatus);
await MarkTaskComplete(task);
}
return(new CompletionResult
{
ResultID = permissions.Contains(PermissionIdentifiers.Request.SkipSubmissionApproval) ? SubmitResultID : ReviewResultID
});
}
else if (activityResultID.Value == SaveResultID) //Save
{
if (_entity.Private)
{
await db.Entry(_entity).ReloadAsync();
_entity.Private = false;
await task.LogAsModifiedAsync(_workflow.Identity, db);
await db.SaveChangesAsync();
}
return(new CompletionResult
{
ResultID = SaveResultID
});
}
else if (activityResultID.Value == DeleteResultID) //Delete
{
_workflow.DataContext.Requests.Remove(_workflow.Entity);
if (task != null)
{
db.Actions.Remove(task);
}
await _workflow.DataContext.SaveChangesAsync();
return(null);
}
else
{
throw new ArgumentOutOfRangeException(CommonMessages.ActivityResultNotSupported);
}
}
public abstract DTO.QueryComposer.QueryComposerResponseDTO Execute(DTO.QueryComposer.QueryComposerRequestDTO request, bool viewSQL);
