/// <summary>
/// Create a new routing rule in the Connection directory
/// </summary>
/// <param name="pConnectionServer">
/// Connection server being edited
/// </param>
/// <param name="pDisplayName">
/// Display Name of the new routing rule - must be unique.
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a property name and a new value for that property to apply to the rule being created.
/// This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. Can be passed as null here.
/// </param>
/// <param name="pRoutingRule">
/// Newly created routing rule instance is passed back in this out parameter
/// </param>
/// <returns>
/// Instance of the WebCallResult class.
/// </returns>
public static WebCallResult AddRoutingRule(ConnectionServerRest pConnectionServer,
string pDisplayName,
ConnectionPropertyList pPropList,
out RoutingRule pRoutingRule)
{
pRoutingRule = null;
WebCallResult res = AddRoutingRule(pConnectionServer, pDisplayName, pPropList);
//if the call went through then the ObjectId will be returned in the URI form.
if (res.Success)
{
//fetch the instance of the rule just created.
try
{
pRoutingRule = new RoutingRule(pConnectionServer, res.ReturnedObjectId);
}
catch (Exception)
{
res.Success = false;
res.ErrorText = "Could not find newly created routing rule by objectId:" + res;
}
}
return(res);
}
/// <summary>
/// Create a new call handler template in the Connection directory
/// </summary>
/// <param name="pConnectionServer">
/// Connection server being edited
/// </param>
/// <param name="pDisplayName">
/// Display Name of the new call handler template - must be unique.
/// </param>
/// <param name="pRecipientUserId">
/// If a user is a recipient, pass the objectId in here - must pass either recipient or distribution list
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a property name and a new value for that property to apply to the template being created.
/// This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. Can be passed as null here.
/// </param>
/// <param name="pCallHandlerTemplate">
/// Newly created call handler template instance is passed back in this out parameter
/// </param>
/// <param name="pMediaSwitchObjectId">
/// Phone system the interviewer will be associated with.
/// </param>
/// <param name="pRecipientDistributionListId">
/// If a list is a recipient, pass the objectId in here - must pass either recipient or distribution list
/// </param>
/// <returns>
/// Instance of the WebCallResult class.
/// </returns>
public static WebCallResult AddCallHandlerTemplate(ConnectionServerRest pConnectionServer,
string pDisplayName,
string pMediaSwitchObjectId,
string pRecipientDistributionListId,
string pRecipientUserId,
ConnectionPropertyList pPropList,
out CallHandlerTemplate pCallHandlerTemplate)
{
pCallHandlerTemplate = null;
WebCallResult res = AddCallHandlerTemplate(pConnectionServer, pDisplayName, pMediaSwitchObjectId, pRecipientDistributionListId,
pRecipientUserId, pPropList);
//if the call went through then the ObjectId will be returned in the URI form.
if (res.Success)
{
//fetc the instance of the template just created.
try
{
pCallHandlerTemplate = new CallHandlerTemplate(pConnectionServer, res.ReturnedObjectId);
}
catch (Exception)
{
res.Success = false;
res.ErrorText = "Could not find newly created handler template by objectId:" + res;
}
}
return(res);
}
/// <summary>
/// Add a new MWI device for a user
/// </summary>
/// <param name="pConnectionServer">
/// Connection server the user is homed on
/// </param>
/// <param name="pUserObjectId">
/// Unique identifier for user to add new MWI to
/// </param>
/// <param name="pDeviceDisplayName">
/// Display name for MWI device
/// </param>
/// <param name="pMediaSwitchObjectId">
/// Phone system the MWI will be associated with
/// </param>
/// <param name="pMwiExtension">
/// Extension number for the new MWI device to activate
/// </param>
/// <param name="pActivated">
/// Is the MWI active or not - you can add MWI devices that are not active that can be turned on later.
/// </param>
/// <returns>
/// Instance of the WebCallResult class with details of the request/response from the server.
/// </returns>
public static WebCallResult AddMwi(ConnectionServerRest pConnectionServer,
string pUserObjectId,
string pDeviceDisplayName,
string pMediaSwitchObjectId,
string pMwiExtension,
bool pActivated)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to AddMwi";
return(res);
}
//make sure that something is passed in for the 2 required params - the extension is optional.
if (String.IsNullOrEmpty(pDeviceDisplayName) |
(String.IsNullOrEmpty(pUserObjectId)) |
(String.IsNullOrEmpty(pMediaSwitchObjectId)) |
(String.IsNullOrEmpty(pMwiExtension)))
{
res.ErrorText = "Empty value passed for one or more required parameters in AddMwi";
return(res);
}
ConnectionPropertyList oProps = new ConnectionPropertyList();
oProps.Add("DisplayName", pDeviceDisplayName);
oProps.Add("MwiExtension", pMwiExtension);
oProps.Add("MediaSwitchObjectId", pMediaSwitchObjectId);
oProps.Add("Active", pActivated);
string strBody = "<Mwi>";
//tack on the property value pair with appropriate tags
foreach (var oProp in oProps)
{
strBody += string.Format("<{0}>{1}</{0}>", oProp.PropertyName, oProp.PropertyValue);
}
strBody += "</Mwi>";
res = pConnectionServer.GetCupiResponse(string.Format("{0}users/{1}/mwis", pConnectionServer.BaseUrl, pUserObjectId),
MethodType.POST, strBody, false);
//if the call went through then the ObjectId will be returned in the URI form.
if (res.Success)
{
string strPrefix = @"/vmrest/users/" + pUserObjectId + "/mwis/";
if (res.ResponseText.Contains(strPrefix))
{
res.ReturnedObjectId = res.ResponseText.Replace(strPrefix, "").Trim();
}
}
return(res);
}
/// <summary>
/// Allows for the creation of a new private list for the currently logged in user. The display name and number ID must be provided.
/// </summary>
/// <param name="pConnectionServer">
/// Reference to the ConnectionServer object that points to the home server where the list is being added.
/// </param>
/// <param name="pUserOwnerObjectId">
/// User that will own the newly created private list
/// </param>
/// <param name="pDisplayName">
/// Display name to be used for the new list.
/// </param>
/// <param name="pNumericId">
/// Private list Id from 1 to 99 (depending on settings - by default private lists are limited to 20, however this routine does not check
/// for that). Pass the default of 0 and the list will be created in the next available slot - this is the best method.
/// </param>
/// <returns>
/// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface.
/// </returns>
public static WebCallResult AddPrivateList(ConnectionServerRest pConnectionServer,
string pUserOwnerObjectId,
string pDisplayName,
int pNumericId = 0)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to AddPrivateList";
return(res);
}
//make sure that something is passed in for the 2 required params - the extension is optional.
if (string.IsNullOrEmpty(pDisplayName))
{
res.ErrorText = "Empty value passed for DisplayName in AddPrivateList on ConnectionServer.cs";
return(res);
}
if (pNumericId < 1 | pNumericId > 99)
{
res.ErrorText = "Invalid list Id passed to AddPrivateList on ConnectionServer.cs:" + pNumericId.ToString();
return(res);
}
ConnectionPropertyList oPropList = new ConnectionPropertyList();
//cheat here a bit and simply add the alias and display name values to the proplist where it can be tossed into the body later.
oPropList.Add("DisplayName", pDisplayName);
oPropList.Add("NumericId", pNumericId);
string strBody = "<PrivateList>";
foreach (var oPair in oPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</PrivateList>";
res = pConnectionServer.GetCupiResponse(pConnectionServer.BaseUrl + string.Format("users/{0}/privatelists",
pUserOwnerObjectId), MethodType.POST, strBody, false);
//if the call went through then the ObjectId will be returned in the URI form.
if (res.Success)
{
string strTemp = string.Format(@"/vmrest/users/{0}/privatelists/", pUserOwnerObjectId);
if (res.ResponseText.Contains(strTemp))
{
res.ReturnedObjectId = res.ResponseText.Replace(strTemp, "").Trim();
}
}
return(res);
}
/// <summary>
/// Import an LDAP user as a local Unity Connection user.
/// </summary>
/// <param name="pConnectionServer">
/// Connection server to import the user on.
/// </param>
/// <param name="pTemplateAlias">
/// Alias of the user template to use when importing the user, required.
/// </param>
/// <param name="pPkid">
/// Unique ID from the Call Manager database for the LDAP synchronized user.
/// </param>
/// <param name="pAlias">
/// Alias of the user in LDAP to import
/// </param>
/// <param name="pFirstName">
/// First name of the user to import
/// </param>
/// <param name="pLastName">
/// Last name of the user to import
/// </param>
/// <param name="pExtension">
/// Extension number to assign the user in Connection's diretory
/// </param>
/// <param name="pPropList">
/// Name value pair list of optional values to include in the import.
/// </param>
/// <returns>
/// Instance of the WebCallResults class with details of the call and results from the server.
/// </returns>
public static WebCallResult ImportLdapUser(ConnectionServerRest pConnectionServer, string pTemplateAlias,
string pPkid, string pAlias, string pFirstName, string pLastName,
string pExtension, ConnectionPropertyList pPropList)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to ImportLdapUser";
return(res);
}
//make sure that something is passed in for the 3 required params
if (String.IsNullOrEmpty(pTemplateAlias) || string.IsNullOrEmpty(pPkid) || string.IsNullOrEmpty(pExtension))
{
res.ErrorText = "Empty value passed for one or more required parameters in ImportLdapUser on ConnectionServer.cs";
return(res);
}
//create an empty property list if it's passed as null since we use it below
if (pPropList == null)
{
pPropList = new ConnectionPropertyList();
}
//cheat here a bit and simply add the alias and extension values to the proplist where it can be tossed into the body later.
pPropList.Add("pkid", pPkid);
pPropList.Add("alias", pAlias);
pPropList.Add("firstName", pFirstName);
pPropList.Add("lastName", pLastName);
pPropList.Add("dtmfAccessId", pExtension);
//use JSON style body payload
string strBody = "{";
foreach (var oPair in pPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("\"{0}\":\"{1}\",", oPair.PropertyName, oPair.PropertyValue);
}
strBody = strBody.TrimEnd(',') + "}";
res = pConnectionServer.GetCupiResponse(pConnectionServer.BaseUrl + "import/users/ldap?templateAlias=" + pTemplateAlias,
MethodType.POST, strBody);
//if the call went through then the ObjectId will be returned in the URI form.
if (res.Success)
{
if (!string.IsNullOrEmpty(res.ResponseText) && res.ResponseText.Contains(@"/vmrest/users/"))
{
res.ReturnedObjectId = res.ResponseText.Replace(@"/vmrest/users/", "").Trim();
}
}
return(res);
}
/// <summary>
/// Generic constructor for Json parsing
/// </summary>
public TransferOption()
{
//make an instanced of the changed prop list to keep track of updated properties on this object
_changedPropList = new ConnectionPropertyList();
//little bit of a hack - CUPI does not return TimeExpires values for null TimeExpires fields so we can only assume that it's abscence
//means the greeting is active
TimeExpires = DateTime.Parse("2200/1/1");
ClearPendingChanges();
}
/// <summary>
/// Allows for the creation of a new COS on the Connection server directory. The display name must be provided .
/// </summary>
/// <param name="pConnectionServer">
/// Reference to the ConnectionServer object that points to the home server where the COS is being added.
/// </param>
/// <param name="pDisplayName">
/// Display name to be used for the new list.
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a property name and a new value for that property to apply to the object being created.
/// This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. Can be passed as null here.
/// </param>
/// <returns>
/// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface.
/// </returns>
public static WebCallResult AddClassOfService(ConnectionServerRest pConnectionServer,
string pDisplayName,
ConnectionPropertyList pPropList)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to AddClassOfService";
return(res);
}
//make sure that something is passed in for the 2 required params - the extension is optional.
if (string.IsNullOrEmpty(pDisplayName))
{
res.ErrorText = "Empty value passed for display name in AddClassOfService";
return(res);
}
//create an empty property list if it's passed as null since we use it below
if (pPropList == null)
{
pPropList = new ConnectionPropertyList();
}
//cheat here a bit and simply add the alias and display name values to the proplist where it can be tossed into the body later.
pPropList.Add("DisplayName", pDisplayName);
string strBody = "<Cos>";
foreach (var oPair in pPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</Cos>";
res = pConnectionServer.GetCupiResponse(pConnectionServer.BaseUrl + "coses", MethodType.POST, strBody, false);
//if the call went through then the ObjectId will be returned in the URI form.
if (res.Success)
{
if (res.ResponseText.Contains(@"/vmrest/coses/"))
{
res.ReturnedObjectId = res.ResponseText.Replace(@"/vmrest/coses/", "").Trim();
}
}
return(res);
}
/// <summary>
/// Create a new routing rule in the Connection directory
/// </summary>
/// <param name="pConnectionServer">
/// Connection server being edited
/// </param>
/// <param name="pDisplayName">
/// Display Name of the new routing rule - must be unique.
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a property name and a new value for that property to apply to the rule being created.
/// This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. Can be passed as null here.
/// </param>
/// <returns>
/// Instance of the WebCallResult class.
/// </returns>
public static WebCallResult AddRoutingRule(ConnectionServerRest pConnectionServer, string pDisplayName, ConnectionPropertyList pPropList)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to AddRoutingRule";
return(res);
}
if (String.IsNullOrEmpty(pDisplayName))
{
res.ErrorText = "Empty value passed for display name in AddRoutingRule";
return(res);
}
//create an empty property list if it's passed as null since we use it below
if (pPropList == null)
{
pPropList = new ConnectionPropertyList();
}
pPropList.Add("DisplayName", pDisplayName);
string strBody = "<RoutingRule>";
foreach (var oPair in pPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</RoutingRule>";
res = pConnectionServer.GetCupiResponse(pConnectionServer.BaseUrl + "routingrules",
MethodType.POST, strBody, false);
//fetch the objectId of the newly created object off the return
if (res.Success)
{
if (res.ResponseText.Contains(@"/vmrest/routingrules/"))
{
res.ReturnedObjectId = res.ResponseText.Replace(@"/vmrest/routingrules/", "").Trim();
}
}
return(res);
}
/// <summary>
/// Import an LDAP user as a local Unity Connection user.
/// </summary>
/// <param name="pConnectionServer">
/// Connection server to import the user on.
/// </param>
/// <param name="pTemplateAlias">
/// Alias of the user template to use when importing the user, required.
/// </param>
/// <param name="pPkid">
/// Unique ID from the Call Manager database for the LDAP synchronized user.
/// </param>
/// <param name="pAlias">
/// Alias of the user in LDAP to import
/// </param>
/// <param name="pFirstName">
/// First name of the user to import
/// </param>
/// <param name="pLastName">
/// Last name of the user to import
/// </param>
/// <param name="pExtension">
/// Extension number to assign the user in Connection's diretory
/// </param>
/// <param name="pPropList">
/// Name value pair list of optional values to include in the import.
/// </param>
/// <param name="pUser">
/// Instance of the UserFull class is passed back filled in with the details of the newly import user if the
/// import succeeds. Null if the import fails.
/// </param>
/// <returns>
/// Instance of the WebCallResults class with details of the call and results from the server.
/// </returns>
public static WebCallResult ImportLdapUser(ConnectionServerRest pConnectionServer, string pTemplateAlias,
string pPkid, string pAlias, string pFirstName, string pLastName,
string pExtension, ConnectionPropertyList pPropList, out UserFull pUser)
{
pUser = null;
var res = ImportLdapUser(pConnectionServer, pTemplateAlias, pPkid, pAlias, pFirstName, pLastName,
pExtension, pPropList);
if (res.Success)
{
return(UserFull.GetUser(pConnectionServer, res.ReturnedObjectId, out pUser));
}
return(res);
}
/// <summary>
/// Allows for the creation of a new COS on the Connection server directory. The name must be provided
/// </summary>
/// <remarks>
/// This is an alternateive AddClassOfService that passes back a ClassOfService object with the newly created list filled
/// out in it if the add goes through.
/// </remarks>
/// <param name="pConnectionServer">
/// Reference to the ConnectionServer object that points to the home server where the list is being added.
/// </param>
/// <param name="pDisplayName">
/// Display name to be used for the new cos.
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a list's property name and a new value for that property to apply to the list being created.
/// This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. Can be passed as null here.
/// </param>
/// <param name="oClassOfService">
/// Out parameter that instance of Class of Service class is returned on if a match is found - null if no match is found.
/// </param>
/// <returns>
/// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface.
/// </returns>
public static WebCallResult AddClassOfService(ConnectionServerRest pConnectionServer,
string pDisplayName,
ConnectionPropertyList pPropList,
out ClassOfService oClassOfService)
{
oClassOfService = null;
WebCallResult res = AddClassOfService(pConnectionServer, pDisplayName, pPropList);
//if the create goes through, fetch the list as an object and return it all filled in.
if (res.Success)
{
res = GetClassOfService(out oClassOfService, pConnectionServer, res.ReturnedObjectId);
}
return(res);
}
/// <summary>
/// Interview handler questions have only 3 properties that can be updated besides the recorded media which is handled via
/// specific WAV or resourceId udpate methods. If the question is active, the maximum length of a response the caller is
/// allowed for the question and some text describing the question. All those are presented as parameters to the update
/// method here.
/// </summary>
/// <param name="pConnectionServer">
/// Connection server the interviewer in question is homed on.
/// </param>
/// <param name="pInterviewHandlerObjectId">
/// Unique identifier for the interview handler this question is associated with.
/// </param>
/// <param name="pInterviewQuestionNumber">
/// questions are numbers 1 through 20.
/// </param>
/// <param name="pActive">
/// True is active, false is disabled
/// </param>
/// <param name="pMaxResponseLength">
/// Maximum length of recorded response for question (in seconds)
/// </param>
/// <param name="pStreamText">
/// Text description of question - shown on web admin only.
/// </param>
/// <returns>
/// Instance of the WebCallResult class with details of the request and response from the server.
/// </returns>
public static WebCallResult UpdateInterviewHandlerQuestion(ConnectionServerRest pConnectionServer,
string pInterviewHandlerObjectId,
int pInterviewQuestionNumber,
bool pActive, int pMaxResponseLength,
string pStreamText = "")
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to UpdateInterviewHandler";
return(res);
}
ConnectionPropertyList oPropList = new ConnectionPropertyList();
oPropList.Add("IsActive", pActive);
oPropList.Add("MaxMsgLength", pMaxResponseLength);
if (!string.IsNullOrEmpty(pStreamText))
{
oPropList.Add("StreamText", pStreamText);
}
string strBody = "<InterviewQuestion>";
foreach (var oPair in oPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</InterviewQuestion>";
string strUri = string.Format("{0}handlers/interviewhandlers/{1}/interviewquestions/{2}",
pConnectionServer.BaseUrl, pInterviewHandlerObjectId, pInterviewQuestionNumber);
return(pConnectionServer.GetCupiResponse(strUri, MethodType.PUT, strBody, false));
}
/// <summary>
/// Allows one or more properties on a port group to be udpated. The caller needs to construct a list of property
/// names and new values using the ConnectionPropertyList class's "Add" method. At least one property pair needs to be passed in
/// but as many as are desired can be included in a single call.
/// </summary>
/// <param name="pConnectionServer">
/// Reference to the ConnectionServer object that points to the home server where the port group is homed.
/// </param>
/// <param name="pPortGroupObjectId">
/// Unique identifier for the port group to update.
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a transfer option property name and a new value for that property to apply to the option
/// being updated. This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. At least one
/// property pair needs to be included for the funtion to execute.
/// </param>
/// <returns>
/// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface.
/// </returns>
public static WebCallResult UpdatePortGroup(ConnectionServerRest pConnectionServer,
string pPortGroupObjectId,
ConnectionPropertyList pPropList)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to UpdatePortGroup";
return(res);
}
if (string.IsNullOrEmpty(pPortGroupObjectId))
{
res.ErrorText = "Empty PortGroupObjectId passed to UpdatePortGroup";
return(res);
}
//the update command takes a body in the request, construct it based on the name/value pair of properties passed in.
//at lest one such pair needs to be present
if (pPropList == null || pPropList.Count < 1)
{
res.ErrorText = "empty property list passed to UpdatePortGroup";
return(res);
}
string strBody = "<PortGroup>";
foreach (var oPair in pPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</PortGroup>";
return(pConnectionServer.GetCupiResponse(string.Format("{0}portgroups/{1}", pConnectionServer.BaseUrl, pPortGroupObjectId),
MethodType.PUT, strBody, false));
}
/// <summary>
/// Allows one or more properties on a MWI. The caller needs to construct a list
/// of property names and new values using the ConnectionPropertyList class's "Add" method. At least one property pair needs to be passed in
/// but as many as are desired can be included in a single call.
/// </summary>
/// <param name="pConnectionServer">
/// Reference to the ConnectionServer object that points to the home server where the alternate extension is homed.
/// </param>
/// <param name="pUserObjectId">
/// Unique identifier for user that owns the alternate extension being edited.
/// </param>
/// <param name="pObjectId">
/// The unqiue GUID identifying the alternate extension owned by the user to be updated.
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a alternate extension property name and a new value for that property to apply to the extension
/// being updated. This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. At least one
/// property pair needs to be included for the funtion to execute.
/// </param>
/// <returns>
/// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface.
/// </returns>
public static WebCallResult UpdateMwi(ConnectionServerRest pConnectionServer,
string pUserObjectId,
string pObjectId,
ConnectionPropertyList pPropList)
{
string strBody = "";
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to UpdateMwi";
return(res);
}
//the update command takes a body in the request, construct it based on the name/value pair of properties passed in.
//at lest one such pair needs to be present
if (pPropList == null || pPropList.Count < 1)
{
res.ErrorText = "empty property list passed to UpdateMwi";
return(res);
}
strBody += "<Mwi>";
//construct the full path to the device type off this user
string strUrl = string.Format("{0}users/{1}/mwis/{2}", pConnectionServer.BaseUrl, pUserObjectId, pObjectId);
foreach (var oPair in pPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</Mwi>";
return(pConnectionServer.GetCupiResponse(strUrl, MethodType.PUT, strBody, false));
}
/// <summary>
/// Allows one or more properties on a transfer option to be udpated. The caller needs to construct a list of property
/// names and new values using the ConnectionPropertyList class's "Add" method. At least one property pair needs to be passed in
/// but as many as are desired can be included in a single call.
/// </summary>
/// <param name="pConnectionServer">
/// Reference to the ConnectionServer object that points to the home server where the transfer option is homed.
/// </param>
/// <param name="pCallHandlerObjectId">
/// Unique identifier for call handler that owns the transfer option being updated
/// </param>
/// <param name="pTransferOptionType">
/// Name of the transfer rule to update (Alternate, Standard, OffHours)
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a transfer option property name and a new value for that property to apply to the option
/// being updated. This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. At least one
/// property pair needs to be included for the funtion to execute.
/// </param>
/// <returns>
/// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface.
/// </returns>
public static WebCallResult UpdateTransferOption(ConnectionServerRest pConnectionServer,
string pCallHandlerObjectId,
TransferOptionTypes pTransferOptionType,
ConnectionPropertyList pPropList)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to UpdateTransferOption";
return(res);
}
//the update command takes a body in the request, construct it based on the name/value pair of properties passed in.
//at lest one such pair needs to be present
if (pPropList == null || pPropList.Count < 1)
{
res.ErrorText = "empty property list passed to UpdateTransferOption";
return(res);
}
string strBody = "<TransferOption>";
foreach (var oPair in pPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</TransferOption>";
return(pConnectionServer.GetCupiResponse(string.Format("{0}handlers/callhandlers/{1}/transferoptions/{2}",
pConnectionServer.BaseUrl, pCallHandlerObjectId, pTransferOptionType.Description()), MethodType.PUT, strBody, false));
}
/// <summary>
/// default constructor used by JSON parser
/// </summary>
public CallHandlerTemplate()
{
_changedPropList = new ConnectionPropertyList();
}
/// <summary>
/// Allows one or more properties on an external service to be udpated. The caller needs to construct a list of property
/// names and new values using the ConnectionPropertyList class's "Add" method. At least one property pair needs to be passed in
/// but as many as are desired can be included in a single call.
/// </summary>
/// <param name="pConnectionServer">
/// Reference to the ConnectionServer object that points to the home server where the service is homed.
/// </param>
/// <param name="pObjectId">
/// Unique identifier for the external service to update.
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a property name and a new value for that property to apply to the object
/// being updated.
/// </param>
/// <returns>
/// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface.
/// </returns>
public static WebCallResult UpdateExternalService(ConnectionServerRest pConnectionServer, string pObjectId, ConnectionPropertyList pPropList)
{
WebCallResult res = new WebCallResult {
Success = false
};
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to UpdateExternalService";
return(res);
}
if (pPropList == null || pPropList.Count < 1)
{
res.ErrorText = "empty property list passed to UpdateExternalService";
return(res);
}
string strBody = "<ExternalService>";
foreach (var oPair in pPropList)
{
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</ExternalService>";
return(pConnectionServer.GetCupiResponse(string.Format("{0}externalservices/{1}", pConnectionServer.BaseUrl, pObjectId),
MethodType.PUT, strBody, false));
}
/// <summary>
/// Generic constructor for JSON parsing library
/// </summary>
public ExternalService()
{
_changedPropList = new ConnectionPropertyList();
}
/// <summary>
/// default constructor used by JSON parser
/// </summary>
public RoutingRule()
{
_changedPropList = new ConnectionPropertyList();
}
/// <summary>
/// General constructor used in the JSON parsing routines.
/// </summary>
public AlternateExtension()
{
//make an instanced of the changed prop list to keep track of updated properties on this object
_changedPropList = new ConnectionPropertyList();
}
/// <summary>
/// Generic constructor for JSON parsing library
/// </summary>
public ClassOfService()
{
//make an instanced of the changed prop list to keep track of updated properties on this object
_changedPropList = new ConnectionPropertyList();
}
/// <summary>
/// Generic constructor for Json parsing libraries
/// </summary>
public Port()
{
_changedPropList = new ConnectionPropertyList();
}
/// <summary>
/// Adds a new port to the system
/// </summary>
/// <param name="pConnectionServer">
/// The Connection server to add the port to
/// </param>
/// <param name="pMediaPortGroupObjectId">
/// Media port group to associate the port with
/// </param>
/// <param name="pNumberOfPorts">
/// Number of ports to add to the port group - should be an even number but that's not enforced.
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a property name and a new value for that property to apply to the port being created.
/// This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. Can be passed as null here.
/// </param>
/// <param name="pPimgPort">
/// If adding ports for PIMG/TIMG pass this as true - the VMSServer value needs to be empty in that case. For SIP and SCCP this needs to
/// be passed.
/// </param>
/// <returns>
/// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface.
/// </returns>
public static WebCallResult AddPort(ConnectionServerRest pConnectionServer, string pMediaPortGroupObjectId, int pNumberOfPorts,
ConnectionPropertyList pPropList, bool pPimgPort = false)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to AddPort";
return(res);
}
//make sure that something is passed in for the required param
if (String.IsNullOrEmpty(pMediaPortGroupObjectId))
{
res.ErrorText = "Empty value passed for portgroupObjecTId in AddPort";
return(res);
}
//create an empty property list if it's passed as null since we use it below
if (pPropList == null)
{
pPropList = new ConnectionPropertyList();
}
pPropList.Add("MediaPortGroupObjectId", pMediaPortGroupObjectId);
pPropList.Add("NumberOfPorts", pNumberOfPorts);
//for SIP and SCCP the VMSserverObjectId is needed, for TIMG/PIMG it needs to be left out
if (!pPimgPort)
{
pPropList.Add("VmsServerObjectId", pConnectionServer.VmsServerObjectId);
}
string strBody = "<Port>";
//tack on the property value pair with appropriate tags
foreach (var oPair in pPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</Port>";
res = pConnectionServer.GetCupiResponse(string.Format("{0}ports", pConnectionServer.BaseUrl),
MethodType.POST, strBody, false);
//if the call went through then the ObjectId will be returned in the URI form.
if (res.Success)
{
const string strPrefix = @"/vmrest/ports/";
if (res.ResponseText.Contains(strPrefix))
{
res.ReturnedObjectId = res.ResponseText.Replace(strPrefix, "").Trim();
}
}
return(res);
}
/// <summary>
/// Special helper function for dealing with the enabled/disabled status of transfer options. This can be done directly using the timeExpiresSetNull
/// option found in the propertis seciton above but it's less than intuative and most users do not get how the timeExpires functionality works for
/// transfer options and greeting rules - as such this routine wraps it up in a simple single call option.
/// If TRUE is passed for the enabled then the greeting TimeExpires is set to null (meaning it's always enabled) unless a pTillDate value is passed.
/// If this value is passed then the TimeExpires value is set to that.
/// If a pTillDate is a time in the passed and it's a time in the past then nothing is done and and error is returned - a TimeExpires in the future
/// means to enable it till that time, there is no reason to pass a time in the past.
/// If the pEnabled is passed as FALSE then the TimeExpires is set to "10/11/1999" which disables it. This date is used for all TimeExpires disabling
/// routines in the ConnectionCUPIFunctions libarary.
/// </summary>
/// <remarks>
/// The change queue will be cleared when this is called - if you wish to make other changes do it ahead of time or after making this call.
/// </remarks>
/// <param name="pConnectionServer">
/// Connection server that the transfer option being edited lives on.
/// </param>
/// <param name="pCallHandlerObjectId">
/// The GUID that identifies the call handler which owns the transfer option being edited.
/// </param>
/// <param name="pTransferOptionType">
/// The transfer option type being edited (Standard, Off Hours, Alternate). You cannot edit the Standard transfer option in this routine, it is always
/// set to enabled on the server and that cannot be changed.
/// </param>
/// <param name="pEnabled">
/// Pass TRUE to enable the transfer option, FALSE to disable it. If you pass TRUE you may optionally pass a pTillDate DateTime property to indicate the
/// date the rule will disable itself automatically.
/// </param>
/// <param name="pTillDate">
/// Optional parameter that can be passed when pEnabled is passed as TRUE. This must be a date/time in the future, a date/time in the past will result in
/// the method returning a failure.
/// </param>
/// <returns></returns>
public static WebCallResult UpdateTransferOptionEnabledStatus(ConnectionServerRest pConnectionServer,
string pCallHandlerObjectId,
TransferOptionTypes pTransferOptionType,
bool pEnabled,
DateTime?pTillDate = null)
{
WebCallResult res = new WebCallResult();
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to UpdateTransferOptionEnabledStatus";
return(res);
}
if (string.IsNullOrEmpty(pCallHandlerObjectId))
{
res.ErrorText = "Empty handler ObjectId or TransferType passed to UpdateTransferOptionEnabledStatus";
return(res);
}
//first make sure the user isn't trying to change the enabled status on the Standard transfer option - this will fail since that option needs to
//always be enabled on the server - fail it up front and pass back the WebCallResult with this information.
if (pTransferOptionType == TransferOptionTypes.Standard)
{
res.ErrorText = "Attempt made to modify Standard transfer option in UpdateTransferOptionEnabledStatus.";
return(res);
}
//invalid
if (pEnabled == false & (pTillDate != null))
{
res.ErrorText = "A date ending time was passed along with enabled=false in UpdateTransferOptionEnabledStatus.";
return(res);
}
//finally - no date in the past is valid
if ((pTillDate != null) && (pTillDate < DateTime.Now))
{
res.ErrorText = "A pTillDate in the past was passed in UpdateTransferOptionEnabledStatus.";
return(res);
}
//ok, everthing looks valid, make the change. The enabled/disaled status of a transfer option rides on the TimeExpires field.
ConnectionPropertyList oProp = new ConnectionPropertyList();
if (pEnabled == false)
{
//use the 10/11/1999 date to disable the transfer rule.
oProp.Add("TimeExpires", DateTime.Parse("10/11/1999"));
}
else
{
if (pTillDate != null)
{
//use the date passed in for the expiration time.
oProp.Add("TimeExpires", pTillDate.Value);
}
else
{
//set it to null to make it never expire - you also have to pass the enabled flag in this case, it's only valid
//for update when the date is cleared.
oProp.Add("TimeExpires", "");
oProp.Add("Enabled", true);
}
}
string strBody = "<TransferOption>";
foreach (var oPair in oProp)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</TransferOption>";
return(pConnectionServer.GetCupiResponse(string.Format("{0}handlers/callhandlers/{1}/transferoptions/{2}",
pConnectionServer.BaseUrl, pCallHandlerObjectId, pTransferOptionType.Description()), MethodType.PUT, strBody, false));
}
/// <summary>
/// Generic constructor for JSON parsing library
/// </summary>
public PhoneSystem()
{
_changedPropList = new ConnectionPropertyList();
}
/// <summary>
/// General constructor for Json parsing library
/// </summary>
public RestrictionTable()
{
_changedPropList = new ConnectionPropertyList();
}
/// <summary>
/// Create a new call handler template in the Connection directory
/// </summary>
/// <param name="pConnectionServer">
/// Connection server being edited
/// </param>
/// <param name="pMediaSwitchObjectId">
/// The ObjectId of a the media switch this call handler should be associated with
/// </param>
/// <param name="pDisplayName">
/// Display Name of the new call handler template - must be unique.
/// </param>
/// <param name="pRecipientUserId">
/// If a user is a recipient, pass the objectId in here - must pass either recipient or distribution list
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a property name and a new value for that property to apply to the template being created.
/// This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. Can be passed as null here.
/// </param>
/// <param name="pRecipientDistributionListId">
/// If a list is a recipient, pass the objectId in here - must pass either recipient or distribution list
/// </param>
/// <returns>
/// Instance of the WebCallResult class.
/// </returns>
public static WebCallResult AddCallHandlerTemplate(ConnectionServerRest pConnectionServer, string pDisplayName,
string pMediaSwitchObjectId, string pRecipientDistributionListId, string pRecipientUserId,
ConnectionPropertyList pPropList)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to AddCallHandlerTemplate";
return(res);
}
if (String.IsNullOrEmpty(pDisplayName) || string.IsNullOrEmpty(pMediaSwitchObjectId))
{
res.ErrorText = "Empty value passed for display name or mediaSwitchObjectId in AddCallHandlerTemplate";
return(res);
}
if (string.IsNullOrEmpty(pRecipientDistributionListId) & string.IsNullOrEmpty(pRecipientUserId))
{
res.ErrorText = "Both user and dl recipientIds passed as blank - a handler template requires a recipient";
return(res);
}
//create an empty property list if it's passed as null since we use it below
if (pPropList == null)
{
pPropList = new ConnectionPropertyList();
}
if (string.IsNullOrEmpty(pRecipientUserId))
{
pPropList.Add("RecipientDistributionListObjectId", pRecipientDistributionListId);
}
else
{
pPropList.Add("RecipientSubscriberObjectId", pRecipientUserId);
}
pPropList.Add("DisplayName", pDisplayName);
pPropList.Add("MediaSwitchObjectId", pMediaSwitchObjectId);
string strBody = "<CallhandlerTemplate>";
foreach (var oPair in pPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</CallhandlerTemplate>";
res = pConnectionServer.GetCupiResponse(pConnectionServer.BaseUrl + "callhandlertemplates", MethodType.POST, strBody, false);
//fetch the objectId of the newly created object off the return
if (res.Success)
{
if (res.ResponseText.Contains(@"/vmrest/callhandlertemplates/"))
{
res.ReturnedObjectId = res.ResponseText.Replace(@"/vmrest/callhandlertemplates/", "").Trim();
}
}
return(res);
}
/// <summary>
/// Allows one or more properties on a menu entry to be udpated (for instance Action). The caller needs to construct a list
/// of property names and new values using the ConnectionPropertyList class's "Add" method. At least one property pair needs to be passed in
/// but as many as are desired can be included in a single call.
/// </summary>
/// <param name="pConnectionServer">
/// Reference to the ConnectionServer object that points to the home server where the menu entry is homed.
/// </param>
/// <param name="pCallHandlerObjectId">
/// Unique identifier for the call handler that owns the menu entry being edited.
/// </param>
/// <param name="pKeyName">
/// The key name to update (0-9 * or #)
/// </param>
/// <param name="pPropList">
/// List ConnectionProperty pairs that identify a menu entry property name and a new value for that property to apply to the entry
/// being updated. This is passed in as a ConnectionPropertyList instance which contains 1 or more ConnectionProperty instances. At least one
/// property pair needs to be included for the funtion to execute.
/// </param>
/// <returns>
/// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface.
/// </returns>
public static WebCallResult UpdateMenuEntry(ConnectionServerRest pConnectionServer, string pCallHandlerObjectId, string pKeyName, ConnectionPropertyList pPropList)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to UpdateMenuEntry";
return(res);
}
//the update command takes a body in the request, construct it based on the name/value pair of properties passed in.
//at lest one such pair needs to be present
if (pPropList == null || pPropList.Count < 1)
{
res.ErrorText = "empty property list passed to UpdateMenuEntry";
return(res);
}
//both the objectID and key name should be passed here.
if (string.IsNullOrEmpty(pCallHandlerObjectId) | string.IsNullOrEmpty(pKeyName))
{
res.ErrorText = "Empty call handler ObjectId or Key Name passed to UpdateMenuEntry";
return(res);
}
string strBody = "<MenuEntry>";
foreach (var oPair in pPropList)
{
//tack on the property value pair with appropriate tags
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</MenuEntry>";
return(pConnectionServer.GetCupiResponse(string.Format("{0}handlers/callhandlers/{1}/menuentries/{2}", pConnectionServer.BaseUrl,
pCallHandlerObjectId, pKeyName), MethodType.PUT, strBody, false));
}
/// <summary>
/// Add a new schedule detail to the schedule
/// </summary>
/// <param name="pConnectionServer">
/// Connection server being edited
/// </param>
/// <param name="pSubject">
/// optional description string for the schedule item
/// </param>
/// <param name="pScheduleObjectId">
/// Schedule to add the detail item to
/// </param>
/// <param name="pStartTime">
/// the start time (in minutes) for the active day or days. the start time is stored as the number of minutes from
/// midnight. so a value of 480 would mean 8:00 am and 1020 would mean 5:00 pm. in addition, a value of 0 for the
/// start time indicates 12:00 am.
/// </param>
/// <param name="pEndTime">
/// the end time (in minutes) for the active day or days. the end time is stored as the number of minutes from
/// midnight. so a value of 480 would mean 8:00 am and 1020 would mean 5:00 pm. in addition, a value of 0 means
/// "till the end of the day" (e.g. 11:59:59 pm in linux land).
/// </param>
/// <param name="pStartDate">
/// the date when this schedule detail becomes active. a value of null means the schedule is active immediately.
/// </param>
/// <param name="pEndDate">
/// the date when this schedule detail ends. a value of null indicates the scheule is active indefinitely.
/// </param>
/// <param name="pActiveMonday"></param>
/// <param name="pActiveTuesday"></param>
/// <param name="pActiveWednesday"></param>
/// <param name="pActiveThursday"></param>
/// <param name="pActiveFriday"></param>
/// <param name="pActiveSaturday"></param>
/// <param name="pActiveSunday"></param>
/// <returns>
/// Instance of the WebCallResult
/// </returns>
public static WebCallResult AddScheduleDetail(ConnectionServerRest pConnectionServer, string pScheduleObjectId, string pSubject,
int pStartTime, int pEndTime,
bool pActiveMonday, bool pActiveTuesday, bool pActiveWednesday, bool pActiveThursday,
bool pActiveFriday, bool pActiveSaturday, bool pActiveSunday,
DateTime?pStartDate = null, DateTime?pEndDate = null)
{
WebCallResult res = new WebCallResult();
res.Success = false;
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to AddScheduleSetMember";
return(res);
}
if (string.IsNullOrEmpty(pScheduleObjectId))
{
res.ErrorText = "Empty pScheduleObjectId passed to AddScheduleDetail";
return(res);
}
ConnectionPropertyList oProps = new ConnectionPropertyList();
oProps.Add("ScheduleObjectId", pScheduleObjectId);
oProps.Add("StartDate", pStartDate);
oProps.Add("StartTime", pStartTime);
oProps.Add("EndTime", pEndTime);
oProps.Add("EndDate", pEndDate);
oProps.Add("IsActiveMonday", pActiveMonday);
oProps.Add("IsActiveTuesday", pActiveTuesday);
oProps.Add("IsActiveWednesday", pActiveWednesday);
oProps.Add("IsActiveThursday", pActiveThursday);
oProps.Add("IsActiveFriday", pActiveFriday);
oProps.Add("IsActiveSaturday", pActiveSaturday);
oProps.Add("IsActiveSunday", pActiveSunday);
string strBody = "<ScheduleDetail>";
//tack on the property value pair with appropriate tags
foreach (var oProp in oProps)
{
strBody += string.Format("<{0}>{1}</{0}>", oProp.PropertyName, oProp.PropertyValue);
}
strBody += "</ScheduleDetail>";
string strPath = string.Format("schedules/{0}/scheduledetails", pScheduleObjectId);
res = pConnectionServer.GetCupiResponse(pConnectionServer.BaseUrl + strPath, MethodType.POST, strBody, false);
//if the call went through then the ObjectId will be returned in the URI form.
strPath += "/";
if (res.Success)
{
if (res.ResponseText.Contains(@"/vmrest/" + strPath))
{
res.ReturnedObjectId = res.ResponseText.Replace(@"/vmrest/" + strPath, "").Trim();
}
}
return(res);
}
/// <summary>
/// Generic constructor for Json libraries
/// </summary>
public PortGroupServer()
{
_changedPropList = new ConnectionPropertyList();
}
/// <summary>
///
/// </summary>
/// <param name="pConnectionServer"></param>
/// <param name="pRestrictionTable"></param>
/// <param name="pPropList"></param>
/// <returns></returns>
public static WebCallResult UpdateRestrictionTable(ConnectionServerRest pConnectionServer, RestrictionTable pRestrictionTable, ConnectionPropertyList pPropList)
{
WebCallResult res = new WebCallResult {
Success = false
};
if (pConnectionServer == null)
{
res.ErrorText = "Null ConnectionServer referenced passed to UpdateRestrictionTable";
return(res);
}
if (pRestrictionTable == null)
{
res.ErrorText = "Null RestrictionTable passed to UpdateRestrictionTable";
return(res);
}
string strBody = "<RestrictionTable>";
foreach (var oPair in pPropList)
{
strBody += string.Format("<{0}>{1}</{0}>", oPair.PropertyName, oPair.PropertyValue);
}
strBody += "</RestrictionTable>";
string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "restrictiontables/" + pRestrictionTable.ObjectId);
res = pConnectionServer.GetCupiResponse(strUrl, MethodType.PUT, strBody, false);
if (res.Success == false)
{
return(res);
}
strBody = "<RestrictionPattern>";
foreach (RestrictionPattern oPattern in pRestrictionTable.RestrictionPatterns())
{
strBody += string.Format("<{0}>{1}</{0}>", "ObjectId", oPattern.ObjectId);
}
strBody += "</RestrictionPattern>";
strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "restrictiontables/" + pRestrictionTable.ObjectId + "/restrictionpatterns");
return(pConnectionServer.GetCupiResponse(strUrl, MethodType.PUT, strBody, false));
}