/// <summary> Insert transaction queue data into DB. </summary>
/// <param name="tranQueue"> TransactionQueueModel model </param>
/// <returns>transactionQueueId </returns>
public async Task <string> CreateTransaction(TransactionQueueModel tranQueue)
{
var entity = _mapper.Map <DBModel.TransactionQueue>(tranQueue);
entity.CreatedBy = UserName.Admin.ToString();
entity.CreatedDate = DateTime.Now;
entity.ModifiedBy = UserName.Admin.ToString();
entity.ModifiedDate = DateTime.Now;
await _collection.InsertOneAsync(entity);
return(entity.Id);
}
private async Task ConvertReplenishmentToCriticalLowOrStockOut(TransactionQueueModel tranQRefillDetail,
TransactionRequest request, TransactionPriority priority, int quantity)
{
tranQRefillDetail.TranPriorityId = priority.TransactionPriorityId;
tranQRefillDetail.Type = TransactionType.Pick;
tranQRefillDetail.Quantity = quantity;
tranQRefillDetail.QuantityProcessed = quantity;
tranQRefillDetail.StatusChangeDT = DateTime.Now;
tranQRefillDetail.StatusChangeUtcDateTime = DateTime.UtcNow;
tranQRefillDetail.IncomingRequestId = request.RequestId;
await _transactionQueueRepository.UpdateTransaction(tranQRefillDetail);
}
/// <summary>
/// Update transaction queue data into DB.
/// </summary>
/// <param name="transaction"> TransactionQueueModel model </param>
public async Task <DBModel.TransactionQueue> UpdateTransaction(TransactionQueueModel transaction)
{
if (!string.IsNullOrEmpty(transaction.TransactionQueueId))
{
var entity = _mapper.Map <DBModel.TransactionQueue>(transaction);
entity.ModifiedBy = UserName.Admin.ToString();
entity.ModifiedDate = DateTime.Now;
await _collection.ReplaceOneAsync(e => e.Id == entity.Id, entity);
return(entity);
}
return(null);
}
private void PublishFormularyLocationRequest(TransactionQueueModel transactionQueue, Dictionary <string, string> headers)
{
var eventMessage = new FormularyLocationRequestEvent
{
TransactionQueueId = transactionQueue.TransactionQueueId,
FormularyId = transactionQueue.FormularyId,
FacilityId = transactionQueue.FacilityId,
ISAId = transactionQueue.IsaId,
Headers = headers
};
_eventBus.Publish(_configuration.KafkaFormularyLocationRequestTopic, eventMessage, eventMessage.Headers);
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.DataPublishedForFormularyLocation, JsonConvert.SerializeObject(eventMessage)));
}
private void SetPatientInfo(TransactionQueueModel tranQNew, TransactionRequest request)
{
var item = request.Patient;
if (!string.IsNullOrEmpty(item.LastName))
{
tranQNew.PatientName = item.LastName;
}
if (!string.IsNullOrEmpty(item.FirstName))
{
tranQNew.PatientName += ", " + item.FirstName.Trim();
}
if (!string.IsNullOrEmpty(item.MiddleName))
{
tranQNew.PatientName += " " + item.MiddleName.Trim();
}
if (!string.IsNullOrEmpty(item.AccountNumber))
{
tranQNew.PatientAcctNumber = item.AccountNumber.Trim();
}
if (!string.IsNullOrEmpty(item.Mrn))
{
tranQNew.Mrn = item.Mrn.Trim();
}
if (!string.IsNullOrEmpty(request.ADM?.StationName))
{
tranQNew.PatientStation = request.ADM.StationName.Trim();
}
if (!string.IsNullOrEmpty(item.Room))
{
tranQNew.PatientRoom = item.Room.Trim();
}
if (!string.IsNullOrEmpty(item.Bed))
{
tranQNew.PatientBed = item.Bed.Trim();
}
if (!string.IsNullOrEmpty(request.Order?.OrderingDrInstructions))
{
tranQNew.Comments = request.Order.OrderingDrInstructions.Trim();
}
}
private void PublishDeviceCommunicationRequest(TransactionQueueModel transactionQueue, Dictionary <string, string> headers)
{
var eventMessage = new ProcessTransactionQueueIntegrationEvent()
{
TransactionData = new TransactionData
{
Quantity = transactionQueue.Quantity.Value,
Type = transactionQueue.Type,
Devices = transactionQueue.Devices.ToList()
},
Headers = headers
};
_eventBus.Publish(_configuration.KafkaDeviceTopic, eventMessage, headers);
_logger.LogInformation(string.Format(Constants.LoggingMessage.DataPublishedDeviceCommunication, JsonConvert.SerializeObject(eventMessage)));
}
/// <summary>
/// Get CriticalLow or StockOut Transactions
/// </summary>
/// <param name="request"></param>
/// <param name="item"></param>
/// <returns></returns>
private async Task <TransactionQueueModel> GetRefillTransaction(TransactionRequest request, Item item)
{
List <Infrastructure.DBModel.TransactionQueue> transactionQueueModels = await _transactionQueueRepository.GetAllTransactions();
TransactionQueueModel tranQClSo = null;
if (transactionQueueModels != null && transactionQueueModels.Any())
{
var result = (from tq in transactionQueueModels
where (tq.Status == TransactionStatus.Pending.ToString() ||
tq.Status == TransactionStatus.Hold.ToString()) &&
(tq.Type == TransactionType.Batch.ToString() ||
(tq.Type == TransactionType.Pick.ToString() && tq.Destination != CommonConstants.Destination.BatchPick)) &&
tq.Destination == request.Patient.DeliverToLocation &&
tq.ItemId == item.ItemId &&
tq.FacilityId == request.Facility.FacilityId
select tq);
if (result != null && result.Any())
{
var lstTransactionQueueModel = new List <TransactionQueueModel>();
foreach (var transaction in result)
{
TransactionPriority priority =
await _transactionPriorityManager.GetTransactionPriority(transaction.TranPriorityId);
if (priority != null && priority.IsAdu.GetValueOrDefault(false) &&
StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISREFILL.ToString()))
{
lstTransactionQueueModel.Add(_mapper.Map <TransactionQueueModel>(transaction));
}
}
if (lstTransactionQueueModel.Any())
{
tranQClSo = (from tq in lstTransactionQueueModel
orderby tq.ReceivedDt descending
select tq).FirstOrDefault();
}
}
}
return(tranQClSo);
}
private async Task <Tuple <bool, bool> > EligibleforAduDupDelete(TransactionQueueModel transactionQueueModel,
ExternalDependencies.BusinessLayer.Models.Facility facility, TransactionRequest request)
{
var lastAduXrefs = await _lastAduXrefRepository.GetAllLastAduXrefTransactions();
LastAduXref lastAduXref = lastAduXrefs?.FirstOrDefault(la => la.FacilityId == facility.Id &&
la.FormularyId == transactionQueueModel.FormularyId &&
la.Destination == request?.Patient?.DeliverToLocation);
var transactions = await _transactionQueueRepository.GetAllTransactions();
var AduItemAlreadyinQueue = transactions?.FirstOrDefault(tqa => tqa.FacilityId == facility.Id &&
tqa.FormularyId == transactionQueueModel.FormularyId &&
tqa.Destination == request?.Patient?.DeliverToLocation &&
(tqa.Status == TransactionStatus.Pending.ToString() || tqa.Status == TransactionStatus.Hold.ToString()));
bool eligibleforAduDupCheck = ((lastAduXref != null && lastAduXref.LastAduTransUtcDateTime != null) ||
(AduItemAlreadyinQueue != null && AduItemAlreadyinQueue.ReceivedUtcDateTime != null)) &&
facility.AduDupeTimeDelay != null &&
facility.AduDupeTimeDelay > 0;
if (eligibleforAduDupCheck)
{
bool eligibleforAduDupDelete =
(lastAduXref != null &&
((DateTime)lastAduXref.LastAduTransUtcDateTime).AddMinutes((int)facility.AduDupeTimeDelay) > DateTime.UtcNow) ||
(AduItemAlreadyinQueue != null &&
((DateTime)AduItemAlreadyinQueue.ReceivedUtcDateTime).AddMinutes((int)facility.AduDupeTimeDelay) > DateTime.UtcNow);
if (eligibleforAduDupDelete)
{
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.ProcessedAdmTransaction, request.RequestId));
//Not updated any existing txn and current txn should be ignored
return(new Tuple <bool, bool>(true, false));
}
}
//Normal processing
//Not updated any existing txn and current txn should also not be ignored
return(new Tuple <bool, bool>(false, false));
}
private void ConfigureTimeToLive(TransactionPriority priority, TransactionQueueModel newTransaction)
{
if (priority.TransactionPriorityCode == Priority.STAT.ToString())
{
newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.Stat));
}
else if (newTransaction.Destination == TransactionType.BatchParent.ToString())
{
newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.BatchPicks));
}
else if (newTransaction.Type == TransactionType.Pick)
{
newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.Pick));
}
else if (newTransaction.Type == TransactionType.CycleCount)
{
newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.CycleCount));
}
else
{
newTransaction.TimeToLive = Convert.ToInt32(configuration.GetValue <string>(CommonConstants.TimeToLive.Other));
}
}
private async Task <Tuple <bool, bool> > UpdateQuantityFromReplenishmentOrder(int quantity, TransactionQueueModel tranQClSo)
{
var priority = await _transactionPriorityManager.GetTransactionPriority(tranQClSo.TranPriorityId);
if (StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISCRITLOW.ToString()))
{
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.UpdatedQuantityForReplenishmentOrder, quantity, tranQClSo.TransactionQueueId));
tranQClSo.Quantity = quantity;
tranQClSo.QuantityProcessed = quantity;
tranQClSo.StatusChangeDT = DateTime.Now;
tranQClSo.StatusChangeUtcDateTime = DateTime.UtcNow;
await _transactionQueueRepository.UpdateTransaction(tranQClSo);
//Updated one existing txn
return(new Tuple <bool, bool>(true, true));
}
else
{
//Not updated any existing txn and current txn should be ignored
return(new Tuple <bool, bool>(true, false));
}
}
/// <summary>
/// This method processes the aggregated incoming request from Aggregator Service, applies business rules and inserts transaction record.
/// </summary>
/// <param name="request">Incoming request</param>
/// <param name="headers">Headers</param>
public async Task ProcessTransactionRequest(TransactionRequest request, Dictionary <string, string> headers)
{
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.ProcessIncomingRequest, JsonConvert.SerializeObject(request)));
var status = TransactionStatus.Interim;
var facilityId = request.Facility.FacilityId;
FacilityStorageSpace storageSpaceInfo = null;
var priority = await _transactionPriorityManager.ValidatePriority(request.Facility.FacilityId, request.Priority);
var facility = await _facilityManager.ValidateFacility(facilityId);
var destination = await _destinationManager.GetDestinationByCode(request?.Patient?.DeliverToLocation);
if (facility != null)
{
if ((facility.AduIgnoreCritLow == true && string.Equals(request.Priority, Priority.PYXISCRITLOW.ToString(), StringComparison.OrdinalIgnoreCase)) ||
(facility.AduIgnoreStockout == true && (string.Equals(request.Priority, Priority.PYXISSTOCKOUT.ToString(), StringComparison.OrdinalIgnoreCase) || string.Equals(request.Priority, Priority.PYXISSTKOUT.ToString(), StringComparison.OrdinalIgnoreCase))))
{
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.RejectedRequest, request.RequestId));
status = TransactionStatus.Ignored;
}
storageSpaceInfo = facility.StorageSpaces?.Where(x => x.IsDefault).FirstOrDefault();
}
var partNo = 0;
var multiMedName = string.Empty;
var transactionList = new List <TransactionQueueModel>();
var orderCount = Enumerable.Count <Item>(request.Items);
var isMultiComponent = orderCount > 1 ? true : false;
foreach (var item in request.Items)
{
FacilityFormulary facilityFormulary = null;
var formulary = await _formularyManager.GetFormularyByItemId(item.ItemId);
if (formulary != null && formulary.FacilityFormulary != null && formulary.FacilityFormulary.FacilityId == facilityId)
{
facilityFormulary = formulary.FacilityFormulary;
}
if (facility != null && facilityFormulary != null &&
((string.Equals(request.Priority, Priority.PYXISCRITLOW.ToString(), StringComparison.OrdinalIgnoreCase) && facilityFormulary.AduIgnoreCritLow != null && (bool)facilityFormulary.AduIgnoreCritLow) ||
((string.Equals(request.Priority, Priority.PYXISSTOCKOUT.ToString(), StringComparison.OrdinalIgnoreCase) || string.Equals(request.Priority, Priority.PYXISSTKOUT.ToString(), StringComparison.OrdinalIgnoreCase)) &&
facilityFormulary.AduIgnoreStockout != null && (bool)facilityFormulary.AduIgnoreStockout)))
{
status = TransactionStatus.Ignored;
}
//Checks for ADUIgnoreCritLow and ADUIgnoreStockOut prior to ADU Cases
if (priority != null && destination != null &&
((priority.TransactionPriorityCode.ToLower() == Priority.PYXISCRITLOW.ToString().ToLower() &&
destination.AduIgnoreCritLow.GetValueOrDefault()) ||
((priority.TransactionPriorityCode.ToLower() == Priority.PYXISSTOCKOUT.ToString().ToLower() || priority.TransactionPriorityCode.ToLower() == Priority.PYXISSTKOUT.ToString().ToLower()) &&
destination.AduIgnoreStockOut.GetValueOrDefault())))
{
status = TransactionStatus.Ignored;
}
int.TryParse(item.OrderAmount, out int quantity);
var newTransaction = new TransactionQueueModel();
if (status != TransactionStatus.Ignored)
{
var isExceptionTransaction = SetExceptionTransaction(facility, formulary, facilityFormulary, storageSpaceInfo, request, item, quantity, newTransaction);
if (!isExceptionTransaction)
{
SetValidTransaction(storageSpaceInfo.Id, newTransaction, status);
}
}
partNo += 1;
SetTransactionDetails(priority, formulary, facility, facilityFormulary, destination, request, item, partNo, orderCount, newTransaction, quantity);
//ADU Processing variables
Tuple <bool, bool> admResult = default(Tuple <bool, bool>);
bool isIgnoredTxn = false, isPartialUpdated = false;
if (newTransaction.Status != TransactionStatus.Exception &&
status != TransactionStatus.Ignored &&
priority.IsAdu.GetValueOrDefault(false))
{
admResult = await _aduTransactionManager.ProcessAduTransaction(request, newTransaction, item, priority, facility);
isIgnoredTxn = admResult.Item1;
isPartialUpdated = admResult.Item2;
//Logging for ADU Processing
if (isIgnoredTxn)
{
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.ProcessedAdmTransaction, request.RequestId));
}
}
ConfigureTimeToLive(priority, newTransaction);
if (status != TransactionStatus.Ignored && !isIgnoredTxn && !isPartialUpdated)
{
newTransaction.TransactionQueueId = await _transactionQueueRepository.CreateTransaction(newTransaction);
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.TransactionCreated, newTransaction.TransactionQueueId, newTransaction.IncomingRequestId));
if (newTransaction.Status == TransactionStatus.Interim)
{
PublishFormularyLocationRequest(newTransaction, headers);
}
}
else if (!isPartialUpdated)
{
newTransaction.Status = TransactionStatus.Ignored;
newTransaction.TransactionQueueId = await _transactionQueueHistoryRepository.CreateTransaction(newTransaction);
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.IgnoredTransactionCreated, newTransaction.TransactionQueueId, newTransaction.IncomingRequestId));
}
}
}
private void SetValidTransaction(int isaId, TransactionQueueModel newTransaction, TransactionStatus status)
{
newTransaction.IsaId = isaId;
newTransaction.Status = status;
}
private bool SetExceptionTransaction(Facility facility, Formulary formulary, FacilityFormulary facilityFormulary, FacilityStorageSpace storageSpaceInfo, TransactionRequest request, Item item, int quantity, TransactionQueueModel newTransaction)
{
var isItemAccepted = (facilityFormulary != null && facilityFormulary.Approved) ? true : false;
var isActiveFormulary = (formulary != null && !formulary.IsActive.GetValueOrDefault()) ? false : true;
if (formulary == null)
{
newTransaction.Description = item.ItemName;
SetTransactionException(newTransaction, CommonConstants.TransactionException.UnknownItemId);
if (!int.TryParse(item.OrderAmount.Trim(), out quantity))
{
newTransaction.Exception += Environment.NewLine + CommonConstants.TransactionException.InvalidQuantity;
}
newTransaction.Quantity = quantity;
return(true);
}
if (!isActiveFormulary)
{
SetTransactionException(newTransaction, CommonConstants.TransactionException.InactiveFormularyItem);
return(true);
}
if (facilityFormulary == null)
{
SetTransactionException(newTransaction, CommonConstants.TransactionException.FormularyNotMapped);
return(true);
}
if (!isItemAccepted)
{
SetTransactionException(newTransaction, CommonConstants.TransactionException.NotApprovedFormularyItem);
return(true);
}
if (quantity <= 0)
{
SetTransactionException(newTransaction, CommonConstants.TransactionException.InvalidUnitQuantity);
return(true);
}
if (storageSpaceInfo == null)
{
SetTransactionException(newTransaction, CommonConstants.TransactionException.UnassignedLocation);
return(true);
}
return(false);
}
private void SetTransactionDetails(TransactionPriority priority, Formulary formulary, Facility facility,
FacilityFormulary facilityFormulary, Destination destination, TransactionRequest incomingRequest,
Item item, int partNo, int orderCount, TransactionQueueModel newTransaction, int quantity)
{
var localNow = DateTime.Now;
var utcNow = DateTime.UtcNow;
User usr = new User(UserName.Admin.ToString());
newTransaction.StatusChangeDT = localNow;
newTransaction.StatusChangeUtcDateTime = utcNow;
if (formulary != null)
{
newTransaction.Description = (priority != null && priority.UseInterfaceItemName.GetValueOrDefault()) ? item.ItemName : formulary.Description;
newTransaction.FormularyId = formulary.FormularyId;
}
// Apply ADU Round if Qualifies
if (quantity > 0 && facility != null && priority != null && destination != null &&
facilityFormulary != null && (priority.IsAdu != null && (bool)priority.IsAdu) &&
(facility.AduQtyRounding != null && (bool)facility.AduQtyRounding) &&
(facilityFormulary.AduQtyRounding != null && (bool)facilityFormulary.AduQtyRounding) &&
(destination.AduQtyRounding != null && (bool)destination.AduQtyRounding))
{
newTransaction.Quantity = AduQtyRound(quantity);
newTransaction.QuantityProcessed = newTransaction.Quantity;
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.AduQuantity, newTransaction.Quantity, incomingRequest.RequestId));
}
else
{
newTransaction.Quantity = quantity;
newTransaction.QuantityProcessed = newTransaction.Quantity;
}
newTransaction.Type = TransactionType.Pick;
newTransaction.OrderId = incomingRequest.Order?.OrderNo;
newTransaction.ItemId = item.ItemId;
if (!string.IsNullOrEmpty(item.ComponentStrength))
{
newTransaction.Strength = item.ComponentStrength.Trim();
}
if (!string.IsNullOrEmpty(item.ComponentStrengthUnits))
{
newTransaction.StrengthUnit = item.ComponentStrengthUnits.Trim();
}
//set these two to real values for display purposes
newTransaction.ComponentNumber = partNo;
newTransaction.NumberOfComponents = orderCount;
// Patient info
SetPatientInfo(newTransaction, incomingRequest);
newTransaction.FacilityId = facility.Id;
newTransaction.IncomingRequestId = incomingRequest.RequestId;
if (priority != null)
{
newTransaction.TranPriorityId = priority.TransactionPriorityId;
}
newTransaction.ReceivedDt = localNow;
newTransaction.ReceivedUtcDateTime = utcNow;
if (usr != null)
{
newTransaction.RequestedBy = usr.UserName;
}
if (!string.IsNullOrEmpty(incomingRequest.Patient?.DeliverToLocation))
{
newTransaction.Destination = incomingRequest.Patient.DeliverToLocation.Trim();
}
if (!string.IsNullOrEmpty(newTransaction.Exception) &&
newTransaction.Exception.Length > 80)
{
newTransaction.Exception = newTransaction.Exception.Substring(0, 80);
}
if (!string.IsNullOrEmpty(item.Concentration))
{
newTransaction.Concentration = item.Concentration.Trim();
}
if (!string.IsNullOrEmpty(item.TotalDose))
{
newTransaction.TotalDose = item.TotalDose.Trim();
}
if (!string.IsNullOrEmpty(item.DispenseAmount))
{
newTransaction.DispenseAmount = item.DispenseAmount.Trim();
}
}
private void SetTransactionException(TransactionQueueModel request, string exceptionMessage)
{
_logger.LogInformation(exceptionMessage);
request.Status = TransactionStatus.Exception;
request.Exception = exceptionMessage;
}
/// <summary>
/// This method is used for processing Adu transaction
/// </summary>
/// <param name="request"></param>
/// <param name="transactionQueueModel"></param>
/// <param name="item"></param>
/// <param name="priority"></param>
/// <param name="facility"></param>
/// <returns></returns>
public async Task <Tuple <bool, bool> > ProcessAduTransaction(TransactionRequest request, TransactionQueueModel transactionQueueModel, Item item,
TransactionPriority priority, ExternalDependencies.BusinessLayer.Models.Facility facility)
{
var result = new Tuple <bool, bool>(false, false);
//PyxisLoad duplicate check
if (await IsPyxisLoadTransactionExists(request.Patient.DeliverToLocation, facility.Id,
transactionQueueModel.FormularyId))
{
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.PyxisLoadTransactionExists, request.RequestId));
//Not updated any existing txn and current txn should be ignored
result = new Tuple <bool, bool>(true, false);
return(result);
}
//If the current transaction is not of type PYXISLOAD
if (priority.IsAdu.GetValueOrDefault(false) && !StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISLOAD.ToString()))
{
//Refill duplicate check
if (StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISREFILL.ToString()) &&
await IsPyxisRefillTransactionExists(request.Patient.DeliverToLocation, facility.Id,
transactionQueueModel.FormularyId))
{
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.PyxisRefillTransactionExists, request.RequestId));
//Not updated any existing txn and current txn should be ignored
result = new Tuple <bool, bool>(true, false);
return(result);
}
//Get the critlow, stockout or stkout transaction from Database
var tranQClSo = await GetCriticalLowOrStockOutTransaction(request, item);
//If the current transaction is refill
if (StringHelper.IsEqual(priority.TransactionPriorityCode, Priority.PYXISREFILL.ToString()) && tranQClSo != null)
{
result = await UpdateQuantityFromReplenishmentOrder(transactionQueueModel.Quantity.Value, tranQClSo);
return(result);
}
//If the current transaction is critlow, stockout or stkout
if (priority != null && IsCriticalLowOrStockoutPriority(priority.TransactionPriorityCode))
{
//Get the refill transaction from Database
var tranQRefillDetail = await GetRefillTransaction(request, item);
//If there is not transation of type Refill present in Database
if (tranQRefillDetail != null)
{
await ConvertReplenishmentToCriticalLowOrStockOut(tranQRefillDetail, request, priority, transactionQueueModel.Quantity.Value);
_logger.LogInformation(string.Format(CommonConstants.LoggingMessage.UpdatedQuantityPriorityAndRequestIdForAduTransaction, transactionQueueModel.Quantity.Value, priority.TransactionPriorityCode, request.RequestId));
//Updated one existing txn
result = new Tuple <bool, bool>(true, true);
return(result);
}
if (tranQClSo != null)
{
var priorityResult = await _transactionPriorityManager.GetTransactionPriority(tranQClSo.TranPriorityId);
//Case when Critical Low exists in DB
if (IsCriticalLowOrStockoutPriority(priority.TransactionPriorityCode) &&
StringHelper.IsEqual(priorityResult.TransactionPriorityCode, Priority.PYXISCRITLOW.ToString()))
{
tranQClSo.Quantity = transactionQueueModel.Quantity.Value;
tranQClSo.QuantityProcessed = tranQClSo.Quantity;
tranQClSo.TranPriorityId = priority.TransactionPriorityId;
tranQClSo.StatusChangeDT = DateTime.Now;
tranQClSo.StatusChangeUtcDateTime = DateTime.UtcNow;
tranQClSo.IncomingRequestId = request.RequestId;
await _transactionQueueRepository.UpdateTransaction(tranQClSo);
//Updated one existing txn
result = new Tuple <bool, bool>(true, true);
}
//Case when Stockout Low exists in DB
else if (IsCriticalLowOrStockoutPriority(priority.TransactionPriorityCode) &&
StringHelper.IsEqual(priorityResult.TransactionPriorityCode,
Priority.PYXISSTOCKOUT.ToString()))
{
tranQClSo.Quantity = transactionQueueModel.Quantity.Value;
tranQClSo.QuantityProcessed = tranQClSo.Quantity;
tranQClSo.StatusChangeDT = DateTime.Now;
tranQClSo.StatusChangeUtcDateTime = DateTime.UtcNow;
tranQClSo.IncomingRequestId = request.RequestId;
await _transactionQueueRepository.UpdateTransaction(tranQClSo);
//Updated one existing txn
result = new Tuple <bool, bool>(true, true);
}
else
{
//Not updated any existing txn and current txn should be ignored
result = new Tuple <bool, bool>(true, false);
}
return(result);
}
return(await EligibleforAduDupDelete(transactionQueueModel, facility, request));
}
}
return(result);
}
private async Task <TransactionQueueModel> UpdateTransactionStatusWhenStatusIsComplete(TransactionQueueModel transaction, TransactionStatus status, Dictionary <string, string> headers)
{
if (transaction.Status == TransactionStatus.Active)
{
var transactionQueueModel = _mapper.Map <TransactionQueueModel>(await _transactionQueueMongoRepository.UpdateTransactionStatus(transaction.TransactionQueueId, status));
PublishDeviceCommunicationRequest(transactionQueueModel, headers);
return(transaction);
}
else if (transaction.Status == TransactionStatus.Complete)
{
return(transaction);
}
return(null);
}
