private async Task <bool> IsPyxisLoadTransactionExists(string deliverToLocation, int facilityId, int formularyId)
{
TransactionPriority priority = await _transactionPriorityManager.GetTransactionPriority(Priority.PYXISLOAD, facilityId);
if (priority != null)
{
var transactionQueueModels = await _transactionQueueRepository.GetAllTransactions(tq =>
{
if ((tq.Status == TransactionStatus.Pending.ToString() ||
tq.Status == TransactionStatus.Hold.ToString()) &&
tq.Destination == deliverToLocation &&
tq.FormularyId == formularyId &&
tq.FacilityId == facilityId &&
tq.TranPriorityId == priority.TransactionPriorityId)
{
return(true);
}
else
{
return(false);
}
});
if (transactionQueueModels != null && transactionQueueModels.Any())
{
return(true);
}
}
return(false);
}
/// <summary>
/// Get TransactionPriority by FacilityId and PriorityCode.
/// This will include TransactionPriorityDetails
/// </summary>
/// <param name="facilityId"></param>
/// <param name="priorityCode"></param>
/// <returns></returns>
public async Task <TransactionPriority> GetTransactionPriority(int facilityId, string priorityCode)
{
TransactionPriority transactionPriority = null;
var transactionPriorityDb = await _transactionPriorityRepository.GetTransactionPriority(facilityId, priorityCode);
if (transactionPriorityDb != null)
{
transactionPriority = _mapper.Map <TransactionPriority>(transactionPriorityDb);
return(transactionPriority);
}
return(transactionPriority);
}
/// <summary>
/// Initializes the private fields
/// </summary>
public TransactionPriorityManagerUnitTest()
{
_requestRepository = new Mock <IRequestRepository>();
_logger = new Mock <ILogger <TransactionPriorityManager> >();
_transactionPriorityRequest = new TransactionPriority
{
PriorityCode = "PATIENTPICK",
FacilityId = 1,
IsActive = true
};
_transactionPriorityManager = new TransactionPriorityManager(_requestRepository.Object, _logger.Object);
}
/// <summary>
/// Check for TransactionPriority.
/// If validation fails, return response message
/// </summary>
/// <param name="transactionPriority"></param>
/// <param name="incomingRequestId"></param>
/// <param name="priorityCode"></param>
private string CheckTransactionPriority(string incomingRequestId, TransactionPriority transactionPriority, string priorityCode)
{
string responseMessage = string.Empty;
if (transactionPriority == null)
{
responseMessage = LoggingMessage.PriorityInvalid;
_logger.LogInformation($"{ incomingRequestId}" + IncomingRequestStatus.Rejected + $"{priorityCode}" + LoggingMessage.PriorityInvalid);
return(responseMessage);
}
return(responseMessage);
}
/// <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 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));
}
}
public async Task GetTransactionPriority_ShouldReturnTransactionPriority()
{
//Arrange
string mockPriorityCode = "PATIENTPICK";
int mockfacilityId = 1;
//Arrange
CCEProxy.API.Infrastructure.DataAccess.DBModel.TransactionPriority transactionPriority = new CCEProxy.API.Infrastructure.DataAccess.DBModel.TransactionPriority()
{
FacilityId = mockfacilityId,
PriorityCode = mockPriorityCode
};
_mockTransactionPriorityRepository.Setup(x => x.GetTransactionPriority(mockfacilityId, mockPriorityCode))
.Returns(Task.FromResult(transactionPriority));
//Act
IRequestRepository requestRepository = new RequestRepository(_mockIncomingRepository.Object, _mockTransactionPriorityRepository.Object, _mockFacilityRepository.Object, _mapper);
TransactionPriority mockResponse = await requestRepository.GetTransactionPriority(mockfacilityId, mockPriorityCode);
//Assert
Assert.Equal(mockPriorityCode, mockResponse.PriorityCode);
}
/// <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 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);
}
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();
}
}
/// <summary>
/// Insert TransactionPriority to db.
/// </summary>
/// <param name="transactionPriority"></param>
public async Task AddTransactionPriorityRequest(TransactionPriority transactionPriority)
{
var insertTransactionPriorityRequest = _mapper.Map <Infrastructure.DataAccess.DBModel.TransactionPriority>(transactionPriority);
await _transactionPriorityRepository.InsertAsync(insertTransactionPriorityRequest);
}
/// <summary>
/// This method processes the facility request from Facility Service and insert the data into database.
/// <param name="transactionPriorityRequest">facilityRequest</param>
/// </summary>
public async Task ProcessTransactionPriorityRequest(TransactionPriority transactionPriorityRequest)
{
_logger.LogInformation(LoggingMessage.ProcessTransactionPriorityRequest, JsonConvert.SerializeObject(transactionPriorityRequest));
await _requestRepository.AddTransactionPriorityRequest(transactionPriorityRequest);
}
