public async Task <IActionResult> Approve(string id, StorageSpace storageSpace)
{
if (id != storageSpace.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
storageSpace.Available = true;
_context.Entry(storageSpace).Property("Available").IsModified = true;
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StorageSpaceExists(storageSpace.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(storageSpace));
}
private bool SaveStorageSpace(out int storageId)
{
StorageSpace storage = ES.Services.StorageSpaces.GetStorageSpaceById(PanelRequest.StorageSpaceId)
?? new StorageSpace();
storage.Id = PanelRequest.StorageSpaceId;
storage.Name = txtName.Text;
storage.LevelId = Utils.ParseInt(ddlSsLevel.SelectedValue);
if (PanelRequest.StorageSpaceId < 1)
{
storage.ServiceId = Utils.ParseInt(ddlStorageService.SelectedValue);
storage.Path = GetCheckedNodeValue(FoldersTree.Nodes);
}
var serviceInfo = ES.Services.Servers.GetServiceInfo(storage.ServiceId);
storage.ServerId = serviceInfo.ServerId;
storage.FsrmQuotaType = rbtnQuotaSoft.Checked ? QuotaType.Soft : QuotaType.Hard;
storage.FsrmQuotaSizeBytes = (long)(decimal.Parse(txtStorageSize.Text) * 1024 * 1024 * 1024);
storage.IsDisabled = chkIsDisabled.Checked;
var result = ES.Services.StorageSpaces.SaveStorageSpace(storage);
storageId = result.Value;
messageBox.ShowMessage(result, "STORAGE_SPACE_SAVE", null);
return(result.IsSuccess);
}
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);
}
private static IntResult SaveStorageSpaceInternal(StorageSpace space, bool isShared = false)
{
var result = TaskManager.StartResultTask <IntResult>("STORAGE_SPACES", "SAVE_STORAGE_SPACE");
try
{
if (space == null)
{
throw new ArgumentNullException("space");
}
var ss = GetStorageSpaceService(space.ServiceId);
if (isShared)
{
var share = ShareStorageSpaceFolderInternal(space.Id, space.Path, space.Name);
space.IsShared = true;
space.UncPath = share.UncPath;
}
if (space.Id > 0)
{
DataProvider.UpdateStorageSpace(space);
TaskManager.Write("Updating Storage Space with id = {0}", space.Id.ToString(CultureInfo.InvariantCulture));
result.Value = space.Id;
}
else
{
result.Value = DataProvider.InsertStorageSpace(space);
TaskManager.Write("Inserting new Storage Space, obtained id = {0}", space.Id.ToString(CultureInfo.InvariantCulture));
space.Id = result.Value;
}
ss.UpdateStorageSettings(space.Path, space.FsrmQuotaSizeBytes, space.FsrmQuotaType);
}
catch (Exception exception)
{
TaskManager.WriteError(exception);
result.AddError("Error saving Storage Space", exception);
}
finally
{
if (!result.IsSuccess)
{
TaskManager.CompleteResultTask(result);
}
else
{
TaskManager.CompleteResultTask();
}
}
return(result);
}
public static bool Connect(Building output, Building input)
{
StorageSpace outputStorageSpace = output.GetStorageSpace();
StorageSpace inputStorageSpace = input.GetStorageSpace();
if (outputStorageSpace && inputStorageSpace)
{
return(Connect(outputStorageSpace, inputStorageSpace));
}
return(false);
}
/// <summary>
/// Creating rack storage space item
/// </summary>
/// <param name="storageSpaceItems"></param>
/// <returns></returns>
private Rack BuildStorageSpaceRack(List <StorageSpace> storageSpaceItems)
{
StorageSpace rack = storageSpaceItems.FirstOrDefault(item => item.ItemType.Equals(((int)StorageSpaceItem.Rack).ToString()));
var spRack = default(Rack);
spRack = new Rack()
{
RackNum = rack?.Number
};
return(spRack);
}
public static bool Connect(StorageSpace output, StorageSpace input)
{
if (output.Outputs.Count >= output.maxOutputs)
{
return(false);
}
if (input.Inputs.Count >= input.maxInputs)
{
return(false);
}
output.Outputs.Add(input);
input.Inputs.Add(output);
return(false);
}
/// <summary>
/// Creating Slot storage spcae item
/// </summary>
/// <param name="storageSpaceItems"></param>
/// <returns></returns>
private Slot BuildStorageSpaceSlot(List <StorageSpace> storageSpaceItems)
{
StorageSpace slot = storageSpaceItems.FirstOrDefault(item => item.ItemType.Equals(((int)StorageSpaceItem.Slot).ToString()));
var spSlot = default(Slot);
spSlot = new Slot()
{
SlotNum = slot?.Number,
DispenseForm = slot?.Attribute?.DispenseForm,
Bin = BuildStorageSpaceBin(storageSpaceItems)
};
return(spSlot);
}
/// <summary>
/// Creating bin storage space item
/// </summary>
/// <param name="storageSpaceItems"></param>
/// <returns></returns>
private Bin BuildStorageSpaceBin(List <StorageSpace> storageSpaceItems)
{
StorageSpace bin = storageSpaceItems.FirstOrDefault(item => item.ItemType.Equals(((int)StorageSpaceItem.Bin).ToString()));
var spBin = default(Bin);
spBin = new Bin()
{
BinNum = bin?.Number,
LeftOffset = bin?.Attribute?.LeftOffset,
Shelf = BuildStorageSpaceShelf(storageSpaceItems)
};
return(spBin);
}
public async Task <IActionResult> Approve(string id)
{
if (id == null)
{
return(NotFound());
}
StorageSpace storageSpace = await _context.StorageSpaces.FirstOrDefaultAsync(m => m.Id == id);
if (storageSpace == null)
{
return(NotFound());
}
return(View(storageSpace));
}
public async Task <IActionResult> Create(StorageSpace storageSpace)
{
if (ModelState.IsValid)
{
var firm = _context.Firms.Where(f => f.UserName == User.Identity.Name).FirstOrDefault();
if (firm == null)
{
return(NotFound());
}
storageSpace.Firm = firm;
_context.Add(storageSpace);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(storageSpace));
}
public async Task <StorageSpace> Handle(EditStorageSpace message, CancellationToken cancellationToken)
{
var storageSpace = await context.StorageSpaces.FindAsync(message.Id);
ValidateStorageSpace(storageSpace);
this.mapper.Map(message, storageSpace);
storageSpace.LastChangeDate = DateTime.Now;
storageSpace.UserCodeLastChange = UserCode();
await this.SetNewAddressToStorageSpace(message, storageSpace);
await context.SaveChangesAsync();
var responseModel = new StorageSpace();
this.mapper.Map(storageSpace, responseModel);
return(responseModel);
}
/// <summary>
/// Creating shelf shallow storage space item
/// </summary>
/// <param name="storageSpaceItems"></param>
/// <returns></returns>
private Shelf BuildStorageSpaceShelfShallow(List <StorageSpace> storageSpaceItems)
{
StorageSpace shelf = storageSpaceItems.FirstOrDefault(item => item.ItemType.Equals(((int)StorageSpaceItem.Shelf).ToString()));
var spShelf = default(Shelf);
if (shelf == null)
{
return(null);
}
spShelf = new Shelf()
{
ShelfNum = shelf?.Number,
OverideBaseAddr = shelf?.Attribute?.OverideBaseAddress
};
return(spShelf);
}
public async Task <ActionResult <StorageSpace> > StorageSpace()
{
var claims = HttpContext.User.Claims;
var email = claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;
var user = (await context.AppUsers.Include(u => u.Files)
.FirstOrDefaultAsync(u => u.Email == email));
//////////////////////
// TODO: cuva se FilePath u bazi, koristi to!
string clientFilesFolder = configuration.GetValue <string>("ClientFilesFolderPath");
string userFolderPath = Path.Combine(clientFilesFolder, user.Id.ToString());
if (!Directory.Exists(userFolderPath))
{
return(new StorageSpace()
{
MaxKBs = user.MaxKBs,
CurrentKBs = 0
});
}
var files = user.Files.ToList();
long sumBytes = 0;
foreach (var file in files)
{
string filePath = Path.Combine(userFolderPath, file.Id.ToString());
long length = new System.IO.FileInfo(filePath).Length;
sumBytes += length;
}
double sumKBs = sumBytes / 1024.0;
StorageSpace storageSpace = new StorageSpace
{
MaxKBs = user.MaxKBs,
CurrentKBs = sumKBs
};
return(storageSpace);
}
//Delete eBook file
private void btnDeleteEbook_Click(object sender, EventArgs e)
{
try
{
if (lstStorageSpaces.SelectedItems.Count > 0)
{
int selectedStorageSpaceID = lstStorageSpaces.SelectedItems[0].Name.ToInt();
StorageSpace storageSpace = (from s in spaces
where s.ID == selectedStorageSpaceID
select s).First();
List <Document> ebooks = storageSpace.BookList;
ListView.SelectedListViewItemCollection itemColl = lstBooks.SelectedItems;
DialogResult dialog = MessageBox.Show($"Are you sure you want to delete {lstBooks.SelectedItems.Count} {(lstBooks.SelectedItems.Count == 1 ? "eBook file" : "eBook files")}?",
"Delete eBook ", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dialog == DialogResult.Yes)
{
foreach (ListViewItem item in itemColl)
{
Document deleteBook = (from b in ebooks
where $"{b.Title}".Equals($"{item.Text}")
select b).First();
if (deleteBook != null)
{
storageSpace.BookList.Remove(deleteBook);
}
lstBooks.Items.Remove(item);
}
spaces.WriteToDataStore(ExtensionMethods.storagePath);
ClearSelectedBook();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
/// <summary>
/// Get actual directory path for given storage space
/// </summary>
public static string GetDirectoryPath(this StorageSpace storageSpace)
{
switch (storageSpace)
{
case StorageSpace.SyncedUserDomain:
return(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData));
case StorageSpace.UserDomain:
return(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
case StorageSpace.MachineDomain:
return(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData));
case StorageSpace.Instance:
return(AppDomain.CurrentDomain.BaseDirectory);
default:
throw new ArgumentOutOfRangeException(nameof(storageSpace), storageSpace, null);
}
}
public override void OnHandleTouch()
{
if (Input.GetMouseButtonUp(0))
{
RaycastHit hit;
Ray ray = V8GameLogic.Instance.Camera.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit))
{
Building hitBuilding = hit.collider.gameObject.GetComponent <Building>();
if (hitBuilding != null)
{
StorageSpace.Connect(V8GameLogic.Instance.SelectedBuilding, hitBuilding);
StateManager.SetState(StateManager.NORMAL_STATE);
}
else
{
V8GameLogic.Instance.Deselect();
StateManager.SetState(StateManager.NORMAL_STATE);
}
}
}
}
//Delete Virtual Storage Space
private void btnDeleteStorageSpace_Click(object sender, EventArgs e)
{
try
{
if (lstStorageSpaces.SelectedItems.Count > 0)
{
DialogResult dialog = MessageBox.Show($"Are you sure you want to delete {lstStorageSpaces.SelectedItems.Count} {(lstStorageSpaces.SelectedItems.Count == 1 ? "Vitural Storage space" : "Vitural Storage spaces")}?",
"Delete Vitural Storage Space", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (dialog == DialogResult.Yes)
{
ListView.SelectedListViewItemCollection itemColl = lstStorageSpaces.SelectedItems;
foreach (ListViewItem item in itemColl)
{
StorageSpace deleteStorage = (from s in spaces
where $"{s.ID}".Equals($"{item.Name}")
select s).First();
if (deleteStorage.BookList.Count > 0)
{
deleteStorage.BookList.Clear();
lstBooks.Items.Clear();
}
spaces.Remove(deleteStorage);
spaces.WriteToDataStore(ExtensionMethods.storagePath);
lstStorageSpaces.Items.Remove(item);
}
ClearSelectedBook();
txtStorageSpaceDescription.Clear();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
static void Transfer(StorageSpace output, StorageSpace input, float amount)
{
output.Remove(amount);
input.Fill(amount);
}
public static async Task <BunnyCdnFtpInfo> GetCreds(StorageSpace space)
{
return((await Utils.FromEncryptedJson <Dictionary <string, BunnyCdnFtpInfo> >("bunnycdn"))[space.ToString()]);
}
public static IntResult SaveStorageSpace(StorageSpace space)
{
return(SaveStorageSpaceInternal(space));
}
public void SetOwnerPlace(StorageSpace place)
{
ownerPlace = place;
}
/// <summary>
/// Get TransactionQueueData
/// </summary>
/// <returns></returns>
private TransactionData CreateTransactionQueueData()
{
StorageSpace spRack = new StorageSpace()
{
ItemType = "1",
Number = 123,
Attribute = new StorageSpaceAttribute()
{
DispenseForm = "asas",
LeftOffset = (decimal)2.4,
OverideBaseAddress = 22
}
};
StorageSpace spShelf = new StorageSpace()
{
ItemType = "2",
Number = 123,
Attribute = new StorageSpaceAttribute()
{
DispenseForm = "asas",
LeftOffset = (decimal)2.4,
OverideBaseAddress = 22
}
};
StorageSpace spBin = new StorageSpace()
{
ItemType = "3",
Number = 123,
Attribute = new StorageSpaceAttribute()
{
DispenseForm = "asas",
LeftOffset = (decimal)2.4,
OverideBaseAddress = 22
}
};
StorageSpace spSlot = new StorageSpace()
{
ItemType = "4",
Number = 123,
Attribute = new StorageSpaceAttribute()
{
DispenseForm = "asas",
LeftOffset = (decimal)2.4,
OverideBaseAddress = 22
}
};
Device spCarousel = new Device()
{
Type = "Carousel",
DeviceId = 2234,
Attribute = new DeviceAttribute()
{
DeviceClass = ControllerType.WhiteIPCDualAccess.ToString().ToUpper(),
IPAddress = "172.17.44.209",
DeviceNumber = "123",
Port = 4001,
RestrictControl = false,
IsDualAccess = false,
MaxRack = 99,
ReturnStatus = false,
ConnectionResetMinutes = 12,
},
StorageSpaces = new List <StorageSpace>()
};
spCarousel.StorageSpaces.Add(spSlot);
spCarousel.StorageSpaces.Add(spBin);
spCarousel.StorageSpaces.Add(spShelf);
spCarousel.StorageSpaces.Add(spRack);
var transactionData = new TransactionData();
transactionData.Devices = new List <Device>();
transactionData.Devices.Add(spCarousel);
transactionData.Devices.Add(new Device()
{
Type = "Display",
DeviceId = 2237,
Attribute = null,
StorageSpaces = null
});
transactionData.Quantity = 1;
return(transactionData);
}
public IntResult SaveStorageSpace(StorageSpace space)
{
return(StorageSpacesController.SaveStorageSpace(space));
}
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);
}
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);
}
