/// <summary>
/// Agents the logout.
/// </summary>
/// <param name="proxyId">The proxy identifier.</param>
/// <returns></returns>
public OutputValues AgentLogout(int proxyId)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
try
{
RequestAgentLogout requestAgentlogout = RequestAgentLogout.Create();
requestAgentlogout.ProxyClientId = proxyId;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestAgentlogout);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAgentLogout = (EventAck)message;
logger.Info("-------------AgentLogout----------------");
logger.Info("ProxyClientId :" + proxyId);
logger.Info("Name :" + eventAgentLogout.Name.ToString());
logger.Info("----------------------------------------");
logger.Trace(eventAgentLogout.ToString());
output.MessageCode = "200";
output.Message = "Agent Logout Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
string LoginErrorCode = Convert.ToString(eventError.ErrorCode);
string LoginErrorDescription = Convert.ToString(eventError.ErrorDescription);
logger.Trace(eventError.ToString());
output.ErrorCode = eventError.ErrorCode;
output.MessageCode = "2002";
output.Message = "AgentLogout() : " + LoginErrorDescription;
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Agent Logout UnSuccessful";
}
}
else
{
logger.Warn("AgentLogout() : Interaction Server Protocol is Null..");
}
}
catch (Exception commonException)
{
logger.Error("Error occurred while Agent Logout request " + commonException.ToString());
output.MessageCode = "2001";
output.Message = commonException.Message;
}
return(output);
}
/// <summary>
/// Calls the OnEventAck method of the modules.
/// </summary>
public void OnEventAck(EventAck eventAck)
{
lock (moduleLock)
{
foreach (ModuleLogic moduleLogic in logicModules)
{
try
{
moduleLogic.OnEventAck(eventAck);
}
catch (Exception ex)
{
log.WriteError(ex, ServerPhrases.ErrorInModule, nameof(OnEventAck), moduleLogic.Code);
}
}
}
}
/// <summary>
/// Acknowledges the event.
/// </summary>
public void AckEvent(EventAck eventAck)
{
if (eventAck == null)
{
throw new ArgumentNullException(nameof(eventAck));
}
RestoreConnection();
DataPacket request = CreateRequest(FunctionID.AckEvent);
int index = ArgumentIndex;
CopyInt64(eventAck.EventID, outBuf, ref index);
CopyTime(eventAck.Timestamp, outBuf, ref index);
CopyInt32(eventAck.UserID, outBuf, ref index);
request.BufferLength = index;
SendRequest(request);
ReceiveResponse(request);
}
/// <summary>
/// Acknowledges the event.
/// </summary>
private void AckEvent(ConnectedClient client, DataPacket request, out ResponsePacket response)
{
byte[] buffer = request.Buffer;
int index = ArgumentIndex;
EventAck eventAck = new EventAck
{
EventID = GetInt64(buffer, ref index),
Timestamp = GetTime(buffer, ref index),
UserID = GetInt32(buffer, ref index)
};
if (eventAck.UserID <= 0)
{
eventAck.UserID = client.UserID;
}
coreLogic.AckEvent(eventAck);
response = new ResponsePacket(request, client.OutBuf);
}
/// <summary>
/// Acknowledges the event.
/// </summary>
public override void AckEvent(EventAck eventAck)
{
EventTable eventTable = GetEventTable(ScadaUtils.RetrieveTimeFromID(eventAck.EventID));
Event ev = eventTable.GetEventByID(eventAck.EventID);
if (ev != null)
{
stopwatch.Restart();
ev.Ack = true;
ev.AckTimestamp = eventAck.Timestamp;
ev.AckUserID = eventAck.UserID;
adapter.FileName = eventTable.FileName;
adapter.WriteEventAck(ev);
eventTable.LastWriteTime = File.GetLastWriteTimeUtc(eventTable.FileName);
stopwatch.Stop();
arcLog?.WriteAction(ServerPhrases.AckEventCompleted, stopwatch.ElapsedMilliseconds);
}
}
/// <summary>
/// Acknowledges the event.
/// </summary>
public void AckEvent(EventAck eventAck)
{
foreach (EventArchiveLogic archiveLogic in eventArchives)
{
if (archiveLogic.IsReady)
{
try
{
archiveLogic.Lock();
archiveLogic.AckEvent(eventAck);
archiveLogic.LastWriteTime = DateTime.UtcNow;
}
catch (Exception ex)
{
log.WriteError(ex, ServerPhrases.ErrorInArchive, nameof(AckEvent), archiveLogic.Code);
}
finally
{
Unlock(archiveLogic);
}
}
}
}
/// <summary>
/// Acknowledges the event.
/// </summary>
public override void AckEvent(EventAck eventAck)
{
try
{
stopwatch.Restart();
conn.Open();
string sql = $"UPDATE {queryBuilder.EventTable} " +
"SET ack = true, ack_timestamp = @ackTimestamp, ack_user_id = @ackUserID " +
"WHERE event_id = @eventID AND @startTime <= time_stamp AND time_stamp < @endTime";
DateTime eventTime = ScadaUtils.RetrieveTimeFromID(eventAck.EventID);
NpgsqlCommand cmd = new NpgsqlCommand(sql, conn);
cmd.Parameters.AddWithValue("ackTimestamp", eventAck.Timestamp);
cmd.Parameters.AddWithValue("ackUserID", eventAck.UserID);
cmd.Parameters.AddWithValue("eventID", eventAck.EventID);
cmd.Parameters.AddWithValue("startTime", eventTime);
cmd.Parameters.AddWithValue("endTime", eventTime.AddSeconds(1.0));
int rowsAffected = cmd.ExecuteNonQuery();
stopwatch.Stop();
if (rowsAffected > 0)
{
arcLog?.WriteAction(ServerPhrases.AckEventCompleted, eventAck.EventID,
stopwatch.ElapsedMilliseconds);
}
else
{
arcLog?.WriteAction(ServerPhrases.AckEventNotFound, eventAck.EventID);
}
}
finally
{
conn.Close();
}
}
public void ReceiveEmailEvents(IMessage events)
{
try
{
if ((Settings.SFDCOptions.SFDCPopupPages != null) && (events != null))
{
this._logger.Info("Agent Email Event : " + events.Name);
switch (events.Id)
{
case EventInvite.MessageId:
this._eventInvite = (EventInvite)events;
Settings.EmailProxyClientId = _eventInvite.ProxyClientId;
IXNCustomData emailInviteData = new IXNCustomData();
emailInviteData.InteractionId = this._eventInvite.Interaction.InteractionId;
emailInviteData.OpenMediaInteraction = this._eventInvite.Interaction;
emailInviteData.UserData = this._eventInvite.Interaction.InteractionUserData;
GetEmailData(emailInviteData.InteractionId, emailInviteData);
EmailInvite.GetInstance().PopupRecords(emailInviteData, emailInviteData.InteractionType);
if ((this._eventInvite.VisibilityMode.ToString() != "Coach") && (this._eventInvite.VisibilityMode.ToString() != "Conference"))
{
}
break;
case EventPulledInteractions.MessageId:
this._eventPulledInteractions = (EventPulledInteractions)events;
if (this._eventPulledInteractions.Interactions.Count == 1)
{
string str = this._eventPulledInteractions.Interactions.AllKeys.GetValue(0).ToString();
object[] kvc = this._eventPulledInteractions.Interactions.GetValues(str);
KeyValueCollection collection = (KeyValueCollection)kvc[0];
IXNCustomData emailPulledData = new IXNCustomData();
emailPulledData.InteractionId = collection["InteractionId"].ToString();
GetEmailData(emailPulledData.InteractionId, emailPulledData);
if (emailPulledData.IXN_Attributes.TypeId == "Inbound")
{
emailPulledData.InteractionType = SFDCCallType.InboundEmailPulled;
}
else if (emailPulledData.IXN_Attributes.TypeId == "Outbound")
{
emailPulledData.InteractionType = SFDCCallType.OutboundEmailPulled;
}
EmailPulled.GetInstance().PopupRecords(emailPulledData, emailPulledData.InteractionType);
}
break;
case EventAck.MessageId:
this._eventAck = (EventAck)events;
if (_eventAck.Extension != null && _eventAck.Extension.ContainsKey("InteractionId") && _eventAck.Extension["InteractionId"] != null)
{
string type = GetEmailInteractionContent(_eventAck.Extension["InteractionId"].ToString(), "type");
if (type.Equals("OutboundNew"))
{
string ToAddress = GetEmailInteractionContent(_eventAck.Extension["InteractionId"].ToString(), "to");
if (!String.IsNullOrEmpty(ToAddress))
{
IXNCustomData emailAckData = new IXNCustomData();
emailAckData.InteractionType = SFDCCallType.OutboundEmailSuccess;
emailAckData.InteractionId = _eventAck.Extension["InteractionId"].ToString();
GetEmailData(emailAckData.InteractionId, emailAckData);
if (IsClick2Email && SFDCHttpServer._emailData.ContainsKey(ToAddress))
{
Settings.ClickToEmailData.Add(_eventAck.Extension["InteractionId"].ToString(), SFDCHttpServer._emailData[ToAddress]);
EmailManager.GetInstance().GetClickToEmailLogs(emailAckData, _eventAck.Extension["InteractionId"].ToString(), SFDCCallType.OutboundEmailSuccess, SFDCHttpServer._emailData[ToAddress], "create");
IsClick2Email = false;
}
else
{
EmailCreate.GetInstance().PopupRecords(emailAckData, SFDCCallType.OutboundEmailSuccess);
}
}
else
{
this._logger.Warn("ReceiveEmailEvents : ToAddress is not found in EventAck");
}
}
else if (type.Equals("OutboundReply"))
{
string ToAddress = GetEmailInteractionContent(_eventAck.Extension["InteractionId"].ToString(), "to");
if (!String.IsNullOrEmpty(ToAddress))
{
IXNCustomData outEmailData = new IXNCustomData();
outEmailData.InteractionType = SFDCCallType.OutboundEmailSuccess;
outEmailData.InteractionId = _eventAck.Extension["InteractionId"].ToString();
GetEmailData(outEmailData.InteractionId, outEmailData);
if (IsClick2Email && SFDCHttpServer._emailData.ContainsKey(ToAddress))
{
Settings.ClickToEmailData.Add(_eventAck.Extension["InteractionId"].ToString(), SFDCHttpServer._emailData[ToAddress]);
EmailManager.GetInstance().GetClickToEmailLogs(outEmailData, _eventAck.Extension["InteractionId"].ToString(), SFDCCallType.OutboundEmailSuccess, SFDCHttpServer._emailData[ToAddress], "create");
IsClick2Email = false;
}
else
{
EmailCreate.GetInstance().PopupRecords(outEmailData, SFDCCallType.OutboundEmailSuccess);
}
}
else
{
this._logger.Warn("ReceiveEmailEvents : ToAddress is not found in EventAck");
}
}
}
break;
}
}
}
catch (Exception exception)
{
this._logger.Error("ReceiveEmailEvents : Error occured while receiving Email events " + exception.ToString());
}
}
/// <summary>
/// Performs actions when acknowledging an event.
/// </summary>
public virtual void OnEventAck(EventAck eventAck)
{
}
/// <summary>
/// Agents the login.
/// </summary>
/// <param name="agentId">The agent identifier.</param>
/// <param name="placeId">The place identifier.</param>
/// <param name="proxyId">The proxy identifier.</param>
/// <param name="chatMedia">The chat media.</param>
/// <param name="chatMediaState">State of the chat media.</param>
/// <param name="tenantId">The tenant identifier.</param>
/// <returns></returns>
public OutputValues AgentLogin(string agentId, string placeId, int proxyId, int tenantDBID, Dictionary <string, int> mediaList)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
try
{
RequestAgentLogin requestAgentlogin = RequestAgentLogin.Create();
requestAgentlogin.AgentId = agentId;
requestAgentlogin.PlaceId = placeId;
requestAgentlogin.ProxyClientId = proxyId;
requestAgentlogin.MediaList = new Genesyslab.Platform.Commons.Collections.KeyValueCollection();
foreach (KeyValuePair <string, int> media in mediaList)
{
requestAgentlogin.MediaList.Add(media.Key, media.Value);
}
requestAgentlogin.TenantId = tenantDBID;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestAgentlogin);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAgentLogin = (EventAck)message;
logger.Info("--------------AgentLogin-----------------");
logger.Info("AgentId :" + agentId);
logger.Info("PlaceId :" + placeId);
logger.Info("ProxyClientId :" + proxyId);
foreach (KeyValuePair <string, int> media in mediaList)
{
logger.Info("Media Name :" + media.Key + "\t Media State :" + media.Value);
}
logger.Info("TenantId :" + requestAgentlogin.TenantId);
logger.Info("Name :" + eventAgentLogin.Name.ToString());
logger.Info("----------------------------------------");
logger.Trace(eventAgentLogin.ToString());
output.MessageCode = "200";
output.Message = "Agent Login Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
string LoginErrorCode = Convert.ToString(eventError.ErrorCode);
string LoginErrorDescription = Convert.ToString(eventError.ErrorDescription);
logger.Trace(eventError.ToString());
output.ErrorCode = eventError.ErrorCode;
output.MessageCode = "2002";
output.Message = LoginErrorDescription;
break;
}
}
else
{
output.MessageCode = "2002";
output.Message = "Agent Login UnSuccessful";
}
}
else
{
output.MessageCode = "2001";
output.Message = "Interaction Server Protocol is Null";
logger.Warn("AgentLogin() : Interaction Server Protocol is Null..");
}
}
catch (Exception commonException)
{
logger.Error("Error occurred while Agent Login request " + commonException.ToString());
output.MessageCode = "2001";
output.Message = commonException.Message;
}
return(output);
}
public OutputValues RequestPlaceWorkbin(string interactionId, string agentId,
//string placeId,
string workbin, int proxyId)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
try
{
WorkbinInfo workbinInfo = WorkbinInfo.Create();
workbinInfo.WorkbinAgentId = agentId;
// workbinInfo.WorkbinPlaceId = placeId;
workbinInfo.WorkbinTypeId = workbin;
RequestPlaceInWorkbin requestPlaceInWorkbin = RequestPlaceInWorkbin.Create();
requestPlaceInWorkbin.InteractionId = interactionId;
requestPlaceInWorkbin.ProxyClientId = proxyId;
requestPlaceInWorkbin.Workbin = workbinInfo;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestPlaceInWorkbin);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAck = (EventAck)message;
logger.Info("------------PlaceInWorkbin-------------");
logger.Info("AgentID :" + agentId);
logger.Info("InteractionID :" + interactionId);
// logger.Info("PlaceID :" + placeId);
logger.Info("ProxyID :" + proxyId);
logger.Info("Workbin :" + workbin);
logger.Info("----------------------------------------------");
logger.Trace(eventAck.ToString());
output.MessageCode = "200";
output.Message = "Place in Workbin Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
logger.Info("------------Error on Email Interaction-------------");
logger.Info("AgentID :" + agentId);
logger.Info("InteractionID :" + interactionId);
// logger.Info("PlaceID :" + placeId);
logger.Info("ProxyID :" + proxyId);
logger.Info("Workbin :" + workbin);
logger.Info("----------------------------------------------");
logger.Trace(eventError.ToString());
output.MessageCode = "2001";
output.Message = Convert.ToString(eventError.ErrorDescription);
logger.Error("Error occurred while placeinworkbin : " + Convert.ToString(eventError.ErrorDescription));
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Place in Workbin UnSuccessful";
}
}
else
{
logger.Warn("PlaceInWorkbin() : Interaction Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Accept the request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Accepts the interaction.
/// </summary>
/// <param name="ticketID">The ticket identifier.</param>
/// <param name="interactionID">The interaction identifier.</param>
/// <param name="proxyID">The proxy identifier.</param>
/// <returns></returns>
public OutputValues AcceptInteraction(int ticketID, string interactionID, int proxyID)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
try
{
RequestAccept requestAccept = RequestAccept.Create();
requestAccept.TicketId = ticketID;
requestAccept.InteractionId = interactionID;
requestAccept.ProxyClientId = Convert.ToInt32(proxyID);
//added 27-02-2015
requestAccept.InitialInFocusState = true;
//end
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestAccept);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAck = (EventAck)message;
logger.Info("------------Accepted Interaction-------------");
logger.Info("TicketID :" + ticketID);
logger.Info("InteractionID :" + interactionID);
logger.Info("ProxyID :" + proxyID);
logger.Info("----------------------------------------------");
logger.Trace(eventAck.ToString());
output.MessageCode = "200";
output.Message = "Accept Interaction Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
logger.Info("------------Error on Email Interaction-------------");
logger.Info("TicketID :" + ticketID);
logger.Info("InteractionID :" + interactionID);
logger.Info("ProxyID :" + proxyID);
logger.Info("----------------------------------------------");
logger.Trace(eventError.ToString());
output.MessageCode = "2001";
output.Message = Convert.ToString(eventError.ErrorDescription);
logger.Error("Error occurred while accepting the interaction : " + Convert.ToString(eventError.ErrorDescription));
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Agent Not Ready UnSuccessful";
}
}
else
{
logger.Warn("AcceptChatInteraction() : Interaction Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Accept the request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
public OutputValues TransferInteractiontoQueue(int proxyClientId, string interactionID, string queueName)
{
OutputValues output = OutputValues.GetInstance();
try
{
RequestChangeProperties requestChangeProperties = RequestChangeProperties.Create();
RequestPlaceInQueue requestPlaceInQueue = RequestPlaceInQueue.Create();
KeyValueCollection attachData = new KeyValueCollection();
attachData.Add("EmailSkills", queueName);
requestChangeProperties.ChangedProperties = attachData;
requestChangeProperties.InteractionId = interactionID;
requestChangeProperties.ProxyClientId = proxyClientId;
requestPlaceInQueue.InteractionId = interactionID;
requestPlaceInQueue.Queue = queueName;
requestPlaceInQueue.ProxyClientId = proxyClientId;
requestPlaceInQueue.AddedProperties = attachData;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestPlaceInQueue);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAck = (EventAck)message;
logger.Info("------------Transfer Interaction By Queue-------------");
logger.Info("InteractionId :" + interactionID);
logger.Info("ProxyClientId :" + proxyClientId);
logger.Info("QueueName :" + queueName);
logger.Info("--------------------------------------------");
logger.Trace(eventAck.ToString());
output.MessageCode = "200";
output.Message = "Transfer interaction Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
logger.Info("------------Error on Transfer Interaction By Queue-------------");
logger.Info("InteractionId :" + interactionID);
logger.Info("ProxyClientId :" + proxyClientId);
logger.Info("QueueName :" + queueName);
logger.Info("--------------------------------------------");
logger.Trace(eventError.ToString());
output.MessageCode = "2001";
output.Message = Convert.ToString(eventError.ErrorDescription);
logger.Error("Error occurred while transferring interaction : " + Convert.ToString(eventError.ErrorDescription));
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Transfer Interaction UnSuccessful";
}
Settings.InteractionProtocol.Send(requestPlaceInQueue);
logger.Info("------------Transfer Interaction By Queue-------------");
logger.Info("InteractionId :" + interactionID);
logger.Info("ProxyClientId :" + proxyClientId);
logger.Info("QueueName :" + queueName);
logger.Info("--------------------------------------------");
logger.Info(requestChangeProperties.ToString());
logger.Info(requestPlaceInQueue.ToString());
}
else
{
logger.Warn("TransferInteractiontoQueue() : Interaction Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while transfer the interaction" + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
public OutputValues TransferInteractiontoAgent(int proxyClientId, string interactionID, string agentID)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
try
{
RequestTransfer requestTransfer = RequestTransfer.Create();
requestTransfer.ProxyClientId = proxyClientId;
requestTransfer.InteractionId = interactionID;
requestTransfer.AgentId = agentID;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestTransfer);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAck = (EventAck)message;
logger.Info("------------Transfer Interaction to agent-------------");
logger.Info("AgentID :" + requestTransfer.AgentId);
logger.Info("ProxyClientId :" + requestTransfer.ProxyClientId);
logger.Info("InteractionId :" + requestTransfer.InteractionId);
logger.Info("----------------------------------------------");
logger.Trace(eventAck.ToString());
output.MessageCode = "200";
output.Message = "Transfer interaction Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
logger.Info("------------Error on Transferring Interaction to Agent-------------");
logger.Info("AgentID :" + requestTransfer.AgentId);
logger.Info("ProxyClientId :" + requestTransfer.ProxyClientId);
logger.Info("InteractionId :" + requestTransfer.InteractionId);
logger.Info("----------------------------------------------");
logger.Trace(eventError.ToString());
output.MessageCode = "2001";
output.Message = Convert.ToString(eventError.ErrorDescription);
logger.Error("Error occurred while transferring interaction : " + Convert.ToString(eventError.ErrorDescription));
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Transfer Interaction UnSuccessful";
}
}
else
{
logger.Warn("TransferInteraction() : Interaction Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while transfer the interaction" + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary> /// Acknowledges the event. /// </summary> public abstract void AckEvent(EventAck eventAck);
/// <summary>
/// Agents the ready.
/// </summary>
/// <param name="proxyClientId">The proxy client identifier.</param>
/// <param name="mediaType">Type of the media.</param>
/// <returns></returns>
public OutputValues AgentNotReadyWithReason(int proxyClientId, string mediaType, string reason, string code)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
try
{
KeyValueCollection ReasonCode = new KeyValueCollection();
if (!string.IsNullOrEmpty(reason))
{
ReasonCode.Add("Name", reason);
ReasonCode.Add("Code", code);
}
RequestChangeMediaStateReason requestChangeMediaStateReason = RequestChangeMediaStateReason.Create(proxyClientId, ReasonCode, mediaType, ReasonInfo.Create(mediaType, reason, Convert.ToInt32(code)));
//requestChangeMediaStateReason.ProxyClientId = proxyClientId;
//requestChangeMediaStateReason.MediaTypeName = mediaType;
//requestChangeMediaStateReason.Extension = ReasonCode;
//requestChangeMediaStateReason.Reason = ReasonInfo.Create(mediaType, reason, Convert.ToInt32(code));
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestChangeMediaStateReason);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAgentNotReady = (EventAck)message;
logger.Info("----------------AgentNotReadyWithReason-------------");
logger.Info("ProxyClientId :" + proxyClientId);
logger.Info("MediaTypeName :" + mediaType);
logger.Info("Name :" + eventAgentNotReady.Name.ToString());
logger.Info("Reason Name :" + reason);
logger.Info("Reason Code :" + code);
logger.Info("----------------------------------------------------");
logger.Trace(eventAgentNotReady.ToString());
output.MessageCode = "200";
output.Message = "Agent Not Ready with reason Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
string LoginErrorCode = Convert.ToString(eventError.ErrorCode);
string LoginErrorDescription = Convert.ToString(eventError.ErrorDescription);
logger.Trace(eventError.ToString());
output.ErrorCode = eventError.ErrorCode;
output.MessageCode = "2002";
output.Message = "AgentNotReadyWithReason() : " + LoginErrorDescription;
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Agent Not Ready with reason UnSuccessful";
}
}
else
{
logger.Warn("AgentNotReadyWithReason() : Interaction Server Protocol is Null..");
}
}
catch (Exception commonException)
{
logger.Error("Error occurred while Agent Not Ready with reason request " + commonException.ToString());
output.MessageCode = "2001";
output.Message = commonException.Message;
}
return(output);
}
public OutputValues NotifyWorbin(int proxyClientId, string workbinType, string worbinEmpId, string workbinGroupId = null, string WorkbinPlaceId = null, string workbinPlaceGroupId = null)
{
OutputValues outPutValues = new OutputValues();
outPutValues.Message = string.Empty;
outPutValues.MessageCode = string.Empty;
outPutValues.ErrorCode = 0;
KeyValueCollection keyVC = new KeyValueCollection();
keyVC.Add("event_processing_stopped", 1);
try
{
RequestWorkbinNotifications reqWorkbinNotifications = RequestWorkbinNotifications.Create();
reqWorkbinNotifications.Workbin = WorkbinInfo.Create(workbinType);
reqWorkbinNotifications.Workbin.WorkbinAgentId = worbinEmpId;
if (!string.IsNullOrEmpty(workbinGroupId))
{
reqWorkbinNotifications.Workbin.WorkbinGroupId = workbinGroupId;
}
if (!string.IsNullOrEmpty(workbinPlaceGroupId))
{
reqWorkbinNotifications.Workbin.WorkbinPlaceGroupId = workbinPlaceGroupId;
}
if (!string.IsNullOrEmpty(WorkbinPlaceId))
{
reqWorkbinNotifications.Workbin.WorkbinPlaceId = WorkbinPlaceId;
}
reqWorkbinNotifications.Reason = ReasonInfo.Create();
reqWorkbinNotifications.ProxyClientId = proxyClientId;
reqWorkbinNotifications.NotifyPropertyChanges = 1;
reqWorkbinNotifications.Extension = keyVC;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(reqWorkbinNotifications);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck _requestWorkbinNotifications = (EventAck)message;
logger.Info("------------Request Workbin Notifications-------------");
logger.Trace(_requestWorkbinNotifications.ToString());
outPutValues.MessageCode = "200";
logger.Trace(_requestWorkbinNotifications.ProxyClientId);
outPutValues.Message = "Request Workbin Notifications Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
logger.Trace(eventError.ToString());
outPutValues.MessageCode = "2001";
outPutValues.Message = "NotifyWorbin() : " + Convert.ToString(eventError.ErrorDescription);
break;
}
}
}
}
catch (Exception error)
{
logger.Error(error.Message.ToString());
outPutValues.MessageCode = "2001";
outPutValues.Message = "NotifyWorbin() : " + error.Message.ToString();
}
return(outPutValues);
}
public string SubmitNewInteraction(int tenantId, int proxyClientId, string queuename, KeyValueCollection userdata)
{
string interactionID = string.Empty;
try
{
RequestSubmit requestSumbit = RequestSubmit.Create();
requestSumbit.TenantId = tenantId;
requestSumbit.ProxyClientId = proxyClientId;
requestSumbit.Queue = queuename;
requestSumbit.InteractionType = "Outbound";
requestSumbit.InteractionSubtype = "OutboundNew";
requestSumbit.MediaType = "email";
requestSumbit.UserData = userdata;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestSumbit);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAck = (EventAck)message;
logger.Info("------------Submit New Email Interaction-------------");
logger.Info("TenantID :" + requestSumbit.TenantId);
logger.Info("ProxyClientId :" + requestSumbit.ProxyClientId);
logger.Info("Queue :" + requestSumbit.Queue);
logger.Info("InteractionType :" + requestSumbit.InteractionType);
logger.Info("InteractionSubtype :" + requestSumbit.InteractionSubtype);
logger.Info("MediaType :" + requestSumbit.MediaType);
logger.Info("UserData :" + requestSumbit.UserData.ToString());
logger.Info("----------------------------------------------");
logger.Trace(eventAck.ToString());
if (eventAck.Extension.ContainsKey("InteractionId"))
{
interactionID = eventAck.Extension["InteractionId"].ToString();
}
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
logger.Info("------------Error on Submitting new Interaction-------------");
logger.Info("TenantID :" + requestSumbit.TenantId);
logger.Info("ProxyClientId :" + requestSumbit.ProxyClientId);
logger.Info("Queue :" + requestSumbit.Queue);
logger.Info("InteractionType :" + requestSumbit.InteractionType);
logger.Info("InteractionSubtype :" + requestSumbit.InteractionSubtype);
logger.Info("MediaType :" + requestSumbit.MediaType);
logger.Info("UserData :" + requestSumbit.UserData.ToString());
logger.Info("----------------------------------------------");
logger.Trace(eventError.ToString());
interactionID = string.Empty;
logger.Error("Error occurred while submittting new interaction : " + Convert.ToString(eventError.ErrorDescription));
break;
}
}
else
{
interactionID = string.Empty;
}
}
else
{
logger.Warn("PlaceInWorkbin() : Interaction Server protocol is Null..");
interactionID = string.Empty;
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while submit the new email interaction" + generalException.ToString());
interactionID = string.Empty;
}
return(interactionID);
}
/// <summary>
/// Rejects the interaction.
/// </summary>
/// <param name="ticketID">The ticket identifier.</param>
/// <param name="interactionID">The interaction identifier.</param>
/// <param name="proxyID">The proxy identifier.</param>
/// <returns></returns>
public OutputValues RejectInteraction(int ticketID, string interactionID, int proxyID, KeyValueCollection data)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
try
{
RequestReject requestReject = RequestReject.Create();
requestReject.TicketId = ticketID;
requestReject.InteractionId = interactionID;
requestReject.ProxyClientId = proxyID;
requestReject.Extension = data;
ReasonInfo reasonInfo = ReasonInfo.Create();
reasonInfo.ReasonDescription = "Agent has reject this interaction";
requestReject.Reason = reasonInfo;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestReject);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventInteractionReject = (EventAck)message;
logger.Info("------------RejectInteraction-------------");
logger.Info("InteractionId :" + interactionID);
logger.Info("ProxyClientId :" + proxyID);
logger.Info("---------------------------------------------");
logger.Trace(eventInteractionReject.ToString());
output.MessageCode = "200";
output.Message = "Reject Interaction Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
string LoginErrorCode = Convert.ToString(eventError.ErrorCode);
string LoginErrorDescription = Convert.ToString(eventError.ErrorDescription);
logger.Trace(eventError.ToString());
output.MessageCode = "2001";
output.Message = "RejectInteraction() : " + LoginErrorDescription;
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Agent Reject Interaction UnSuccessful";
}
}
else
{
logger.Warn("RejectInteraction() : Interaction Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Reject Interaction request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
public OutputValues RequestPlaceQueue(string interactionId, int proxyId, string queueName)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
try
{
RequestPlaceInQueue requestPlaceInQueue = RequestPlaceInQueue.Create();
requestPlaceInQueue.InteractionId = interactionId;
requestPlaceInQueue.Queue = queueName;
requestPlaceInQueue.ProxyClientId = proxyId;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestPlaceInQueue);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAck = (EventAck)message;
logger.Info("------------PlaceInQueue-------------");
logger.Info("InteractionID :" + interactionId);
logger.Info("ProxyID :" + proxyId);
logger.Info("Queue Name :" + queueName);
logger.Info("----------------------------------------------");
logger.Trace(eventAck.ToString());
output.MessageCode = "200";
output.Message = "Place in Queue Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
logger.Info("------------Error on Place In Queue-------------");
logger.Info("InteractionID :" + interactionId);
logger.Info("ProxyID :" + proxyId);
logger.Info("Queue Name :" + queueName);
logger.Info("----------------------------------------------");
logger.Trace(eventError.ToString());
output.MessageCode = "2001";
output.Message = Convert.ToString(eventError.ErrorDescription);
logger.Error("Error occurred while placeinqueue : " + Convert.ToString(eventError.ErrorDescription));
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Place in Queue UnSuccessful";
}
}
else
{
logger.Warn("PlaceInQueue() : Interaction Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Accept the request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Agents the register.
/// </summary>
/// <param name="clientName">Name of the client.</param>
/// <returns></returns>
public OutputValues AgentRegister(string clientName)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
try
{
RequestRegisterClient requestRegisterClient = RequestRegisterClient.Create();
requestRegisterClient.ClientName = clientName;
requestRegisterClient.ClientType = InteractionClient.AgentApplication;
requestRegisterClient.ProxyClientId = 0;
requestRegisterClient.Extension = null;
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.InteractionProtocol.Request(requestRegisterClient);
if (message != null)
{
switch (message.Id)
{
case EventAck.MessageId:
EventAck eventAgentRegister = (EventAck)message;
logger.Info("------------AgentRegister-------------");
logger.Info("ClientName :" + clientName);
logger.Info("--------------------------------------");
logger.Trace(eventAgentRegister.ToString());
output.MessageCode = "200";
output.ProxyID = eventAgentRegister.ProxyClientId;
output.Message = "Agent Register Successful";
break;
case EventError.MessageId:
EventError eventError = (EventError)message;
string LoginErrorCode = Convert.ToString(eventError.ErrorCode);
string LoginErrorDescription = Convert.ToString(eventError.ErrorDescription);
logger.Trace(eventError.ToString());
output.MessageCode = "2001";
output.Message = "AgentRegister() : " + LoginErrorDescription;
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Agent Register UnSuccessful";
}
}
else
{
logger.Warn("AgentRegister() : Interaction Server Protocol is Null..");
}
}
catch (Exception commonException)
{
logger.Error("Error occurred while Register request " + commonException.ToString());
output.MessageCode = "2001";
output.Message = commonException.Message;
}
return(output);
}
/// <summary>
/// Notifies the email interaction.
/// </summary>
/// <param name="message">The message.</param>
public void NotifyEmailInteraction(Genesyslab.Platform.Commons.Protocols.IMessage message)
{
try
{
switch (message.Id)
{
case EventInvite.MessageId:
// Newly Added
// Start
CheckAutoAnswer(message as EventInvite);
// Stop
//Old Code
// Start
// EventInvite eventInvite = message as EventInvite;
//if (ConfigContainer.Instance().AllKeys.Contains("email.enable.auto-answer")
// && ((string)ConfigContainer.Instance().GetValue("email.enable.auto-answer")).ToLower().Equals("true"))
//{
// //EmailNotifier.needPerformAccept = true;
// _taskbarNotifier.eventInvite = eventInvite;
// _taskbarNotifier.ReadContactName();
// _taskbarNotifier.DoEmailAccept();
//}
//else
// ShowEmailNotifier(eventInvite);
// Stop
break;
case EventRevoked.MessageId:
EventRevoked eventRevoked = message as EventRevoked;
if (_taskbarNotifier != null)
{
_taskbarNotifier.BindInfo(eventRevoked);
}
break;
case EventAck.MessageId:
EventAck eventAck = message as EventAck;
break;
case EventPulledInteractions.MessageId:
EventPulledInteractions puledIteraction = message as EventPulledInteractions;
if (puledIteraction.Interactions != null && puledIteraction.Interactions.Count > 0)
{
string[] keys = puledIteraction.Interactions.AllKeys;
var _interactionID = keys[0];
if (_interactionID != null)
{
EmailMainWindow mailWindow = new EmailMainWindow(puledIteraction);
mailWindow.Show();
}
}
break;
}
}
catch (Exception exception)
{
logger.Error("NotifyEmailInteraction" + exception.ToString());
}
}
