/// <summary>
/// Changes the properties.
/// </summary>
/// <param name="interactionId">The interaction identifier.</param>
/// <param name="proxyId">The proxy identifier.</param>
/// <param name="dispositionNotes">The disposition notes.</param>
/// <returns></returns>
public OutputValues ChangeProperties(string interactionId, int proxyId, KeyValueCollection addedProperties, KeyValueCollection changedProperties)
{
OutputValues output = OutputValues.GetInstance();
output.Message = string.Empty;
output.MessageCode = string.Empty;
output.ErrorCode = 0;
RequestChangeProperties requestChangeProperties = RequestChangeProperties.Create();
try
{
requestChangeProperties.InteractionId = interactionId;
requestChangeProperties.ProxyClientId = proxyId;
if (changedProperties != null)
{
requestChangeProperties.ChangedProperties = changedProperties;
}
if (addedProperties != null)
{
requestChangeProperties.AddedProperties = addedProperties;
}
if (Settings.InteractionProtocol != null && Settings.InteractionProtocol.State == ChannelState.Opened)
{
IMessage response = Settings.InteractionProtocol.Request(requestChangeProperties);
if (response.Id == EventPropertiesChanged.MessageId || response.Id == EventAck.MessageId)
{
logger.Info("------------RequestChangeProperties-------------");
logger.Info("InteractionId :" + interactionId);
logger.Info("ProxyClientId :" + proxyId);
logger.Info(" RequestChangeProperties : response :" + response.ToString());
logger.Info("-------------------------------------------------");
logger.Trace(response.ToString());
output.MessageCode = "200";
output.Message = "Change Properties Successful";
}
else
{
output.MessageCode = "2001";
output.Message = "Don't Change Properties Successful";
}
}
else
{
logger.Warn("ChangeProperties() : Interaction Server Protocol is Null..");
}
}
catch (ProtocolException protocolException)
{
logger.Error("Error occurred while change properties request " + protocolException.ToString());
output.MessageCode = "2001";
output.Message = protocolException.Message;
}
catch (Exception generalException)
{
logger.Error("Error occurred while change properties request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Saves the initialize parameters.
/// </summary>
/// <param name="Filepath">The file path.</param>
/// <param name="FileName">Name of the file.</param>
/// <param name="dicHoldingDetails">The dictionary holding details.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
#region SaveInitializeParameters
public bool SaveInitializeParameters(Dictionary <string, string> dicHoldingDetails, iCallData value)
{
bool isSaved = false;
try
{
string folder = "";
if (value.FileData.DirectoryPath != string.Empty)
{
folder = Path.Combine(value.FileData.DirectoryPath, "");
}
else
{
logger.Warn("SaveInitializeParameters File path is not specified");
folder = Path.Combine(Environment.CurrentDirectory.ToString(), "");
}
try
{
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
string file = "";
if (value.FileData.FileName != string.Empty)
{
file = Path.Combine(folder, value.FileData.FileName);
}
else
{
logger.Warn("SaveInitializeParameters File Name is not specified");
file = Path.Combine(folder, "calldata_vd");
}
writeUserDetails = new XmlTextWriter(file + ".txt", Encoding.Default);
}
catch (Exception fileException)
{
logger.Error("Error occurred while writing data in Text file" + fileException.ToString());
}
IDictionaryEnumerator Enumerator = dicHoldingDetails.GetEnumerator();
while (Enumerator.MoveNext())
{
writeUserDetails.WriteElementString(Enumerator.Key.ToString(), Enumerator.Value.ToString());
}
writeUserDetails.Close();
writeUserDetails = null;
}
catch (Exception generalException)
{
logger.Error("Error occurred " + generalException.ToString());
}
return(isSaved);
}
/// <summary>
/// Releases the force party chat session.
/// </summary>
/// <param name="sessionID">The session identifier.</param>
/// <param name="proxyID">The proxy identifier.</param>
/// <param name="userId">The user identifier.</param>
/// <param name="chatClosingProtocol">The chat closing protocol.</param>
/// <returns></returns>
public static Pointel.Interactions.Chat.Core.General.OutputValues ReleaseForcePartyChatSession(string sessionID, int proxyID, string userId, string messageText)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
Pointel.Interactions.Chat.Core.General.OutputValues output = Pointel.Interactions.Chat.Core.General.OutputValues.GetInstance();
try
{
Genesyslab.Platform.WebMedia.Protocols.BasicChat.MessageText newMessageText = Genesyslab.Platform.WebMedia.Protocols.BasicChat.MessageText.Create();
newMessageText.Text = messageText;
Genesyslab.Platform.WebMedia.Protocols.BasicChat.Requests.RequestReleaseParty requestReleaseParty = Genesyslab.Platform.WebMedia.Protocols.BasicChat.Requests.RequestReleaseParty.Create(sessionID, userId, Genesyslab.Platform.WebMedia.Protocols.BasicChat.Action.ForceClose,
newMessageText);
if (Pointel.Interactions.Chat.Core.Util.Settings.ChatProtocol != null && Pointel.Interactions.Chat.Core.Util.Settings.ChatProtocol.State == Genesyslab.Platform.Commons.Protocols.ChannelState.Opened)
{
Pointel.Interactions.Chat.Core.Util.Settings.ChatProtocol.Send(requestReleaseParty);
logger.Info("------------ReleaseForcePartyChatSession-------------");
logger.Info("SessionID :" + sessionID);
logger.Info("ProxyID :" + proxyID);
logger.Info("UserID :" + userId);
logger.Info("-----------------------------------------------------");
logger.Info(requestReleaseParty.ToString());
output.MessageCode = "200";
output.Message = "Release Force Party ChatSession Successful";
}
else
{
logger.Warn("ReleaseForcePartyChatSession() : Chat Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Release Party Chat Session request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Handles the Click event of the Right control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
private void Right_Click(object sender, RoutedEventArgs e)
{
Button tempbtn = sender as Button;
if (tempbtn.Content.ToString().Contains("Reject"))
{
string a = _dataContext.DialedNumbers;
if (!string.IsNullOrEmpty(_dataContext.ThridpartyDN))
{
if (_dataContext.ThisDN == _dataContext.ThridpartyDN)
{
logger.Warn("Redirect DN and This DN are same.");
}
else
{
SoftPhone softRedirect = new SoftPhone();
softRedirect.Redirect(_dataContext.ThridpartyDN);
}
}
_dataContext.CallTypeStatus = string.Empty;
}
else if (tempbtn.Content.ToString().Contains("Accept"))
{
SoftPhone softAnswer = new SoftPhone();
softAnswer.Answer();
}
base.stayOpenTimer.Stop();
base.DisplayState = Pointel.TaskbarNotifier.TaskbarNotifier.DisplayStates.Hiding;
}
public static IMessage RequestUpdateInteraction(InteractionContent interactionContent, InteractionAttributes interactionAttributes, BaseEntityAttributes baseEntityAttributes)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
IMessage iMessage = null;
RequestUpdateInteraction updateInteraction = new RequestUpdateInteraction();
if (interactionContent != null)
{
updateInteraction.InteractionContent = interactionContent;
}
if (interactionAttributes != null)
{
updateInteraction.InteractionAttributes = interactionAttributes;
}
if (baseEntityAttributes != null)
{
updateInteraction.EntityAttributes = baseEntityAttributes;
}
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("------------RequestUpdateInteraction-------------");
logger.Info("Interaction Attributes : " + (updateInteraction.InteractionAttributes != null ? "null" : updateInteraction.InteractionAttributes.ToString()));
logger.Info("Entity Attributes : " + (updateInteraction.InteractionAttributes != null ? "null" : updateInteraction.EntityAttributes.ToString()));
logger.Info("---------------------------------------------------");
iMessage = Settings.UCSProtocol.Request(updateInteraction);
updateInteraction = null;
logger.Trace("Response : " + (iMessage != null ? "null" : iMessage.ToString()));
}
else
{
logger.Warn("Error occurred as : Universal Contact Server protocol is Null or Closed");
}
return(iMessage);
}
/// <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>
/// Joins the consult chat session.
/// </summary>
/// <param name="sessionID">The session unique identifier.</param>
/// <param name="subject">The subject.</param>
/// <param name="message">The message.</param>
/// <param name="userData">The user data.</param>
/// <returns></returns>
public static Pointel.Interactions.Chat.Core.General.OutputValues JoinConsultChatSession(string sessionID, string subject, string message, Genesyslab.Platform.Commons.Collections.KeyValueCollection userData)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
Pointel.Interactions.Chat.Core.General.OutputValues output = Pointel.Interactions.Chat.Core.General.OutputValues.GetInstance();
try
{
Genesyslab.Platform.WebMedia.Protocols.BasicChat.Requests.RequestJoin requestJoinChat = Genesyslab.Platform.WebMedia.Protocols.BasicChat.Requests.RequestJoin.Create();
Genesyslab.Platform.WebMedia.Protocols.BasicChat.MessageText newMessageText = Genesyslab.Platform.WebMedia.Protocols.BasicChat.MessageText.Create();
newMessageText.Text = message;
requestJoinChat.MessageText = newMessageText;
requestJoinChat.SessionId = sessionID;
requestJoinChat.UserData = userData;
requestJoinChat.Visibility = Genesyslab.Platform.WebMedia.Protocols.BasicChat.Visibility.Int;
requestJoinChat.Subject = subject;
if (Pointel.Interactions.Chat.Core.Util.Settings.ChatProtocol != null && Pointel.Interactions.Chat.Core.Util.Settings.ChatProtocol.State == Genesyslab.Platform.Commons.Protocols.ChannelState.Opened)
{
Genesyslab.Platform.Commons.Protocols.IMessage iMessage = Pointel.Interactions.Chat.Core.Util.Settings.ChatProtocol.Request(requestJoinChat);
if (iMessage != null)
{
logger.Info("------------JoinConsultChatSession-------------");
logger.Info("SessionID :" + sessionID);
logger.Info("subject :" + subject);
logger.Info("MessageText:" + message);
logger.Info("----------------------------------------");
logger.Trace(iMessage.ToString());
output.RequestJoinIMessage = iMessage;
output.MessageCode = "200";
output.Message = "Join Consult Chat Session Successful";
}
else
{
logger.Warn("JoinConsultChatSession() : IMessage is Null..");
}
}
else
{
logger.Warn("JoinConsultChatSession() : Interaction Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Join the consult chat session request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Leaves the interaction from conference.
/// </summary>
/// <param name="interactionID">The interaction identifier.</param>
/// <param name="proxyID">The proxy identifier.</param>
/// <param name="agentID">The agent identifier.</param>
/// <param name="_chatClosingProtocol">The _chat closing protocol.</param>
/// <returns></returns>
public static Pointel.Interactions.Chat.Core.General.OutputValues LeaveInteractionFromConference(string interactionID, int proxyID, string agentID)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
Pointel.Interactions.Chat.Core.General.OutputValues output = Pointel.Interactions.Chat.Core.General.OutputValues.GetInstance();
try
{
Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestLeaveInteraction requestLeaveInteraction = Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestLeaveInteraction.Create();
requestLeaveInteraction.InteractionId = interactionID;
requestLeaveInteraction.ProxyClientId = proxyID;
requestLeaveInteraction.Reason = null;
//ReasonInfo reasonInfo = ReasonInfo.Create();
//reasonInfo.ReasonDescription = agentID.ToString() + " Leaving from the Conference";
//requestLeaveInteraction.Reason = reasonInfo;
requestLeaveInteraction.Extension = null;
if (Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol != null && Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.State == Genesyslab.Platform.Commons.Protocols.ChannelState.Opened)
{
Genesyslab.Platform.Commons.Protocols.IMessage response = Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.Request(requestLeaveInteraction);
if (response != null)
{
switch (response.Id)
{
case Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventAck.MessageId:
logger.Info("------------LeaveInteractionFromConference-------------");
logger.Info("InteractionId :" + interactionID);
logger.Info("ProxyClientId :" + proxyID);
logger.Info("AgentId :" + agentID);
logger.Info("-------------------------------------------------------");
logger.Trace(response.ToString());
output.MessageCode = "200";
output.Message = "Leave Interaction From Conference Successful";
break;
case Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventError.MessageId:
logger.Trace(response.ToString());
output.MessageCode = "2001";
output.Message = "Don't Leave Interaction From Conference Successful";
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Don't Leave Interaction From Conference Successful";
}
}
else
{
logger.Warn("LeaveInteractionFromConference() : Interaction Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Leave Interaction From Conference request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
public static Pointel.Interactions.Chat.Core.General.OutputValues ResumeInteraction(int proxyID, string sessionID, KeyValueCollection extensions, ReasonInfo reason)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
Pointel.Interactions.Chat.Core.General.OutputValues output = Pointel.Interactions.Chat.Core.General.OutputValues.GetInstance();
try
{
Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestResume requestResume = Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestResume.Create();
requestResume.InteractionId = sessionID;
requestResume.ProxyClientId = proxyID;
requestResume.Extension = extensions;
requestResume.Reason = reason;
if (Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol != null && Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.State == Genesyslab.Platform.Commons.Protocols.ChannelState.Opened)
{
Genesyslab.Platform.Commons.Protocols.IMessage message = Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.Request(requestResume);
if (message != null)
{
switch (message.Id)
{
case Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventAck.MessageId:
logger.Info("------------RequestResume-------------");
logger.Info("SessionID :" + sessionID);
logger.Info("ProxyID :" + proxyID);
logger.Info("--------------------------------------");
logger.Info(requestResume.ToString());
output.MessageCode = "200";
output.Message = "Interaction Resume Successful.";
break;
case Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventError.MessageId:
Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventError eventError = (Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventError)message;
string LoginErrorCode = Convert.ToString(eventError.ErrorCode);
string LoginErrorDescription = Convert.ToString(eventError.ErrorDescription);
logger.Trace(eventError.ToString());
output.MessageCode = "2001";
output.Message = "ResumeInteraction() : " + LoginErrorDescription;
break;
}
}
else
{
output.MessageCode = "2001";
output.Message = "Chat Media Resume Interaction UnSuccessful";
}
}
else
{
logger.Warn("ResumeInteraction() : IXN Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Resume Interaction request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Gets the contact list.
/// </summary>
/// <param name="tenantId">The tenant identifier.</param>
/// <returns></returns>
public static OutputValues GetContactList(int tenantId, List <string> attributeNames, int startIndex)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
try
{
RequestGetContacts requestGetContacts = new RequestGetContacts();
requestGetContacts.IndexOfFirst = startIndex;
StringList stringList = new StringList();
for (int count = 0; count < attributeNames.Count; count++)
{
stringList.Add(attributeNames[count].ToString());
}
//stringList.Add("EmailAddress");
//stringList.Add("FirstName");
//stringList.Add("LastName");
requestGetContacts.AttributeList = stringList;
requestGetContacts.TenantId = tenantId;
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("------------GetContacts-------------");
logger.Info("TenantId :" + tenantId);
logger.Info("AttributeList: " + stringList);
logger.Info("-------------------------------------");
IMessage message = Settings.UCSProtocol.Request(requestGetContacts);
if (message != null)
{
logger.Trace(message.ToString());
output.IContactMessage = message;
output.MessageCode = "200";
output.Message = "Get Contacts Successful";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Don't Get Contacts Successful";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("GetContactList() : Universal Contact Server Protocol is Null");
}
}
catch (Exception generalException)
{
logger.Error("Error Occurred while Get Contacts request" + generalException.ToString());
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Changes the properties.
/// </summary>
/// <param name="interactionId">The interaction identifier.</param>
/// <param name="proxyId">The proxy identifier.</param>
/// <param name="dispositionNotes">The disposition notes.</param>
/// <returns></returns>
public static Pointel.Interactions.Chat.Core.General.OutputValues ChangeProperties(string interactionId, int proxyId, Genesyslab.Platform.Commons.Collections.KeyValueCollection addedProperties, Genesyslab.Platform.Commons.Collections.KeyValueCollection changedProperties)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
Pointel.Interactions.Chat.Core.General.OutputValues output = Pointel.Interactions.Chat.Core.General.OutputValues.GetInstance();
Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestChangeProperties requestChangeProperties = Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestChangeProperties.Create();
try
{
requestChangeProperties.InteractionId = interactionId;
requestChangeProperties.ProxyClientId = proxyId;
if (changedProperties != null)
{
requestChangeProperties.ChangedProperties = changedProperties;
}
if (addedProperties != null)
{
requestChangeProperties.AddedProperties = addedProperties;
}
if (Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol != null && Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.State == Genesyslab.Platform.Commons.Protocols.ChannelState.Opened)
{
Genesyslab.Platform.Commons.Protocols.IMessage response = Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.Request(requestChangeProperties);
if (response.Id == Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventPropertiesChanged.MessageId || response.Id == Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventAck.MessageId)
{
logger.Info("------------RequestChangeProperties-------------");
logger.Info("InteractionId :" + interactionId);
logger.Info("ProxyClientId :" + proxyId);
logger.Info(" RequestChangeProperties : response :" + response.ToString());
logger.Info("-------------------------------------------------");
logger.Trace(response.ToString());
output.MessageCode = "200";
output.Message = "Change Properties Successful";
}
else
{
output.MessageCode = "2001";
output.Message = "Don't Change Properties Successful";
}
}
else
{
logger.Warn("ChangeProperties() : Interaction Server Protocol is Null..");
}
}
catch (Genesyslab.Platform.Commons.Protocols.ProtocolException protocolException)
{
logger.Error("Error occurred while change properties request " + protocolException.ToString());
output.MessageCode = "2001";
output.Message = protocolException.Message;
}
catch (Exception generalException)
{
logger.Error("Error occurred while change properties request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Adds the agent favorite response.
/// </summary>
/// <param name="stdResponse">The standard response.</param>
/// <param name="agentId">The agent identifier.</param>
/// <returns></returns>
public static OutputValues AddAgentFavoriteResponse(string stdResponse, string agentId)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
try
{
RequestAddAgentStdRespFavorite requestAddAgentStdRespFavorite = new RequestAddAgentStdRespFavorite();
requestAddAgentStdRespFavorite.StandardResponse = stdResponse;
// requestAddFavouriteResponse.Name = stdName;
// string strAgentID = "1001";
int? agentid = int.Parse(agentId.ToString());
requestAddAgentStdRespFavorite.AgentId = agentid;
// requestAddFavouriteResponse.Name = stdResponse;
// requestAddFavouriteResponse.Name = name;
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("------------AddAgentFavoriteResponse-------------");
logger.Info("StandardResponse :" + stdResponse);
logger.Info("AgentId :" + agentId);
logger.Info("-------------------------------------------------");
IMessage response = Settings.UCSProtocol.Request(requestAddAgentStdRespFavorite);
if (response != null)
{
logger.Trace(response.ToString());
output.IContactMessage = response;
output.MessageCode = "200";
output.Message = "Add Agent Standard Response Favorite Successful";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Don't Add Agent Standard Response Favorite.";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("AddAgentFavoriteResponse() : Universal Contact Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Add Agent Standard Response Favorite request " + generalException.ToString());
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return output;
}
private void DGAttachData_KeyUp(object sender, KeyEventArgs e)
{
if (e.Key == Key.C && Keyboard.Modifiers == ModifierKeys.Control)
{
try
{
if (DGAttachData.SelectedCells != null && DGAttachData.SelectedCells[0].Item != null)
{
var data = (DGAttachData.SelectedCells[0].Item as CallData).Value;
data = Uri.UnescapeDataString(data);
Clipboard.Clear();
Clipboard.SetText(data);
return;
}
_logger.Warn("warning clipboard data not updated.");
}
catch (Exception ex)
{
_logger.Warn("Warning occurred while copying data as " + ex.Message);
}
}
}
internal static bool AuthenticateUser(string userName, string password)
{
bool output = false;
try
{
RequestAuthenticate requestAuthenticate = RequestAuthenticate.Create(userName, password);
IMessage response = _configContainer.ConfServiceObject.Protocol.Request(requestAuthenticate);
if (response != null)
{
switch (response.Id)
{
case EventAuthenticated.MessageId:
{
output = true;
_logger.Info("User " + userName + " Authenticated ");
break;
}
case EventError.MessageId:
{
EventError eventError = (EventError)response;
if (eventError.Description != null)
{
_logger.Warn("User " + userName + " is not Authenticated " + eventError.Description);
}
output = false;
_logger.Warn("User " + userName + " is not Authenticated ");
break;
}
}
}
}
catch (Exception commonException)
{
_logger.Error("Error occurred while authenticating user " + userName + " " + commonException.ToString());
}
return(output);
}
/// <summary>
/// Gets the interactions count.
/// </summary>
/// <param name="mediaType">Type of the media.</param>
/// <returns></returns>
public static OutputValues GetInteractionsCount(string mediaType)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
try
{
RequestGetInteractionsWithStatus requestGetInteractionsWithStatus = new RequestGetInteractionsWithStatus();
requestGetInteractionsWithStatus.MediaType = mediaType;
requestGetInteractionsWithStatus.InteractionType = "Inbound";
requestGetInteractionsWithStatus.InteractionSubtype = "InboundNew";
requestGetInteractionsWithStatus.Status = new Genesyslab.Platform.Contacts.Protocols.ContactServer.NullableStatuses(Statuses.InProcess);
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("--------GetInteractionsCount---------");
logger.Info("MediaType :" + mediaType);
logger.Info("-------------------------------------");
IMessage response = Settings.UCSProtocol.Request(requestGetInteractionsWithStatus);
if (response != null)
{
logger.Trace(response.ToString());
output.IContactMessage = response;
output.MessageCode = "200";
output.Message = "Get Interaction Count Successful";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Don't Get Interaction Count Successful";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("GetInteractionsCount() : Universal Contact Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error Occurred while Get Interaction Count request" + generalException.ToString());
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
IDesktopMessenger GetThirdParty()
{
var file = Path.Combine(Path.Combine(System.Windows.Forms.Application.StartupPath, "Plugins"), "Pointel.Integration.Core.dll");
if (File.Exists(file))
{
Assembly asm = Assembly.LoadFile(file);
return((IDesktopMessenger)(from asmType in asm.GetTypes() where asmType.GetInterface("IDesktopMessenger") != null select(IDesktopMessenger) Activator.CreateInstance(asmType)).FirstOrDefault());
}
else
{
_logger.Warn("Integration.Core Plug-in dll not exist");
}
return(null);
}
/// <summary>
/// Removes the attach document.
/// </summary>
/// <param name="interactionId">The interaction identifier.</param>
/// <param name="documentId">The document identifier.</param>
/// <returns></returns>
public static OutputValues RemoveAttachDocument(string interactionId, string documentId)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
try
{
RequestRemoveDocument requestRemoveDocument = new RequestRemoveDocument();
requestRemoveDocument.InteractionId = interactionId;
requestRemoveDocument.DocumentId = documentId;
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("--------RemoveAttachDocument------------");
logger.Info("InteractionId :" + interactionId);
logger.Info("DocumentId :" + documentId);
logger.Info("----------------------------------------");
IMessage response = Settings.UCSProtocol.Request(requestRemoveDocument);
if (response != null)
{
logger.Trace(response.ToString());
output.IContactMessage = response;
output.MessageCode = "200";
output.Message = "Remove Attach Document Successful";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Don't Remove Attach Document Successful";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("RemoveAttachDocument() : Universal Contact Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error Occurred while Remove Attach Document request" + generalException.ToString());
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Deletes the case information.
/// </summary>
/// <param name="interactionid">The interactionid.</param>
/// <param name="keyvalues">The keyvalues.</param>
/// <returns></returns>
public static Pointel.Interactions.Chat.Core.General.OutputValues DeleteCaseInformation(string interactionId, int proxyClientID, Genesyslab.Platform.Commons.Collections.KeyValueCollection keyvalues)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
Pointel.Interactions.Chat.Core.General.OutputValues output = Pointel.Interactions.Chat.Core.General.OutputValues.GetInstance();
try
{
Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestChangeProperties deletedProperties = Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestChangeProperties.Create();
deletedProperties.InteractionId = interactionId;
deletedProperties.ProxyClientId = proxyClientID;
if (keyvalues != null)
{
deletedProperties.DeletedProperties = keyvalues;
}
if (Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol != null && Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.State == Genesyslab.Platform.Commons.Protocols.ChannelState.Opened)
{
Genesyslab.Platform.Commons.Protocols.IMessage response = Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.Request(deletedProperties);
if (response.Id == Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventPropertiesChanged.MessageId || response.Id == Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Events.EventAck.MessageId)
{
logger.Info("------------DeleteCaseInformation-------------");
logger.Info("InteractionId :" + interactionId);
logger.Info("ProxyClientId :" + proxyClientID);
logger.Info("KVC : " + keyvalues.ToString());
logger.Info("AddCaseInformation : response :" + response.ToString());
logger.Info("---------------------------------------------");
logger.Trace(response.ToString());
output.MessageCode = "200";
output.Message = "Delete Case Information Successful";
}
else
{
logger.Trace(response.ToString());
output.MessageCode = "2001";
output.Message = "Add Properties UnSuccessful";
}
}
else
{
logger.Warn("AddCaseInformation() : Interaction Server Protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while doing Add Case Information:" + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Gets the content of the response.
/// </summary>
/// <param name="tenantID">The tenant unique identifier.</param>
/// <returns></returns>
public static OutputValues GetResponseContent(int tenantID)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
try
{
logger.Debug("Getting the AllAttributes from the UCS server");
RequestGetAllCategories getAllCategories = new RequestGetAllCategories();
getAllCategories.TenantId = tenantID;
getAllCategories.Language = "English";
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("--------GetResponseContent---------");
logger.Info("TenantId :" + tenantID);
logger.Info("-----------------------------------");
IMessage response = Settings.UCSProtocol.Request(getAllCategories);
if (response != null)
{
logger.Trace(response.ToString());
output.IContactMessage = response;
output.MessageCode = "200";
output.Message = "Get All Response Content Successful";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Don't Get All Response Content Successful";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("GetResponseContent() : Universal Contact Server protocol is Null..");
}
}
catch (Exception ex)
{
output.IContactMessage = null;
output.Message = "Error occurred while get all standard response ";
output.MessageCode = "2001";
logger.Error("GetResponseContent()" + ex.ToString());
}
return(output);
}
public static OutputValues IdentifyContact(string mediaType, int tenantId, KeyValueCollection userData)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
try
{
RequestIdentifyContact requestIdentifyContact = RequestIdentifyContact.Create();
requestIdentifyContact.TenantId = tenantId;
requestIdentifyContact.MediaType = mediaType;
requestIdentifyContact.CreateContact = true;
requestIdentifyContact.OtherFields = userData;
logger.Info("------------RequestIdentifyContact-------------");
logger.Info(requestIdentifyContact.ToString());
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
IMessage message = Settings.UCSProtocol.Request(requestIdentifyContact);
if (message != null)
{
logger.Trace(message.ToString());
output.IContactMessage = message;
output.MessageCode = "200";
output.Message = "Identify Contact Successfully";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Don't Identify Contact Successfully";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("RequestToIdentifyContact() : Contact Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Request To Identify Contact " + generalException.ToString());
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
public static OutputValues RequestInsertContact(int tenantId, AttributesList attribute)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
try
{
RequestInsert reqInsertContact = new RequestInsert();
reqInsertContact.TenantId = tenantId;
reqInsertContact.Attributes = attribute;
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("------------RequestInsertContact-------------");
logger.Info("Tenant ID : " + tenantId);
logger.Info("---------------------------------------------------");
IMessage message = Settings.UCSProtocol.Request(reqInsertContact);
if (message != null)
{
logger.Trace(message.ToString());
output.IContactMessage = message;
output.MessageCode = "200";
output.Message = "Contact Inserted Successfully";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Can't Insert Contact Successfully";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("RequestDeleteContact() : Contact Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Insert Contact " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Gets the standard response.
/// </summary>
/// <param name="standardresponseId">The standard response identifier.</param>
/// <returns></returns>
public static OutputValues GetStandardResponse(string standardresponseId)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
try
{
RequestGetStandardResponse requestGetStandardResponse = new RequestGetStandardResponse();
requestGetStandardResponse.StandardResponseId = standardresponseId;
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("--------GetStandardResponse------------");
logger.Info("StandardResponseId :" + standardresponseId);
logger.Info("---------------------------------------");
IMessage message = Settings.UCSProtocol.Request(requestGetStandardResponse);
if (message != null)
{
logger.Trace(message.ToString());
output.IContactMessage = message;
output.MessageCode = "200";
output.Message = "Get Standard Response Successful";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Don't Get Standard Response Successful";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("GetStandardResponse() : Universal Contact Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error Occurred while Get Standard Response request" + generalException.ToString());
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Deletes the interaction from ucs.
/// </summary>
/// <param name="interactionID">The interaction unique identifier.</param>
/// <returns></returns>
public static OutputValues DeleteInteractionFromUCS(string interactionID)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
OutputValues output = OutputValues.GetInstance();
try
{
RequestDeleteInteraction requestDeleteInteraction = new RequestDeleteInteraction();
requestDeleteInteraction.InteractionId = interactionID;
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("--------DeleteInteractionFromUCS------------");
logger.Info("InteractionId :" + interactionID);
logger.Info("--------------------------------------------");
IMessage response = Settings.UCSProtocol.Request(requestDeleteInteraction);
if (response != null)
{
logger.Trace(response.ToString());
output.IContactMessage = response;
output.MessageCode = "200";
output.Message = "Delete Interaction from UCS Successful";
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Delete Interaction from UCS UnSuccessful";
}
}
else
{
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = "Universal Contact Server protocol is Null or Closed";
logger.Warn("DeleteInteractionFromUCS() : Universal Contact Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error Occurred while Delete Interaction from UCS" + generalException.ToString());
output.IContactMessage = null;
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Creates the XML file.
/// </summary>
public void CreateXMLFile()
{
try
{
if (!Directory.Exists(Path.GetDirectoryName(Datacontext.GetInstance().CorporateFavoriteFile)))
{
Directory.CreateDirectory(Path.GetDirectoryName(Datacontext.GetInstance().CorporateFavoriteFile));
}
if (!File.Exists(Datacontext.GetInstance().CorporateFavoriteFile))
{
_logger.Warn("Corporate Favorite File Not Found");
XDocument config = new XDocument(
new XDeclaration("1.0", "utf-8", ""),
new XElement("UserFavorites"));
config.Save(@Datacontext.GetInstance().CorporateFavoriteFile);
}
}
catch (Exception ex)
{
_logger.Error("Error in creating favorite XMLFile : " + ex.Message.ToString());
}
}
/// <summary>
/// Sends the type start notification.
/// </summary>
/// <param name="sessionID">The session unique identifier.</param>
/// <param name="noticeText">The notice text.</param>
/// <param name="chatProtocol">The chat protocol.</param>
/// <returns></returns>
public static Pointel.Interactions.Chat.Core.General.OutputValues SendTypeStartNotification(string sessionID, string noticeText)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
Pointel.Interactions.Chat.Core.General.OutputValues output = Pointel.Interactions.Chat.Core.General.OutputValues.GetInstance();
try
{
Genesyslab.Platform.WebMedia.Protocols.BasicChat.Requests.RequestNotify requestNotify = Genesyslab.Platform.WebMedia.Protocols.BasicChat.Requests.RequestNotify.Create();
requestNotify.SessionId = sessionID;
Genesyslab.Platform.WebMedia.Protocols.BasicChat.NoticeText newNoticeText = Genesyslab.Platform.WebMedia.Protocols.BasicChat.NoticeText.Create();
newNoticeText.NoticeType = Genesyslab.Platform.WebMedia.Protocols.NoticeType.TypingStarted;
newNoticeText.Text = noticeText;
requestNotify.NoticeText = newNoticeText;
requestNotify.Visibility = Genesyslab.Platform.WebMedia.Protocols.BasicChat.Visibility.All;
if (Pointel.Interactions.Chat.Core.Util.Settings.ChatProtocol != null && Pointel.Interactions.Chat.Core.Util.Settings.ChatProtocol.State == Genesyslab.Platform.Commons.Protocols.ChannelState.Opened)
{
Pointel.Interactions.Chat.Core.Util.Settings.ChatProtocol.Send(requestNotify);
logger.Info("------------Send Type Start Notification-------------");
logger.Info("SessionID :" + sessionID);
logger.Info("NoticeText :" + noticeText);
logger.Info("----------------------------------------");
logger.Info(requestNotify.ToString());
output.MessageCode = "200";
output.Message = "Send Type Start Notification Successful";
}
else
{
logger.Warn("SendTypeStartNotification() : Basic Chat Protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Send Type Start Notification request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Stops the interaction process.
/// </summary>
/// <param name="stopInteractionId">The stop interaction identifier.</param>
/// <param name="proxyId">The proxy identifier.</param>
/// <returns></returns>
public static Pointel.Interactions.Chat.Core.General.OutputValues StopInteractionProcess(string stopInteractionId, int proxyId)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
Pointel.Interactions.Chat.Core.General.OutputValues output = Pointel.Interactions.Chat.Core.General.OutputValues.GetInstance();
try
{
Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestStopProcessing requestStopProcessing = Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.Requests.InteractionManagement.RequestStopProcessing.Create();
requestStopProcessing.InteractionId = stopInteractionId;
requestStopProcessing.ProxyClientId = proxyId;
Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.ReasonInfo reasonInfo = Genesyslab.Platform.OpenMedia.Protocols.InteractionServer.ReasonInfo.Create();
reasonInfo.ReasonSystemName = "Stop Processing Reason Normal";
reasonInfo.ReasonDescription = "Normal";
requestStopProcessing.Reason = reasonInfo;
logger.Info("Trying to Stop the interaction :" + stopInteractionId);
if (Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol != null && Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.State == Genesyslab.Platform.Commons.Protocols.ChannelState.Opened)
{
Pointel.Interactions.Chat.Core.Util.Settings.IxnServerProtocol.Send(requestStopProcessing);
logger.Info("------------StopChatSession-------------");
logger.Info("InteractionId :" + stopInteractionId);
logger.Info("ProxyClientId :" + proxyId);
logger.Info("------------------------------------------------");
output.MessageCode = "200";
output.Message = "Stop Chat Session Successful";
}
else
{
logger.Warn("StopInteractionProcess() : Interaction Server protocol is Null..");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while Stop Chat Interaction request " + generalException.ToString());
output.MessageCode = "2001";
output.Message = generalException.Message;
}
return(output);
}
/// <summary>
/// Gets the recent interaction list.
/// </summary>
/// <param name="universalContactServerProtocol">The universal contact server protocol.</param>
/// <param name="mediaType">Type of the media.</param>
/// <param name="interactionID">The interaction unique identifier.</param>
/// <returns></returns>
public static IMessage GetInteractionContent(string interactionID, bool isAttachments)
{
Pointel.Logger.Core.ILog logger = Pointel.Logger.Core.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType, "AID");
IMessage message = null;
try
{
RequestGetInteractionContent requestGetInteractionContent = RequestGetInteractionContent.Create();
requestGetInteractionContent.InteractionId = interactionID;
requestGetInteractionContent.IncludeAttachments = isAttachments;
if (Settings.UCSProtocol != null && Settings.UCSProtocol.State == ChannelState.Opened)
{
logger.Info("------------RequestToGetInteractionContent-------------");
logger.Info("InteractionId :" + interactionID);
logger.Info("-------------------------------------------------------");
message = Settings.UCSProtocol.Request(requestGetInteractionContent);
if (message != null)
{
logger.Trace(message.ToString());
}
else
{
logger.Trace("null response from RequestGetInteractionContent");
}
}
else
{
logger.Warn("Universal Contact Server protocol is Null or Closed");
}
}
catch (Exception generalException)
{
logger.Error("Error occurred while sending Request Get Interaction Content as : " + generalException.ToString());
}
return(message);
}
/// <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);
}
public void OnNext(iCallData value)
{
Thread objThread = new Thread(() =>
{
//if (DesktopMessenger.communicateUI != null)
// DesktopMessenger.communicateUI.NotifyMIDState(_himmsConfiguration.IsEnablePopupButton);
// DesktopMessenger.communicateUI.NotifyMIDState(false);
if (value == null)
{
_logger.Warn("The event data is nul.");
return;
}
if (value.MediaType != _himmsConfiguration.MediaType)
{
_logger.Info("The media type is not matching to HIMMS integration");
return;
}
if (!_himmsConfiguration.PopupEvent.Contains(value.EventMessage.Name.ToLower()))
{
return;
}
if (value.MediaType == MediaType.Voice)
{
//DesktopMessenger.communicateUI.NotifyMIDState(false,0);
HandleVoice(value);
}
else if (value.MediaType == MediaType.Email)
{
}
else if (value.MediaType == MediaType.Chat)
{
}
});
objThread.Start();
}
public bool ConnectStatServer(string primaryHostName, string primaryPort, string secondaryHostName, string secondaryPort, int addpServerTimeOut, int addpClientTimeOut,
int warmStandbyTimeout, short warmStandbyAttempts)
{
//StatServerConfiguration _statServerConfiguration = new StatServerConfiguration(Datacontext.GetInstance().StatServerName);
//if (Datacontext.GetInstance().ProtocolManager != null)
// Datacontext.GetInstance().ProtocolManager = null;
//EventBrokerService _eventBrokerService = null;
try
{
//_statServerConfiguration.Uri = new System.Uri("tcp://" + primaryHostName + ":" + primaryPort);
//_statServerConfiguration.ClientName = Datacontext.GetInstance().StatServerName + "_" + Datacontext.GetInstance().UserName;
//_statServerConfiguration.FaultTolerance = new FaultToleranceMode?(FaultToleranceMode.WarmStandby);
//_statServerConfiguration.WarmStandbyTimeout = new int?(warmStandbyTimeout);
//_statServerConfiguration.WarmStandbyAttempts = new short?(warmStandbyAttempts);
//_statServerConfiguration.WarmStandbyUri = new System.Uri("tcp://" + secondaryHostName + ":" + secondaryPort);
//_statServerConfiguration.UseAddp = new bool?(true);
//_statServerConfiguration.AddpServerTimeout = new int?(addpServerTimeOut);
//_statServerConfiguration.AddpClientTimeout = new int?(addpClientTimeOut);
//_statServerConfiguration.AddpTrace = "both";
//Datacontext.GetInstance().ProtocolManager.Register(_statServerConfiguration);
//_eventBrokerService = new EventBrokerService(Datacontext.GetInstance().ProtocolManager.Receiver);
//_eventBrokerService.Activate();
//_eventBrokerService.Register(Listener.Listener.ReportingSuccessMessage);
//Datacontext.GetInstance().ProtocolManager[Datacontext.GetInstance().StatServerName].Opened += new EventHandler(StatServerOpened);
//Datacontext.GetInstance().ProtocolManager[Datacontext.GetInstance().StatServerName].Closed +=new EventHandler(StatServerClosed);
//Datacontext.GetInstance().ProtocolManager[Datacontext.GetInstance().StatServerName].Open();
StatServerConfProperties _statServerProperties = new StatServerConfProperties();
_statServerProperties.Create(new Uri("tcp://" + primaryHostName + ":" + primaryPort), Datacontext.GetInstance().UserName,
new Uri("tcp://" + secondaryHostName + ":" + secondaryPort), warmStandbyTimeout, warmStandbyAttempts, addpServerTimeOut, addpClientTimeOut,
Genesyslab.Platform.Commons.Connection.Configuration.AddpTraceMode.Both);
try
{
ProtocolManagers.Instance().ProtocolManager.Unregister(ServerType.Statisticsserver.ToString());
_logger.Warn("Protocol configuration is already registered, clear existing configurations");
}
catch (Exception ex)
{
_logger.Warn("Try to remove existing protocol configurations throws exception");
}
string error = "";
if (!ProtocolManagers.Instance().ConnectServer(_statServerProperties.Protocolconfiguration, out error))
{
_logger.Error("Statserver protocol is not opened due to, " + error);
return(false);
}
Listener _listener = new Listener();
((StatServerProtocol)ProtocolManagers.Instance().ProtocolManager[ServerType.Statisticsserver.ToString()]).Received += _listener.ReportingSuccessMessage;
if (ProtocolManagers.Instance().ProtocolManager[ServerType.Statisticsserver.ToString()].State == Genesyslab.Platform.Commons.Protocols.ChannelState.Opened)
{
_logger.Info("Stat server connection opened");
Datacontext.GetInstance().IsStatAlive = true;
ProtocolManagers.Instance().ProtocolManager[ServerType.Statisticsserver.ToString()].Opened += new EventHandler(StatisticsConnectionManager_Opened);
ProtocolManagers.Instance().ProtocolManager[ServerType.Statisticsserver.ToString()].Closed += new EventHandler(StatisticsConnectionManager_Closed);
return(true);
}
else
{
_logger.Info("Stat server connection not opened");
Datacontext.GetInstance().IsStatAlive = false;
return(false);
}
}
catch (Exception ex)
{
_logger.Error("Error occurred while connecting statistics server : " + ((ex.InnerException == null) ? ex.Message : ex.InnerException.ToString()));
return(false);
}
}
