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); }