private void InsertMesureDetailForSensor(object sender, ProcessQueueItemEventArgs <List <MeasureDetail> > data)
{
if (data == null || data.ProcessItem == null || data.ProcessItem.Count == 0)
{
return;
}
//Console.WriteLine("sensor: " + data.ProcessItem.First().DBName);
AppManager.GetDBChildConnection(data.ProcessItem.First().DBName).InsertMeasureDetailBulk(data.ProcessItem);
}
/// <summary>
/// This method is called to process a outgoing message.
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">Event arguments</param>
private void OutgoingMessageQueue_ProcessItem(object sender, ProcessQueueItemEventArgs <MDSDataTransferMessage> e)
{
try
{
SendMessageToWebService(e.ProcessItem);
}
catch (Exception ex)
{
Logger.Error(ex.Message, ex);
}
}
/// <summary>
/// This event handles processing messages when a message is added to queue (_incomingMessageQueue).
/// </summary>
/// <param name="sender">Reference to message queue</param>
/// <param name="e">Event arguments</param>
private void IncomingMessageQueue_ProcessItem(object sender, ProcessQueueItemEventArgs <MDSMessage> e)
{
//Process only MDSDataTransferMessage objects.
if (e.ProcessItem.MessageTypeId != MDSMessageFactory.MessageTypeIdMDSDataTransferMessage)
{
return;
}
//Create IncomingDataMessage from MDSDataTransferMessage
var dataMessage = new IncomingDataMessage(this, e.ProcessItem as MDSDataTransferMessage);
try
{
//Check if client application registered to MessageReceived event.
if (MessageReceived == null)
{
dataMessage.Reject("Client application did not registered to MessageReceived event to receive messages.");
return;
}
//Raise MessageReceived event
MessageReceived(this, new MessageReceivedEventArgs {
Message = dataMessage
});
//Check if client application acknowledged or rejected message
if (dataMessage.AckState != MessageAckStates.WaitingForAck)
{
return;
}
//Check if auto acknowledge is active
if (!AutoAcknowledgeMessages)
{
dataMessage.Reject("Client application did not acknowledged or rejected message.");
return;
}
//Auto acknowledge message
dataMessage.Acknowledge();
}
catch
{
try
{
dataMessage.Reject("An unhandled exception occured during processing message by client application.");
}
catch (Exception ex)
{
Logger.Warn(ex.Message, ex);
}
}
}
private void ExceptionForSensor(object sender, ProcessQueueItemEventArgs <DSF602Exception> exception)
{
if (exception == null || exception.ProcessItem == null)
{
return;
}
var obj = (QueueProcessorThread <DSF602Exception>)sender;
var sensorId = ConvertHelper.CnvNullToInt(obj.Name);
if (ErrorsReceiveDataFromBlock != null)
{
ErrorsReceiveDataFromBlock(sensorId, exception.ProcessItem);
}
}
/// <summary>
/// This event handles processing messages when a message is added to queue (_incomingMessageQueue).
/// </summary>
/// <param name="sender">Reference to message queue</param>
/// <param name="e">Event arguments</param>
private void IncomingMessageQueue_ProcessItem(object sender, ProcessQueueItemEventArgs <NGRIDMessage> e)
{
try
{
if (e.ProcessItem.MessageTypeId == NGRIDMessageFactory.MessageTypeIdNGRIDControllerMessage && ControlMessageReceived != null)
{
var controllerMessage = e.ProcessItem as NGRIDControllerMessage;
if (controllerMessage == null)
{
return;
}
ControlMessageReceived(this, new ControlMessageReceivedEventArgs(DeserializeControlMessage(controllerMessage)));
}
}
catch (Exception ex)
{
Logger.Error(ex.Message, ex);
}
}
private void eventProcessCharge(object sender, ProcessQueueItemEventArgs <DataCharge> e)
{
var sensor = e.ProcessItem.Sensor;
var state = e.ProcessItem.ChargeState;
var item = e.ProcessItem.BlockThread;
var sensorId = sensor.SensorId;
var isAlarm = e.ProcessItem.IsAlarm;
if (isAlarm)
{
sensor.Result_Measure = (int)clsConst.emMeasureResult.Fail;
sensor.Alarm = true;
}
sensor.MeasureState = state;
if (state == MeasureState.Positive)
{
isDecayRuning = true;
var objLayout = tabGraph.Controls[0] as GraphTypeBase;
if (objLayout == null)
{
return;
}
var graph = objLayout.GetPlotterDisplayExByIndex(sensor.Ordinal_Display - 1);
if (graph.InvokeRequired)
{
graph.Invoke(new MethodInvoker(() => clsSupportGraph.GraphInit(graph)));
}
else
{
clsSupportGraph.GraphInit(graph);
}
sensor.ActualDecayPositiveTime = 0;
sensor.ActualDecayNegativeTime = 0;
sensor.ActualIBMax = 0;
item.SelectSensor(sensorId);
item.Charge(sensorId, 1);
}
else if (state == MeasureState.StopPositive)
{
item.StopCharge(sensorId, 1);
Thread.Sleep(800);
}
else if (state == MeasureState.Negative)
{
item.Charge(sensorId, -1);
}
else if (state == MeasureState.StopNegative)
{
item.StopCharge(sensorId, -1);
}
else if (state == MeasureState.Ion)
{
item.ConnectGround(sensorId);
}
else if (state == MeasureState.StopIon)
{
item.ConnectGround(sensorId, true);
var objLayout = tabGraph.Controls[0] as GraphTypeBase;
if (objLayout == null)
{
return;
}
var lbl = objLayout.GetDisplaySensorByIndex(sensor.Ordinal_Display - 1);
if (lbl != null)
{
this.UpdateSafeControl(lbl, l =>
{
if (sensor.Active == (int)clsConst.emBlockStatus.Active)
{
sensor.ActualIBMax = maxIonVal;
((DisplaySensor)l).DisplayDecayValue(maxIonVal, sensor.MeasureState);
}
});
}
isDecayRuning = false;
}
Console.WriteLine(DateTime.Now.ToString("HH:mm:ss:ffff") + ": " + state.ToString());
}
/// <summary>
/// This event handles processing messages when a message is added to queue (_incomingMessageQueue).
/// </summary>
/// <param name="sender">Reference to message queue</param>
/// <param name="e">Event arguments</param>
private void IncomingMessageQueue_ProcessItem(object sender, ProcessQueueItemEventArgs<MDSMessage> e)
{
try
{
if (e.ProcessItem.MessageTypeId == MDSMessageFactory.MessageTypeIdMDSControllerMessage && ControlMessageReceived != null)
{
var controllerMessage = e.ProcessItem as MDSControllerMessage;
if (controllerMessage == null)
{
return;
}
ControlMessageReceived(this, new ControlMessageReceivedEventArgs(DeserializeControlMessage(controllerMessage)));
}
}
catch(Exception ex)
{
Logger.Error(ex.Message, ex);
}
}
/// <summary>
/// This method is called for each incoming message by _incomingMessageQueue to process incoming messages as ordered.
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">Event arguments</param>
private void IncomingMessageQueue_ProcessItem(object sender, ProcessQueueItemEventArgs<MessageReceivedFromCommunicatorEventArgs> e)
{
OnMessageReceived(this, e.ProcessItem);
}
/// <summary>
/// This method is called for each incoming message by _incomingMessageQueue to process incoming messages as ordered.
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">Event arguments</param>
private void IncomingMessageQueue_ProcessItem(object sender, ProcessQueueItemEventArgs <MessageReceivedFromCommunicatorEventArgs> e)
{
OnMessageReceived(this, e.ProcessItem);
}
/// <summary>
/// This method is called to process a outgoing message.
/// </summary>
/// <param name="sender">Sender object</param>
/// <param name="e">Event arguments</param>
private void OutgoingMessageQueue_ProcessItem(object sender, ProcessQueueItemEventArgs<NGRIDDataTransferMessage> e)
{
try
{
SendMessageToWebService(e.ProcessItem);
}
catch (Exception ex)
{
Logger.Error(ex.Message, ex);
}
}
/// <summary>
/// This event handles processing messages when a message is added to queue (_incomingMessageQueue).
/// </summary>
/// <param name="sender">Reference to message queue</param>
/// <param name="e">Event arguments</param>
private void IncomingMessageQueue_ProcessItem(object sender, ProcessQueueItemEventArgs<NGRIDMessage> e)
{
//Process only NGRIDDataTransferMessage objects.
if (e.ProcessItem.MessageTypeId != NGRIDMessageFactory.MessageTypeIdNGRIDDataTransferMessage)
{
return;
}
//Create IncomingDataMessage from NGRIDDataTransferMessage
var dataMessage = new IncomingDataMessage(this, e.ProcessItem as NGRIDDataTransferMessage);
try
{
//Check if client application registered to MessageReceived event.
if (MessageReceived == null)
{
dataMessage.Reject("Client application did not registered to MessageReceived event to receive messages.");
return;
}
//Raise MessageReceived event
MessageReceived(this, new MessageReceivedEventArgs { Message = dataMessage });
//Check if client application acknowledged or rejected message
if (dataMessage.AckState != MessageAckStates.WaitingForAck)
{
return;
}
//Check if auto acknowledge is active
if (!AutoAcknowledgeMessages)
{
dataMessage.Reject("Client application did not acknowledged or rejected message.");
return;
}
//Auto acknowledge message
dataMessage.Acknowledge();
}
catch
{
try
{
dataMessage.Reject("An unhandled exception occured during processing message by client application.");
}
catch (Exception ex)
{
Logger.Warn(ex.Message, ex);
}
}
}