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