From f06037a353cde55d8c37d9882c9ca455a3db5095 Mon Sep 17 00:00:00 2001 From: guangyuzhang Date: Fri, 29 Aug 2014 15:28:56 +0800 Subject: [PATCH] Inital commit of the XML RPC Client Library --- README.md | 1 + XMLRPCClient.sln | 20 + XMLRPCClient.suo | Bin 0 -> 19456 bytes XMLRPCClient/Properties/AssemblyInfo.cs | 36 + XMLRPCClient/XMLRPCClient.csproj | 56 + XMLRPCClient/XmlHelper.cs | 278 ++ XMLRPCClient/XmlRpcClient.cs | 2399 +++++++++++++++++ ...gnTimeResolveAssemblyReferencesInput.cache | Bin 0 -> 5722 bytes .../XMLRPCClient.csproj.FileListAbsolute.txt | 5 + XMLRPCClient/obj/Debug/XMLRPCClient.dll | Bin 0 -> 38912 bytes XMLRPCClient/obj/Debug/XMLRPCClient.pdb | Bin 0 -> 95744 bytes 11 files changed, 2795 insertions(+) create mode 100644 XMLRPCClient.sln create mode 100644 XMLRPCClient.suo create mode 100644 XMLRPCClient/Properties/AssemblyInfo.cs create mode 100644 XMLRPCClient/XMLRPCClient.csproj create mode 100644 XMLRPCClient/XmlHelper.cs create mode 100644 XMLRPCClient/XmlRpcClient.cs create mode 100644 XMLRPCClient/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache create mode 100644 XMLRPCClient/obj/Debug/XMLRPCClient.csproj.FileListAbsolute.txt create mode 100644 XMLRPCClient/obj/Debug/XMLRPCClient.dll create mode 100644 XMLRPCClient/obj/Debug/XMLRPCClient.pdb diff --git a/README.md b/README.md index 7eddb37..b5f05ce 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,3 @@ XmlRpcClient ============ +This is XML RPC Client Library in C#.NET diff --git a/XMLRPCClient.sln b/XMLRPCClient.sln new file mode 100644 index 0000000..19b79af --- /dev/null +++ b/XMLRPCClient.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual Studio 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XMLRPCClient", "XMLRPCClient\XMLRPCClient.csproj", "{CF207A79-E0CD-4CAB-BE7B-DDE7E37BE195}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {CF207A79-E0CD-4CAB-BE7B-DDE7E37BE195}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CF207A79-E0CD-4CAB-BE7B-DDE7E37BE195}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CF207A79-E0CD-4CAB-BE7B-DDE7E37BE195}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CF207A79-E0CD-4CAB-BE7B-DDE7E37BE195}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/XMLRPCClient.suo b/XMLRPCClient.suo new file mode 100644 index 0000000000000000000000000000000000000000..235c766cc5b41da930174128f510ffbaf80c0e23 GIT binary patch literal 19456 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 + + + Debug + AnyCPU + 8.0.30703 + 2.0 + {CF207A79-E0CD-4CAB-BE7B-DDE7E37BE195} + Library + Properties + XMLRPCClient + XMLRPCClient + v4.0 + 512 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/XMLRPCClient/XmlHelper.cs b/XMLRPCClient/XmlHelper.cs new file mode 100644 index 0000000..81d18bf --- /dev/null +++ b/XMLRPCClient/XmlHelper.cs @@ -0,0 +1,278 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Xml; +using System.Xml.Linq; +using System.Runtime.Serialization; + +namespace XMLRPCClient +{ + public static class XmlHelper + { + //XmlRpc requires tags for int's http://www.xmlrpc.com/spec + public static string getFullXML(XDocument xdoc) + { + try + { + string xml; + using (System.IO.MemoryStream memStream = new System.IO.MemoryStream()) + { + XmlWriter writer = XmlWriter.Create(memStream); + xdoc.Save(writer); + writer.Close(); + memStream.Position = 0; + + xml = System.Text.Encoding.ASCII.GetString(memStream.GetBuffer(), 0, Convert.ToInt32(memStream.Length)).TrimEnd('\0'); + xml = xml.Trim(); + memStream.Close(); + xml = xml.Replace("<", "<"); + xml = xml.Replace(">", ">"); + return xml; + } + } + catch (Exception ex) + { + throw ex; + } + } + public static string removeXMLNodeTags(string message) + { + message = message.Replace("<", "<"); + message = message.Replace(">", ">"); + + return message; + } + public static string ReplaceXmlTag(string message) + { + message = message.Replace("<", "["); + message = message.Replace(">", "]"); + return message; + + } + public static string getFullXML(XElement xElement) + { + XDocument xdoc = new XDocument(new XDeclaration("1.0", "ISO-8859-1", String.Empty), xElement); + + //xdoc.AddAfterSelf(xElement); + return getFullXML(xdoc); + } + + public static string ConvertDataContractToText(object dataContractOjbect) + { + string value = ""; + value = getFullXML(RemoveAllNamespaces(dataContractOjbect)); + + return value; + } + public static XElement RemoveAllNamespaces(object dataContractObject) + { + try + { + Type objectType = dataContractObject.GetType(); + DataContractSerializer dcs = new DataContractSerializer(objectType); + + String text; + using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream()) + { + dcs.WriteObject(memoryStream, dataContractObject); + text = System.Text.Encoding.ASCII.GetString(memoryStream.ToArray()); + XElement xelement = XmlHelper.RemoveAllXElementNamespaces(XElement.Parse(text)); + + return xelement; + } + } + catch (Exception ex) + { + throw ex; + } + + } + + private static XElement RemoveAllXElementNamespaces(XElement xmlDocument) + { + try + { + if (!xmlDocument.HasElements) + { + XElement xElement = new XElement(xmlDocument.Name.LocalName); + xElement.Value = xmlDocument.Value; + return xElement; + } + return new XElement(xmlDocument.Name.LocalName, xmlDocument.Elements().Select(el => RemoveAllXElementNamespaces(el))); + } + catch (Exception ex) + { + throw ex; + } + } + + public static String RemoveXmlDeclarations(string possibleXmlText) + { + + try + { + if (possibleXmlText.Contains("", startTagLocation); + possibleXmlText = possibleXmlText.Remove(startTagLocation, endTagLocation - startTagLocation + 1); + possibleXmlText = RemoveXmlDeclarations(possibleXmlText); + + } + return possibleXmlText; + } + catch (Exception ex) + { + throw ex; + } + } + } + [DataContract(Name = "methodCall")] + public class MethodCall + { + public MethodCall(string username, string password, string methodName) + { + MethodName = methodName; + methodParameterList = new List(); + methodParameterList.Add(new MethodParameter(username)); + methodParameterList.Add(new MethodParameter(password)); + } + + [DataMember(Name = "methodName", Order = 1)] + public string MethodName { get; set; } + + [DataMember(Name = "params", Order = 2)] + public List methodParameterList { get; set; } + + public string Request + { + get + { + XElement xElement = XmlHelper.RemoveAllNamespaces(this); + return XmlHelper.getFullXML(xElement); + } + } + } + + [DataContract(Name = "param")] + public class MethodParameter + { + public MethodParameter() + { } + public MethodParameter(string valueToSet) + { + value = valueToSet; + } + + + [DataMember(IsRequired = true)] + public string value { get; set; } + } + + [DataContract(Name = "param")] + public class MethodIntArrayParameter : MethodParameter + { + public MethodIntArrayParameter() + { } + public MethodIntArrayParameter(string[] valueToSet) + { + StringBuilder sb = new StringBuilder(""); + foreach (string x in valueToSet) + { + sb.Append(""); + sb.Append(x); + sb.Append(""); + } + sb.Append(""); + value = sb.ToString(); + } + + public MethodIntArrayParameter(int[] valueToSet) + { + StringBuilder sb = new StringBuilder(""); + foreach (int x in valueToSet) + { + sb.Append(""); + sb.Append(x.ToString()); + sb.Append(""); + } + sb.Append(""); + value = sb.ToString(); + } + } + + [DataContract(Name = "param")] + public class MethodStringArrayParameter : MethodParameter + { + public MethodStringArrayParameter() + { } + public MethodStringArrayParameter(string[] valueToSet) + { + StringBuilder sb = new StringBuilder(valueToSet.Count()); + foreach (string x in valueToSet) + { + sb.Append(x + ","); + //value = "" + valueToSet.ToString() + ""; + } + value = sb.ToString(); + } + } + + [DataContract(Name = "param")] + public class MethodDateTimeArrayParameter : MethodParameter + { + public MethodDateTimeArrayParameter(DateTime [] valueToSet) + { + StringBuilder sb = new StringBuilder(""); + foreach (DateTime x in valueToSet) + { + sb.Append(""); + sb.Append(x.ToString("yyyyMMddTHH:mm:ss")); + sb.Append(""); + } + sb.Append(""); + value = sb.ToString(); + } + public MethodDateTimeArrayParameter(string[] valueToSet) + { + StringBuilder sb = new StringBuilder(""); + foreach (string x in valueToSet) + { + sb.Append(""); + sb.Append(x); + sb.Append(""); + } + sb.Append(""); + value = sb.ToString(); + } + } + + [DataContract(Name = "param")] + public class MethodIntegerParameter : MethodParameter + { + public MethodIntegerParameter(int valueToSet) + { + value = "" + valueToSet.ToString() + ""; + } + public MethodIntegerParameter(string valueToSet) + { + value = "" + valueToSet + ""; + } + } + + + [DataContract(Name = "param")] + public class MethodDateTimeParameter : MethodParameter + { + public MethodDateTimeParameter(DateTime valueToSet) + { + value = "" + valueToSet.ToString("yyyyMMddTHH:mm:ss") + ""; + } + public MethodDateTimeParameter(string valueToSet) + { + value = "" + valueToSet + ""; + } + } +} + diff --git a/XMLRPCClient/XmlRpcClient.cs b/XMLRPCClient/XmlRpcClient.cs new file mode 100644 index 0000000..e066755 --- /dev/null +++ b/XMLRPCClient/XmlRpcClient.cs @@ -0,0 +1,2399 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Xml.Linq; +using System.Runtime.Serialization; +using System.Net; +using System.IO; + + +namespace XMLRPCClient +{ + public class XmlRpcClient + { + private string username; + private string password; + private string url; + public XmlRpcClient(string username, string password, string url) + { + this.username = username; + this.password = password; + this.url = url; + } + + #region Access Group Methods + /// + /// + /// + /// + /// name for new Access Group + /// GUID for new Access Group (autoassigned if "NULL") + /// GUID for the partition which owns this access group (ignored on non-partitioned systems) + /// 0 = non-public, 1 = public (ignored on non-partitioned systems) + /// array of Terminal GUIDs + /// array of Terminal Group GUIDs + /// + public string AccessGroupAdd(string sAccessGroupName, string sAccessGroupGuid, string sPartitionGuid, int iPublic, string[] sTerminalGuids, string[] sTerminalGroupGuids) + { + MethodCall methodCall = CreateMessage("AccessGroupAdd"); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupName)); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPublic)); + methodCall.methodParameterList.Add(new MethodStringArrayParameter(sTerminalGuids)); + methodCall.methodParameterList.Add(new MethodStringArrayParameter(sTerminalGroupGuids)); + + return WebPostSend(methodCall.Request); + } + /// + /// + /// + /// name for new Access Group + /// GUID for new Access Group (autoassigned if "NULL") + /// name of the partition which owns this access group (ignored on non-partitioned systems) + /// 0 = non-public, 1 = public (ignored on non-partitioned systems) + /// array of Terminal names + /// array of Terminal Group names + /// Returns TRUE (1) if successful, Fault Structure if failure. + /// Available in P2000 V3.5 and later. + public string AccessGroupAddByName(string sAccessGroupName, string sAccessGroupGuid, string sPartitionName, string iPublic, string[] sTerminals, string[] sTerminalGroups) + { + MethodCall methodCall = CreateMessage("AccessGroupAddByName"); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupName)); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPublic)); + methodCall.methodParameterList.Add(new MethodStringArrayParameter(sTerminals)); + methodCall.methodParameterList.Add(new MethodStringArrayParameter(sTerminalGroups)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of Partition to get AccessGroup list for (ignored on non-partitioned systems) + public string AccessGroupGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("AccessGroupGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of Partition to get AccessGroup list for (ignored on non-partitioned systems) + public string AccessGroupGetListByName( string sPartitionName) + { + MethodCall methodCall = CreateMessage("AccessGroupGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// GUID of Access Group + /// array of Terminal GUIDs + /// array of Terminal Group GUIDs + public string AccessGroupModify(string sAccessGroupGuid, string [] sTerminalGuids, string [] sTerminalGroupGuids) + { + MethodCall methodCall = CreateMessage("AccessGroupModify"); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupGuid)); + methodCall.methodParameterList.Add(new MethodStringArrayParameter(sTerminalGuids)); + methodCall.methodParameterList.Add(new MethodStringArrayParameter(sTerminalGroupGuids)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of Access Group + /// name of partition (ignored on non-partitioned systems) + /// array of Terminal names + /// array of Terminal Group names + /// + public string AccessGroupModifyByName(string sAccessGroupName, string sPartitionName, string[] sTerminalNames, string[] sTerminalGroupNames) + { + + MethodCall methodCall = CreateMessage("AccessGroupModifyByName"); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodStringArrayParameter(sTerminalNames)); + methodCall.methodParameterList.Add(new MethodStringArrayParameter(sTerminalGroupNames)); + + return WebPostSend(methodCall.Request); + + } + + /// + /// + /// + /// GUID of Access Group + public string AccessGroupDelete(string sAccessGroupGuid) + { + MethodCall methodCall = CreateMessage("AccessGroupDelete"); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of Access Group + /// name of partition (ignored on non-partitioned systems) + /// + public string AccessGroupDeleteByName(string sAccessGroupName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("AccessGroupDeleteByName"); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } +#endregion + #region Alarm Methods + /// + /// + /// + /// Unique type GUID of alarm to be created (alarms with the same type GUID are considered to be alarms for the same item) + /// Guid of partition that alarm belongs to (ignored on non-partitioned systems) + /// Public flag of alarm (ignored on non-partitioned systems) + /// Name of item generating alarm + /// Alarm description + /// Alarm Instructions (may be left blank) + /// Alarm priority (0 to 255) + /// Alarm category (default category if blank) + /// Alarm query string (may be left blank) + /// Ack required flag + /// Response required flag + /// Alarm Monitor popup flag + /// + public string AlarmCreate(string sAlarmTypeGuid, string sPartitionGuid, int iPublic, string sItemName, + string sDescription, string sInstructions, int iPriority, string sCategory, string sQueryString, + int iAckRequired, int iResponseRequired, int iPopup) + { + MethodCall methodCall = CreateMessage("AlarmCreate"); + //Unique type GUID of alarm to be created (alarms with the same type GUID are considered to be alarms for the same item) + methodCall.methodParameterList.Add(new MethodParameter(sAlarmTypeGuid)); + //Guid of partition that alarm belongs to (ignored on non-partitioned systems) + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + //Public flag of alarm (ignored on non-partitioned systems) + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPublic)); + //Name of item generating alarm + methodCall.methodParameterList.Add(new MethodParameter(sItemName)); + //Alarm description + methodCall.methodParameterList.Add(new MethodParameter(sDescription)); + //Alarm Instructions (may be left blank) + methodCall.methodParameterList.Add(new MethodParameter(sInstructions)); + //Alarm priority (0 to 255) + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPriority)); + //Alarm category (default category if blank) + methodCall.methodParameterList.Add(new MethodParameter(sCategory)); + //Alarm query string (may be left blank) + methodCall.methodParameterList.Add(new MethodParameter(sQueryString)); + //Ack required flag + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAckRequired)); + //Response required flag + methodCall.methodParameterList.Add(new MethodIntegerParameter(iResponseRequired)); + //Alarm Monitor popup flag + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPopup)); + return WebPostSend(methodCall.Request); + } + + + /// + /// + /// + /// Unique type GUID of alarm to be created (alarms with the same type GUID are considered to be alarms for the same item) + /// Guid of partition that alarm belongs to (ignored on non-partitioned systems) + /// Public flag of alarm (ignored on non-partitioned systems) + /// Name of item generating alarm + /// Alarm description + /// Alarm Instructions (may be left blank) + /// P2000 Alarm Type + /// Alarm priority (0 to 255) + /// Alarm category (default category if blank) + /// Alarm query string (may be left blank) + /// Ack required flag + /// Response required flag + /// Alarm Monitor popup flag + /// Time of the alarm in UTC + public string AlarmCreateDetailed(string sAlarmTypeGuid, string sPartitionGuid, int iPublic, + string sItemName, string sDescription, string sInstructions, int iAlarmType, int iPriority, + string sCategory, string sQueryString, int iAckRequired, int iResponseRequired, int iPopup, DateTime dtAlarmTime) + { + MethodCall methodCall = CreateMessage("AlarmCreateDetailed"); + methodCall.methodParameterList.Add(new MethodParameter(sAlarmTypeGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPublic)); + methodCall.methodParameterList.Add(new MethodParameter(sItemName)); + methodCall.methodParameterList.Add(new MethodParameter(sDescription)); + methodCall.methodParameterList.Add(new MethodParameter(sInstructions)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAlarmType)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPriority)); + methodCall.methodParameterList.Add(new MethodParameter(sCategory)); + methodCall.methodParameterList.Add(new MethodParameter(sQueryString)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAckRequired)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iResponseRequired)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPopup)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(dtAlarmTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of partition to search (ignored on non-partitioned systems) + public string AlarmGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("AlarmGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Name of partition to search (ignored on non-partitioned systems) + public string AlarmGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("AlarmGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of alarm to be updated + public string AlarmGetState(string sAlarmGuid) + { + MethodCall methodCall = CreateMessage("AlarmGetState"); + methodCall.methodParameterList.Add(new MethodParameter(sAlarmGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// P2000 V3.x: database GUID of alarm to be updated + /// 1 = alarm completed, 2 = alarm responding, 3 = alarm acknowledged + /// response to be recorded with alarm (only valid for iAlarmState = 2) + public string AlarmUpdate(string sAlarmGuid, int iAlarmState, string sResponse) + { + MethodCall methodCall = CreateMessage("AlarmUpdate"); + methodCall.methodParameterList.Add(new MethodParameter(sAlarmGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAlarmState)); + methodCall.methodParameterList.Add(new MethodParameter(sResponse)); + + return WebPostSend(methodCall.Request); + } +#endregion + #region Badge Methods + /// + /// + /// + /// Badge number + /// GUID of Access Group + /// GUID of Timezone + /// Optional arguments in P2000 V3.9 and later: + /// date Access Group starts (NULL if 0:0:00 AM Jan 1, 1900) + /// date Access Group ends (NULL if 0:0:00 AM Jan 1, 1900) + /// name of Enterprise site to modify (ignored for non-Enterprise systems) + public string BadgeAddAccessGroup(string sBadgeNumber, string sAccessGroupGuid, string sTimezoneGuid, DateTime? dtStartDate = null, DateTime? dtVoidDate = null, string sSiteName = null) + { + MethodCall methodCall = CreateMessage("BadgeAddAccessGroup"); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + if(dtStartDate != null) + { + methodCall.methodParameterList.Add(new MethodDateTimeParameter((DateTime)dtStartDate)); + } + if (dtVoidDate != null) + { + methodCall.methodParameterList.Add(new MethodDateTimeParameter((DateTime)dtVoidDate)); + } + if (sSiteName != null) + { + methodCall.methodParameterList.Add(new MethodParameter(sSiteName)); + } + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Badge number + /// name of partition (ignored on non-partitioned systems) + /// name of Access Group + /// name of Timezone + /// Optional arguments in P2000 V3.9 and later: + /// date Access Group starts (NULL if 0:0:00 AM Jan 1, 1900) + /// date Access Group ends (NULL if 0:0:00 AM Jan 1, 1900) + /// name of Enterprise site to modify (ignored for non-Enterprise systems) + public string BadgeAddAccessGroupByName(string sBadgeNumber, string sPartitionName, string sAccessGroupName, + string sTimezoneName, DateTime? dtStartDate=null, DateTime? dtVoidDate=null, string sSiteName=null) + { + MethodCall methodCall = CreateMessage("BadgeAddAccessGroupByName"); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupName)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneName)); + if(dtStartDate != null) + { + methodCall.methodParameterList.Add(new MethodDateTimeParameter((DateTime)dtStartDate)); + } + if (dtVoidDate != null) + { + methodCall.methodParameterList.Add(new MethodDateTimeParameter((DateTime)dtVoidDate)); + } + if (sSiteName != null) + { + methodCall.methodParameterList.Add(new MethodParameter(sSiteName)); + } + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Badge number + /// Optional arguments in P2000 V3.9 and later: + /// name of Enterprise site to get data for (ignored for non-Enterprise systems) + public string BadgeGetInfo(string sBadgeNumber, string sSiteName) + { + MethodCall methodCall = CreateMessage("BadgeGetInfo"); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + methodCall.methodParameterList.Add(new MethodParameter(sSiteName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Badge number + /// Optional arguments in P2000 V3.9 and later: + /// name of Enterprise site to get data for (ignored for non-Enterprise systems) + public string BadgeGetInfoDetailed(string sBadgeNumber, string sSiteName) + { + MethodCall methodCall = CreateMessage("BadgeGetInfoDetailed"); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + methodCall.methodParameterList.Add(new MethodParameter(sSiteName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Badge number + public string BadgeGetLastBadgeInfo(string sBadgeNumber) + { + MethodCall methodCall = CreateMessage("BadgeGetLastBadgeInfo"); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Badge number + public string BadgeGetPurpose(string sBadgeNumber) + { + MethodCall methodCall = CreateMessage("BadgeGetPurpose"); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Badge number + /// GUID of Access Group + /// Optional arguments in P2000 V3.9 and later: + /// name of Enterprise site to get data for (ignored for non-Enterprise systems) + public string BadgeRemoveAccessGroup(string sBadgeNumber, string sAccessGroupGuid, string sSiteName = null) + { + MethodCall methodCall = CreateMessage("BadgeRemoveAccessGroup"); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + if (sSiteName != null) + { + methodCall.methodParameterList.Add(new MethodParameter(sSiteName)); + } + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Badge number + /// name of partition (ignored on non-partitioned systems) + /// name of Access Group + /// Optional arguments in P2000 V3.9 and later: + /// name of Enterprise site to get data for (ignored for non-Enterprise systems) + public string BadgeRemoveAccessGroupByName(string sBadgeNumber, string sPartitionName, string sAccessGroupName, + string sSiteName = null) + { + MethodCall methodCall = CreateMessage("BadgeRemoveAccessGroupByName"); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodParameter(sAccessGroupName)); + if (sSiteName !=null) + { + methodCall.methodParameterList.Add(new MethodParameter(sSiteName)); + } + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Badge number + /// 0 = undefined, 1 = in, 2 = out + public string BadgeSetEntryExitStatus(string sBadgeNumber, int iStatus) + { + MethodCall methodCall = CreateMessage("BadgeSetEntryExitStatus"); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iStatus)); + + return WebPostSend(methodCall.Request); + } +#endregion + #region Cardholder Methods + /// + /// + /// + /// Guid of cardholder + public string CardholderGetAllUdf(string sCardholderGuid) + { + MethodCall methodCall = CreateMessage("CardholderGetAllUdf"); + methodCall.methodParameterList.Add(new MethodParameter(sCardholderGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of cardholder + /// Guid of partition to search (ignored on non-partitioned systems) + public string CardholderGetBadgeList(string sCardholderGuid, string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("CardholderGetBadgeList"); + methodCall.methodParameterList.Add(new MethodParameter(sCardholderGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of cardholder + public string CardholderGetImage(string sCardholderGuid) + { + MethodCall methodCall = CreateMessage("CardholderGetImage"); + methodCall.methodParameterList.Add(new MethodParameter(sCardholderGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// employee ID of cardholder + public string CardholderGetImageByID(string sEmployeeID) + { + MethodCall methodCall = CreateMessage("CardholderGetImageByID"); + methodCall.methodParameterList.Add(new MethodParameter(sEmployeeID)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of cardholder + public string CardholderGetInfo(string sCardholderGuid) + { + MethodCall methodCall = CreateMessage("CardholderGetInfo"); + methodCall.methodParameterList.Add(new MethodParameter(sCardholderGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// + public string CardholderGetInfoByID(string sEmployeeID) + { + MethodCall methodCall = CreateMessage("CardholderGetInfoByID"); + methodCall.methodParameterList.Add(new MethodParameter(sEmployeeID)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// employee ID of cardholder + public string CardholderGetLastBadgeInfo(string sEmployeeID) + { + MethodCall methodCall = CreateMessage("CardholderGetLastBadgeInfo"); + methodCall.methodParameterList.Add(new MethodParameter(sEmployeeID)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of cardholder + public string CardholderGetLastBadgeInfoByID(string sCardholderGuid) + { + MethodCall methodCall = CreateMessage("CardholderGetLastBadgeInfoByID"); + methodCall.methodParameterList.Add(new MethodParameter(sCardholderGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of partition to search (ignored on non-partitioned systems) + /// first name search filter string* + /// last name search filter string* + /// the maximum number of results to return; + public string CardholderGetList(string sPartitionGuid, string sFirstNameFilter, string sLastNameFilter, + int iMaxCount) + { + MethodCall methodCall = CreateMessage("CardholderGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sFirstNameFilter)); + methodCall.methodParameterList.Add(new MethodParameter(sLastNameFilter)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iMaxCount)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// + /// + /// + /// + /// + public string CardholderGetListByName(string sPartitionName, string sFirstNameFilter, + string sLastNameFilter, int iMaxCount) + { + MethodCall methodCall = CreateMessage("CardholderGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodParameter(sFirstNameFilter)); + methodCall.methodParameterList.Add(new MethodParameter(sLastNameFilter)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iMaxCount)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of partition to search (ignored on non-partitioned systems) + /// first name search filter string* + /// last name search filter string* + public string CardholderGetListCount(string sPartitionGuid, string sFirstNameFilter, string sLastNameFilter) + { + MethodCall methodCall = CreateMessage("CardholderGetListCount"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sFirstNameFilter)); + methodCall.methodParameterList.Add(new MethodParameter(sLastNameFilter)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of partition to search (ignored on non-partitioned systems) + /// first name search filter string* + /// last name search filter string* + public string CardholderGetListCountByName(string sPartitionName, string sFirstNameFilter, string sLastNameFilter) + { + MethodCall methodCall = CreateMessage("CardholderGetListCountByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodParameter(sFirstNameFilter)); + methodCall.methodParameterList.Add(new MethodParameter(sLastNameFilter)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of cardholder + /// Guid of Udf + public string CardholderGetUdf(string sCardholderGuid, string sUdfGuid) + { + MethodCall methodCall = CreateMessage("CardholderGetUdf"); + methodCall.methodParameterList.Add(new MethodParameter(sCardholderGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sUdfGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of cardholder + /// 0 = undefined, 1 = in, 2 = out + public string CardholderSetEntryExitStatus( string sCardholderGuid, int iStatus) + { + MethodCall methodCall = CreateMessage("CardholderSetEntryExitStatus"); + methodCall.methodParameterList.Add(new MethodParameter(sCardholderGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iStatus)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// employee ID of cardholder + /// 0 = undefined, 1 = in, 2 = out + public string CardholderSetEntryExitStatusByID(string sEmployeeID, int iStatus) + { + MethodCall methodCall = CreateMessage("CardholderSetEntryExitStatusByID"); + methodCall.methodParameterList.Add(new MethodParameter(sEmployeeID)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iStatus)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of cardholder + /// Guid of Udf + /// UDF value of proper type for UDF (boolean, integer, string, or date) + //public string CardholderSetUdf( string sCardholderGuid, string sUdfGuid, Value) + //{ + // MethodCall methodCall = CreateMessage(""); + // methodCall.methodParameterList.Add(new MethodParameter()); + // methodCall.methodParameterList.Add(new MethodStringArrayParameter()); + + // return WebPostSend(methodCall.Request); + //} +#endregion + #region Company Methods + /// + /// + /// + /// Guid of Partition to get Company list for (ignored on non-partitioned systems) + public string CompanyGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("CompanyGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of Partition to get Company list for (ignored on non-partitioned systems) + public string CompanyGetListByName( string sPartitionName) + { + MethodCall methodCall = CreateMessage("CompanyGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region Counter Methods + /// + /// + /// + /// Guid of Partition to get counter list for (ignored on non-partitioned systems) + public string CounterGetList( string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("CounterGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + /// + /// + /// + /// name of Partition to get counter list for (ignored on non-partitioned systems) + public string CounterGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("CounterGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of counter + public string CounterGetValue(string sCounterGuid) + { + MethodCall methodCall = CreateMessage("CounterGetValue"); + methodCall.methodParameterList.Add(new MethodParameter(sCounterGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of counter + /// name of the partition (ignored on non-partitioned systems) + public string CounterGetValueByName(string sCounterName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("CounterGetValueByName"); + methodCall.methodParameterList.Add(new MethodParameter(sCounterName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of counter + /// value to set counter to + public string CounterSetValue(string sCounterGuid, int iValue) + { + MethodCall methodCall = CreateMessage("CounterSetValue"); + methodCall.methodParameterList.Add(new MethodParameter(sCounterGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iValue)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of counter + /// name of Partition (ignored on non-partitioned systems) + /// value to set counter to + public string CounterSetValueByName(string sCounterName, string sPartitionName, int iValue) + { + MethodCall methodCall = CreateMessage("CounterSetValueByName"); + methodCall.methodParameterList.Add(new MethodParameter(sCounterName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iValue)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of counter + /// value to increment counter by + public string CounterChangeValue(string sCounterGuid, int iValueBy) + { + MethodCall methodCall = CreateMessage("CounterChangeValue"); + methodCall.methodParameterList.Add(new MethodParameter(sCounterGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iValueBy)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Counter Name + /// Partition Name (ignored if system is not partitioned) + /// value to increment counter by + public string CounterChangeValueByName(string sCounterName, string sPartitionName, int iValueBy) + { + MethodCall methodCall = CreateMessage("CounterChangeValueByName"); + methodCall.methodParameterList.Add(new MethodParameter(sCounterName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iValueBy)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region Department Methods + /// + /// + /// + /// Guid of Partition to get Department list for (ignored on non-partitioned systems) + public string DepartmentGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("DepartmentGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Name of Partition to get Department list for (ignored on non-partitioned systems) + public string DepartmentGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("DepartmentGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region Door Methods + + /// + /// + /// + /// ID of scheduled action to be deleted + public string DoorDeleteScheduled( int iScheduledID) + { + MethodCall methodCall = CreateMessage("DoorDeleteScheduled"); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iScheduledID)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// 1 = enabled, 0 = disabled + public string DoorEnable(string sTerminalGuid, int iEnable) + { + MethodCall methodCall = CreateMessage("DoorEnable"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iEnable)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + public string DoorGetAlarmInputs(string sTerminalGuid) + { + MethodCall methodCall = CreateMessage("DoorGetAlarmInputs"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored for non-partitioned system) + public string DoorGetAlarmInputsByName(string sTerminalName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("DoorGetAlarmInputsByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of Partition to get door list for (ignored on non-partitioned systems) + public string DoorGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("DoorGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of Partition to get door list for (ignored on non-partitioned systems) + /// + public string DoorGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("DoorGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + public string DoorGetScheduled(string sTerminalGuid) + { + MethodCall methodCall = CreateMessage("DoorGetScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored for non-partitioned systems) + public string DoorGetScheduledByName(string sTerminalName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("DoorGetScheduledByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of Partition to get list for (ignored on non-partitioned systems) + public string DoorGetAllScheduled(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("DoorGetAllScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of Partition to get list for (ignored on non-partitioned systems) + public string DoorGetAllScheduledByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("DoorGetAllScheduledByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of door as retrieve from door point list + public string DoorGetSecurityLevel(string sDoorGuid) + { + MethodCall methodCall = CreateMessage("DoorGetSecurityLevel"); + methodCall.methodParameterList.Add(new MethodParameter(sDoorGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of door + /// partition name (ignored on non-partitioned systems) + public string DoorGetSecurityLevelByName (string sDoorName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("DoorGetSecurityLevelByName"); + methodCall.methodParameterList.Add(new MethodParameter(sDoorName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + public string DoorGetStatus(string sTerminalGuid) + { + MethodCall methodCall = CreateMessage("DoorGetStatus"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// partition name (ignored on non-partitioned systems) + public string DoorGetStatusByName(string sTerminalName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("DoorGetStatusByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + public string DoorLock(string sTerminalGuid) + { + MethodCall methodCall = CreateMessage("DoorLock"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// time for action to occur + public string DoorLockScheduled(string sTerminalGuid, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorLockScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + public string DoorLockByName(string sTerminalName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("DoorLockByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + /// time for action to occur + public string DoorLockByNameScheduled(string sTerminalName, string sPartitionName, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorLockByNameScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// database GUID of the Timezone + public string DoorSetOverrideTimezone(string sTerminalGuid, string sTimezoneGuid) + { + MethodCall methodCall = CreateMessage("DoorSetOverrideTimezone"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + /// name of the Timezone + public string DoorSetOverrideTimezoneByName(string sTerminalName, string sPartitionName, string sTimezoneName) + { + MethodCall methodCall = CreateMessage("DoorSetOverrideTimezoneByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// 1 = override timezone enabled, 0 = override timezone disabled + public string DoorSetOverrideTimezoneEnable(string sTerminalGuid, int iEnable) + { + MethodCall methodCall = CreateMessage("DoorSetOverrideTimezoneEnable"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iEnable)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + /// 1 = override timezone enabled, 0 = override timezone disabled + public string DoorSetOverrideTimezoneEnableByName(string sTerminalName, string sPartitionName, int iEnable) + { + MethodCall methodCall = CreateMessage("DoorSetOverrideTimezoneEnableByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iEnable)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// database GUID of time zone to be overridden + /// time for action to occur + public string DoorSetOverrideTimezoneScheduled(string sTerminalGuid, string sTimezoneGuid, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorSetOverrideTimezoneScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + /// database GUID of time zone to be overridden + /// time for action to occur + public string DoorSetOverrideTimezoneByNameScheduled( string sTerminalName, string sPartitionName, + string sTimezoneGuid, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorSetOverrideTimezoneByNameScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// Enable flag + /// time for action to occur + public string DoorSetOverrideTimezoneEnableScheduled(string sTerminalGuid, int iEnable, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorSetOverrideTimezoneEnableScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iEnable)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + /// Enable flag + /// time for action to occur + public string DoorSetOverrideTimezoneEnableByNameScheduled (string sTerminalName, string sPartitionName, + int iEnable, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorSetOverrideTimezoneEnableByNameScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iEnable)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// the new security level for this door (0 .. 99) + public string DoorSetSecurityLevel(string sTerminalGuid, int iSecurityLevel) + { + MethodCall methodCall = CreateMessage("DoorSetSecurityLevel"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iSecurityLevel)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// partition name (ignored on non-partitioned systems) + /// the new security level for this door (0 .. 99) + public string DoorSetSecurityLevelByName (string sTerminalName, string sPartitionName, int iSecurityLevel) + { + MethodCall methodCall = CreateMessage("DoorSetSecurityLevelByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iSecurityLevel)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// new security level for this door (0 = clear, 1 = green, 2 = blue, 3 = yellow, 4 = orange, 5 = red) + public string DoorSetSecurityLevelColor(string sTerminalGuid, int iSecurityLevelColor) + { + MethodCall methodCall = CreateMessage("DoorSetSecurityLevelColor"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iSecurityLevelColor)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// partition name (ignored on non-partitioned systems) + /// the new security level for this door ("clear", "green", "blue", "yellow", "orange", or "red") + public string DoorSetSecurityLevelColorByName (string sTerminalName, string sPartitionName, + string sSecurityLevelColor) + { + MethodCall methodCall = CreateMessage("DoorSetSecurityLevelColorByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// amount of time to unlock door in minutes (maximum of 1440 minutes) + public string DoorTimedUnlock(string sTerminalGuid, int iTime) + { + MethodCall methodCall = CreateMessage("DoorTimedUnlock"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// amount of time to unlock door in minutes (maximum of 1440 minutes) + /// time for action to occur + public string DoorTimedUnlockScheduled(string sTerminalGuid, int iTime, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorTimedUnlockScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iTime)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + /// amount of time to unlock door in minutes (maximum of 1440 minutes) + public string DoorTimedUnlockByName(string sTerminalName, string sPartitionName, int iTime) + { + MethodCall methodCall = CreateMessage("DoorTimedUnlockByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + /// amount of time to unlock door in minutes (maximum of 1440 minutes) + /// time for action to occur + public string DoorTimedUnlockByNameScheduled(string sTerminalName, string sPartitionName, + int iTime, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorTimedUnlockByNameScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iTime)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + public string DoorUnlock(string sTerminalGuid) + { + MethodCall methodCall = CreateMessage("DoorUnlock"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of terminal + /// time for action to occur + public string DoorUnlockScheduled(string sTerminalGuid, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorUnlockScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalGuid)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + public string DoorUnlockByName(string sTerminalName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("DoorUnlockByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of terminal + /// name of partition (ignored on non-partitioned systems) + /// time for action to occur + public string DoorUnlockByNameScheduled(string sTerminalName, string sPartitionName, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("DoorUnlockByNameScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// 0 = return to normal, 1 = unlock + /// Guid of Partition of doors to unlock (ignored on non-partitioned systems) + public string DoorUnlockAll(int iUnlock, string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("DoorUnlockAll"); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iUnlock)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// 0 = return to normal, 1 = unlock + /// name of Partition of doors to unlock (ignored on non-partitioned systems) + public string DoorUnlockAllByName(int iUnlock, string sPartitionName) + { + MethodCall methodCall = CreateMessage("DoorUnlockAllByName"); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iUnlock)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region Event Methods + + /// + /// + /// + /// ID of scheduled action to be deleted + public string EventDeleteScheduled(int iScheduledID) + { + MethodCall methodCall = CreateMessage("EventDeleteScheduled"); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iScheduledID)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of partition to get scheduled events for (ignored for non-partitioned systems) + public string EventGetAllScheduled(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("EventGetAllScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of partition to get scheduled events for (ignored for non-partitioned systems) + public string EventGetAllScheduledByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("EventGetAllScheduledByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of event to be triggered + public string EventTrigger(string sEventGuid) + { + MethodCall methodCall = CreateMessage("EventTrigger"); + methodCall.methodParameterList.Add(new MethodParameter(sEventGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of event to be triggered + /// name of partition (ignored on non-partitioned systems) + public string EventTriggerByName(string sEventName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("EventTriggerByName"); + methodCall.methodParameterList.Add(new MethodParameter(sEventName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of event to be triggered + /// name of partition (ignored on non-partitioned systems) + /// time for action to occur + public string EventTriggerByNameScheduled(string sEventName, string sPartitionName, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("EventTriggerByNameScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sEventName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of event to be triggered + /// time for action to occur + public string EventTriggerScheduled(string sEventGuid, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("EventTriggerScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sEventGuid)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region Input Methods + + /// + /// + /// + /// database GUID of input point + /// 1 = disable input, 0 = enable input + public string InputDisable(string sInputGuid, int iDisable) + { + MethodCall methodCall = CreateMessage("InputDisable"); + methodCall.methodParameterList.Add(new MethodParameter(sInputGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iDisable)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of input + /// name of partition (ignored on non-partitioned systems) + /// 1 = disable input, 0 = enable input + public string InputDisableByName(string sInputName, string sPartitionName, int iDisable) + { + MethodCall methodCall = CreateMessage("InputDisableByName"); + methodCall.methodParameterList.Add(new MethodParameter(sInputName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iDisable)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of partition to get input list for (ignored on non-partitioned systems) + public string InputGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("InputGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of partition to get Input list for (ignored on non-partitioned systems) + public string InputGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("InputGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of input point + public string InputGetStatus(string sInputGuid) + { + MethodCall methodCall = CreateMessage("InputGetStatus"); + methodCall.methodParameterList.Add(new MethodParameter(sInputGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of input + /// name of partition (ignored on non-partitioned systems) + public string InputGetStatusByName(string sInputName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("InputGetStatusByName"); + methodCall.methodParameterList.Add(new MethodParameter(sInputName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of input point + /// duration in seconds (0 to cancel suppression) + public string InputSuppress(string sInputGuid, int iDuration) + { + MethodCall methodCall = CreateMessage("InputSuppress"); + methodCall.methodParameterList.Add(new MethodParameter(sInputGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iDuration)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of input + /// name of partition (ignored on non-partitioned systems) + /// duration in seconds (0 to cancel suppression) + public string InputSuppressByName(string sInputName, string sPartition, int iDuration) + { + MethodCall methodCall = CreateMessage("InputSuppressByName"); + methodCall.methodParameterList.Add(new MethodParameter(sInputName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartition)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iDuration)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region Output Methods + + /// + /// + /// + /// ID of scheduled action to be deleted + public string OutputDeleteScheduled(int iScheduledID) + { + MethodCall methodCall = CreateMessage("OutputDeleteScheduled"); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iScheduledID)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of Partition to get Output list for (ignored on non-partitioned systems) + public string OutputGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("OutputGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of partition to get Output list for (ignored on non-partitioned systems) + public string OutputGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("OutputGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of output point + public string OutputGetScheduled(string sOutputGuid) + { + MethodCall methodCall = CreateMessage("OutputGetScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of output point + /// name of partition (ignored on non-partitioned systems) + public string OutputGetScheduledByName(string sOutputName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("OutputGetScheduledByName"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of output point + public string OutputGetStatus(string sOutputGuid) + { + MethodCall methodCall = CreateMessage("OutputGetStatus"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of output + /// name of partition (ignored on non-partitioned systems) + public string OutputGetStatusByName(string sOutputName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("OutputGetStatusByName"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of output point + /// 0 = reset output, 1 = set output, 2 = slow flash, 3 = fast flash, 4 = preset + public string OutputSet(string sOutputGuid, int iAction) + { + MethodCall methodCall = CreateMessage("OutputSet"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAction)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of output point + /// name of partition (ignored on non-partitioned systems) + /// 0 = reset output, 1 = set output, 2 = slow flash, 3 = fast flash, 4 = preset + public string OutputSetByName(string sOutputName, string sPartitionName, int iAction) + { + MethodCall methodCall = CreateMessage("OutputSetByName"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAction)); + + return WebPostSend(methodCall.Request); + } + + + /// + /// + /// + /// name of output point + /// name of partition (ignored on non-partitioned systems) + /// 0 = reset output, 1 = set output + /// time for action to occur + public string OutputSetByNameScheduled(string sOutputName, string sPartitionName, int iAction, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("OutputSetByNameScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAction)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of output point + /// 0 = reset output, 1 = set output + /// duration in seconds (ignored if action is reset) + public string OutputSetForDuration(string sOutputGuid, int iAction, int iDuration) + { + MethodCall methodCall = CreateMessage("OutputSetForDuration"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAction)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iDuration)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of output point + /// name of partition (ignored on non-partitioned systems) + /// 0 = reset output, 1 = set output + /// duration in seconds (ignored if action is reset) + public string OutputSetForDurationByName(string sOutputName, string sPartitionName, int iAction, int iDuration) + { + MethodCall methodCall = CreateMessage("OutputSetForDurationByName"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAction)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iDuration)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of output point + /// 0 = reset output, 1 = set output + /// duration in seconds (ignored if action is reset) + /// time for action to occur + public string OutputSetForDurationScheduled(string sOutputGuid, int iAction, int iDuration, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage("OutputSetForDurationScheduled"); + methodCall.methodParameterList.Add(new MethodParameter(sOutputGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAction)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iDuration)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tScheduledTime)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of output point + /// name of partition (ignored on non-partitioned systems) + /// 0 = reset output, 1 = set output + /// duration in seconds (ignored if action is reset) + /// time for action to occur + public string OutputSetForDurationByNameScheduled(string sOutputName, string sPartitionName, + int iAction, int iDuration, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage(""); + methodCall.methodParameterList.Add(new MethodParameter()); + methodCall.methodParameterList.Add(new MethodStringArrayParameter()); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of output point + /// 0 = reset output, 1 = set output + /// time for action to occur + public string OutputSetScheduled(string sOutputGuid, int iAction, DateTime tScheduledTime) + { + MethodCall methodCall = CreateMessage(""); + methodCall.methodParameterList.Add(new MethodParameter()); + methodCall.methodParameterList.Add(new MethodStringArrayParameter()); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region P2000 Methods + + /// + /// + /// + public string P2000GetVersion() + { + MethodCall methodCall = CreateMessage("P2000GetVersion"); + methodCall.methodParameterList.Add(new MethodParameter()); + methodCall.methodParameterList.Add(new MethodStringArrayParameter()); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region Panel Methods + + /// + /// + /// + /// Guid of panel + /// Guid of Partition to get component list for (ignored on non-partitioned systems) + public string PanelGetComponents(string sPanelGuid, string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("PanelGetComponents"); + methodCall.methodParameterList.Add(new MethodParameter(sPanelGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of panel + /// name of Partition to get component list for (ignored on non-partitioned systems) + public string PanelGetComponentsByName(string sPanelName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("PanelGetComponentsByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPanelName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of Partition to get Panel list for (ignored on non-partitioned systems) + public string PanelGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("PanelGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of Partition to get Panel list for (ignored on non-partitioned systems) + public string PanelGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("PanelGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of panel + public string PanelGetTimezones(string sPanelGuid) + { + MethodCall methodCall = CreateMessage("PanelGetTimezones"); + methodCall.methodParameterList.Add(new MethodParameter(sPanelGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of panel + /// name of partition (ignored on non-partitioned systems) + public string PanelGetTimezonesByName(string sPanelName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("PanelGetTimezonesByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPanelName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of panel + /// position of Timezone (1 to 64) + /// Guid of Timezone ("" if none) + /// Guid of output group ("" if none) + public string PanelModifyTimezone(string sPanelGuid, int iTimezonePos, string sTimezoneGuid, string sOutputGrpGuid) + { + MethodCall methodCall = CreateMessage("PanelModifyTimezone"); + methodCall.methodParameterList.Add(new MethodParameter(sPanelGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iTimezonePos)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sOutputGrpGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of panel + /// name of partition (ignored on non-partitioned systems) + /// position of Timezone (1 to 64) + /// name of Timezone ("" if none) + /// name of output group ("" if none) + public string PanelModifyTimezoneByName(string sPanelName, string sPartitionName, int iTimezonePos, + string sTimezoneName, string sOutputGrpName) + { + MethodCall methodCall = CreateMessage("PanelModifyTimezoneByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPanelName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iTimezonePos)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneName)); + methodCall.methodParameterList.Add(new MethodParameter(sOutputGrpName)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region Partition Methods + /// + /// + /// + /// + public string PartitionGetList() + { + MethodCall methodCall = CreateMessage("PartitionGetList"); + return WebPostSend(methodCall.Request); + } + + #endregion + + #region Terminal Methods + + /// + /// + /// + /// Guid of Partition to get terminal list for (ignored on non-partitioned systems) + public string TerminalGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("TerminalGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + /// + /// + /// + /// name of Partition to get terminal list for (ignored on non-partitioned systems) + public string TerminalGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("TerminalGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region TimeZone Methods + + /// + /// + /// + /// name for new Timezone + /// GUID for new Timezone (autoassigned if "NULL") + /// GUID for the partition which owns this timezone (ignored on non-partitioned systems) + /// 0 = non-public, 1 = public (ignored on non-partitioned systems) + /// 0 = do not add to panels, 1 = add to all panels + /// array of 10 initial states (0 = starts disabled at midnight, 1 = starts enabled at midnight) + /// array of 70 timezone toggles (ignored if 00:00:00) + public string TimezoneAdd(string sTimezoneName, string sTimezoneGuid, string sPartitionGuid, + int iPublic, int iAddToAllPanels, int [] iInitialStates, DateTime[] tTimes) + { + MethodCall methodCall = CreateMessage("TimezoneAdd"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneName)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPublic)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAddToAllPanels)); + methodCall.methodParameterList.Add(new MethodIntArrayParameter(iInitialStates)); + methodCall.methodParameterList.Add(new MethodDateTimeArrayParameter(tTimes)); + + return WebPostSend(methodCall.Request); + } + + + /// + /// + /// + /// name for new Timezone + /// GUID for new Timezone (autoassigned if "NULL") + /// name of the partition which owns this timezone (ignored on non-partitioned systems) + /// 0 = non-public, 1 = public (ignored on non-partitioned systems) + /// 0 = do not add to panels, 1 = add to all panels + /// array of 10 initial states (0 = starts disabled at midnight, 1 = starts enabled at midnight) + /// array of 70 timezone toggles (ignored if 00:00:00) + public string TimezoneAddByName(string sTimezoneName, string sTimezoneGuid, string sPartitionName, + int iPublic, int iAddToAllPanels, int [] iInitialStates, DateTime[] tTimes) + { + MethodCall methodCall = CreateMessage("TimezoneAddByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneName)); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPublic)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iAddToAllPanels)); + methodCall.methodParameterList.Add(new MethodIntArrayParameter(iInitialStates)); + methodCall.methodParameterList.Add(new MethodDateTimeArrayParameter(tTimes)); + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of the Timezone + public string TimezoneIsActive(string sTimezoneGuid) + { + MethodCall methodCall = CreateMessage("TimezoneIsActive"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of the Timezone + /// name of partition (ignored on non-partitioned systems) + public string TimezoneIsActiveByName(string sTimezoneName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("TimezoneIsActiveByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of the Timezone + public string TimezoneGetInfo(string sTimezoneGuid) + { + MethodCall methodCall = CreateMessage("TimezoneGetInfo"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of the Timezone + /// name of partition (ignored on non-partitioned systems) + public string TimezoneGetInfoByName(string sTimezoneName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("TimezoneGetInfoByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of Partition to get Timezone list for (ignored on non-partitioned systems) + public string TimezoneGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("TimezoneGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of Partition to get Timezone list for (ignored on non-partitioned systems) + public string TimezoneGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("TimezoneGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of the Timezone + /// array of 10 initial states (0 = starts disabled at midnight, 1 = starts enabled at midnight) + /// array of 70 timezone toggles (ignored if 00:00:00) + public string TimezoneModify(string sTimezoneGuid, int iInitialState, DateTime [] tTimes) + { + MethodCall methodCall = CreateMessage("TimezoneModify"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iInitialState)); + methodCall.methodParameterList.Add(new MethodDateTimeArrayParameter(tTimes)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of the Timezone + /// name of Partition (ignored on non-partitioned systems) + /// array of 10 initial states (0 = starts disabled at midnight, 1 = starts enabled at midnight) + /// array of 70 timezone toggles (ignored if 00:00:00) + public string TimezoneModifyByName(string sTimezoneName, string sPartitionName, + int iInitialState, DateTime[] tTimes) + { + MethodCall methodCall = CreateMessage("TimezoneModifyByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iInitialState)); + methodCall.methodParameterList.Add(new MethodDateTimeArrayParameter(tTimes)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// database GUID of the Timezone + public string TimezoneDelete(string sTimezoneGuid) + { + MethodCall methodCall = CreateMessage("TimezoneDelete"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of the Timezone + /// name of partition (ignored if system is not partitioned) + public string TimezoneDeleteByName(string sTimezoneName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("TimezoneDeleteByName"); + methodCall.methodParameterList.Add(new MethodParameter(sTimezoneName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region UDF Methods + + /// + /// + /// + /// Guid of Partition to get UDF list for (ignored on non-partitioned systems) + public string UdfGetList(string sPartitionGuid) + { + MethodCall methodCall = CreateMessage("UdfGetList"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of Partition to get UDF list for (ignored on non-partitioned systems) + public string UdfGetListByName(string sPartitionName) + { + MethodCall methodCall = CreateMessage("UdfGetListByName"); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// Guid of UDF to get selection choices for + public string UdfGetSelectionChoices(string sUdfGuid) + { + MethodCall methodCall = CreateMessage("UdfGetSelectionChoices"); + methodCall.methodParameterList.Add(new MethodParameter(sUdfGuid)); + + return WebPostSend(methodCall.Request); + } + + /// + /// + /// + /// name of UDF to get selection choices for + /// name of partition (ignored on non-partitioned systems) + public string UdfGetSelectionChoicesByName(string sUdfName, string sPartitionName) + { + MethodCall methodCall = CreateMessage("UdfGetSelectionChoicesByName"); + methodCall.methodParameterList.Add(new MethodParameter(sUdfName)); + methodCall.methodParameterList.Add(new MethodParameter(sPartitionName)); + + return WebPostSend(methodCall.Request); + } + + #endregion + + #region XAction Methods + + /// + /// + /// + /// History Type + /// name of panel + /// Terminal name + /// Point name + /// Badge number + /// First name + /// Last name + /// Override time + /// Issue Level of badge + /// Facility code of badge + /// name of event + /// timestamp of transaction + /// name of partition which owns this action + /// 0 = non-public, 1 = public + public string XActionSave(int iHistType, string sPanelName, string sTerminalName, + string sPointName, string sBadgeNumber, string sFirstName, string sLastName, + int iTimedOverride, int iIssueLevel, int iFacilityCode, string sEventName, + DateTime tTime, string sPartition, int iPublic) + { + MethodCall methodCall = CreateMessage("XActionSave"); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iHistType)); + methodCall.methodParameterList.Add(new MethodParameter(sPanelName)); + methodCall.methodParameterList.Add(new MethodParameter(sTerminalName)); + methodCall.methodParameterList.Add(new MethodParameter(sPointName)); + methodCall.methodParameterList.Add(new MethodParameter(sBadgeNumber)); + methodCall.methodParameterList.Add(new MethodParameter(sFirstName)); + methodCall.methodParameterList.Add(new MethodParameter(sLastName)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iTimedOverride)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iIssueLevel)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iFacilityCode)); + methodCall.methodParameterList.Add(new MethodParameter(sEventName)); + methodCall.methodParameterList.Add(new MethodDateTimeParameter(tTime)); + methodCall.methodParameterList.Add(new MethodParameter(sPartition)); + methodCall.methodParameterList.Add(new MethodIntegerParameter(iPublic)); + + return WebPostSend(methodCall.Request); + } + #endregion + + private MethodCall CreateMessage(string methodName) + { + MethodCall methodCall = new MethodCall(this.username, this.password, methodName); + return methodCall; + } + + private string WebPostSend(string postData) + { + string responseData = ""; + try + { + HttpWebRequest request = (HttpWebRequest)WebRequest.Create(this.url); + request.AllowAutoRedirect = true; + request.Timeout = 6000; + request.Method = "POST"; + request.ContentType = "text/xml"; + + request.ContentType = "application/x-www-form-urlencoded"; + ASCIIEncoding encoding = new System.Text.ASCIIEncoding(); + byte[] postByteArray = encoding.GetBytes(postData); + request.ContentLength = postByteArray.Length; + + Stream postStream = request.GetRequestStream(); + postStream.Write(postByteArray, 0, postByteArray.Length); + postStream.Close(); + + HttpWebResponse response = (HttpWebResponse)request.GetResponse(); + if (response.StatusCode == HttpStatusCode.OK) + { + Stream responseStream = response.GetResponseStream(); + StreamReader myStreamReader = new StreamReader(responseStream); + responseData = myStreamReader.ReadToEnd(); + } + response.Close(); + } + catch (System.Net.WebException webEx) + { + throw webEx; + } + catch (Exception e) + { + throw e; + } + return responseData; + } + } + +} diff --git a/XMLRPCClient/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache b/XMLRPCClient/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache new file mode 100644 index 0000000000000000000000000000000000000000..8f11f57253c96c081ecc5a3d7f780262e1901f6b GIT binary patch literal 5722 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 literal 0 HcmV?d00001 diff --git a/XMLRPCClient/obj/Debug/XMLRPCClient.pdb b/XMLRPCClient/obj/Debug/XMLRPCClient.pdb new file mode 100644 index 0000000000000000000000000000000000000000..e00f896ff9de33efb3680222e77fed8b2f9cfe24 GIT binary patch literal 95744 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