public SortedQueue GetSortedQueue(List <Models.TransactionQueue> pendingTransactions, string sortedColumnName, int sortedDirection, int page, int pageSize)
{
//instance to hold values of anonymous type
var sortedQueue = new SortedQueue();
//fetch data of priority rules
var priorityRules = _priorityRules.GetPriorityRules();
//fetch values of smartsort Columns dynamically by priority rules, it can be more than 1 column
//if smart sort columns are not defined set values of default column as TransactionPriorityOrder
var listofSmartCol = SortColumns.GetSmartColumn(priorityRules.Result);
//fetch data after making join pending transaction and priority rules
var result = (from pt in pendingTransactions
join pr in priorityRules.Result
on pt.TranPriorityId equals pr.TransactionPriorityId
//orderby
//pt.Status descending,
//pt.Type descending,
//pr.TransactionPriorityOrder ascending,
////listofSmartCol,
//pt.ReceivedDt ascending,
//pt.ComponentNumber ascending
select new TransactionQueueItems()
{
Id = pt.Id,
PriorityName = pr.TransactionPriorityCode,
TransactionPriorityOrder = pr.TransactionPriorityOrder,
Quantity = pt.Quantity,
Item = pt.Description,
Location = pt.Location,
Destination = pt.Destination,
PatientName = pt.PatientName,
Description = pt.Description,
Color = pr.Color,
Status = pt.Status,
Type = pt.Type,
ReceivedDT = pt.ReceivedDt,
ComponentNumber = pt.ComponentNumber,
Rack = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Rack),
Shelf = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Shelf),
Bin = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Bin),
Slot = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Slot)
}
)
.ToList();
DoSmartSort smartSort = new DoSmartSort();
var sortedList = smartSort.OrderBySmartSort(result, listofSmartCol);
if (page >= 1 && pageSize >= 1)
{
sortedList = sortedList.Skip((page - 1) * pageSize).Take(pageSize).ToList();
}
sortedQueue.QueueList = sortedList;
return(sortedQueue);
}
public TransactionQueueStatusWiseResponse GetSortedTransaction(List <Models.TransactionQueue> activeAndPendingTransaction, bool isStaled, List <Models.TransactionQueue> holdTransaction, string sortedColumnName, int sortedDirection, int page, int pageSize)
{
bool IsRemoved = false;
TransactionQueueStatusWiseResponse response = new TransactionQueueStatusWiseResponse()
{
ActiveTransaction = new TransactionQueueItems()
{
},
LockedTransactions = new List <TransactionQueueItems>(),
RestockReturnTransactions = new List <TransactionQueueItems>()
};
#region If there is AN Active Transaction
var priorityRules = _priorityRules.GetPriorityRules();
int?ComponentNumber = 0; string PriorityCode = null; int PriorityOrder = 0; DateTime?ReceivedDt = null; string Color = null; int Rack = 0; int Shelf = 0; int Bin = 0; int Slot = 0;
//Fetch frist transaction which is Active
var activeTransaction = activeAndPendingTransaction.Where(x => x.Status == TransactionQueueStatus.Active.ToString()).FirstOrDefault();
if (activeTransaction != null)
{
#region set already Active Transaction
var activeList = activeAndPendingTransaction.Where(x => x.Id == activeTransaction.Id).ToList();
// Rack = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Rack),
var all = (from al in activeList
join pt in priorityRules.Result
on al.TranPriorityId equals pt.TransactionPriorityId
select new
{
al.TranPriorityId,
pt.Color,
al.ReceivedDt,
al.ComponentNumber,
pt.TransactionPriorityCode,
pt.TransactionPriorityOrder,
al.Devices
}).ToList();
foreach (var item in all)
{
ComponentNumber = item.ComponentNumber;
PriorityCode = item.TransactionPriorityCode;
PriorityOrder = item.TransactionPriorityOrder;
ReceivedDt = item.ReceivedDt;
Color = item.Color;
Rack = StorageSpace.GetStorageSpace(item.Devices, Models.StorageSpaceItemType.Rack);
Shelf = StorageSpace.GetStorageSpace(item.Devices, Models.StorageSpaceItemType.Shelf);
Bin = StorageSpace.GetStorageSpace(item.Devices, Models.StorageSpaceItemType.Bin);
Slot = StorageSpace.GetStorageSpace(item.Devices, Models.StorageSpaceItemType.Slot);
}
response.ActiveTransaction.Id = activeTransaction.Id;
response.ActiveTransaction.PriorityName = PriorityCode;
response.ActiveTransaction.Quantity = activeTransaction.Quantity;
response.ActiveTransaction.Item = activeTransaction.Description;
response.ActiveTransaction.Location = activeTransaction.Location;
response.ActiveTransaction.Destination = activeTransaction.Description;
response.ActiveTransaction.PatientName = activeTransaction.PatientName;
response.ActiveTransaction.Description = activeTransaction.Description;
response.ActiveTransaction.Color = Color;
response.ActiveTransaction.Status = activeTransaction.Status;
response.ActiveTransaction.Type = activeTransaction.Type;
response.ActiveTransaction.ReceivedDT = DateTime.Now;
response.ActiveTransaction.TransactionPriorityOrder = 0;
response.ActiveTransaction.ComponentNumber = ComponentNumber;
response.ActiveTransaction.Rack = Rack;
response.ActiveTransaction.Shelf = Shelf;
response.ActiveTransaction.Bin = Bin;
response.ActiveTransaction.Slot = Slot;
#endregion set already Active Transaction
//Remove Already Active Transaction from Pending
IsRemoved = activeAndPendingTransaction.Remove(activeTransaction);
if (IsRemoved)
{
//Pending minus Hold
activeAndPendingTransaction.RemoveAll(x => holdTransaction.Any(y => y.Id == x.Id));
//Get All Pending Sorted Transaction
var allPendingSortedTransaction = GetAllSortedTransaction(activeAndPendingTransaction, sortedColumnName, sortedDirection, 0, 0);
//Assign All Pending into Pending Item List
if (page >= 1 && pageSize >= 1)
{
response.PendingTransactions = allPendingSortedTransaction.QueueList.Skip((page - 1) * pageSize).Take(pageSize).ToList();
}
else
{
response.PendingTransactions = allPendingSortedTransaction.QueueList;
}
//Get All Pending Sorted Transaction
var allHoldSortedTransaction = GetAllSortedTransaction(holdTransaction, sortedColumnName, sortedDirection, 0, 0);
//Assign All Hold into Hold Item List
if (page >= 1 && pageSize >= 1)
{
response.HoldTransactions = allHoldSortedTransaction.QueueList.Skip((page - 1) * pageSize).Take(pageSize).ToList();
}
else
{
response.HoldTransactions = allHoldSortedTransaction.QueueList;
}
}
}
#endregion If there is AN Active Transaction
#region If there is NO Active Transaction
else
{
//Pending minus Hold
activeAndPendingTransaction.RemoveAll(x => holdTransaction.Any(y => y.Id == x.Id));
//Get All Pending Sorted Transaction
var allPendingSortedTransaction = GetAllSortedTransaction(activeAndPendingTransaction, sortedColumnName, sortedDirection, 0, 0);
//Fetch top 1 from Pending List which will be an ActiveTransaction
var OnlyActivetransaction = allPendingSortedTransaction.QueueList.FirstOrDefault();
if (OnlyActivetransaction != null)
{
//Update top 1 from Pending Transaction into Active State into DB
_transactionQueueRepository.UpdateTransactionsAsync(OnlyActivetransaction.Id);
//Remove Active (top 1 from Pending) from pending List
IsRemoved = allPendingSortedTransaction.QueueList.Remove(OnlyActivetransaction);
if (IsRemoved)
{
//Assign Fetch top 1 from Pending Transaction into Active Item Object
OnlyActivetransaction.Status = TransactionQueueStatus.Active.ToString();
response.ActiveTransaction = OnlyActivetransaction;
//Assign All Pending into Pending Item List
if (page >= 1 && pageSize >= 1)
{
response.PendingTransactions = allPendingSortedTransaction.QueueList.Skip((page - 1) * pageSize).Take(pageSize).ToList();
}
else
{
response.PendingTransactions = allPendingSortedTransaction.QueueList;
}
}
}
//Get All Pending Sorted Transaction
var allHoldSortedTransaction = GetAllSortedTransaction(holdTransaction, sortedColumnName, sortedDirection, 0, 0);
//Assign All Hold into Hold Item List
if (page >= 1 && pageSize >= 1)
{
response.HoldTransactions = allHoldSortedTransaction.QueueList.Skip((page - 1) * pageSize).Take(pageSize).ToList();
}
else
{
response.HoldTransactions = allHoldSortedTransaction.QueueList;
}
}
#endregion If there is no Active Transaction
#region If there is ANY Stale Transaction
//Assign Stale flag if it is true
response.IsStaled = isStaled;
#endregion If there is Stale Transaction
//return all response
return(response);
}
public SortedQueue GetSortedQueue(List <Models.TransactionQueue> pendingTransactions, string sortedColumnName, int sortedDirection, int page, int pageSize)
{
//fetch column name dynamically
var ColumnName = typeof(TransactionQueueItems).GetProperty(sortedColumnName);
//var ColumnNameBySortDir = SortColumns.GetDefaultColumn(sortedColumnName, sortedDirection);
//instance to hold values of anonymous type
var sortedQueue = new SortedQueue();
//fetch data of priority rules
var priorityRules = _priorityRules.GetPriorityRules();
//fetch data by doing join
var sortedList = (from pt in pendingTransactions
join pr in priorityRules.Result
on pt.TranPriorityId equals pr.TransactionPriorityId
//orderby
//pt.Status descending,
//pt.Type descending,
////ColumnNameBySortDir,
//pt.ReceivedDT ascending
select new TransactionQueueItems()
{
Id = pt.Id,
PriorityName = pr.TransactionPriorityCode,
TransactionPriorityOrder = pr.TransactionPriorityOrder,
Quantity = pt.Quantity,
Item = pt.Description,
Location = pt.Location,
Destination = pt.Destination,
PatientName = pt.PatientName,
Description = pt.Description,
Color = pr.Color,
Status = pt.Status,
Type = pt.Type,
ReceivedDT = pt.ReceivedDt,
ComponentNumber = pt.ComponentNumber,
Rack = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Rack),
Shelf = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Shelf),
Bin = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Bin),
Slot = StorageSpace.GetStorageSpace(pt.Devices, Models.StorageSpaceItemType.Slot)
}
)
.ToList();
if (sortedDirection == 1)
{
sortedList = sortedList.OrderByDescending(pt => pt.Status)
.ThenByDescending(pt => pt.Type)
.ThenByDescending(col => ColumnName.GetValue(col, null))
.ThenBy(pr => pr.ReceivedDT)
.ToList();
}
else
{
sortedList = sortedList.OrderByDescending(pt => pt.Status)
.ThenByDescending(pt => pt.Type)
.ThenBy(col => ColumnName.GetValue(col, null))
.ThenBy(pr => pr.ReceivedDT)
.ToList();
}
if (page >= 1 && pageSize >= 1)
{
sortedList = sortedList.Skip((page - 1) * pageSize).Take(pageSize).ToList();
}
sortedQueue.QueueList = sortedList;
return(sortedQueue);
}
