340 lines
13 KiB
C#
340 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Reflection;
|
|
using Pluto.Registration;
|
|
|
|
namespace RegistrationAPI
|
|
{
|
|
/// <remarks>
|
|
/// Communication Manager to Practice Choice Client API
|
|
/// </remarks>
|
|
public static class API
|
|
{
|
|
#region Construction
|
|
|
|
private static HiddenMainForm _hiddenFrm = null;
|
|
static API()
|
|
{
|
|
_hiddenFrm = new HiddenMainForm();
|
|
_hiddenFrm.Opacity = 0;
|
|
_hiddenFrm.Show();
|
|
_hiddenFrm.Visible = false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Change Network Settings
|
|
|
|
/// <summary>
|
|
/// Use this function to change the URL and port for the client to use when
|
|
/// communicating (affects entire API)
|
|
/// </summary>
|
|
/// <param name="url"></param>
|
|
/// <param name="port"></param>
|
|
public static void SetNetworkSettings(string url, uint port)
|
|
{
|
|
bool bChangeOccured = false;
|
|
if (!String.IsNullOrEmpty(url) && String.Compare(_hiddenFrm.ClientChannel.Hostname, url, true) != 0)
|
|
{
|
|
bChangeOccured = true;
|
|
_hiddenFrm.ClientChannel.Hostname = url;
|
|
}
|
|
if (port > 0 && _hiddenFrm.ClientChannel.Port != (int)port)
|
|
{
|
|
bChangeOccured = true;
|
|
_hiddenFrm.ClientChannel.Port = (int)port;
|
|
}
|
|
if (bChangeOccured)
|
|
{
|
|
_hiddenFrm.ClientChannel.TargetUrl = String.Format("tcp://{0}:{1}/bin", _hiddenFrm.ClientChannel.Hostname, _hiddenFrm.ClientChannel.Port);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Methods (coded here)
|
|
|
|
/// <summary>
|
|
/// The max number of characters a practice name can take on
|
|
/// </summary>
|
|
public const int PRACTICENAME_LENGTH = 50;
|
|
|
|
/// <summary>
|
|
/// Const will be used when registering in order to distinguish an internal Practice from a real Customer
|
|
/// </summary>
|
|
public const string INTERNAL_TEST_PRACTICE = " (Mck)";
|
|
|
|
/// <summary>
|
|
/// Because the practice can only be 50 chars, call this function to get INTERNAL_TEST_PRACTICE
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public static string GetMcKInternalizedPracticeName(string PracticeName)
|
|
{
|
|
if (!String.IsNullOrEmpty(PracticeName))
|
|
{
|
|
int nLen = PracticeName.Length + INTERNAL_TEST_PRACTICE.Length;
|
|
if (nLen > RegistrationAPI.API.PRACTICENAME_LENGTH)
|
|
{
|
|
string PName = PracticeName.Substring(0, (RegistrationAPI.API.PRACTICENAME_LENGTH - INTERNAL_TEST_PRACTICE.Length));
|
|
return (PName + INTERNAL_TEST_PRACTICE);
|
|
}
|
|
else
|
|
{
|
|
return (PracticeName + INTERNAL_TEST_PRACTICE);
|
|
}
|
|
}
|
|
return INTERNAL_TEST_PRACTICE.Trim();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Useful System Registration API Calls
|
|
|
|
/// <summary>
|
|
/// Retrieve the Api Mobile Host for the specified System Key
|
|
/// </summary>
|
|
/// <param name="SystemApiKey"></param>
|
|
/// <returns></returns>
|
|
public static Host GetApiMobile(string SystemApiKey)
|
|
{
|
|
if (!String.IsNullOrEmpty(SystemApiKey))
|
|
{
|
|
return _hiddenFrm.fRegistration.GetApiHostMobile(SystemApiKey);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Is Mobile Host Reachable
|
|
/// </summary>
|
|
/// <param name="SystemApiKey"></param>
|
|
/// <returns></returns>
|
|
public static bool IsApiMobileReachable(string SystemApiKey)
|
|
{
|
|
if (!String.IsNullOrEmpty(SystemApiKey))
|
|
{
|
|
return _hiddenFrm.fRegistration.IsClientReachable(SystemApiKey);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Useful Windows Client Registration API
|
|
|
|
/// <summary>
|
|
/// Allow retrival of different registration server
|
|
/// </summary>
|
|
/// <param name="UserApiKey"></param>
|
|
/// <param name="UserApiPin"></param>
|
|
/// <param name="host"></param>
|
|
/// <param name="port"></param>
|
|
public static void GetRegistrationServer(string UserApiKey, string UserApiPin, out string host, out uint port)
|
|
{
|
|
host = String.Empty;
|
|
port = 0;
|
|
string systemAPIKey = _hiddenFrm.fRegistration.RegisterNewClient(UserApiKey, UserApiPin);
|
|
if (!String.IsNullOrEmpty(systemAPIKey))
|
|
{
|
|
Host hostServer = _hiddenFrm.fRegistration.GetRegistrationServer(systemAPIKey);
|
|
if (!String.IsNullOrEmpty(hostServer.host) && hostServer.port > 0)
|
|
{
|
|
host = hostServer.host;
|
|
port = (uint)hostServer.port;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register a new Practice, should only be called once for a new practice
|
|
/// </summary>
|
|
/// <param name="ServerGuid"></param>
|
|
/// <param name="PracticeName"></param>
|
|
/// <param name="InternalIP"></param>
|
|
/// <param name="ExternalIP"></param>
|
|
/// <param name="Port"></param>
|
|
/// <param name="ServerType"></param>
|
|
/// <param name="UserApiKey"></param>
|
|
/// <param name="UserApiPin"></param>
|
|
/// <returns></returns>
|
|
public static bool RegisterNewServerPractice(Guid ServerGuid, string PracticeName, string InternalIP, string ExternalIP, uint Port, string ServerType, out string UserApiKey, out string UserApiPin)
|
|
{
|
|
UserApiKey = String.Empty;
|
|
UserApiPin = String.Empty;
|
|
if (!String.IsNullOrEmpty(PracticeName) && (!String.IsNullOrEmpty(InternalIP) || !String.IsNullOrEmpty(ExternalIP)) &&
|
|
Port > 0 && !String.IsNullOrEmpty(ServerType))
|
|
{
|
|
Server server = new Server();
|
|
server.HostGUID = ServerGuid.ToString();
|
|
server.InternalIP = InternalIP;
|
|
server.ExternalIP = ExternalIP;
|
|
server.Port = (int)Port;
|
|
string PName = (PracticeName.Length > PRACTICENAME_LENGTH) ? PracticeName.Substring(0, PRACTICENAME_LENGTH) : PracticeName;
|
|
bool bSuccess = _hiddenFrm.fRegistration.RegisterNewServerPractice(PName, server, ServerType, out UserApiKey, out UserApiPin);
|
|
return bSuccess;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieve the system api key for a userapikey and pin
|
|
/// </summary>
|
|
/// <param name="UserApiKey"></param>
|
|
/// <param name="UserApiPin"></param>
|
|
/// <returns></returns>
|
|
public static string RegisterNewClient(string UserApiKey, string UserApiPin)
|
|
{
|
|
if (!String.IsNullOrEmpty(UserApiKey) && !String.IsNullOrEmpty(UserApiPin))
|
|
{
|
|
return _hiddenFrm.fRegistration.RegisterNewClient(UserApiKey, UserApiPin);
|
|
}
|
|
return String.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieve the pin for a UserApiKey
|
|
/// </summary>
|
|
/// <param name="UserApiKey"></param>
|
|
/// <returns></returns>
|
|
public static string RetrieveUserApiKeyPin(string UserApiKey)
|
|
{
|
|
if (!String.IsNullOrEmpty(UserApiKey))
|
|
{
|
|
return _hiddenFrm.fRegistration.RetrieveNewClientPin(UserApiKey);
|
|
}
|
|
return String.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update the server external ip, internal ip, and port
|
|
/// </summary>
|
|
/// <param name="ServerGuid"></param>
|
|
/// <param name="InternalIP"></param>
|
|
/// <param name="ExternalIP"></param>
|
|
/// <param name="Port"></param>
|
|
/// <returns></returns>
|
|
public static bool UpdateServer(Guid ServerGuid, string InternalIP, string ExternalIP, uint Port)
|
|
{
|
|
if ((!String.IsNullOrEmpty(InternalIP) || !String.IsNullOrEmpty(ExternalIP)) && Port > 0)
|
|
{
|
|
Server server = new Server();
|
|
server.HostGUID = ServerGuid.ToString();
|
|
server.InternalIP = InternalIP;
|
|
server.ExternalIP = ExternalIP;
|
|
server.Port = (int)Port;
|
|
bool bSuccess = _hiddenFrm.fRegistration.UpdateServer(server);
|
|
return bSuccess;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update the practice name for a specified userapikey
|
|
/// </summary>
|
|
/// <param name="UserApiKey"></param>
|
|
/// <param name="UserApiPin"></param>
|
|
/// <param name="PracticeName"></param>
|
|
/// <returns></returns>
|
|
public static bool UpdatePracticeName(string UserApiKey, string UserApiPin, string PracticeName)
|
|
{
|
|
if (!String.IsNullOrEmpty(UserApiKey) && !String.IsNullOrEmpty(UserApiPin) &&
|
|
!String.IsNullOrEmpty(PracticeName))
|
|
{
|
|
string PName = (PracticeName.Length > PRACTICENAME_LENGTH) ? PracticeName.Substring(0, PRACTICENAME_LENGTH) : PracticeName;
|
|
return _hiddenFrm.fRegistration.UpdatePracticeName(UserApiKey, UserApiPin, PName);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Callback from registration server to see if it can communicate to the specified ip / port
|
|
/// </summary>
|
|
/// <param name="ExternalIP"></param>
|
|
/// <param name="Port"></param>
|
|
/// <returns></returns>
|
|
public static bool IsServerReachable(string ExternalIP, uint Port)
|
|
{
|
|
if (!String.IsNullOrEmpty(ExternalIP) && Port > 0)
|
|
{
|
|
Server server = new Server();
|
|
server.ExternalIP = ExternalIP;
|
|
server.Port = (int)Port;
|
|
bool bRetVal = _hiddenFrm.fRegistration.IsServerReachable(server);
|
|
return bRetVal;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Callback from registration server to see if the specified ip / port exposes a Pluto HostGUID
|
|
/// </summary>
|
|
/// <param name="ExternalIP"></param>
|
|
/// <param name="Port"></param>
|
|
/// <returns></returns>
|
|
public static string RetrievePlutoHostGUID(string ExternalIP, uint Port)
|
|
{
|
|
if (!String.IsNullOrEmpty(ExternalIP) && Port > 0)
|
|
{
|
|
Server server = new Server();
|
|
server.ExternalIP = ExternalIP;
|
|
server.Port = (int)Port;
|
|
string result = _hiddenFrm.fRegistration.RetrieveHostGUIDForServerFromInternet(server);
|
|
return result;
|
|
}
|
|
return String.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check to see if the Host Guid exists on the server
|
|
/// </summary>
|
|
/// <param name="ServerGuid"></param>
|
|
/// <returns></returns>
|
|
public static bool DoesServerHostGUIDExist(Guid HostGuid)
|
|
{
|
|
if (HostGuid != null)
|
|
{
|
|
bool bExists = _hiddenFrm.fRegistration.DoesServerHostGUIDExist(HostGuid.ToString());
|
|
return bExists;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allow the Service to communicate back to the Service that a new Version has been installed
|
|
/// </summary>
|
|
/// <param name="Version"></param>
|
|
public static void ServerHasBeenUpdated(Guid HostGuid, string Version)
|
|
{
|
|
if (!String.IsNullOrEmpty(Version) && HostGuid != null)
|
|
{
|
|
_hiddenFrm.fRegistration.ServerHasBeenUpdated(HostGuid.ToString(), Version);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region AutoUpdate / Client / Server Calls
|
|
|
|
public static Client[] GetExternalClients()
|
|
{
|
|
List<Client> clientToReturn = new List<Client>();
|
|
Client[] clients = _hiddenFrm.fRegistration.GetClients(false);
|
|
if (clients != null && clients.Length > 0)
|
|
{
|
|
foreach (Client client in clients)
|
|
{
|
|
if (!String.IsNullOrEmpty(client.host.host))
|
|
{
|
|
clientToReturn.Add(client);
|
|
}
|
|
}
|
|
}
|
|
return clientToReturn.ToArray();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|