public async Task <ICollection <NotificacionQueueItem> > GetByStatusAsync(QueueStatus queueStatus) { using (IDbConnection db = new SqlConnection(connectionString)) { string sqlCommand = "SELECT * FROM dbo.NotificationQ WHERE Status = @status"; string status = queueStatus.ToString(); var notificationQList = await db.QueryAsync <Entities.NotificationQ>(sqlCommand, new { status }); var outputResult = new List <NotificacionQueueItem>(); if (notificationQList == null) { return(outputResult); } foreach (var notificacionQ in notificationQList) { var actionType = (ActionType)Enum.Parse(typeof(ActionType), notificacionQ.ActionType); var qStatus = (QueueStatus)Enum.Parse(typeof(QueueStatus), notificacionQ.Status); outputResult.Add(NotificacionQueueItem.Load(notificacionQ.ID, notificacionQ.FuncionarioID, notificacionQ.UserName, actionType, qStatus, notificacionQ.CreateDate, notificacionQ.ModifyDate, notificacionQ.ErrorMessage)); } return(outputResult); } }
public void Start() { if (_status == QueueStatus.None || _status == QueueStatus.Stoped) { //set status to starting _status = QueueStatus.Starting; Debugger.AddMsg("Start Queue " + this.Name); //Init Task Pool TaskPool_Init(); //Raise Event Started Started?.Invoke(this, EventArgs.Empty); //set status to started _status = QueueStatus.Started; Debugger.AddMsg("Start Queue " + this.Name + " Successfully."); } else { throw new InvalidOperationException("Queue status must None when start queue"); } }
protected void OnStatusChange(QueueStatus newStatus) { if (StatusChange != null) { StatusChange(this, new StatusChangeEventArgs(newStatus)); } }
public void GetAllQueueStatus() { QueueStatus status = new QueueStatus() { StatusDate = DateTime.Now, StatusMessage = "Ending the Queue", StatusIndicator = 0 }; _service.AddQueueStatus(status); Assert.NotNull(status); Assert.NotEqual(Guid.Empty, status.StatusId); var data = JsonConvert.SerializeObject(_service.GetAllQueueStatus(DateTime.Now)); Assert.NotNull(data); Assert.NotEqual("", data); Assert.NotEqual("[]", data); List <QueueStatus> dailyStatus = JsonConvert.DeserializeObject <List <QueueStatus> >(data); Assert.NotNull(dailyStatus); Assert.NotEmpty(dailyStatus); }
internal static IQueueState Create(ChannelQueue queue, QueueStatus status) { switch (status) { case QueueStatus.Route: return(new RouteQueueState(queue)); case QueueStatus.Push: return(new PushQueueState(queue)); case QueueStatus.RoundRobin: return(new RoundRobinQueueState(queue)); case QueueStatus.Pull: return(new PullQueueState(queue)); case QueueStatus.Cache: return(new CacheQueueState(queue)); case QueueStatus.Paused: return(new PauseQueueState(queue)); case QueueStatus.Stopped: return(new StopQueueState(queue)); default: return(new StopQueueState(queue)); } }
public void GetLastQueueStatus() { QueueStatus status = new QueueStatus() { StatusDate = DateTime.Now, StatusMessage = "Ending the Queue", StatusIndicator = 0 }; _service.AddQueueStatus(status); Assert.NotNull(status); Assert.NotEqual(Guid.Empty, status.StatusId); var data = JsonConvert.SerializeObject(_service.GetLastQueueStatus()); Assert.NotNull(data); Assert.NotEqual("", data); Assert.NotEqual("[]", data); QueueStatus lastStatus = JsonConvert.DeserializeObject <List <QueueStatus> >(data).FirstOrDefault(); Assert.Equal(status.StatusId, lastStatus.StatusId); Assert.Equal(status.StatusMessage, lastStatus.StatusMessage); }
protected void CreateModuleIfNeeded(string queueName, ConsumerQueueTypes type) { if (Queues.ContainsKey(queueName)) { return; } switch (type) { case ConsumerQueueTypes.Poco: Queues.Add(queueName, _queueContainer.Value.CreateConsumer(queueName, ConfigurationManager.AppSettings["Connection"])); break; case ConsumerQueueTypes.Method: Queues.Add(queueName, _queueContainer.Value.CreateMethodConsumer(queueName, ConfigurationManager.AppSettings["Connection"])); break; } QueueStatus?.AddStatusProvider( QueueStatusContainer.Value.CreateStatusProvider <TTransportInit>(queueName, ConfigurationManager.AppSettings["Connection"])); }
//--------------------------------------------------------------------------------------Queue---------------------------------------------------------------------------------- public void AstroQueueUpdate(String jSon) { jSon = StringCompression.DecompressString(jSon); JObject obj = JObject.Parse(jSon); STATIONNAME stationName = TTCSHelper.StationStrConveter(obj["StationName"].ToString()); String Id = obj["Id"].ToString(); String Event = obj["Event"].ToString(); DateTime TimeStamp = DateTime.Parse(obj["TimeStamp"].ToString()); Console.WriteLine("[AstroQueueUpdate] " + obj["StationName"] + " : " + obj["Event"] + " --> " + Id); AstroQueueImpl astroQueue = DBQueueEngine.FindById(stationName, Id); if (Event == "RECEIVED") { QueueStatus queueStatus = new QueueStatus(QUEUE_STATUS.WAITINGSTATION, SENDING_STATUS.COMPLETED, TimeStamp); astroQueue.QueueStatus.Add(queueStatus); astroQueue.Save(); } Task task = Task.Run(async() => { await Task.Delay(100); StationHandler StationCommunication = AstroData.GetStationObject(stationName); StationCommunication.AckTarget(astroQueue, QUEUE_STATUS.WAITINGSTATION, SENDING_STATUS.COMPLETED); }); }
private void NextTask() { if (_isEnabled) { OfficeTask task; lock (_lockObj) { if (!_tasks.Any()) { NotifyQueueFinished(); return; } task = _tasks.Dequeue(); if (task == null) { return; } } if (task != null) { CurrrentStatus = QueueStatus.Running; task.Convert(); } else { NotifyQueuePaused(); } } else { NotifyQueuePaused(); } }
protected virtual void AddLog(IncomeQueue queueItem, QueueStatus logStatus, Exception e = null) { PublishingLog log = new PublishingLog() { UUID = Kooboo.UniqueIdGenerator.GetInstance().GetBase32UniqueId(20), QueueType = QueueType.Incoming, QueueUUID = queueItem.UUID, ObjectTitle = queueItem.ObjectTitle, SiteName = queueItem.SiteName, PublishingObject = queueItem.PublishingObject, ObjectUUID = queueItem.ObjectUUID, //PublishingType = PublishingType.Remote, RemoteEndpoint = null, TextFolderMapping = null, UserId = queueItem.Vendor, Status = logStatus, Vendor = queueItem.Vendor, UtcProcessedTime = queueItem.UtcProcessedTime, Message = e == null ? queueItem.Message : e.Message, StackTrace = e == null ? "" : e.StackTrace, PublishingAction = queueItem.Action, QueueObject = queueItem }; _publishingLogProvider.Add(log); }
private int GetBuildStatusImage(QueueStatus status, IBuildDetail detail) { int image = 5; switch (status) { case QueueStatus.InProgress: image = 0; break; case QueueStatus.Completed: image = GetBuildStatusImage(detail.Status); break; // case QueueStatus.PartiallySucceeded: // image = 2; // break; // case QueueStatus.Failed: // image = 3; // break; case QueueStatus.Canceled: image = 4; break; case QueueStatus.Postponed: case QueueStatus.Queued: image = 5; break; } return(image); }
public async Task UpdateStatus(Guid taskId, TaskStatus taskStatus, QueueStatus queueStatus) { await Collection().FindOneAndUpdateAsync(t => t.TaskId == taskId, Update .Set(t => t.QueueStatus, queueStatus) .Set(t => t.TaskStatus, taskStatus)); }
public void Stop() { if (_status == QueueStatus.Started) { Debugger.AddMsg("Stop Queue " + this.Name); //set status to stopping _status = QueueStatus.Stopping; while (_jobList.Count > 0) { //sleep 100ms when has job Thread.Sleep(100); } //Raise Event Started this.Stopped?.Invoke(this, EventArgs.Empty); //set status to started _status = QueueStatus.Started; Debugger.AddMsg("Stop Queue " + this.Name + " Successfully."); } else { throw new InvalidOperationException("Queue status must None when start queue"); } }
private async void NextTask() { if (_isEnabled) { FFMpegEncoderTask task; lock (_lockObj) { if (!_tasks.Any()) { NotifyQueueFinished(); return; } _tasks = new Queue <FFMpegEncoderTask>(_tasks.OrderBy <FFMpegEncoderTask, int>(t => (int)t.VideoHeight)); task = _tasks.Dequeue(); if (task == null) { return; } } if (task != null) { CurrrentStatus = QueueStatus.Running; await Task.Factory.StartNew(() => task.Convert()); } else { NotifyQueuePaused(); } } else { NotifyQueuePaused(); } }
public QueueTicket() { QueueLane = new Lane(); PriorityNumber = 0; //default priority QueueDateTime = DateTime.Now; Status = QueueStatus.WAITING; }
private async void QueueStatusChanged(object sender, EventArgs e) { QueueStatus status = ((IMediaChannel)sender).QueueStatus; switch (status.ChangeType) { case QueueChangeType.Insert: await RefreshQueueAsync(status.ItemIds); break; case QueueChangeType.Update: Queue = new ObservableCollection <QueueItem>(Queue.OrderBy(i => Array.IndexOf(status.ItemIds, i.ItemId))); break; case QueueChangeType.Remove: IList <QueueItem> currentQueue = Queue.ToList(); foreach (int itemId in status.ItemIds) { currentQueue.Remove(currentQueue.FirstOrDefault(i => i.ItemId == itemId)); } Queue = new ObservableCollection <QueueItem>(currentQueue); break; } RaisePropertyChanged(nameof(AreButtonsEnabled)); }
private static void UpdateQueueItem(DataContext dbContext, long id, QueueStatus queueStatus) { var connection = (OracleConnection)dbContext.Database.Connection; using (var command = new OracleCommand()) { try { if (connection.State != ConnectionState.Open) { connection.Open(); } command.Parameters.Add("P_PAYMENT_PROVIDER_QUEUE_ID", OracleDbType.Int64).Value = id; command.Parameters.Add("P_QUEUE_STATUS_ID", OracleDbType.Int32).Value = (int)queueStatus; ExcecuteNonQuery(command, "finance.PAYMENT_PROVIDER_REQUEST_INFO.UPDATE_QUEUE", connection); } finally { foreach (OracleParameter parameter in command.Parameters) { if (parameter.Value is IDisposable) { ((IDisposable)(parameter.Value)).Dispose(); } parameter.Dispose(); } } } }
public ActionResult Index(string siteName, string search, int?publishingObject, int?status, string sortField, string sortDir) { var query = this._manager.CreateQuery(Site); if (!string.IsNullOrWhiteSpace(search)) { query = query.Where(it => it.ObjectUUID.Contains(search, StringComparison.OrdinalIgnoreCase)); } if (publishingObject.HasValue) { PublishingObject po = (PublishingObject)publishingObject.Value; query = query.Where(it => it.PublishingObject == po); } if (status.HasValue) { QueueStatus qs = (QueueStatus)status; query = query.Where(it => it.Status == qs); } if (!string.IsNullOrWhiteSpace(sortField)) { query = query.SortByField(sortField, sortDir); } else { query = query.OrderByDescending(it => it.UtcCreationDate); } return(View(query.ToList())); }
/// <summary> /// Called when a message for this channel is received /// </summary> /// <param name="message">message to process</param> public override Task OnMessageReceivedAsync(IMessage message) { switch (message) { case NextMessage nextMessage: NextRequested?.Invoke(this, EventArgs.Empty); break; case PreviousMessage prevMessage: PreviousRequested?.Invoke(this, EventArgs.Empty); break; case QueueItemIdsMessage itemIdsMessage: ItemIds = itemIdsMessage.ItemIds; break; case QueueItemsMessage itemsMessage: Items = itemsMessage.Items; break; case QueueChangeMessage changeMessage: QueueStatus = new QueueStatus() { ChangeTypeString = changeMessage.ChangeType, ItemIds = changeMessage.ItemIds }; QueueStatusChanged?.Invoke(this, EventArgs.Empty); break; } return(base.OnMessageReceivedAsync(message)); }
private void CreateModuleIfNeeded(string queueNameReceive, string queueNameResponse, ConsumerQueueTypes type) { if (!_queues.ContainsKey(queueNameReceive)) { var connection = ConfigurationManager.AppSettings["Connection"]; switch (type) { case ConsumerQueueTypes.Poco: _queues.Add(queueNameReceive, _queueContainer.Value.CreateRpc <SimpleResponse, SimpleMessage, PostgreSqlRpcConnection>( new PostgreSqlRpcConnection(connection, queueNameReceive, connection, queueNameResponse))); break; case ConsumerQueueTypes.Method: _queues.Add(queueNameReceive, _queueContainer.Value.CreateMethodRpc( new PostgreSqlRpcConnection(connection, queueNameReceive, connection, queueNameResponse))); break; } QueueStatus?.AddStatusProvider(QueueStatusContainer.Value.CreateStatusProvider <PostgreSqlMessageQueueInit>(queueNameReceive, connection)); QueueStatus?.AddStatusProvider(QueueStatusContainer.Value.CreateStatusProvider <PostgreSqlMessageQueueInit>(queueNameResponse, connection)); } }
public void SetStatus(QueueStatus status) { _conn[_redLed] = false; _conn[_yellowLed] = false; _conn[_greenLed] = false; switch (status) { case QueueStatus.Ready: Blink(_greenLed, 4); Blink(_yellowLed, 4); Blink(_redLed, 4); break; case QueueStatus.Error: Blink(_redLed, 6); System.Threading.Thread.Sleep(1000); _conn[_redLed] = true; break; case QueueStatus.WaitingForNetwork: Blink(_yellowLed, 2); break; default: break; } }
/// <summary> /// Stop the queue, clears all queued messages and re-starts /// </summary> /// <returns></returns> public async Task Restart() { QueueStatus prev = Status; await SetStatus(QueueStatus.Stopped); await SetStatus(prev); }
public async Task <NextPipeTask> SetTaskStartedWithMetadata <T>(Guid taskId, QueueStatus queueStatus, TaskStatus taskStatus, T metadata) where T : BaseMetadata { return(await Collection().FindOneAndUpdateAsync(t => t.TaskId == taskId, Update .Set(t => t.QueueStatus, queueStatus) .Set(t => t.TaskStatus, taskStatus) .Set(t => t.Metadata, metadata))); }
private PropertyBagBasedQueueInfo(PropertyStreamReader reader) : base(new QueueInfoPropertyBag()) { KeyValuePair <string, object> item; reader.Read(out item); if (!string.Equals("NumProperties", item.Key, StringComparison.OrdinalIgnoreCase)) { throw new SerializationException(string.Format("Cannot deserialize PropertyBagBasedQueueInfo. Expected property NumProperties, but found '{0}'", item.Key)); } int value = PropertyStreamReader.GetValue <int>(item); for (int i = 0; i < value; i++) { reader.Read(out item); if (string.Equals(ExtensibleQueueInfoSchema.Identity.Name, item.Key, StringComparison.OrdinalIgnoreCase)) { QueueIdentity value2 = QueueIdentity.Parse(PropertyStreamReader.GetValue <string>(item)); this[this.propertyBag.ObjectIdentityPropertyDefinition] = value2; } else if (string.Equals(ExtensibleQueueInfoSchema.DeliveryType.Name, item.Key, StringComparison.OrdinalIgnoreCase)) { DeliveryType deliveryType = (DeliveryType)PropertyStreamReader.GetValue <int>(item); this.propertyBag[ExtensibleQueueInfoSchema.DeliveryType] = deliveryType; } else if (string.Equals(ExtensibleQueueInfoSchema.Status.Name, item.Key, StringComparison.OrdinalIgnoreCase)) { QueueStatus value3 = (QueueStatus)PropertyStreamReader.GetValue <int>(item); this.propertyBag[ExtensibleQueueInfoSchema.Status] = value3; } else if (string.Equals(ExtensibleQueueInfoSchema.RiskLevel.Name, item.Key, StringComparison.OrdinalIgnoreCase)) { RiskLevel value4 = (RiskLevel)PropertyStreamReader.GetValue <int>(item); this.propertyBag[ExtensibleQueueInfoSchema.RiskLevel] = value4; } else if (string.Equals(ExtensibleQueueInfoSchema.NextHopCategory.Name, item.Key, StringComparison.OrdinalIgnoreCase)) { NextHopCategory value5 = (NextHopCategory)PropertyStreamReader.GetValue <int>(item); this.propertyBag[ExtensibleQueueInfoSchema.NextHopCategory] = value5; } else { PropertyDefinition fieldByName = PropertyBagBasedQueueInfo.schema.GetFieldByName(item.Key); if (fieldByName != null) { this.propertyBag.SetField((QueueViewerPropertyDefinition <ExtensibleQueueInfo>)fieldByName, item.Value); } else { ExTraceGlobals.SerializationTracer.TraceWarning <string>(0L, "Cannot convert key index '{0}' into a property in the ExtensibleQueueInfo schema", item.Key); } } } if (this.propertyBag[ExtensibleQueueInfoSchema.NextHopDomain] != null) { QueueIdentity queueIdentity = (QueueIdentity)this[this.propertyBag.ObjectIdentityPropertyDefinition]; queueIdentity.NextHopDomain = (string)this.propertyBag[ExtensibleQueueInfoSchema.NextHopDomain]; } }
private static bool OnQueueStatusThunk(QueueStatus status) { if (SpatialOS.OnQueueStatus != null) { SpatialOS.OnQueueStatus(status); } return(!SpatialOS.Disconnecting); }
/// <summary> /// Изменить статус элемента очереди /// </summary> /// <param name="RunnerQueueId"></param> /// <param name="queueStatus"> /// 1: Новый /// 2: В обработке /// 3: Успешно обработан /// 4: Ошибка обработки /// </param> public void SetQueueElementStatus(int RunnerQueueId, QueueStatus queueStatus, string ErrorMessage = "") { string responseFromServer; SetQueueElementStatusRequest postData = new SetQueueElementStatusRequest() { QueueStatusId = ((int)queueStatus).ToString(), ErrorMessage = ErrorMessage }; string postDataJson = JsonConvert.SerializeObject(postData); try { string strPutUrl = WEBSERVICE_URL + "/" + RunnerQueueId; byte[] byteArray = Encoding.UTF8.GetBytes(postDataJson); WebRequest request = WebRequest.Create(strPutUrl); request.Method = "Put"; request.Timeout = 20000; request.ContentType = "application/json"; request.ContentLength = byteArray.Length; using (var s = request.GetRequestStream()) { using (var sw = new StreamWriter(s)) { sw.Write(postDataJson); } } using (WebResponse response = request.GetResponse()) { Console.WriteLine("[Put] Response status = " + ((HttpWebResponse)response).StatusDescription); using (Stream dataStream = response.GetResponseStream()) { using (StreamReader reader = new StreamReader(dataStream)) { responseFromServer = reader.ReadToEnd(); Console.WriteLine(responseFromServer); } } } } catch (WebException ex) { var reader = new StreamReader(ex.Response.GetResponseStream()); var content = reader.ReadToEnd(); Console.WriteLine("Web error: " + content.ToString()); } catch (Exception ex) { Console.WriteLine("Exception: " + ex.Message); throw ex; } }
private new void Update() { if (term == null) { return; } long v; string s; QueueStatus q = term.GetQueueStatus(); v = q.OutQueueSize; textBoxTxS.Text = (v > 0)? v.ToString() : "Unknown"; textBoxTxQ.Text = q.OutQueue.ToString(); textBoxTxI.Text = q.immediateWaiting? "1" : "0"; s = ""; if (q.ctsHold) { s = s + "CTS "; } if (q.dsrHold) { s = s + "DSR "; } if (q.rlsdHold) { s = s + "RLSD "; } if (q.ctsHold) { s = s + "RxXoff "; } if (q.ctsHold) { s = s + "TxXoff "; } if (s == "") { labelTxS.Text = "Transmitting"; } else { labelTxS.Text = "Blocked: " + s; } if (term.IsCongested()) { labelCongested.Text = "Congested"; } else { labelCongested.Text = "Not Congested"; } v = q.InQueueSize; textBoxRxS.Text = (v > 0)? v.ToString() : "Unknown"; textBoxRxQ.Text = q.InQueue.ToString(); }
public QueueTicket(QueueTicket otherQT) { QueueID = otherQT.QueueID; QueueNumber = otherQT.QueueNumber; QueueLane = new Lane(otherQT.QueueLane); PriorityNumber = otherQT.PriorityNumber; this.owner = otherQT.owner; QueueDateTime = otherQT.QueueDateTime; Status = otherQT.Status; }
public static QueueStatus GetCurrentStatus() { QueueStatus status = new QueueStatus(); var data = HttpClientHelper.GetServiceAsync($"{baseUrl}/api/Event/GetCurrenQueueStatus"); status = JsonConvert.DeserializeObject <List <QueueStatus> >(data).FirstOrDefault(); return(status); }
private static bool QueueCallback(QueueStatus queueStatus) { if (!string.IsNullOrEmpty(queueStatus.Error)) { Console.Error.WriteLine("Error while queueing: " + queueStatus.Error); Environment.Exit(ErrorExitStatus); } Console.WriteLine("Worker of type '" + WorkerType + "' connecting through locator: queueing."); return(true); }
public MasterReportQueueEntryDto(int queueEntryId, string userId, DateTime from, DateTime to, int masterReportId, DateTime requestDate, DateTime? finishDate, QueueStatus queueStatus) { _queueEntryId = queueEntryId; _userId = userId; _from = from; _to = to; _masterReportId = masterReportId; _queueStatus = queueStatus; _finishDate = finishDate; _requestDate = requestDate; }
public ActionResult Edit(string uuid,QueueStatus status, string @return) { var resultEntry = new JsonResultData(ModelState); if (ModelState.IsValid) { resultEntry.RunWithTry((data) => { var oldModel = _manager.Get(uuid); var newModel = _manager.Get(uuid); newModel.Status = status; _manager.Update(newModel, oldModel); resultEntry.RedirectUrl = @return; }); } return Json(resultEntry); }
public IEnumerable<Queue> FindQueues(string topic, QueueStatus? status = null) { var queues = _queueDict.Values.Where(x => x.Topic == topic); if (status != null) { return queues.Where(x => x.Status == status.Value); } return queues; }
public Queue(string topic, int queueId) { Topic = topic; QueueId = queueId; Status = QueueStatus.Normal; }
private void UpdateStatus(QueueStatus newStatus) { lock (lockable) { if (Status != newStatus) { Status = newStatus; if (QueueStatusChanged != null) { QueueStatusChanged(this, new QueueEventArgs(this)); } } } }
public void Enable() { Status = QueueStatus.Normal; }
public void Disable() { Status = QueueStatus.Disabled; }
public RxQueueData(QueueStatus status, int bytesAvailable) { this._status = status; this._bytesAvailable = bytesAvailable; }
internal static ProjectActivity GetProjectActivity(QueueStatus queueStatus) { switch (queueStatus) { case QueueStatus.Completed: case QueueStatus.Canceled: case QueueStatus.Postponed: return ProjectActivity.Sleeping; case QueueStatus.InProgress: return ProjectActivity.Building; default: return ProjectActivity.Pending; } }
public static void SetMasterReportStatus(int masterReportId, QueueStatus status) { AdminRegistry.QueueDao.SetMasterReportStatus(masterReportId, status); }
//Private functions void MakeNextRequest() { if (currentStatus == QueueStatus.OnGoing) { if (requests.Count() == 0) { currentStatus = QueueStatus.Stopped; } else if (requests.Count() > 0 && WebRequest == null) { MakeRequest(); } } else if (currentStatus == QueueStatus.Stopped) { if (requests.Count() > 0 && WebRequest == null) { currentStatus = QueueStatus.OnGoing; MakeRequest(); } } }
public HTTPRequestQueue() { currentStatus = QueueStatus.Stopped; WebRequest = null; }
public IEnumerable<Queue> GetOrCreateQueues(string topic, QueueStatus? status = null) { var queues = _queueDict.Values.Where(x => x.Topic == topic); if (queues.IsEmpty() && BrokerController.Instance.Setting.AutoCreateTopic) { CreateTopic(topic, BrokerController.Instance.Setting.TopicDefaultQueueCount); queues = _queueDict.Values.Where(x => x.Topic == topic); } if (status != null) { return queues.Where(x => x.Status == status.Value); } return queues; }
//This will stop request queue and save pending requests to a file. public void StopAndSaveQueue() { if (currentStatus == QueueStatus.OnGoing) { currentStatus = QueueStatus.Stopped; if (WebRequest != null) WebRequest.Abort(); requests.Insert(0, currentRequest); } Save(); }