public async Task <JsonResult> LoadSyncPendingDMDList(string searchTxt)
{
string token = HttpContext.Session.GetString("access_token");
var dmdResponseTask = TerminologyAPIService.SearchDMDSyncLog(searchTxt, token);
var dmdResponse = await dmdResponseTask;
if (dmdResponse.StatusCode != DataService.APIModel.StatusCode.Success)
{
var errors = "Error getting the DMD data.";
if (dmdResponse.ErrorMessages.IsCollectionValid())
{
errors = errors + string.Join('\n', dmdResponse.ErrorMessages);
}
_toastNotification.AddErrorToastMessage(errors);
return(Json(null));
}
var dmds = dmdResponse.Data;
if (!dmds.Data.IsCollectionValid())
{
return(Json(null));
}
var orderedDataList = dmds.Data.OrderBy(rec => rec.Name).ToList();
var formularyList = FillFormularyTreeModel(orderedDataList);
return(Json(formularyList));
}
public async Task <IActionResult> SearchFormularyByName(string q)
{
string token = HttpContext.Session.GetString("access_token");
var filterCriteria = new FormularyFilterCriteriaAPIModel()
{
searchTerm = q,
hideArchived = false,
showOnlyDuplicate = false
};
var response = await TerminologyAPIService.SearchFormulariesAsList(filterCriteria, token);
if (response.StatusCode != DataService.APIModel.StatusCode.Success)
{
_toastNotification.AddErrorToastMessage(string.Join('\n', response.ErrorMessages));
return(Json(null));
}
var formularies = response.Data;
if (!formularies.IsCollectionValid())
{
return(Json(null));
}
return(Json(formularies));
}
/// <summary>
/// This method will check if the field is dirty after edit and will consider only those dirty fields for update - rest are ignored
/// </summary>
/// <param name="editedData"></param>
/// <param name="orginalObj"></param>
private async Task MergeOnlyModified(BulkFormularyEditModel editedData, BulkFormularyEditModel orginalObj, string currentFormularyVersionId)
{
string token = HttpContext.Session.GetString("access_token");
var response = await TerminologyAPIService.GetFormularyDetailRuleBound(currentFormularyVersionId, token);
var formulariesfromAPI = response.Data;
await FillLookupsToViewBag(formulariesfromAPI.RecStatusCode);
var modelFromDb = GetFormularyEditModel(formulariesfromAPI);
IBulkEditMergeHandler mergeHandler = null;
if (string.Compare(editedData.ProductType, "vtm", true) == 0)
{
mergeHandler = new VTMBulkEditMergeHandler();
}
else if (string.Compare(editedData.ProductType, "vmp", true) == 0)
{
mergeHandler = new VMPBulkEditMergeHandler();
}
else if (string.Compare(editedData.ProductType, "amp", true) == 0)
{
mergeHandler = new AMPBulkEditMergeHandler();
}
mergeHandler.Merge(editedData, orginalObj, modelFromDb);
}
public async Task <JsonResult> GetDMDVersion()
{
string token = HttpContext.Session.GetString("access_token");
var response = await TerminologyAPIService.GetDmdSnomedVersion(token);
if (response.StatusCode != DataService.APIModel.StatusCode.Success)
{
var errors = "Error while getting the DMD SNOMED version data.";
if (response.ErrorMessages.IsCollectionValid())
{
errors = errors + string.Join('\n', response.ErrorMessages);
}
_toastNotification.AddErrorToastMessage(errors);
return(Json(null));
}
var dmdSnomedVersion = response.Data;
if (dmdSnomedVersion.IsNotNull())
{
var result = dmdSnomedVersion.DmdVersion;
return(Json(result));
}
else
{
return(Json(null));
}
}
public async Task <JsonResult> GetLatestFormulariesHeaderOnly()
{
string token = HttpContext.Session.GetString("access_token");
var response = await TerminologyAPIService.GetLatestFormulariesHeaderOnly(token);
if (response.StatusCode != DataService.APIModel.StatusCode.Success)
{
var errors = "Error getting the DMD data.";
if (response.ErrorMessages.IsCollectionValid())
{
errors = errors + string.Join('\n', response.ErrorMessages);
}
_toastNotification.AddErrorToastMessage(errors);
return(Json(null));
}
var dmds = response.Data;
if (dmds.IsCollectionValid())
{
var result = dmds.Distinct(x => x.code).ToHashSet();
return(Json(result));
}
else
{
return(Json(null));
}
}
public async Task <JsonResult> GetHistoryOfFormularies()
{
string token = HttpContext.Session.GetString("access_token");
var response = await TerminologyAPIService.GetHistoryOfFormularies(token);
if (response.StatusCode != DataService.APIModel.StatusCode.Success)
{
var errors = "Error while getting the history of formularies data.";
if (response.ErrorMessages.IsCollectionValid())
{
errors = errors + string.Join('\n', response.ErrorMessages);
}
_toastNotification.AddErrorToastMessage(errors);
return(Json(null));
}
var formulariesHistory = response.Data;
if (!formulariesHistory.IsCollectionValid())
{
return(Json(null));
}
var result = formulariesHistory;
return(Json(result));
}
public async Task <IActionResult> UpdateFormularyStatus(string formularyVersionId, string reason, string status)
{
string token = HttpContext.Session.GetString("access_token");
UpdateFormularyStatusAPIRequest request = new UpdateFormularyStatusAPIRequest();
request.RequestData = new List <UpdateFormularyStatusAPRequestData>()
{
new UpdateFormularyStatusAPRequestData
{
FormularyVersionId = formularyVersionId,
RecordStatusCode = status,
RecordStatusCodeChangeMsg = reason
}
};
var resultResponse = await TerminologyAPIService.UpdateFormularyStatus(request, token);
if (resultResponse == null)
{
_toastNotification.AddErrorToastMessage(UNKNOWN_SAVE_STATUS_MSG);
return(Json(null));
}
if (resultResponse.StatusCode != DataService.APIModel.StatusCode.Success)
{
string errors = "Error updating the status.";
if (resultResponse.ErrorMessages.IsCollectionValid())
{
errors += string.Join('\n', resultResponse.ErrorMessages.ToArray());
}
_toastNotification.AddErrorToastMessage(errors);
return(Json(null));
}
if (resultResponse.StatusCode == DataService.APIModel.StatusCode.Success)
{
if (resultResponse.Data.Status != null && resultResponse.Data.Status.ErrorMessages.IsCollectionValid())
{
var errors = string.Join('\n', resultResponse.Data.Status.ErrorMessages);
_toastNotification.AddInfoToastMessage(errors);
return(Json(null));
}
}
var recordStatuses = await _formularyLookupService.GetRecordStatusLookup();//Let it throw the error if not exist
var statusName = recordStatuses?[status];
_toastNotification.AddSuccessToastMessage(STATUS_SUCCESS_MSG.ToFormat(statusName));
return(Json(new List <string> {
"success"
}));
}
private async Task <List <FormularyListAPIModel> > InvokeSearchAPI(FormularyFilterCriteriaAPIModel filterCriteria, string token)
{
//If has any search criteria - hit search api
if (filterCriteria.searchTerm.IsNotEmpty() || filterCriteria.formularyStatusCd.IsCollectionValid() || filterCriteria.IncludeDeleted || filterCriteria.recStatusCds.IsCollectionValid() || filterCriteria.Flags.IsCollectionValid() || filterCriteria.hideArchived)
{
var recStsCodes = new List <string>();
if (filterCriteria.recStatusCds.IsCollectionValid())
{
recStsCodes = filterCriteria.recStatusCds;
}
//if (filterCriteria.hideArchived)
//{
// recStsCodes.Clear();
// recStsCodes.Add("004");
//}
if (recStsCodes.IsCollectionValid())
{
filterCriteria.recStatusCds = recStsCodes;
}
var formulariesResponse = await TerminologyAPIService.SearchFormularies(filterCriteria, token);
if (formulariesResponse.StatusCode != DataService.APIModel.StatusCode.Success)
{
string errors = "Error getting the Formularies data.";
if (formulariesResponse.ErrorMessages.IsCollectionValid())
{
errors += string.Join('\n', formulariesResponse.ErrorMessages.ToArray());
}
_toastNotification.AddErrorToastMessage(errors);
return(null);
}
return(formulariesResponse.Data?.data);
}
else
{
var formulariesResponse = await TerminologyAPIService.GetLatestTopLevelFormulariesBasicInfo(token);
if (formulariesResponse.StatusCode != DataService.APIModel.StatusCode.Success)
{
string errors = "Error getting the Formularies data.";
if (formulariesResponse.ErrorMessages.IsCollectionValid())
{
errors += string.Join('\n', formulariesResponse.ErrorMessages.ToArray());
}
_toastNotification.AddErrorToastMessage(errors);
return(null);
}
return(formulariesResponse.Data);
}
}
public async Task <IActionResult> ImportMeds(List <string> meds)
{
string token = HttpContext.Session.GetString("access_token");
var resultResponse = await TerminologyAPIService.ImportMeds(meds, token);
if (resultResponse == null)
{
_toastNotification.AddErrorToastMessage(UNKNOWN_SAVE_STATUS_MSG);
return(Json(null));
}
if (resultResponse.StatusCode != DataService.APIModel.StatusCode.Success)
{
string errors = "Error Importing the data.";
if (resultResponse.ErrorMessages.IsCollectionValid())
{
errors += string.Join('\n', resultResponse.ErrorMessages);
}
_toastNotification.AddErrorToastMessage(errors);
return(Json(null));
}
if (resultResponse.StatusCode == DataService.APIModel.StatusCode.Success)
{
if (resultResponse.Data.Status != null && resultResponse.Data.Status.ErrorMessages.IsCollectionValid())
{
var errors = string.Join('\n', resultResponse.Data.Status.ErrorMessages);
_toastNotification.AddWarningToastMessage(errors);
return(Json(null));
}
else
{
var postProcessImportResponse = await TerminologyAPIService.InvokePostImportProcess(token, meds);
if (postProcessImportResponse.StatusCode != DataService.APIModel.StatusCode.Success)
{
string errors = "Error Completing post import process of the data.";
if (postProcessImportResponse.ErrorMessages.IsCollectionValid())
{
errors += string.Join('\n', postProcessImportResponse.ErrorMessages);
}
_toastNotification.AddErrorToastMessage(errors);
return(Json(null));
}
}
}
_toastNotification.AddSuccessToastMessage(SUCCESS_IMPORT_MSG);
return(Json(new List <string> {
"Success"
})); //Just to indicate the client
}
public async Task <IActionResult> SearchAMPByName(string q)
{
const string AMP_TYPE = "AMP";
string token = HttpContext.Session.GetString("access_token");
var response = await TerminologyAPIService.GetLatestFormulariesHeaderOnlyByNameOrCode(token, q, AMP_TYPE, false);
if (response.StatusCode != DataService.APIModel.StatusCode.Success)
{
_toastNotification.AddErrorToastMessage(string.Join('\n', response.ErrorMessages));
return(Json(null));
}
var formularies = response.Data;
if (!formularies.IsCollectionValid())
{
return(Json(null));
}
var matchingStartsWith = formularies
.Where(rec => rec.Name.StartsWith(q, StringComparison.OrdinalIgnoreCase))
.Select(rec =>
{
return(new CodeNameSelectorModel {
Id = rec.FormularyVersionId, Name = $"({rec.Code})-{rec.Name}", Source = TerminologyConstants.DMD_DATA_SOURCE, IsReadonly = false
});
}).ToList();
var matchingContains = formularies
.Where(rec => rec.Name.Contains(q, StringComparison.OrdinalIgnoreCase))
.Select(rec =>
{
return(new CodeNameSelectorModel {
Id = rec.FormularyVersionId, Name = $"({rec.Code})-{rec.Name}", Source = TerminologyConstants.DMD_DATA_SOURCE, IsReadonly = false
});
}).ToList();
if (!matchingStartsWith.IsCollectionValid())
{
return(Json(matchingContains));
}
if (!matchingContains.IsCollectionValid())
{
return(Json(matchingStartsWith));
}
matchingStartsWith.AddRange(matchingContains);
matchingStartsWith = matchingStartsWith.Distinct(rec => rec.Id).ToList();
return(Json(matchingStartsWith));
}
public async Task <JsonResult> GetBasisOfPharmaStrength()
{
string token = HttpContext.Session.GetString("access_token");
var basisOfPharmaStrength = await TerminologyAPIService.GetBasisOfPharmaStrength(token);
basisOfPharmaStrength.Insert(0, new BasisOfPharmaStrengthAPIModel {
Cd = "", Desc = "Please Select", Recordstatus = 1
});
return(Json(basisOfPharmaStrength));
}
public async Task <JsonResult> GetAdditionalCodeSystems()
{
var token = HttpContext.Session.GetString("access_token");
var additionalCodeSystems = await TerminologyAPIService.GetClassificationCodeTypesLookup(token);
additionalCodeSystems.Insert(0, new FormularyLookupAPIModel {
Cd = "", Desc = "Please Select", Recordstatus = 1
});
return(Json(additionalCodeSystems));
}
private async Task <int> ImportDeltasToFormulary()
{
string token = HttpContext.Session.GetString("access_token");
var response = await TerminologyAPIService.ImportDeltas(token);
if (response == null || response.StatusCode == DataService.APIModel.StatusCode.Fail)
{
_toastNotification.AddErrorToastMessage("Error Importing DMD data to MMC System.");
return(0);
}
return(1);
}
public async Task <JsonResult> LoadFormularyList(FormularyListSearchCriteria searchCriteria)
{
var pageSize = 100;
if (int.TryParse(_configuration["Settings:FormularyResultsPageSize"], out int configPageSize))
{
pageSize = configPageSize;
}
var paginatedVM = new FormularyTreePaginatedModel {
PageSize = pageSize
};
string token = HttpContext.Session.GetString("access_token");
HttpContext.Session.Remove(SynapseSession.FormularySearchResults);
FormularyFilterCriteriaAPIModel filterCriteria = ConstructFormularyListFilterModel(searchCriteria);
var recordStatusDictionary = HttpContext.Session.GetObject <Dictionary <string, string> >(SynapseSession.FormularyRecStatusLkpKey);
var formularies = await InvokeSearchAPI(filterCriteria, token);
if (!formularies.IsCollectionValid())
{
return(Json(paginatedVM));
}
if (!recordStatusDictionary.IsCollectionValid())
{
var recordStatusLkp = await TerminologyAPIService.GetRecordStatusLookup(token);
if (recordStatusLkp.IsCollectionValid())
{
recordStatusDictionary = recordStatusLkp.Where(rec => rec.Recordstatus == 1).ToDictionary(k => k.Cd.ToString(), v => v.Desc);
HttpContext.Session.SetObject(SynapseSession.FormularyRecStatusLkpKey, recordStatusDictionary);
}
}
var formulariesAsTreeModel = ConvertToFormularyTreeModel(formularies, recordStatusDictionary);
paginatedVM.TotalRecords = formulariesAsTreeModel.Count;
HttpContext.Session.SetObject(SynapseSession.FormularySearchResults, formulariesAsTreeModel);
paginatedVM.Results = formulariesAsTreeModel.Skip(0).Take(pageSize).ToList();
return(Json(paginatedVM));
}
public async Task <JsonResult> GetSuppliers()
{
string token = HttpContext.Session.GetString("access_token");
var suppliers = await TerminologyAPIService.GetSuppliers(token);
if (!suppliers.IsCollectionValid())
{
return(Json(null));
}
var textSup = suppliers.Select(s => new { Cd = s.Cd.ToString(), Desc = s.Desc });
;
return(Json(textSup));
}
public async Task <JsonResult> GetUOMs()
{
string token = HttpContext.Session.GetString("access_token");
var uoms = await TerminologyAPIService.GetUOMs(token);
if (!uoms.IsCollectionValid())
{
return(Json(null));
}
var uomsTxt = uoms.Select(u => new { Cd = u.Cd.ToString(), Desc = u.Desc });
return(Json(uomsTxt));
}
public async Task <JsonResult> GetFormCodes()
{
string token = HttpContext.Session.GetString("access_token");
var formCodes = await TerminologyAPIService.GetFormCodes(token);
if (!formCodes.IsCollectionValid())
{
return(Json(null));
}
var formCodesTxt = formCodes.Select(rec => new CodeNameSelectorModel {
Id = rec.Cd, Name = rec.Desc, IsReadonly = false, Source = TerminologyConstants.MANUAL_DATA_SOURCE, SourceColor = TerminologyConstants.GetColorForRecordSource(TerminologyConstants.MANUAL_DATA_SOURCE)
});
return(Json(formCodesTxt));
}
public async Task <JsonResult> GetRoutes()
{
var routesInSession = await _formularyLookupService.GetRoutesLookup();
if (!routesInSession.IsCollectionValid())
{
string token = HttpContext.Session.GetString("access_token");
var routes = await TerminologyAPIService.GetRoutes(token);
return(Json(routes));
}
var routesAsLkp = routesInSession.Select(rec => new RouteLookup {
Cd = rec.Key, Desc = rec.Value
});
return(Json(routesAsLkp));
}
public async Task <JsonResult> SearchRoutes(string q)
{
if (q.IsEmpty())
{
return(Json(null));
}
var routesInSession = await _formularyLookupService.GetRoutesLookup();
if (!routesInSession.IsCollectionValid())
{
string token = HttpContext.Session.GetString("access_token");
var routes = await TerminologyAPIService.GetRoutes(token);
if (!routes.IsCollectionValid())
{
return(Json(null));
}
var matchingRoutes = routes.Where(rec => rec.Desc.ToLower().StartsWith(q.ToLower())).ToList();
if (!matchingRoutes.IsCollectionValid())
{
return(Json(null));
}
var routesAsCodeName = matchingRoutes.Select(rec => new CodeNameSelectorModel {
Id = rec.Cd, Name = rec.Desc, IsReadonly = false, Source = TerminologyConstants.MANUAL_DATA_SOURCE, SourceColor = TerminologyConstants.GetColorForRecordSource(TerminologyConstants.MANUAL_DATA_SOURCE)
});
return(Json(routesAsCodeName));
}
var matchingRoutesInSession = routesInSession.Where(rec => rec.Value.ToLower().StartsWith(q.ToLower())).ToList();
if (!matchingRoutesInSession.IsCollectionValid())
{
return(Json(null));
}
var routesAsLkp = matchingRoutesInSession.Select(rec => new CodeNameSelectorModel {
Id = rec.Key, Name = rec.Value, IsReadonly = false, Source = TerminologyConstants.MANUAL_DATA_SOURCE, SourceColor = TerminologyConstants.GetColorForRecordSource(TerminologyConstants.MANUAL_DATA_SOURCE)
});
return(Json(routesAsLkp));
}
public async Task <JsonResult> LoadChildrenFormularies(FormularyListSearchCriteria searchCriteria)
{
string token = HttpContext.Session.GetString("access_token");
var apiRequest = new GetFormularyDescendentForCodesAPIRequest()
{
Codes = new List <string> {
searchCriteria.FormularyCode
}, OnlyNonDeleted = false
};
var formulariesResponse = await TerminologyAPIService.GetFormularyDescendentForCodes(apiRequest, token);
var recordStatusDictionary = HttpContext.Session.GetObject <Dictionary <string, string> >(SynapseSession.FormularyRecStatusLkpKey);
if (formulariesResponse.StatusCode != DataService.APIModel.StatusCode.Success)
{
string errors = "Error getting the Formularies data.";
if (formulariesResponse.ErrorMessages.IsCollectionValid())
{
errors = errors + string.Join('\n', formulariesResponse.ErrorMessages.ToArray());
}
_toastNotification.AddErrorToastMessage(errors);
return(Json(null));
}
if (formulariesResponse == null || !formulariesResponse.Data.IsCollectionValid())
{
return(Json(new List <FormularyTreeModel>()));
}
var formularyData = formulariesResponse.Data;
if (searchCriteria.HideArchived == true)
{
formularyData = formularyData.Where(rec => rec.RecStatusCode != TerminologyConstants.ARCHIEVED_STATUS_CD).ToList();
}
var vm = ConvertToFormularyTreeModel(formularyData, recordStatusDictionary);
return(Json(vm));
}
public async Task <JsonResult> SearchTradeFamily(string q)
{
const string semanticTag = "product";
var token = HttpContext.Session.GetString("access_token");
var searchResult = await TerminologyAPIService.SearchSNOMEDData(q, semanticTag, token);
if (searchResult == null || !searchResult.Data.IsCollectionValid())
{
return(Json(new List <string>()));
}
var resultsAsCodeText = searchResult.Data.Select(rec => new CodeNameSelectorModel {
Id = rec.Code, Name = rec.Term, IsReadonly = false, Source = TerminologyConstants.MANUAL_DATA_SOURCE, SourceColor = TerminologyConstants.GetColorForRecordSource(TerminologyConstants.MANUAL_DATA_SOURCE)
});
return(Json(resultsAsCodeText));
}
public async Task <IActionResult> BulkUpdateFormularyStatus(UpdateFormularyStatusAPIRequest request)
{
string token = HttpContext.Session.GetString("access_token");
var resultResponse = await TerminologyAPIService.BulkUpdateFormularyStatus(request, token);
if (resultResponse == null)
{
//_toastNotification.AddErrorToastMessage(UNKNOWN_SAVE_STATUS_MSG);
return(Json(null));
}
if (resultResponse.StatusCode != DataService.APIModel.StatusCode.Success)
{
string errors = "";
if (resultResponse.ErrorMessages.IsCollectionValid())
{
errors += string.Join('\n', resultResponse.ErrorMessages.ToArray());
}
//_toastNotification.AddErrorToastMessage(errors);
return(Json(errors));
}
if (resultResponse.StatusCode == DataService.APIModel.StatusCode.Success)
{
if (resultResponse.Data.Status != null && resultResponse.Data.Status.ErrorMessages.IsCollectionValid())
{
var errors = string.Join('\n', resultResponse.Data.Status.ErrorMessages);
//_toastNotification.AddInfoToastMessage(errors);
return(Json(errors));
}
}
return(Json(new List <string> {
"success"
}));
}
public async Task <IActionResult> LoadFormularyDetails(string formularyVersionId)
{
const string MMC_CONFIG_KEY = "MMC_Control_Source";
string token = HttpContext.Session.GetString("access_token");
var responseTask = TerminologyAPIService.GetFormularyDetailRuleBound(formularyVersionId, token);// TerminologyAPIService.GetFormularyDetail(formularyVersionId, token);
var terminologyConfigTask = TerminologyAPIService.GetTerminologyConfiguration(MMC_CONFIG_KEY, token);
await Task.WhenAll(responseTask, terminologyConfigTask);
var response = await responseTask;
var terminologyConfigResponse = await terminologyConfigTask;
if ((response == null || response.StatusCode == DataService.APIModel.StatusCode.Fail) || ((terminologyConfigResponse == null || terminologyConfigResponse.StatusCode == DataService.APIModel.StatusCode.Fail)))
{
const string ErrorResponse = "Error getting details for the selected record";
var errors = "";
if (response.ErrorMessages.IsCollectionValid())
{
errors = string.Join('\n', ErrorResponse, response.ErrorMessages.ToArray());
}
if (terminologyConfigResponse.ErrorMessages.IsCollectionValid())
{
errors = string.Join('\n', ErrorResponse, terminologyConfigResponse.ErrorMessages.ToArray());
}
_toastNotification.AddErrorToastMessage(errors);
return(null);
}
var formulariesfromAPI = response.Data;
await FillLookupsToViewBag(formulariesfromAPI.RecStatusCode);
FormularyEditModel vm = GetFormularyEditModel(formulariesfromAPI);
return(PartialView(GetFormularyEditView(formulariesfromAPI.ProductType), vm));
}
public async Task <Dictionary <string, string> > GetRestrictionsOnAvailability(Action <Dictionary <string, string> > onResultFetch = null)
{
string token = _httpContext.Session.GetString("access_token");
var dataDictionary = _httpContext.Session.GetObject <Dictionary <string, string> >(SynapseSession.RestrictionsOnAvailability);
if (!dataDictionary.IsCollectionValid())
{
var restrictionsOnAvailabilityLkp = await TerminologyAPIService.GetRestrictionsOnAvailability(token);
if (restrictionsOnAvailabilityLkp.IsCollectionValid())
{
dataDictionary = restrictionsOnAvailabilityLkp.Where(rec => rec.Recordstatus == 1).ToDictionary(k => k.Cd.ToString(), v => v.Desc);
_httpContext.Session.SetObject(SynapseSession.RestrictionsOnAvailability, dataDictionary);
}
}
dataDictionary = dataDictionary ?? new Dictionary <string, string>();
onResultFetch?.Invoke(dataDictionary);
return(dataDictionary);
}
public async Task <Dictionary <string, string> > GetIdentificationCodeTypes(Action <Dictionary <string, string> > onResultFetch = null)
{
string token = _httpContext.Session.GetString("access_token");
var dataDictionary = _httpContext.Session.GetObject <Dictionary <string, string> >(SynapseSession.IdentificationCodeTypes);
if (!dataDictionary.IsCollectionValid())
{
var codeSystemsLkp = await TerminologyAPIService.GetIdentificationCodeTypesLookup(token);
if (codeSystemsLkp.IsCollectionValid())
{
dataDictionary = codeSystemsLkp.Where(rec => rec.Recordstatus == 1).ToDictionary(k => k.Cd.ToString(), v => v.Desc);
_httpContext.Session.SetObject(SynapseSession.IdentificationCodeTypes, dataDictionary);
}
}
dataDictionary = dataDictionary ?? new Dictionary <string, string>();
onResultFetch?.Invoke(dataDictionary);
return(dataDictionary);
}
//public async Task<Dictionary<string, string>> GetOrderFormTypes(Action<Dictionary<string, string>> onResultFetch = null)
//{
// string token = _httpContext.Session.GetString("access_token");
// var dataDictionary = _httpContext.Session.GetObject<Dictionary<string, string>>(SynapseSession.OrderFormTypes);
// if (!dataDictionary.IsCollectionValid())
// {
// var orderFormTypesLkp = await TerminologyAPIService.GetOrderFormTypes(token);
// if (orderFormTypesLkp.IsCollectionValid())
// {
// dataDictionary = orderFormTypesLkp.Where(rec => rec.Recordstatus == 1).ToDictionary(k => k.Cd.ToString(), v => v.Desc);
// _httpContext.Session.SetObject(SynapseSession.OrderFormTypes, dataDictionary);
// }
// }
// dataDictionary = dataDictionary ?? new Dictionary<string, string>();
// onResultFetch?.Invoke(dataDictionary);
// return dataDictionary;
//}
public async Task <Dictionary <string, string> > GetBasisOfPharmaStrengths(Action <Dictionary <string, string> > onResultFetch = null)
{
string token = _httpContext.Session.GetString("access_token");
var dataDictionary = _httpContext.Session.GetObject <Dictionary <string, string> >(SynapseSession.BasisOfPharmaStrengths);
if (!dataDictionary.IsCollectionValid())
{
var basisOfPharmaStrengths = await TerminologyAPIService.GetBasisOfPharmaStrength(token);
if (basisOfPharmaStrengths.IsCollectionValid())
{
dataDictionary = basisOfPharmaStrengths.Where(rec => rec.Recordstatus == 1).ToDictionary(k => k.Cd.ToString(), v => v.Desc);
_httpContext.Session.SetObject(SynapseSession.BasisOfPharmaStrengths, dataDictionary);
}
}
dataDictionary = dataDictionary ?? new Dictionary <string, string>();
onResultFetch?.Invoke(dataDictionary);
return(dataDictionary);
}
//public async Task<Dictionary<string, string>> GetFormAndRoutesLookup(Action<Dictionary<string, string>> onResultFetch = null)
//{
// string token = _httpContext.Session.GetString("access_token");
// var dataDictionary = _httpContext.Session.GetObject<Dictionary<string, string>>(SynapseSession.FormNRoutesLkpKey);
// if (!dataDictionary.IsCollectionValid())
// {
// var dataLkp = await DataService.TerminologyAPIService.GetFormAndRoutes(token);
// if (dataLkp.IsCollectionValid())
// {
// dataDictionary = dataLkp.Where(rec => rec.Recordstatus == 1).ToDictionary(k => k.Cd.ToString(), v => v.Desc);
// _httpContext.Session.SetObject(SynapseSession.FormNRoutesLkpKey, dataDictionary);
// }
// }
// dataDictionary = dataDictionary ?? new Dictionary<string, string>();
// onResultFetch?.Invoke(dataDictionary);
// return dataDictionary;
//}
public async Task <Dictionary <string, string> > GetIngredientsLookup(Action <Dictionary <string, string> > onResultFetch = null)
{
string token = _httpContext.Session.GetString("access_token");
var dataDictionary = _httpContext.Session.GetObject <Dictionary <string, string> >(SynapseSession.IngredientsLkpKey);
if (!dataDictionary.IsCollectionValid())
{
var dataLkp = await TerminologyAPIService.GetIngredients(token);
if (dataLkp.IsCollectionValid())
{
dataDictionary = dataLkp.Where(rec => rec.Recordstatus == 1 && !rec.Invalid.HasValue).ToDictionary(k => k.Isid.ToString(), v => v.Nm);
_httpContext.Session.SetObject(SynapseSession.IngredientsLkpKey, dataDictionary);
}
}
dataDictionary = dataDictionary ?? new Dictionary <string, string>();
onResultFetch?.Invoke(dataDictionary);
return(dataDictionary);
}
public async Task <IActionResult> LoadHistoryFormularyDetails(string previousFormularyVersionId, string currentFormularyVersionId, string previousOrCurrent)
{
const string MMC_CONFIG_KEY = "MMC_Control_Source";
string token = HttpContext.Session.GetString("access_token");
var previousResponseTask = TerminologyAPIService.GetFormularyDetailRuleBound(previousFormularyVersionId, token);// TerminologyAPIService.GetFormularyDetail(formularyVersionId, token);
var currentResponseTask = TerminologyAPIService.GetFormularyDetailRuleBound(currentFormularyVersionId, token);
var terminologyConfigTask = TerminologyAPIService.GetTerminologyConfiguration(MMC_CONFIG_KEY, token);
await Task.WhenAll(previousResponseTask, terminologyConfigTask);
await Task.WhenAll(currentResponseTask, terminologyConfigTask);
var previousResponse = await previousResponseTask;
var currentResponse = await currentResponseTask;
var terminologyConfigResponse = await terminologyConfigTask;
if ((previousResponse == null || previousResponse.StatusCode == DataService.APIModel.StatusCode.Fail) || (currentResponse == null || currentResponse.StatusCode == DataService.APIModel.StatusCode.Fail) || ((terminologyConfigResponse == null || terminologyConfigResponse.StatusCode == DataService.APIModel.StatusCode.Fail)))
{
const string ErrorResponse = "Error getting details for the selected record";
var errors = "";
if (previousResponse.ErrorMessages.IsCollectionValid())
{
errors = string.Join('\n', ErrorResponse, previousResponse.ErrorMessages.ToArray());
}
if (currentResponse.ErrorMessages.IsCollectionValid())
{
errors = string.Join('\n', ErrorResponse, currentResponse.ErrorMessages.ToArray());
}
if (terminologyConfigResponse.ErrorMessages.IsCollectionValid())
{
errors = string.Join('\n', ErrorResponse, terminologyConfigResponse.ErrorMessages.ToArray());
}
_toastNotification.AddErrorToastMessage(errors);
return(null);
}
var previousFormulariesfromAPI = previousResponse.Data;
var currentFormulariesfromAPI = currentResponse.Data;
await FillLookupsToViewBag(previousFormulariesfromAPI.RecStatusCode);
await FillLookupsToViewBag(currentFormulariesfromAPI.RecStatusCode);
FormularyEditModel previousVM = GetFormularyEditModel(previousFormulariesfromAPI);
FormularyEditModel currentVM = GetFormularyEditModel(currentFormulariesfromAPI);
var prevProductName = previousVM.Name;
var prevProductType = previousVM.ProductType;
var prevCode = previousVM.Code;
var prevCodeSystem = previousVM.CodeSystem;
var currProductName = currentVM.Name;
var currProductType = currentVM.ProductType;
var currCode = currentVM.Code;
var currCodeSystem = currentVM.CodeSystem;
var differences = previousVM.Diff(currentVM, ComparisonOptions.All | ComparisonOptions.AllowCollectionsToBeOutOfOrder | ComparisonOptions.AllowEqualsOverride,
".FormularyVersionIds", ".Excipients.FormularyVersionId", ".FormularyClassificationCodes.FormularyVersionId", ".FormularyIdentificationCodes.FormularyVersionId", ".Ingredients.FormularyVersionId",
".UnlicensedRoute.Source", ".UnlicensedRoute.SourceColor", ".Route.Source", ".Route.SourceColor", ".LocalLicensedRoute.Source", ".LocalLicensedRoute.SourceColor", ".LocalUnlicensedRoute.Source", ".LocalUnlicensedRoute.SourceColor",
".Cautions.Source", ".Cautions.SourceColor", ".ContraIndications.Source", ".ContraIndications.SourceColor", ".SideEffects.Source", ".SideEffects.SourceColor", ".SafetyMessages.Source", ".SafetyMessages.SourceColor",
".LicensedUse.Source", ".LicensedUse.SourceColor", ".UnlicensedUse.Source", ".UnlicensedUse.SourceColor", ".LocalLicensedUse.Source", ".LocalLicensedUse.SourceColor", ".LocalUnlicensedUse.Source", ".LocalUnlicensedUse.SourceColor",
".FormCd.Source", ".FormCd.SourceColor", ".UnitDoseFormUnits.Source", ".UnitDoseFormUnits.SourceColor", ".UnitDoseUnitOfMeasure.Source", ".UnitDoseUnitOfMeasure.SourceColor", ".Supplier.Source", ".Supplier.SourceColor",
".TradeFamily.Source", ".TradeFamily.SourceColor", ".MedusaPreparationInstructions.Source", ".MedusaPreparationInstructions.SourceColor", ".ControlledDrugCategories.Source", ".ControlledDrugCategories.SourceColor",
".TitrationTypes.Source", ".TitrationTypes.SourceColor", ".Diluents.Source", ".Diluents.SourceColor", ".HighAlertMedicationSource", ".BlackTriangleSource", ".PrescribableSource");
if (differences.Count > 0)
{
List <KeyValuePair <string, object> > prevObjects = new List <KeyValuePair <string, object> >();
foreach (var diff in differences)
{
prevObjects.Add(new KeyValuePair <string, object>(diff.Property, diff.LeftValue));
}
FormularyEditModel prevVM = new FormularyEditModel();
prevVM.Differences = new List <Difference>();
prevVM.Differences.AddRange(differences);
var prevVMType = prevVM.GetType();
foreach (KeyValuePair <string, object> _pair in prevObjects)
{
if (prevVMType.GetProperty(_pair.Key).PropertyType.Name == "List`1")
{
if (_pair.Value != null)
{
object instance = Activator.CreateInstance(prevVMType.GetProperty(_pair.Key).PropertyType);
IList list = (IList)instance;
list.Add(_pair.Value);
if (prevVM.GetType().GetProperty(_pair.Key).GetValue(prevVM, null).IsNotNull())
{
foreach (var value in (dynamic)prevVM.GetType().GetProperty(_pair.Key).GetValue(prevVM, null))
{
list.Add(value);
}
prevVMType.GetProperty(_pair.Key).SetValue(prevVM, list, null);
}
else
{
prevVMType.GetProperty(_pair.Key).SetValue(prevVM, list, null);
}
}
else
{
object instance = Activator.CreateInstance(prevVMType.GetProperty(_pair.Key).PropertyType);
IList list = (IList)instance;
list.Add(_pair.Value);
prevVMType.GetProperty(_pair.Key).SetValue(prevVM, list, null);
}
}
else
{
prevVMType.GetProperty(_pair.Key).SetValue(prevVM, _pair.Value);
}
}
previousVM = prevVM;
previousVM.IsDiff = true;
previousVM.Name = prevProductName;
previousVM.ProductType = prevProductType;
previousVM.Code = prevCode;
previousVM.CodeSystem = prevCodeSystem;
List <KeyValuePair <string, object> > currObjects = new List <KeyValuePair <string, object> >();
foreach (var diff in differences)
{
currObjects.Add(new KeyValuePair <string, object>(diff.Property, diff.RightValue));
}
FormularyEditModel currVM = new FormularyEditModel();
currVM.Differences = new List <Difference>();
currVM.Differences.AddRange(differences);
var currVMType = currVM.GetType();
foreach (KeyValuePair <string, object> _pair in currObjects)
{
if (currVMType.GetProperty(_pair.Key).PropertyType.Name == "List`1")
{
if (_pair.Value != null)
{
object instance = Activator.CreateInstance(currVMType.GetProperty(_pair.Key).PropertyType);
IList list = (IList)instance;
list.Add(_pair.Value);
if (currVM.GetType().GetProperty(_pair.Key).GetValue(currVM, null).IsNotNull())
{
foreach (var value in (dynamic)currVM.GetType().GetProperty(_pair.Key).GetValue(currVM, null))
{
list.Add(value);
}
currVMType.GetProperty(_pair.Key).SetValue(currVM, list, null);
}
else
{
currVMType.GetProperty(_pair.Key).SetValue(currVM, list, null);
}
}
else
{
object instance = Activator.CreateInstance(currVMType.GetProperty(_pair.Key).PropertyType);
IList list = (IList)instance;
list.Add(_pair.Value);
currVMType.GetProperty(_pair.Key).SetValue(currVM, list, null);
}
}
else
{
currVMType.GetProperty(_pair.Key).SetValue(currVM, _pair.Value);
}
}
currentVM = currVM;
currentVM.IsDiff = true;
currentVM.Name = currProductName;
currentVM.ProductType = currProductType;
currentVM.Code = currCode;
currentVM.CodeSystem = currCodeSystem;
}
else
{
previousVM = new FormularyEditModel();
currentVM = new FormularyEditModel();
previousVM.IsDiff = false;
previousVM.Name = prevProductName;
previousVM.ProductType = prevProductType;
previousVM.Code = prevCode;
previousVM.CodeSystem = prevCodeSystem;
currentVM.IsDiff = false;
currentVM.Name = currProductName;
currentVM.ProductType = currProductType;
currentVM.Code = currCode;
currentVM.CodeSystem = currCodeSystem;
}
if (previousVM.BlackTriangle != currentVM.BlackTriangle)
{
previousVM.IsDiffBlackTriangle = true;
currentVM.IsDiffBlackTriangle = true;
}
else
{
previousVM.IsDiffBlackTriangle = false;
currentVM.IsDiffBlackTriangle = false;
}
if (previousVM.ClinicalTrialMedication != currentVM.ClinicalTrialMedication)
{
previousVM.IsDiffClinicalTrialMedication = true;
currentVM.IsDiffClinicalTrialMedication = true;
}
else
{
previousVM.IsDiffClinicalTrialMedication = false;
currentVM.IsDiffClinicalTrialMedication = false;
}
if (previousVM.CriticalDrug != currentVM.CriticalDrug)
{
previousVM.IsDiffCriticalDrug = true;
currentVM.IsDiffCriticalDrug = true;
}
else
{
previousVM.IsDiffCriticalDrug = false;
currentVM.IsDiffCriticalDrug = false;
}
if (previousVM.EmaAdditionalMonitoring != currentVM.EmaAdditionalMonitoring)
{
previousVM.IsDiffEMAAddMontorng = true;
currentVM.IsDiffEMAAddMontorng = true;
}
else
{
previousVM.IsDiffEMAAddMontorng = false;
currentVM.IsDiffEMAAddMontorng = false;
}
if (previousVM.IsGastroResistant != currentVM.IsGastroResistant)
{
previousVM.IsDiffGastroResistant = true;
currentVM.IsDiffGastroResistant = true;
}
else
{
previousVM.IsDiffGastroResistant = false;
currentVM.IsDiffGastroResistant = false;
}
if (previousVM.IsModifiedRelease != currentVM.IsModifiedRelease)
{
previousVM.IsDiffModifiedRelease = true;
currentVM.IsDiffModifiedRelease = true;
}
else
{
previousVM.IsDiffModifiedRelease = false;
currentVM.IsDiffModifiedRelease = false;
}
if (previousVM.ExpensiveMedication != currentVM.ExpensiveMedication)
{
previousVM.IsDiffExpensiveMedication = true;
currentVM.IsDiffExpensiveMedication = true;
}
else
{
previousVM.IsDiffExpensiveMedication = false;
currentVM.IsDiffExpensiveMedication = false;
}
if (previousVM.HighAlertMedication != currentVM.HighAlertMedication)
{
previousVM.IsDiffHighAlertMedication = true;
currentVM.IsDiffHighAlertMedication = true;
}
else
{
previousVM.IsDiffHighAlertMedication = false;
currentVM.IsDiffHighAlertMedication = false;
}
if (previousVM.IVToOral != currentVM.IVToOral)
{
previousVM.IsDiffIVtoOral = true;
currentVM.IsDiffIVtoOral = true;
}
else
{
previousVM.IsDiffIVtoOral = false;
currentVM.IsDiffIVtoOral = false;
}
if (previousVM.NotForPrn != currentVM.NotForPrn)
{
previousVM.IsDiffNotforPRN = true;
currentVM.IsDiffNotforPRN = true;
}
else
{
previousVM.IsDiffNotforPRN = false;
currentVM.IsDiffNotforPRN = false;
}
if (previousVM.IsBloodProduct != currentVM.IsBloodProduct)
{
previousVM.IsDiffBloodProduct = true;
currentVM.IsDiffBloodProduct = true;
}
else
{
previousVM.IsDiffBloodProduct = false;
currentVM.IsDiffBloodProduct = false;
}
if (previousVM.IsDiluent != currentVM.IsDiluent)
{
previousVM.IsDiffDiluent = true;
currentVM.IsDiffDiluent = true;
}
else
{
previousVM.IsDiffDiluent = false;
currentVM.IsDiffDiluent = false;
}
if (previousVM.Prescribable != currentVM.Prescribable)
{
previousVM.IsDiffPrescribable = true;
currentVM.IsDiffPrescribable = true;
}
else
{
previousVM.IsDiffPrescribable = false;
currentVM.IsDiffPrescribable = false;
}
if (previousVM.OutpatientMedication != currentVM.OutpatientMedication)
{
previousVM.IsDiffOutpatientMedication = true;
currentVM.IsDiffOutpatientMedication = true;
}
else
{
previousVM.IsDiffOutpatientMedication = false;
currentVM.IsDiffOutpatientMedication = false;
}
if (previousVM.SugarFree != currentVM.SugarFree)
{
previousVM.IsDiffSugarFree = true;
currentVM.IsDiffSugarFree = true;
}
else
{
previousVM.IsDiffSugarFree = false;
currentVM.IsDiffSugarFree = false;
}
if (previousVM.GlutenFree != currentVM.GlutenFree)
{
previousVM.IsDiffGlutenFree = true;
currentVM.IsDiffGlutenFree = true;
}
else
{
previousVM.IsDiffGlutenFree = false;
currentVM.IsDiffGlutenFree = false;
}
if (previousVM.PreservativeFree != currentVM.PreservativeFree)
{
previousVM.IsDiffPreservativeFree = true;
currentVM.IsDiffPreservativeFree = true;
}
else
{
previousVM.IsDiffPreservativeFree = false;
currentVM.IsDiffPreservativeFree = false;
}
if (previousVM.CFCFree != currentVM.CFCFree)
{
previousVM.IsDiffCFCFree = true;
currentVM.IsDiffCFCFree = true;
}
else
{
previousVM.IsDiffCFCFree = false;
currentVM.IsDiffCFCFree = false;
}
if (previousVM.UnlicensedMedication != currentVM.UnlicensedMedication)
{
previousVM.IsDiffUnlicensedMedication = true;
currentVM.IsDiffUnlicensedMedication = true;
}
else
{
previousVM.IsDiffUnlicensedMedication = false;
currentVM.IsDiffUnlicensedMedication = false;
}
if (previousVM.ParallelImport != currentVM.ParallelImport)
{
previousVM.IsDiffParallelImport = true;
currentVM.IsDiffParallelImport = true;
}
else
{
previousVM.IsDiffParallelImport = false;
currentVM.IsDiffParallelImport = false;
}
if (previousVM.IgnoreDuplicateWarnings != currentVM.IgnoreDuplicateWarnings)
{
previousVM.IsDiffIgnoreDuplicateWarnings = true;
currentVM.IsDiffIgnoreDuplicateWarnings = true;
}
else
{
previousVM.IsDiffIgnoreDuplicateWarnings = false;
currentVM.IsDiffIgnoreDuplicateWarnings = false;
}
if (previousVM.IsCustomControlledDrug != currentVM.IsCustomControlledDrug)
{
previousVM.IsDiffControlledDrug = true;
currentVM.IsDiffControlledDrug = true;
}
else
{
previousVM.IsDiffControlledDrug = false;
currentVM.IsDiffControlledDrug = false;
}
if (previousVM.IsIndicationMandatory != currentVM.IsIndicationMandatory)
{
previousVM.IsDiffIndicationIsMandatory = true;
currentVM.IsDiffIndicationIsMandatory = true;
}
else
{
previousVM.IsDiffIndicationIsMandatory = false;
currentVM.IsDiffIndicationIsMandatory = false;
}
if (previousVM.WitnessingRequired != currentVM.WitnessingRequired)
{
previousVM.IsDiffWitnessingRequired = true;
currentVM.IsDiffWitnessingRequired = true;
}
else
{
previousVM.IsDiffWitnessingRequired = false;
currentVM.IsDiffWitnessingRequired = false;
}
if (previousOrCurrent.IsEmpty())
{
return(null);
}
string viewName = string.Empty;
if (string.Compare(previousOrCurrent, "previous", true) == 0)
{
viewName = "_FormularyPreviousDetails";
return(PartialView(viewName, previousVM));
}
if (string.Compare(previousOrCurrent, "current", true) == 0)
{
viewName = "_FormularyCurrentDetails";
return(PartialView(viewName, currentVM));
}
return(null);
}
public async Task <IActionResult> UpdateFormulary(FormularyEditModel editedData)
{
BulkFormularyEditModel bulkEditedData = null;
string token = HttpContext.Session.GetString("access_token");
var partialView = GetFormularyEditView(editedData.ProductType);
if (editedData.IsBulkEdit)
{
bulkEditedData = editedData as BulkFormularyEditModel;
partialView = GetFormularyEditViewForBulkEdit(editedData.ProductType);
}
if (!ModelState.IsValid)
{
await FillLookupsToViewBag(editedData.OriginalStatus);
editedData.IsSaveSuccessful = false;
return(PartialView(partialView, editedData));
}
var apiModels = new List <FormularyHeaderAPIModel>();
var uniqueIds = editedData.FormularyVersionIds;
foreach (var rec in uniqueIds)
{
FormularyHeaderAPIModel apiModel = null;
if (editedData.IsBulkEdit)
{
var orginalObj = JsonConvert.DeserializeObject <BulkFormularyEditModel>(bulkEditedData.SerializedOriginalObj);
var edDataDeserializedObj = _mapper.Map <BulkFormularyEditModel>(bulkEditedData);
await MergeOnlyModified(edDataDeserializedObj, orginalObj, rec);
apiModel = _mapper.Map <FormularyHeaderAPIModel>(edDataDeserializedObj);
}
else
{
apiModel = _mapper.Map <FormularyHeaderAPIModel>(editedData);
}
apiModel.FormularyVersionId = rec;
apiModel.RecStatusCode = apiModel.RecStatusCode; //editedData.IsBulkEdit ? null : apiModel.RecStatusCode;//For bulk-edit mode - Record status is not editable
apiModels.Add(apiModel);
}
TerminologyAPIResponse <UpdateFormularyAPIResponse> response = await TerminologyAPIService.UpdateFormulary(apiModels, token);
if (response.StatusCode != DataService.APIModel.StatusCode.Success)
{
await FillLookupsToViewBag(editedData.OriginalStatus);
_toastNotification.AddErrorToastMessage(string.Join('\n', response.ErrorMessages));
editedData.IsSaveSuccessful = false;
return(PartialView(partialView, editedData));
}
if (response.StatusCode == DataService.APIModel.StatusCode.Success)
{
if (response.Data.Status != null && response.Data.Status.ErrorMessages.IsCollectionValid())
{
var errors = string.Join('\n', response.Data.Status.ErrorMessages);
_toastNotification.AddInfoToastMessage(errors);
await FillLookupsToViewBag(editedData.OriginalStatus);
editedData.IsSaveSuccessful = true;
return(PartialView(partialView, editedData));
}
}
_toastNotification.AddSuccessToastMessage("Successfully Updated Formulary details");
editedData.IsSaveSuccessful = true;
return(Json(null));
}
public async Task <IActionResult> FormularyList()
{
await LoadLookupData();
string token = HttpContext.Session.GetString("access_token");
var recordStatusDictionary = HttpContext.Session.GetObject <Dictionary <string, string> >(SynapseSession.FormularyRecStatusLkpKey);
var formularyStatusDictionary = HttpContext.Session.GetObject <Dictionary <string, string> >(SynapseSession.FormularyStatusLkpKey);
if (!formularyStatusDictionary.IsCollectionValid() || !recordStatusDictionary.IsCollectionValid())
{
var recordStatusLkpTask = TerminologyAPIService.GetRecordStatusLookup(token);
var formularyStatusLkpTask = TerminologyAPIService.GetFormularyStatusLookup(token);
await Task.WhenAll(recordStatusLkpTask, formularyStatusLkpTask);
var recordStatusLkp = await recordStatusLkpTask;
if (recordStatusLkp.IsCollectionValid())
{
recordStatusDictionary = recordStatusLkp.Where(rec => rec.Recordstatus == 1).ToDictionary(k => k.Cd.ToString(), v => v.Desc);
HttpContext.Session.SetObject(SynapseSession.FormularyRecStatusLkpKey, recordStatusDictionary);
}
var formularyStatusLkp = await formularyStatusLkpTask;
if (formularyStatusLkp.IsCollectionValid())
{
formularyStatusDictionary = formularyStatusLkp.Where(rec => rec.Recordstatus == 1).ToDictionary(k => k.Cd.ToString(), v => v.Desc);
HttpContext.Session.SetObject(SynapseSession.FormularyStatusLkpKey, formularyStatusDictionary);
}
}
var vm = new FormularyListFilterModel();
var statusItems = new List <SelectListItem>();
if (recordStatusDictionary != null)
{
recordStatusDictionary.Keys.Each(K =>
{
statusItems.Add(new SelectListItem()
{
Value = $"Rec|{K}", Text = recordStatusDictionary[K], Group = new SelectListGroup()
{
Name = "RecordStatus"
}
});
});
}
if (formularyStatusDictionary != null)
{
formularyStatusDictionary.Keys.Each(K =>
{
statusItems.Add(new SelectListItem()
{
Value = $"Form|{K}", Text = formularyStatusDictionary[K], Group = new SelectListGroup()
{
Name = "FormularyStatus"
}
});
});
}
var possibleFlags = FormularyListSearchCriteria.GetPossibleFlags();
if (possibleFlags.IsCollectionValid())
{
possibleFlags.Keys.Each(K =>
{
statusItems.Add(new SelectListItem()
{
Value = $"Flags|{K}", Text = possibleFlags[K], Group = new SelectListGroup()
{
Name = "Flags"
}
});
});
}
vm.FilterStatuses = statusItems.FindAll(i => i.Value == "Rec|001" || i.Value == "Rec|002" || i.Value == "Rec|003" || i.Value == "Form|001" || i.Value == "Form|002" || (i.Group != null && i.Group.Name == "Flags"));
vm.SelectedFilterStatuses = new List <string>();
return(View(vm));
}
