/// <summary> /// Gets the list of all schedule sets and resturns them as a generic list of ScheduleSet objects. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that references the server the schedulesets should be pulled from /// </param> /// <param name="pScheduleSets"> /// Out parameter that is used to return the list of ScheduleSet objects defined on Connection - there must be at least one. /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter /// at a time are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetSchedulesSets(ConnectionServerRest pConnectionServer, out List<ScheduleSet> pScheduleSets, int pPageNumber = 1, int pRowsPerPage = 20, params string[] pClauses) { WebCallResult res; pScheduleSets = new List<ScheduleSet>(); if (pConnectionServer == null) { res = new WebCallResult(); res.ErrorText = "Null ConnectionServer referenced passed to GetSchedulesSets"; return res; } List<String> oParams; if (pClauses == null) { oParams = new List<string>(); } else { oParams = pClauses.ToList(); } oParams.Add("pageNumber=" + pPageNumber); oParams.Add("rowsPerPage=" + pRowsPerPage); string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "schedulesets",oParams.ToArray()); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return res; } if (string.IsNullOrEmpty(res.ResponseText)) { res.ErrorText = "Empty response received"; res.Success = false; return res; } //no error here - just return the empty list. if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return res; } pScheduleSets = pConnectionServer.GetObjectsFromJson<ScheduleSet>(res.ResponseText); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pScheduleSets) { oObject.HomeServer = pConnectionServer; } return res; }
/// <summary> /// This function allows for a GET of coses from Connection via HTTP - it allows for passing any number of additional clauses /// for filtering (query directives), sorting and paging of results. The format of the clauses should look like: /// filter: "query=(displayname startswith ab)" /// sort: "sort=(displayname asc)" /// page: "pageNumber=0" /// : "rowsPerPage=8" /// Escaping of spaces is done automatically, no need to account for that. /// </summary> /// <param name="pConnectionServer"> /// Reference to the ConnectionServer object that points to the home server where the lists are being fetched from. /// </param> /// <param name="pClassOfServices"> /// The list of coses returned from the CUPI call (if any) is returned as a generic list of ClassOfService class /// instances via this out param. If no COSes are found an empty list is returned. /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter at a time /// are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" and "query=(FirstName startswith a)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetClassesOfService(ConnectionServerRest pConnectionServer, out List <ClassOfService> pClassOfServices, params string[] pClauses) { WebCallResult res = new WebCallResult(); res.Success = false; pClassOfServices = new List <ClassOfService>(); if (pConnectionServer == null) { res.ErrorText = "Null Connection server object passed to GetClassOfService"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "coses", pClauses); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.Success = false; res.ErrorText = "Empty response recieved"; return(res); } //not a failure, just return an empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pClassOfServices = pConnectionServer.GetObjectsFromJson <ClassOfService>(res.ResponseText, "cos"); if (pClassOfServices == null) { pClassOfServices = new List <ClassOfService>(); res.ErrorText = "Could not parse JSON into COS objects:" + res.ResponseText; res.Success = false; return(res); } //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pClassOfServices) { oObject.HomeServer = pConnectionServer; oObject.ClearPendingChanges(); } return(res); }
/// <summary> /// Fetches all private lists defined for the currently logged in user (if any). An empty list may be returned. /// </summary> /// <param name="pConnectionServer"> /// Reference to the ConnectionServer object that points to the home server where the lists are being fetched from. /// </param> /// <param name="pOwnerUserObjectId"> /// Owner of the private distribution list /// </param> /// <param name="pPrivateLists"> /// The list of private lists returned from the CUPI call (if any) is returned as a generic list of PrivateList class /// instances via this out param. If no lists are found found an empty list is returned. /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetPrivateLists(ConnectionServerRest pConnectionServer, string pOwnerUserObjectId, out List <PrivateList> pPrivateLists, int pPageNumber = 1, int pRowsPerPage = 20) { WebCallResult res = new WebCallResult { Success = false }; pPrivateLists = new List <PrivateList>(); if (pConnectionServer == null) { res.ErrorText = "Null Connection server object passed to GetPrivateLists"; return(res); } if (string.IsNullOrEmpty(pOwnerUserObjectId)) { res.ErrorText = "Empty OWnerUserObjectId passed to GetPrivateLists"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(string.Format("{0}users/{1}/privatelists", pConnectionServer.BaseUrl, pOwnerUserObjectId), "pageNumber=" + pPageNumber, "rowsPerPage=" + pRowsPerPage); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.ErrorText = "Empty response received"; res.Success = false; return(res); } //not an error, just return empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pPrivateLists = pConnectionServer.GetObjectsFromJson <PrivateList>(res.ResponseText); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pPrivateLists) { oObject.HomeServer = pConnectionServer; oObject.UserObjectId = pOwnerUserObjectId; oObject.ClearPendingChanges(); } return(res); }
/// <summary> /// Gets the list of all restriction patterns and resturns them as a generic list of RestrictionPattern objects. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that references the server the templates should be pulled from /// </param> /// <param name="pRestrictionTableObjectId"> /// The objectId of the restriction table to fetch patterns for. /// </param> /// <param name="pRestrictionPatterns"> /// Out parameter that is used to return the list of RestrictionTable objects defined on Connection - there must be at least one. /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetRestrictionPatterns(ConnectionServerRest pConnectionServer, string pRestrictionTableObjectId, out List <RestrictionPattern> pRestrictionPatterns, int pPageNumber = 1, int pRowsPerPage = 20) { WebCallResult res; pRestrictionPatterns = new List <RestrictionPattern>(); if (pConnectionServer == null) { res = new WebCallResult(); res.ErrorText = "Null ConnectionServer referenced passed to GetRestrictionPatterns"; return(res); } if (string.IsNullOrEmpty(pRestrictionTableObjectId)) { res = new WebCallResult(); res.ErrorText = "Empty restriction table objectId passed to GetRestrictionPatterns"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(string.Format("{0}restrictiontables/{1}/restrictionpatterns", pConnectionServer.BaseUrl, pRestrictionTableObjectId), "pageNumber=" + pPageNumber, "rowsPerPage=" + pRowsPerPage); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.ErrorText = "Empty response received"; res.Success = false; return(res); } //no error, just return an empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pRestrictionPatterns = pConnectionServer.GetObjectsFromJson <RestrictionPattern>(res.ResponseText); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pRestrictionPatterns) { oObject.HomeServer = pConnectionServer; oObject.RestrictionTableObjectId = pRestrictionTableObjectId; } return(res); }
/// <summary> /// Get a list of all users associated with a phone system /// </summary> /// <param name="pConnectionServer"> /// Connection server to do the query against /// </param> /// <param name="pObjectId"> /// ObjectId of the phone system to get associations for /// </param> /// <param name="pAssociations"> /// List of associated users is returned on this parameter /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <returns> /// Instance of the WebCallResults class with details of the fetch results. /// </returns> public static WebCallResult GetPhoneSystemAssociations(ConnectionServerRest pConnectionServer, string pObjectId, out List <PhoneSystemAssociation> pAssociations, int pPageNumber = 1, int pRowsPerPage = 20) { WebCallResult res = new WebCallResult { Success = false }; pAssociations = new List <PhoneSystemAssociation>(); if (pConnectionServer == null) { res.ErrorText = "Null ConnectionServer referenced passed to GetPhoneSystemAssociation"; return(res); } if (string.IsNullOrEmpty(pObjectId)) { res.ErrorText = "Blank ObjectId passed to GetPhonesystemAssociations"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(string.Format("{0}phonesystems/{1}/phonesystemassociations", pConnectionServer.BaseUrl, pObjectId), "pageNumber=" + pPageNumber, "rowsPerPage=" + pRowsPerPage); res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.Success = false; res.ErrorText = "Empty response received"; return(res); } //not an error, just return the empty list if (res.TotalObjectCount == 0) { return(res); } pAssociations = pConnectionServer.GetObjectsFromJson <PhoneSystemAssociation>(res.ResponseText); if (pAssociations == null) { pAssociations = new List <PhoneSystemAssociation>(); res.ErrorText = "Could not parse JSON into PhoneSystemAssociations:" + res.ResponseText; res.Success = false; return(res); } return(res); }
/// <summary> /// This function allows for a GET of port group templates from Connection via HTTP - typically there are only three templates defined /// on the server and there's no provision for creating more so there's no filter clauses or the like supported to keep it simple. /// </summary> /// <param name="pConnectionServer"> /// Reference to the ConnectionServer object that points to the home server where the templates are being fetched from. /// </param> /// <param name="pTemplates"> /// The list of port group templates is returned via this out parameter /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetPortGroupTemplates(ConnectionServerRest pConnectionServer, out List <PortGroupTemplate> pTemplates) { WebCallResult res = new WebCallResult(); res.Success = false; pTemplates = new List <PortGroupTemplate>(); if (pConnectionServer == null) { res.ErrorText = "Null Connection server object passed to GetPortGroupTemplates"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "portgrouptemplates"); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.Success = false; res.ErrorText = "Empty response received"; return(res); } //not an error, just return an empty list if (res.TotalObjectCount == 0 || res.ResponseText.Length < 20) { return(res); } pTemplates = pConnectionServer.GetObjectsFromJson <PortGroupTemplate>(res.ResponseText); if (pTemplates == null) { pTemplates = new List <PortGroupTemplate>(); res.ErrorText = "Failed to parse JSON into PortGroupTemplates:" + res.ResponseText; res.Success = false; return(res); } //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pTemplates) { oObject.HomeServer = pConnectionServer; } return(res); }
/// <summary> /// This function allows for a GET of RtpCodec definitions from Connection via HTTP /// </summary> /// <param name="pConnectionServer"> /// Reference to the ConnectionServer object that points to the home server where the templates are being fetched from. /// </param> /// <param name="pCodecDefs"> /// The list of rtp codecs defined on the server (typically only 5) /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetRtpCodecDefs(ConnectionServerRest pConnectionServer, out List <RtpCodecDef> pCodecDefs) { WebCallResult res = new WebCallResult(); res.Success = false; pCodecDefs = new List <RtpCodecDef>(); if (pConnectionServer == null) { res.ErrorText = "Null Connection server object passed to GetRtpCodecDefs"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "rtpcodecdefs"); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.Success = false; res.ErrorText = "Empty response recieved"; return(res); } //if the call was successful the JSON dictionary should always be populated with something, but just in case do a check here. //if this is empty that's not an error, just return an empty list if (res.ResponseText.Length < 20 || res.TotalObjectCount == 0) { return(res); } pCodecDefs = pConnectionServer.GetObjectsFromJson <RtpCodecDef>(res.ResponseText); if (pCodecDefs == null) { pCodecDefs = new List <RtpCodecDef>(); res.ErrorText = "Could not parse JSON into RtpCodecDef objects:" + res.ResponseText; res.Success = false; return(res); } //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pCodecDefs) { oObject.HomeServer = pConnectionServer; } return(res); }
/// <summary> /// This function allows for a GET of VMS Servers from Connection via HTTP - typically there are only one defined /// on the server so there's no filter clauses or the like supported to keep it simple. /// </summary> /// <param name="pConnectionServer"> /// Reference to the ConnectionServer object that points to the home server where the servers are being fetched from. /// </param> /// <param name="pServers"> /// The list of VMSServers is returned via this out parameter /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetVmsServers(ConnectionServerRest pConnectionServer, out List <VmsServer> pServers) { WebCallResult res = new WebCallResult(); res.Success = false; pServers = null; if (pConnectionServer == null) { res.ErrorText = "Null Connection server object passed to GetVmsServers"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "vmsservers"); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } //if the call was successful the JSON dictionary should always be populated with something, but just in case do a check here. //if this is empty that's an error - a zero count is also not valid since there must always be one. if (string.IsNullOrEmpty(res.ResponseText) || res.TotalObjectCount == 0) { pServers = new List <VmsServer>(); res.Success = false; return(res); } pServers = pConnectionServer.GetObjectsFromJson <VmsServer>(res.ResponseText); if (pServers == null) { pServers = new List <VmsServer>(); res.ErrorText = "Could not parse JSON into VmsServers:" + res.ResponseText; res.Success = false; return(res); } //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pServers) { oObject.HomeServer = pConnectionServer; } return(res); }
/// <summary> /// Gets the list of all routing rule conditions associated with a routing rule. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that references the server the routing rule should be pulled from /// </param> /// <param name="pRoutingRuleObjectId"> /// Routing rule to fetch conditions for /// </param> /// <param name="pRoutingRuleConditions"> /// Out parameter that is used to return the list of RoutingRuleCondition objects defined on Connection. This /// list can be empty, conditions are not required /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetRoutingRuleConditions(ConnectionServerRest pConnectionServer, string pRoutingRuleObjectId, out List <RoutingRuleCondition> pRoutingRuleConditions, int pPageNumber = 1, int pRowsPerPage = 20) { pRoutingRuleConditions = null; WebCallResult res = new WebCallResult { Success = false }; if (pConnectionServer == null) { res.ErrorText = "Null ConnectionServer referenced passed to GetRoutingRuleConditions"; return(res); } if (string.IsNullOrEmpty(pRoutingRuleObjectId)) { res.ErrorText = "Empty RoutingRuleObjectId referenced passed to GetRoutingRuleConditions"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "routingrules/" + pRoutingRuleObjectId + "/routingruleconditions", "pageNumber=" + pPageNumber, "rowsPerPage=" + pRowsPerPage); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } //if the call was successful the JSON dictionary should always be populated with something, but just in case do a check here. //if this is empty that does not mean an error - routing rules don't need conditions if (string.IsNullOrEmpty(res.ResponseText) || (res.TotalObjectCount == 0)) { pRoutingRuleConditions = new List <RoutingRuleCondition>(); return(res); } pRoutingRuleConditions = pConnectionServer.GetObjectsFromJson <RoutingRuleCondition>(res.ResponseText); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pRoutingRuleConditions) { oObject.HomeServer = pConnectionServer; } return(res); }
/// <summary> /// This method allows for a GET of configuration valies from Connection via HTTP - it allows for passing any number of additional clauses /// for filtering (query directives), sorting and paging of results. The format of the clauses should look like: /// filter: "query=(FullName startswith System)" /// sort: "sort=(fullname asc)" /// page: "pageNumber=0" /// : "rowsPerPage=8" /// Escaping of spaces is done automatically, no need to account for that. /// </summary> /// <param name="pConnectionServer"> /// Reference to the ConnectionServer object that points to the home server where the values are being fetched from. /// </param> /// <param name="pConfigurationValues"> /// The values found will be returned in this generic list of ConfigurationValues /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter at a time /// are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" and "query=(FirstName startswith a)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetConfigurationValues(ConnectionServerRest pConnectionServer, out List <ConfigurationValue> pConfigurationValues, params string[] pClauses) { WebCallResult res = new WebCallResult(); res.Success = false; pConfigurationValues = null; if (pConnectionServer == null) { res.ErrorText = "Null Connection server object passed to GetConfigurationValues"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "configurationvalues", pClauses); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } //if the call was successful the JSON dictionary should always be populated with something, but just in case do a check here. //if this is empty that is not an error, just return the empty list if (string.IsNullOrEmpty(res.ResponseText)) { pConfigurationValues = new List <ConfigurationValue>(); res.Success = false; return(res); } //no error, just return empty list. if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { pConfigurationValues = new List <ConfigurationValue>(); return(res); } pConfigurationValues = pConnectionServer.GetObjectsFromJson <ConfigurationValue>(res.ResponseText); foreach (var oObject in pConfigurationValues) { oObject.HomeServer = pConnectionServer; } return(res); }
/// <summary> /// Returns a list of CallHandlerOwner objects representing the owners (users or public distribution lists) for a particular /// system call handler. /// A call handler may have no owners in which case an empty list is returned. /// </summary> /// <param name="pConnectionServer"></param> /// <param name="pCallHandlerObjectId"> /// Call handler to fetch owner information for. /// </param> /// <param name="pCallHandlerOwners"> /// List of CallHandlerOwner objects. Can represent users or public distribution lists. /// </param> /// <param name="pClauses"> /// Optional search clauses such as "query=(name is testname)" /// </param> /// <returns> /// Instance of the WebCallResult object with details of the call and results. /// </returns> public static WebCallResult GetCallHandlerOwners(ConnectionServerRest pConnectionServer, string pCallHandlerObjectId, out List <CallHandlerOwner> pCallHandlerOwners, params string[] pClauses) { WebCallResult res = new WebCallResult(); res.Success = false; pCallHandlerOwners = new List <CallHandlerOwner>(); if (pConnectionServer == null) { res.ErrorText = "Null Connection server object passed to GetCallHandlerOwners"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "handlers/callhandlers/" + pCallHandlerObjectId + "/callhandlerowners", pClauses); res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.Success = false; res.ErrorText = "Empty response recieved"; return(res); } //not a failure, just return an empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pCallHandlerOwners = pConnectionServer.GetObjectsFromJson <CallHandlerOwner>(res.ResponseText, "CallhandlerOwner"); if (pCallHandlerOwners == null) { pCallHandlerOwners = new List <CallHandlerOwner>(); res.ErrorText = "Could not parse JSON into call handler owner objects:" + res.ResponseText; res.Success = false; } return(res); }
/// <summary> /// Gets the list of all notification templates and resturns them as a generic list of NotificationTemplate objects. This /// list can be used for providing drop down list selection for user creation purposes or the like. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that references the server the templates should be pulled from /// </param> /// <param name="pTemplates"> /// Out parameter that is used to return the list of NotificationTemplate objects defined on Connection - /// there must be at least one. /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetNotificationTemplates(ConnectionServerRest pConnectionServer, out List <NotificationTemplate> pTemplates, int pPageNumber = 1, int pRowsPerPage = 20) { WebCallResult res; pTemplates = new List <NotificationTemplate>(); if (pConnectionServer == null) { res = new WebCallResult(); res.ErrorText = "Null ConnectionServer referenced passed to GetNotificationTemplates"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "notificationtemplates", "pageNumber=" + pPageNumber, "rowsPerPage=" + pRowsPerPage); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.ErrorText = "Empty response received"; res.Success = false; return(res); } //not an error just return the empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pTemplates = pConnectionServer.GetObjectsFromJson <NotificationTemplate>(res.ResponseText); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pTemplates) { oObject.HomeServer = pConnectionServer; } return(res); }
/// <summary> /// This function allows for a GET of Ldapusers from Connection via HTTP - it allows for passing any number of additional clauses /// for filtering (query directives), sorting and paging of results. The format of the clauses should look like: /// filter: "query=(firstname startswith ab)" /// sort: "sort=(alias asc)" /// Escaping of spaces is done automatically, no need to account for that. /// </summary> /// <remarks> /// While this method name does have the plural in it, you'll want to use it for fetching single users as well. If searching by /// pKid just construct a query in the form "query=(pkid is {pkid})". /// </remarks> /// <param name="pConnectionServer"> /// Reference to the ConnectionServer object that points to the home server where the users are being fetched from. /// </param> /// <param name="pUsers"> /// The list of users returned from the CUPI call (if any) is returned as a generic list of UserLdap class instances via this out param. /// If no users are found this is returned as en empty /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter at a time /// are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" and "query=(FirstName startswith a)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetLdapUsers(ConnectionServerRest pConnectionServer, out List <UserLdap> pUsers, params string[] pClauses) { WebCallResult res = new WebCallResult(); res.Success = false; pUsers = new List <UserLdap>(); if (pConnectionServer == null) { res.ErrorText = "Null Connection server object passed to GetLdapUsers"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "import/users/ldap", pClauses); res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.ErrorText = "Empty response received"; res.Success = false; return(res); } //not an error, just return empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pUsers = pConnectionServer.GetObjectsFromJson <UserLdap>(res.ResponseText, "ImportUser"); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oUser in pUsers) { oUser.HomeServer = pConnectionServer; } return(res); }
/// <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)); }
public static WebCallResult GetRestrictionTable(ConnectionServerRest pConnectionServer, string pRestrictionTableObjectId, out RestrictionTable pRestrictionTable) { WebCallResult res = new WebCallResult { Success = false }; pRestrictionTable = null; if (pConnectionServer == null) { res.ErrorText = "Null ConnectionServer referenced passed to GetRestrictionTable"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "restrictiontables/" + pRestrictionTableObjectId); res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.ErrorText = "Empty response received"; res.Success = false; return(res); } try { pRestrictionTable = JsonConvert.DeserializeObject <RestrictionTable>(res.ResponseText); pRestrictionTable.HomeServer = pConnectionServer; } catch (Exception ex) { res.ErrorText = "Could not convert response text into a RestrictionTable object:" + ex; res.Success = false; return(res); } return(res); }
/// <summary> /// Gets the list of all SmppProviders and resturns them as a generic list of SmppProvider objects. This /// list can be used for providing drop down list selection for notification device creation purposes or the like. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that references the server the SmppProviders should be pulled from /// </param> /// <param name="pSmppProviders"> /// Out parameter that is used to return the list of SmppProvider objects defined on Connection - the list may be empty /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter at a time /// are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" and "query=(FirstName startswith a)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetSmppProviders(ConnectionServerRest pConnectionServer, out List <SmppProvider> pSmppProviders, params string[] pClauses) { WebCallResult res; pSmppProviders = new List <SmppProvider>(); if (pConnectionServer == null) { res = new WebCallResult(); res.ErrorText = "Null ConnectionServer referenced passed to GetSmppProviders"; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "smppproviders", pClauses); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } //if the call was successful the JSON dictionary should always be populated with something, but just in case do a check here. //if this is empty that's an error if (string.IsNullOrEmpty(res.ResponseText) || res.TotalObjectCount == 0) { return(res); } pSmppProviders = pConnectionServer.GetObjectsFromJson <SmppProvider>(res.ResponseText); if (pSmppProviders == null) { pSmppProviders = new List <SmppProvider>(); res.Success = false; res.ErrorText = "Failed to parse SmppProviders from response text:" + res.ResponseText; return(res); } return(res); }
/// <summary> /// Gets the list of all roles and resturns them as a generic list of Role objects. This /// list can be used for providing drop down list selection or the like. /// The roles in Connection are static and cannot be added to. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that the roles should be pulled from /// </param> /// <param name="pRoles"> /// Out parameter that is used to return the list of Role objects defined on Connection /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter /// at a time are currently supported by CUPI - in other words you can't have "query=(rolename startswith ab)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetRolesForSystem(ConnectionServerRest pConnectionServer, out List <Role> pRoles, params string[] pClauses) { WebCallResult res; pRoles = new List <Role>(); if (pConnectionServer == null) { res = new WebCallResult { ErrorText = "Null ConnectionServer referenced passed to GetRolesForSystem", Success = false }; return(res); } string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "roles", pClauses); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } //if the call was successful the JSON dictionary should always be populated with something, but just in case do a check here. //if this is empty that means an error in this case - should always be at least one role if (string.IsNullOrEmpty(res.ResponseText) || res.TotalObjectCount == 0) { res.Success = false; return(res); } pRoles = pConnectionServer.GetObjectsFromJson <Role>(res.ResponseText); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pRoles) { oObject.HomeServer = pConnectionServer; } return(res); }
/// <summary> /// Gets the list of all call handler templates and resturns them as a generic list of CallHandlerTemplate objects. This /// list can be used for providing drop down list selection for handler creation purposes or the like. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that references the server the templates should be pulled from /// </param> /// <param name="pCallHandlerTemplates"> /// Out parameter that is used to return the list of CallHandlerTemplate objects defined on Connection - there must be at least one. /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter at a time /// are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" and "query=(FirstName startswith a)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetCallHandlerTemplates(ConnectionServerRest pConnectionServer, out List <CallHandlerTemplate> pCallHandlerTemplates , int pPageNumber = 1, int pRowsPerPage = 20, params string[] pClauses) { WebCallResult res; pCallHandlerTemplates = new List <CallHandlerTemplate>(); if (pConnectionServer == null) { res = new WebCallResult(); res.ErrorText = "Null ConnectionServer referenced passed to GetCallHandlerTemplates"; return(res); } List <string> temp; if (pClauses == null) { temp = new List <string>(); } else { temp = pClauses.ToList(); } temp.Add("pageNumber=" + pPageNumber); temp.Add("rowsPerPage=" + pRowsPerPage); string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "callhandlertemplates", temp.ToArray()); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.ErrorText = "Empty response recieved"; res.Success = false; return(res); } //not an error, just no templates returned with query if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pCallHandlerTemplates = pConnectionServer.GetObjectsFromJson <CallHandlerTemplate>(res.ResponseText); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pCallHandlerTemplates) { oObject.HomeServer = pConnectionServer; oObject.ClearPendingChanges(); } return(res); }
/// <summary> /// Gets the list of all external services and resturns them as a generic list of ExternalService objects. This /// list can be used for providing drop down list selection for user creation purposes or the like. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that references the server the external service should be pulled from /// </param> /// <param name="pExternalServices"> /// Out parameter that is used to return the list of ExternalService objects defined on Connection - there must be at least one. /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter /// at a time are currently supported by CUPI - in other words you can't have "query=(displayname startswith ab)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetExternalServices(ConnectionServerRest pConnectionServer, out List <ExternalService> pExternalServices, int pPageNumber = 1, int pRowsPerPage = 20, params string[] pClauses) { WebCallResult res; pExternalServices = new List <ExternalService>(); if (pConnectionServer == null) { res = new WebCallResult { ErrorText = "Null ConnectionServer referenced passed to GetExternalServices" }; return(res); } List <String> oParams; if (pClauses == null) { oParams = new List <string>(); } else { oParams = pClauses.ToList(); } oParams.Add("pageNumber=" + pPageNumber); oParams.Add("rowsPerPage=" + pRowsPerPage); string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "externalservices", oParams.ToArray()); res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.Success = false; res.ErrorText = "Empty response received"; return(res); } if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pExternalServices = pConnectionServer.GetObjectsFromJson <ExternalService>(res.ResponseText); if (pExternalServices == null) { pExternalServices = new List <ExternalService>(); res.ErrorText = "Could not parse JSON into ExternalService:" + res.ResponseText; res.Success = false; return(res); } //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pExternalServices) { oObject.HomeServer = pConnectionServer; oObject.ClearPendingChanges(); } return(res); }
/// <summary> /// Gets the list of all Schedules and resturns them as a generic list of Schedule objects. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that references the server the templates should be pulled from /// </param> /// <param name="pSchedules"> /// Out parameter that is used to return the list of Schedule objects defined on Connection - there must be at least one. /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter /// at a time are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetSchedules(ConnectionServerRest pConnectionServer, out List <Schedule> pSchedules, int pPageNumber = 1, int pRowsPerPage = 20, params string[] pClauses) { pSchedules = new List <Schedule>(); if (pConnectionServer == null) { return(new WebCallResult { Success = false, ErrorText = "Null ConnectionServer referenced passed to GetSchedules" }); } List <String> oParams; if (pClauses == null) { oParams = new List <string>(); } else { oParams = pClauses.ToList(); } oParams.Add("pageNumber=" + pPageNumber); oParams.Add("rowsPerPage=" + pRowsPerPage); string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "schedules", oParams.ToArray()); //issue the command to the CUPI interface WebCallResult res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } //if the call was successful the JSON dictionary should always be populated with something, but just in case do a check here. //if this is empty that means an error in this case if (string.IsNullOrEmpty(res.ResponseText)) { res.ErrorText = "Empty response received"; res.Success = false; return(res); } //no error, just return an empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pSchedules = pConnectionServer.GetObjectsFromJson <Schedule>(res.ResponseText); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pSchedules) { oObject.HomeServer = pConnectionServer; } return(res); }
/// <summary> /// GET all the members of a public distribution list returned as a generic list of DistributionListMember objects. /// </summary> /// <param name="pDistributionListObjectId"> /// Distribution list to fetch membership for /// </param> /// <param name="pMemberList"> /// list of members is returned on this out param as a generic list. /// </param> /// <param name="pConnectionServer"> /// Connection server to query against /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter at a time /// are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" and "query=(FirstName startswith a)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// WebCallResult instance /// </returns> public static WebCallResult GetDistributionListMembers(ConnectionServerRest pConnectionServer, string pDistributionListObjectId, out List <DistributionListMember> pMemberList, int pPageNumber = 1, int pRowsPerPage = 20, params string[] pClauses) { WebCallResult res = new WebCallResult(); pMemberList = new List <DistributionListMember>(); if (pConnectionServer == null) { res.ErrorText = "Null Connection server object passed to GetDistributionListMembers"; return(res); } if (string.IsNullOrEmpty(pDistributionListObjectId)) { res.ErrorText = "Empty DistributionListObjectId passed to GetDistributionListMembers"; return(res); } //tack on the paging items to the parameters list List <string> temp; if (pClauses == null) { temp = new List <string>(); } else { temp = pClauses.ToList(); } temp.Add("pageNumber=" + pPageNumber); temp.Add("rowsPerPage=" + pRowsPerPage); string strUrl = ConnectionServerRest.AddClausesToUri(string.Format("{0}distributionlists/{1}/distributionlistmembers", pConnectionServer.BaseUrl, pDistributionListObjectId), temp.ToArray()); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.Success = false; res.ErrorText = "Empty response received"; return(res); } //not an error, just return an empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pMemberList = pConnectionServer.GetObjectsFromJson <DistributionListMember>(res.ResponseText); //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pMemberList) { //manually determine the member type here - this is a little hacky but it make life a bit easier by being able to filter //member types out in a way that is not provided by CUPI natively. if (!string.IsNullOrEmpty(oObject.MemberContactObjectId)) { oObject.MemberType = DistributionListMemberType.Contact; } else if (!string.IsNullOrEmpty(oObject.MemberDistributionListObjectId)) { oObject.MemberType = DistributionListMemberType.DistributionList; } else if (!string.IsNullOrEmpty(oObject.MemberUserObjectId)) { oObject.MemberType = DistributionListMemberType.LocalUser; } else { oObject.MemberType = DistributionListMemberType.GlobalUser; } } return(res); }
/// <summary> /// Gets the list of all search spaces and resturns them as a generic list of SearchSpace objects. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that the search space should be pulled from /// </param> /// <param name="pSearchSpaces"> /// Out parameter that is used to return the list of SearchSpace objects defined on Connection - there must be at least one. /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts, page directives). Only one query and one sort parameter at a time /// are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" and "query=(FirstName startswith a)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> public static WebCallResult GetSearchSpaces(ConnectionServerRest pConnectionServer, out List <SearchSpace> pSearchSpaces, int pPageNumber = 1, int pRowsPerPage = 20, params string[] pClauses) { WebCallResult res = new WebCallResult(); pSearchSpaces = new List <SearchSpace>(); if (pConnectionServer == null) { res.ErrorText = "Null ConnectionServer referenced passed to GetSearchSpaces"; return(res); } //tack on the paging items to the parameters list List <string> temp; if (pClauses == null) { temp = new List <string>(); } else { temp = pClauses.ToList(); } temp.Add("pageNumber=" + pPageNumber); temp.Add("rowsPerPage=" + pRowsPerPage); string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "searchspaces", temp.ToArray()); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.ErrorText = "Empty response received"; res.Success = false; return(res); } //not an error, just return empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pSearchSpaces = pConnectionServer.GetObjectsFromJson <SearchSpace>(res.ResponseText); if (pSearchSpaces == null) { pSearchSpaces = new List <SearchSpace>(); res.ErrorText = "Could not parse response text into SearchSpaces:" + res.ResponseText; res.Success = false; return(res); } //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pSearchSpaces) { oObject.HomeServer = pConnectionServer; } return(res); }
/// <summary> /// Gets the list of all port groups and resturns them as a generic list of PortGroup objects. /// </summary> /// <param name="pConnectionServer"> /// The Connection server object that is being queried /// </param> /// <param name="pPortGroups"> /// Out parameter that is used to return the list of PortGroup objects defined on Connection - there may be none - this list can be /// returned empty. /// </param> /// <param name="pPageNumber"> /// Results page to fetch - defaults to 1 /// </param> /// <param name="pRowsPerPage"> /// Results to return per page, defaults to 20 /// </param> /// <param name="pClauses"> /// Zero or more strings can be passed for clauses (filters, sorts). Only one query and one sort parameter at a time /// are currently supported by CUPI - in other words you can't have "query=(alias startswith ab)" and "query=(FirstName startswith a)" in /// the same call. Also if you have a sort and a query clause they must both reference the same column. /// </param> /// <returns> /// Instance of the WebCallResults class containing details of the items sent and recieved from the CUPI interface. /// </returns> public static WebCallResult GetPortGroups(ConnectionServerRest pConnectionServer, out List <PortGroup> pPortGroups, int pPageNumber = 1, int pRowsPerPage = 20, params string[] pClauses) { WebCallResult res; pPortGroups = new List <PortGroup>(); if (pConnectionServer == null) { res = new WebCallResult(); res.ErrorText = "Null ConnectionServer referenced passed to GetPortGroups"; return(res); } //add on the paging directive to existing clauses List <string> temp; if (pClauses == null) { temp = new List <string>(); } else { temp = pClauses.ToList(); } temp.Add("pageNumber=" + pPageNumber); temp.Add("rowsPerPage=" + pRowsPerPage); string strUrl = ConnectionServerRest.AddClausesToUri(pConnectionServer.BaseUrl + "portgroups", temp.ToArray()); //issue the command to the CUPI interface res = pConnectionServer.GetCupiResponse(strUrl, MethodType.GET, ""); if (res.Success == false) { return(res); } if (string.IsNullOrEmpty(res.ResponseText)) { res.Success = false; res.ErrorText = "Empty response received"; return(res); } //not an error, return empty list if (res.TotalObjectCount == 0 | res.ResponseText.Length < 25) { return(res); } pPortGroups = pConnectionServer.GetObjectsFromJson <PortGroup>(res.ResponseText); if (pPortGroups == null) { pPortGroups = new List <PortGroup>(); res.ErrorText = "Failed parsing JSON into PortGroups:" + res.ResponseText; res.Success = false; } //the ConnectionServer property is not filled in in the default class constructor used by the Json parser - //run through here and assign it for all instances. foreach (var oObject in pPortGroups) { oObject.HomeServer = pConnectionServer; oObject.ClearPendingChanges(); } return(res); }