private void FinalizePsdkApplicationBlocks()
{
if (confServiceContract != null)
{
ConfServiceFactory.ReleaseConfService(confServiceContract);
}
// Cleanup code
eventBrokerService.Deactivate();
eventBrokerService.Dispose();
// Close Connection if opened (check status of protocol object)
IProtocol protocol = protocolManagementService[configServerId];
if (protocol.State == ChannelState.Opened) // Close only if the protocol state is opened
{
try
{
protocol.Close();
}
catch (Exception ex)
{
Console.Write(ex.Message + "\n" + ex.StackTrace + "\n");
}
}
protocolManagementService.Unregister(configServerId);
}
private static void FinalizePSDKApplicationBlocks()
{
ConfServiceFactory.ReleaseConfService(confService);
// Cleanup code
eventBrokerService.Deactivate();
eventBrokerService.Dispose();
// Close Connection if opened (check status of protocol object)
IProtocol protocol = protocolManagementService[CONFIGSERVER_IDENTIFIER];
if (protocol.State == ChannelState.Opened) // Close only if the protocol state is opened
{
try
{
protocol.Close();
}
catch (Exception ex)
{
log.Error(ex.Message, ex);
}
}
protocolManagementService.Unregister(CONFIGSERVER_IDENTIFIER);
}
private void Connect(string appName, int addpClientTimeout, int addpServerTimeout, string addpTrace)
{
configServerId = CConfServerIdentifier + Guid.NewGuid();
confServerConfiguration = new ConfServerConfiguration(configServerId)
{
Uri = new Uri(configServerPrimaryUri),
ClientName = appName,
UserName = "",
UserPassword = "",
WarmStandbyUri = new Uri(configServerBackupUri),
WarmStandbyAttempts = 5,
UseAddp = true,
AddpClientTimeout = addpClientTimeout,
AddpServerTimeout = addpServerTimeout,
AddpTrace = addpTrace
};
protocolManagementService = new ProtocolManagementService();
protocolManagementService.ProtocolOpened += OnProtocolOpened;
protocolManagementService.ProtocolClosed += OnProtocolClosed;
protocolManagementService.Register(confServerConfiguration);
eventBrokerService = BrokerServiceFactory.CreateEventBroker(protocolManagementService.Receiver);
confServiceContract = ConfServiceFactory.CreateConfService(protocolManagementService[configServerId], eventBrokerService);
confServiceContract.Register(OnConfEvent);
protocolManagementService.BeginOpen();
}
private static void InitializePSDKApplicationBlocks()
{
// Setup Application Blocks:
// Create Protocol Manager Service object
protocolManagementService = new ProtocolManagementService();
// Create and initialize connection configuration object for TServer.
confServerConfiguration = new ConfServerConfiguration(CONFIGSERVER_IDENTIFIER);
var ConfServerURI = WebConfigurationManager.AppSettings["CfgServer.URI"];
var ClientName = WebConfigurationManager.AppSettings["CfgServer.ClientName"];
var UserName = WebConfigurationManager.AppSettings["CfgServer.UserName"];
var UserPassword = WebConfigurationManager.AppSettings["CfgServer.UserPassword"];
// Set required values
try
{
confServerConfiguration.Uri = new Uri(ConfServerURI);
}
catch (Exception ex)
{
log.Error(ex.Message, ex);
}
confServerConfiguration.ClientName = ClientName;
confServerConfiguration.UserName = UserName;
confServerConfiguration.UserPassword = UserPassword;
if (System.Web.Configuration.WebConfigurationManager.AppSettings["CfgServer.HASupport"] == "1")
{
var uriBakup = System.Web.Configuration.WebConfigurationManager.AppSettings["CfgServer.URI_BAKUP"];
confServerConfiguration.WarmStandbyAttempts = 3;
confServerConfiguration.WarmStandbyTimeout = 3000;
confServerConfiguration.WarmStandbyUri = new Uri(uriBakup);
confServerConfiguration.FaultTolerance = FaultToleranceMode.WarmStandby;
}
// Register this connection configuration with Protocol Manager
protocolManagementService.Register(confServerConfiguration);
protocolManagementService.ProtocolOpened += new EventHandler <ProtocolEventArgs>(OnProtocolOpened);
protocolManagementService.ProtocolClosed += new EventHandler <ProtocolEventArgs>(OnProtocolClosed);
// Create and Initialize Message Broker Application Block
eventBrokerService = new EventBrokerService(protocolManagementService.Receiver);
// Activate event broker service
eventBrokerService.Activate();
confService = ConfServiceFactory.CreateConfService(
protocolManagementService[CONFIGSERVER_IDENTIFIER],
eventBrokerService);
eventBrokerService.Register(
eventConfServerEventsHandler,
new MessageFilter(protocolManagementService[CONFIGSERVER_IDENTIFIER].ProtocolId));
}
/// <summary>
/// Disconnects the configuration server.
/// </summary>
public void DisconnectConfigServer()
{
try
{
if (ProtocolManagers.Instance().ProtocolManager[ServerType.Configserver.ToString()].State == ChannelState.Opened ||
ProtocolManagers.Instance().ProtocolManager[ServerType.Configserver.ToString()].State == ChannelState.Opening)
{
try
{
if (ConfigContainer.Instance().ConfServiceObject != null)
{
ConfServiceFactory.ReleaseConfService(ConfigContainer.Instance().ConfServiceObject);
}
ProtocolManagers.Instance().DisConnectServer(ServerType.Configserver);
if (_configContainer.ConfServiceObject != null)
{
if (_configContainer.ConfServiceObject.Protocol != null && _configContainer.ConfServiceObject.Protocol.State == ChannelState.Opened)
{
_configContainer.ConfServiceObject.Protocol.Close();
}
_configContainer.ConfServiceObject = null;
}
//_configContainer.AllKeys.Clear();
_configContainer.CMEValues.Clear();
}
catch { }
}
else if (ProtocolManagers.Instance().ProtocolManager[ServerType.Configserver.ToString()].State == ChannelState.Closed)
{
//_configContainer.AllKeys.Clear();
_configContainer.CMEValues.Clear();
}
}
catch (Exception generalException)
{
_logger.Error("Error occurred while closing the config server : " +
((generalException.InnerException == null) ? generalException.Message : generalException.InnerException.ToString()));
}
}
private static IConfService OpenCfg()
{
var ConfServerURI = WebConfigurationManager.AppSettings["CfgServer.URI"];
var ClientName = WebConfigurationManager.AppSettings["CfgServer.ClientName"];
var UserName = WebConfigurationManager.AppSettings["CfgServer.UserName"];
var UserPassword = WebConfigurationManager.AppSettings["CfgServer.UserPassword"];
Endpoint confServerUri = new Endpoint(new Uri(ConfServerURI));
ConfServerProtocol cfgServiceProtocol;
EventBrokerService _eventBrokerService;
cfgServiceProtocol = new ConfServerProtocol(confServerUri);
cfgServiceProtocol.ClientName = ClientName;
cfgServiceProtocol.UserName = UserName;
cfgServiceProtocol.UserPassword = UserPassword;
cfgServiceProtocol.ClientApplicationType = (int)CfgAppType.CFGSCE;
try
{
cfgServiceProtocol.Open();
}
catch (ProtocolException e)
{
log.Error(e.Message);
}
catch (Exception e)
{
log.Error(e.Message);
}
_eventBrokerService = BrokerServiceFactory.CreateEventBroker(cfgServiceProtocol);
IConfService cfgService = ConfServiceFactory.CreateConfService(cfgServiceProtocol, _eventBrokerService);
return(cfgService);
}
public static IConfService InitializeConfigService(string cfgsrvHost,
int cfgsrvPort, string username, string password)
{
Endpoint confServerUri = new Endpoint(new Uri("tcp://" + cfgsrvHost + ":" + cfgsrvPort));
String _clientName = "default";
ConfServerProtocol cfgServiceProtocol;
EventBrokerService _eventBrokerService;
cfgServiceProtocol = new ConfServerProtocol(confServerUri);
cfgServiceProtocol.ClientName = _clientName;
cfgServiceProtocol.UserName = username;
cfgServiceProtocol.UserPassword = password;
cfgServiceProtocol.ClientApplicationType = (int)CfgAppType.CFGSCE;
try
{
cfgServiceProtocol.Open();
}
catch (ProtocolException e)
{
log.Info(e.Message);
}
catch (Exception e)
{
log.Info(e.Message);
}
_eventBrokerService = BrokerServiceFactory
.CreateEventBroker(cfgServiceProtocol);
IConfService cfgService = ConfServiceFactory.CreateConfService(
cfgServiceProtocol, _eventBrokerService);
return(cfgService);
}
/// <summary>
/// Establish connection to the configuration server
/// </summary>
/// <param name="pri_ConfigServerHost">The pri_ configuration server host.</param>
/// <param name="pri_ConfigServerPort">The pri_ configuration server port.</param>
/// <param name="clientName">Name of the client.</param>
/// <param name="applicationName">Name of the application.</param>
/// <param name="userName">Name of the user.</param>
/// <param name="password">The password.</param>
/// <param name="sec_ConfigServerHost">The sec_ configuration server host.</param>
/// <param name="sec_ConfigServerPort">The sec_ configuration server port.</param>
/// <returns></returns>
public OutputValues ConfigConnectionEstablish(string pri_ConfigServerHost, string pri_ConfigServerPort, string applicationName,
string userName, string password, string sec_ConfigServerHost, string sec_ConfigServerPort, string[] sectionToRead, params string[] sections)
{
_configContainer = null;
_configContainer = ConfigContainer.Instance();
OutputValues output = new OutputValues();
try
{
var assembly = typeof(ConfigManager).Assembly;
if (assembly != null)
{
_logger.Info("-----------------------------------------------------------------------------");
_logger.Info(assembly.GetName().Name + " : " + assembly.GetName().Version);
_logger.Info("-----------------------------------------------------------------------------");
}
}
catch (Exception generalException)
{
_logger.Error("Error occurred while getting the assembly version of library : " +
((generalException.InnerException == null) ? generalException.Message : generalException.InnerException.ToString()));
}
ConfigConnectionManager connect = new ConfigConnectionManager();
//Clear and null all values
if (_configContainer.ConfServiceObject != null)
{
if (_configContainer.ConfServiceObject.Protocol != null && _configContainer.ConfServiceObject.Protocol.State == ChannelState.Opened)
{
_configContainer.ConfServiceObject.Protocol.Close();
}
if (_configContainer.ConfServiceObject != null)
{
ConfServiceFactory.ReleaseConfService(_configContainer.ConfServiceObject);
}
_configContainer.ConfServiceObject = null;
}
//_configContainer.AllKeys.Clear();
_configContainer.CMEValues.Clear();
//Connect Config Server
output = connect.ConnectConfigServer(pri_ConfigServerHost, pri_ConfigServerPort, applicationName, userName, password,
sec_ConfigServerHost, sec_ConfigServerPort);
if (output.MessageCode == "200")
{
//Authenticate the user first and read the CME configurations
output = AuthenticateUser(userName, password);
if (output.MessageCode == "200")
{
ConfigurationHandler readValues = new ConfigurationHandler();
ConfigContainer.Instance().UserName = userName;
//Get access group first then read values hierarchy
//Read System section to get Tenant and switch type
output = readValues.ReadSystemSection(applicationName);
if (output.MessageCode == "2001")
{
return(output);
}
//Register for CME Alter Notification
//readValues.RegisterCMEAlterNotification(_configContainer.TenantDbId);
//Read logger to print CME values in log
readValues.ReadLoggerData(userName, applicationName);
InitializeLogger(userName);
//Read Application keys
readValues.ReadApplication(applicationName, sectionToRead, sections);
//Read Agent Group Keys and override existing application keys
readValues.ReadAgentGroup(userName, sectionToRead, sections);
//Read person Keys and override existing application keys and Agent group keys
readValues.ReadPerson(userName, sectionToRead, sections);
GetContactBusinessAttribute("ContactAttributes");
//Check the user is in access group
bool accessAuthenticationEnable = true;
try
{
if (_configContainer.CMEValues.ContainsKey("login.enable.access.group-authentication"))
{
if (!string.IsNullOrEmpty(((ConfigValue)_configContainer.CMEValues["login.access-group"]).Value.ToString()) &&
!Convert.ToBoolean(((ConfigValue)_configContainer.CMEValues["login.enable.access.group-authentication"]).Value.ToString()))
{
accessAuthenticationEnable = false;
}
}
}
catch
{
_logger.Warn("Authentication using access group may not work as expected. Implementing default functionality.");
}
if (_configContainer.CMEValues.ContainsKey("login.access-group"))
{
if (_configContainer.CMEValues["login.access-group"] != null &&
((ConfigValue)_configContainer.CMEValues["login.access-group"]).Value.ToString() != string.Empty)
{
if (accessAuthenticationEnable)
{
output = readValues.ReadAccessPermission(((ConfigValue)_configContainer.CMEValues["login.access-group"]).Value);
if (output.MessageCode == "2001")
{
return(output);
}
}
}
else
{
_logger.Warn("login.access-group value is null or empty");
output.MessageCode = "2001";
output.Message = "Access group name is not configured. Please contact your Administrator";
return(output);
}
}
else
{
_logger.Warn("login.access-group key is not configured");
output.MessageCode = "2001";
output.Message = "Access group name is not configured. Please contact your Administrator";
return(output);
}
//Read the available Queues such as ACD queues
if (_configContainer.CMEValues.ContainsKey("login.voice.available-queues") && ((ConfigValue)_configContainer.CMEValues["login.voice.available-queues"]).Value != null)
{
readValues.ReadQueues(((ConfigValue)_configContainer.CMEValues["login.voice.available-queues"]).Value.ToString());
}
else
{
_logger.Warn("login.voice.available-queues key-value is not configured");
}
//Check case data and disposition from business attribute or transaction object
if (_configContainer.CMEValues.ContainsKey("interaction.casedata.use-transaction-object") &&
((ConfigValue)_configContainer.CMEValues["interaction.casedata.use-transaction-object"]).Value.ToLower().Equals("true") ? true : false)
{
//Read the case data Transaction object for add/filter/sort case data
if (_configContainer.CMEValues.ContainsKey("interaction.casedata-object-name") &&
!string.IsNullOrEmpty(((ConfigValue)_configContainer.CMEValues["interaction.casedata-object-name"]).Value))
{
readValues.ReadCaseDataTransactionObject(((ConfigValue)_configContainer.CMEValues["interaction.casedata-object-name"]).Value.ToString());
readValues.ReadCaseDataFilterTransactionObject(((ConfigValue)_configContainer.CMEValues["interaction.casedata-object-name"]).Value.ToString());
readValues.ReadCaseDataSortingTransactionObject(((ConfigValue)_configContainer.CMEValues["interaction.casedata-object-name"]).Value.ToString());
}
else
{
_logger.Warn("interaction.casedata-object-name value is not configured");
}
//Read the case data Transaction object for disposition
if (_configContainer.CMEValues.ContainsKey("interaction.disposition-object-name") &&
!string.IsNullOrEmpty(((ConfigValue)_configContainer.CMEValues["interaction.disposition-object-name"]).Value))
{
readValues.ReadDispositionTransctionObject(((ConfigValue)_configContainer.CMEValues["interaction.disposition-object-name"]).Value.ToString());
}
else
{
_logger.Warn("interaction.disposition-object-name value is not configured");
}
}
else
{
if (_configContainer.CMEValues.ContainsKey("interaction.casedata-object-name") &&
!string.IsNullOrEmpty(((ConfigValue)_configContainer.CMEValues["interaction.casedata-object-name"]).Value))
{
//Read casedata information from Business attributes
readValues.ReadCaseDataFromBusinessAttribute(((ConfigValue)_configContainer.CMEValues["interaction.casedata-object-name"]).Value.ToString());
}
else
{
_logger.Warn("interaction.casedata-object-name key-value is not configured");
}
if (_configContainer.CMEValues.ContainsKey("interaction.disposition-object-name") &&
!string.IsNullOrEmpty(((ConfigValue)_configContainer.CMEValues["interaction.disposition-object-name"]).Value))
{
//Read disposition information from Business attributes
readValues.ReadDispositionFromBusinessAttribute(((ConfigValue)_configContainer.CMEValues["interaction.disposition-object-name"]).Value.ToString());
}
else
{
_logger.Warn("interaction.disposition-object-name key-value is not configured");
}
}
//Read all skills
readValues.ReadAllSkills();
//Read all places
readValues.ReadAllPlaces();
//Read all DN's based on switch type
//readValues.ReadAllDNs();
//Read channel based not ready reason codes for voice, email and chat medias
readValues.ReadChannelNotReadyReasonCodes();
//Read global not ready reason codes
if (_configContainer.AllKeys.Contains("agent-global-status.not-ready-reasoncodes"))
{
string[] notReadyReasonCodes = ((string)_configContainer.GetValue("agent-global-status.not-ready-reasoncodes")).Split(',');
if (notReadyReasonCodes.Length > 0)
{
readValues.ReadGlobalNotReadyReasonCodes(notReadyReasonCodes.Distinct().ToArray <string>());
}
}
//Read Voice not Ready Reason Codes
if (_configContainer.AllKeys.Contains("agent-voice-status.not-ready-reasoncodes"))
{
string[] notReadyReasonCodes = ((string)_configContainer.GetValue("agent-voice-status.not-ready-reasoncodes")).Split(',');
if (notReadyReasonCodes.Length > 0)
{
readValues.ReadVoiceHierarchyLevelNotReadyReasonCodes(notReadyReasonCodes.Distinct().ToArray <string>());
}
}
CfgPersonQuery qPerson = new CfgPersonQuery();
qPerson.TenantDbid = ConfigContainer.Instance().TenantDbId;
qPerson.IsAgent = 0;// 0 - Means select only Agents (or) 1 - means select only user(default)
System.Collections.Generic.ICollection <CfgPerson> _allPersons = _configContainer.ConfServiceObject.RetrieveMultipleObjects <CfgPerson>(qPerson);
//_configContainer.AllKeys.Add("AllPersons");
_configContainer.CMEValues.Add("AllPersons", _allPersons);
readValues.RegisterCMEAlterNotification(ConfigContainer.Instance().TenantDbId);
readValues = null;
}
else
{
return(output);
}
}
return(output);
}
/// <summary> /// Gets or creates an <see cref="IConfService"/> from the provided <paramref name="protocol"/>. /// </summary> /// <param name="protocol">The protocol object to retrieve a Service from.</param> /// <returns>An <see cref="IConfService"/> instance.</returns> public static IConfService GetConfService(this ConfServerProtocol protocol) => ConfServiceFactory.RetrieveConfService(protocol) ?? ConfServiceFactory.CreateConfService(protocol);
/// <summary>
/// Connects the config server.
/// </summary>
/// <param name="ConfigServerHost">The config server host.</param>
/// <param name="ConfigServerPort">The config server port.</param>
/// <param name="userName">Name of the user.</param>
/// <param name="password">The password.</param>
/// <returns></returns>
public OutputValues ConnectConfigServer(string ConfigServerHost, string ConfigServerPort,
string userName, string password, string clientName, string logUserName)
{
EventBrokerService comEventBrokerService;
OutputValues output = OutputValues.GetInstance();
ReadApplication read = new ReadApplication();
try
{
StatisticsSetting.GetInstance().logUserName = logUserName;
logger.Debug("ConfigConnectionManager : ConnectConfigServer Method: Entry");
if (StatisticsSetting.GetInstance().protocolManager == null)
{
StatisticsSetting.GetInstance().configurationProperties = new ConfServerConfiguration("config");
StatisticsSetting.GetInstance().protocolManager = new ProtocolManagementService();
//Primary Server settings
StatisticsSetting.GetInstance().configurationProperties.Uri = new Uri("tcp://" + ConfigServerHost + ":"
+ ConfigServerPort);
StatisticsSetting.GetInstance().configurationProperties.ClientApplicationType = CfgAppType.CFGAgentDesktop;
StatisticsSetting.GetInstance().configurationProperties.ClientName = clientName;
StatisticsSetting.GetInstance().configurationProperties.UserName = userName;
StatisticsSetting.GetInstance().configurationProperties.UserPassword = password;
//Set ADDP
StatisticsSetting.GetInstance().configurationProperties.UseAddp = true;
StatisticsSetting.GetInstance().configurationProperties.AddpServerTimeout = 30;
StatisticsSetting.GetInstance().configurationProperties.AddpClientTimeout = 60;
//Open the connection
try
{
StatisticsSetting.GetInstance().protocolManager.Register(StatisticsSetting.GetInstance().configurationProperties);
}
catch (Exception generalException)
{
output.MessageCode = "2001";
output.Message = (generalException.InnerException == null ? generalException.Message : generalException.InnerException.Message);
logger.Error("ConfigConnectionManager : ConnectConfigServer Method: " + generalException.Message.ToString());
return(output);
}
StatisticsSetting.GetInstance().protocolManager[StatisticsSetting.ConfServer].Open();
comEventBrokerService = new EventBrokerService(StatisticsSetting.GetInstance().protocolManager.Receiver);
comEventBrokerService.Activate();
//comEventBrokerService.Register(OnConfEventError);
//comEventBrokerService.Register(OnConfEventObjectsRead);
//comEventBrokerService.Register(OnConfEventObjectsSent);
//KeyValueCollection filterKey = new KeyValueCollection();
//filterKey.Add("switch_dbid", 102);
//filterKey.Add("dn_type", (int)CfgDNType.CFGExtension);
//RequestReadObjects requestReadObjects = RequestReadObjects.Create((int)CfgObjectType.CFGDN, filterKey);
//StatisticsSetting.GetInstance().protocolManager[StatisticsSetting.ConfServer].Send(requestReadObjects);
if (StatisticsSetting.GetInstance().confObject == null)
{
StatisticsSetting.GetInstance().confObject = (ConfService)ConfServiceFactory.CreateConfService(
StatisticsSetting.GetInstance().protocolManager[StatisticsSetting.ConfServer] as ConfServerProtocol,
comEventBrokerService, true);
}
//NotificationQuery NQuery=new NotificationQuery();
//NQuery.ObjectType=CfgObjectType.CFGPerson;
//StatisticsSetting.GetInstance().confObject.Subscribe(NQuery);
if (StatisticsSetting.GetInstance().protocolManager[StatisticsSetting.ConfServer].State == ChannelState.Opened)
{
StatisticsSetting.GetInstance().confProtocol = (ConfServerProtocol)StatisticsSetting.GetInstance().protocolManager[StatisticsSetting.ConfServer];
read.ReadLoggerDetails(StatisticsSetting.GetInstance().AppName);
output.MessageCode = "2000";
output.Message = "Config Server Protocol Opened";
logger.Trace("ConfigConnectionManager : ConnectConfigServer Method: Config Server Protocol Opened");
}
else
{
output.MessageCode = "2001";
output.Message = "Config Server Protocol Closed";
logger.Warn("ConfigConnectionManager : ConnectConfigServer Method: Config Server Protocol Closed");
}
}
}
catch (Exception connectionException)
{
logger.Error("ConfigConnectionManager : ConnectConfigServer Method: " + connectionException.Message.ToString());
output.MessageCode = "2001";
output.Message = (connectionException.InnerException == null ? connectionException.Message : connectionException.InnerException.Message);
}
finally
{
logger.Debug("ConfigConnectionManager : ConnectConfigServer Method: Exit");
//StatisticsSetting.GetInstance().protocolManager = null;
GC.Collect();
}
return(output);
}
private void confserv()
{
try
{
IAgent agent = container.Resolve <IAgent>();
#region ADDP settings
PropertyConfiguration config = new PropertyConfiguration();
config.UseAddp = true;
config.AddpServerTimeout = 30;
config.AddpClientTimeout = 90;
//config.AddpTrace = "both";
config.AddpTraceMode = AddpTraceMode.Both;
#endregion
Endpoint endpoint = new Endpoint("10.220.57.1", 2020);
ConfServerProtocol confProtocol = new ConfServerProtocol(endpoint);
confProtocol.ClientApplicationType = (int)CfgAppType.CFGSCE;
confProtocol.ClientName = "default";
confProtocol.UserName = agent.UserName;
confProtocol.UserPassword = agent.Password;
try
{
confProtocol.BeginOpen();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
IConfService confservice = (ConfService)ConfServiceFactory.CreateConfService(confProtocol);
CfgPersonQuery query = new CfgPersonQuery();
query.UserName = agent.UserName;
CfgPerson person = confservice.RetrieveObject <CfgPerson>(query);
//MessageBox.Show(person.ToString());
CfgAccessGroupQuery querys = new CfgAccessGroupQuery();
querys.PersonDbid = person.DBID;
querys.TenantDbid = 101;
ICollection <CfgAccessGroup> accessGroups = confservice.RetrieveMultipleObjects <CfgAccessGroup>(querys);
foreach (CfgAccessGroup accessGroup in accessGroups)
{
agentProfile = accessGroup.GroupInfo.Name.ToString();
MessageBox.Show(agentProfile);
if (agentProfile.Equals("Azf_Nar"))
{
agentProfile = "Azf_Nar";
MessageBox.Show(agentProfile);
break;
}
else if (agentProfile.Equals("Azf_Fixed"))
{
agentProfile = "Azf_Fixed";
MessageBox.Show(agentProfile);
break;
}
else if (agentProfile.Equals("Backcell"))
{
agentProfile = "Backcell";
MessageBox.Show(agentProfile);
break;
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
private static void CloseCfg(IConfService _confService)
{
ConfServiceFactory.ReleaseConfService(_confService);
}
public static void FinalizeConfigService(IConfService _confService)
{
ConfServiceFactory.ReleaseConfService(_confService);
}
public OutputValues ConnectConfigServer(string pri_ConfigServerHost, string pri_ConfigServerPort,
string applicationName, string userName, string password, string sec_ConfigServerHost,
string sec_ConfigServerPort, bool switchoverServer = true)
{
var output = new OutputValues();
var confServerProperties = new ConfigurationServerConfProperties();
try
{
_logger.Debug("ConnectTServer : Applied primary server properties to Voice protocol");
_logger.Debug("ConnectTServer : Primary server uri " + "tcp://" + pri_ConfigServerHost
+ ":" + pri_ConfigServerPort);
if (sec_ConfigServerHost != null)
{
_logger.Debug("ConnectTServer : Applied secondary server properties to Voice protocol");
_logger.Debug("ConnectTServer : Secondary server uri " + "tcp://" + sec_ConfigServerHost
+ ":" + sec_ConfigServerPort);
}
else
{
_logger.Warn("ConnectTServer : Secondary server is not mentioned");
_logger.Info("ConnectTServer : Application has no backup servers");
}
if (ConfigContainer.Instance().ConfServiceObject != null)
{
ConfServiceFactory.ReleaseConfService(ConfigContainer.Instance().ConfServiceObject);
}
ProtocolManagers.Instance().DisConnectServer(ServerType.Configserver);
confServerProperties.Create(new Uri("tcp://" + pri_ConfigServerHost + ":" + pri_ConfigServerPort), CfgAppType.CFGAgentDesktop, applicationName,
userName, password, new Uri("tcp://" + (sec_ConfigServerHost == "optional" ? pri_ConfigServerHost : sec_ConfigServerHost) +
":" + (sec_ConfigServerPort == "optional" ? pri_ConfigServerPort : sec_ConfigServerPort)),
10, 5, 60, 60, Genesyslab.Platform.Commons.Connection.Configuration.AddpTraceMode.Both);
var cfgProtocolConfiguration = confServerProperties.Protocolconfiguration;
string error = "";
if (!ProtocolManagers.Instance().ConnectServer(cfgProtocolConfiguration, out error))
{
_logger.Error("Configuration protocol is not opened due to, " + error);
output.MessageCode = "2001";
output.Message = error;
return(output);
}
ConfigContainer.Instance().ConfServiceObject = (ConfService)ConfServiceFactory.CreateConfService(
ProtocolManagers.Instance().ProtocolManager[cfgProtocolConfiguration.Name] as ConfServerProtocol);
if (ProtocolManagers.Instance().ProtocolManager[cfgProtocolConfiguration.Name].State == ChannelState.Opened)
{
_logger.Debug("getProtocol : Configuration protocol is opened ");
_logger.Info("getProtocol : Configuration Protocol object id is "
+ ProtocolManagers.Instance().ProtocolManager[cfgProtocolConfiguration.Name].GetHashCode().ToString());
output.MessageCode = "200";
output.Message = "Config Server Protocol Opened";
}
else
{
_logger.Debug("getProtocol : Configuration protocol is closed ");
output.MessageCode = "2001";
output.Message = "Config Server Connection not Established";
}
#region Old Code
//catch (Exception generalException)
//{
// _logger.Info("Configuration protocol already opened " + generalException.ToString());
// output.MessageCode = "2001";
// output.Message = (generalException.InnerException == null ? generalException.Message : generalException.InnerException.Message);
// return output;
//}
//_logger.Debug("getProtocol : Registered protocol manager ");
////Open the connection
//ConnectionSettings.protocolManager[ConnectionSettings.ConfServer].Open();
//comEventBrokerService = new EventBrokerService(ConnectionSettings.protocolManager.Receiver);
////Subscription of CFGObjects
//// Register(new Action<ConfEvent>(ReadApplicationObject.GetInstance().ConfigServiceHandler), new MessageIdFilter(EventObjectUpdated.MessageId));
////comEventBrokerService.Register(ReadApplicationObject.GetInstance().OnCMEObjectUpdated, new MessageIdFilter(EventObjectUpdated.MessageId));
////if (ConnectionSettings.comObject != null)
//// ConfServiceFactory.ReleaseConfService(ConnectionSettings.comObject);
//if (ConfigContainer.Instance().ConfServiceObject != null)
// ConfServiceFactory.ReleaseConfService(ConfigContainer.Instance().ConfServiceObject);
//ConfigContainer.Instance().ConfServiceObject = (ConfService)ConfServiceFactory.CreateConfService(
// ConnectionSettings.protocolManager[ConnectionSettings.ConfServer] as ConfServerProtocol,
// comEventBrokerService, true);
//comEventBrokerService.Activate();
//_logger.Debug("Trying to open the connection");
//if (ConnectionSettings.protocolManager[ConnectionSettings.ConfServer].State == ChannelState.Opened)
//{
// _logger.Debug("getProtocol : Configuration protocol is opened ");
// _logger.Info("getProtocol : Configuration Protocol object id is "
// + ConnectionSettings.protocolManager[ConnectionSettings.ConfServer].GetHashCode().ToString());
// output.MessageCode = "200";
// output.Message = "Config Server Protocol Opened";
//}
//else
//{
// _logger.Debug("getProtocol : Configuration protocol is closed ");
// output.MessageCode = "2001";
// output.Message = "Config Server Connection Established";
//}
#endregion old code
}
catch (Exception connectionException)
{
if (switchoverServer)
{
output = ConnectConfigServer(sec_ConfigServerHost, sec_ConfigServerPort,
applicationName, userName, password, pri_ConfigServerHost,
pri_ConfigServerPort, false);
}
else
{
output.MessageCode = "2001";
output.Message = (connectionException.InnerException == null ? connectionException.Message : connectionException.InnerException.Message);
}
}
return(output);
}
