/// <summary> /// Get bounces for a given contact. /// </summary> /// <param name="contactId">Contact id.</param> /// <param name="limit">Specifies the number of results per page in the output, from 1 - 500, default = 500.</param> /// <param name="pag">Pagination object.</param> /// <returns>ResultSet containing a results array of @link BounceActivity</returns> private ResultSet <BounceActivity> GetBounces(string contactId, int?limit, Pagination pag) { string url = (pag == null) ? ConstructUrl(Settings.Endpoints.Default.ContactTrackingBounces, new object[] { contactId }, new object[] { "limit", limit }) : pag.GetNextUrl(); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var results = response.Get <ResultSet <BounceActivity> >(); return(results); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
/// <summary> /// Get opt outs for a given contact. /// </summary> /// <param name="contactId">Contact id.</param> /// <param name="limit">Specifies the number of results per page in the output, from 1 - 500, default = 500.</param> /// <param name="createdSince">filter for activities created since the supplied date in the collection</param> /// <param name="pag">Pagination object.</param> /// <returns>ResultSet containing a results array of @link OptOutActivity.</returns> private ResultSet <OptOutActivity> GetOptOuts(string contactId, int?limit, DateTime?createdSince, Pagination pag) { string url = (pag == null) ? ConstructUrl(Settings.Endpoints.Default.ContactTrackingUnsubscribes, new object[] { contactId }, new object[] { "limit", limit, "created_since", Extensions.ToISO8601String(createdSince) }) : pag.GetNextUrl(); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var results = response.Get <ResultSet <OptOutActivity> >(); return(results); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
/// <summary> /// Get a set of campaigns. /// </summary> /// <param name="status">Returns list of email campaigns with specified status.</param> /// <param name="limit">Specifies the number of results per page in the output, from 1 - 500, default = 500.</param> /// <param name="modifiedSince">limit campaigns to campaigns modified since the supplied date</param> /// <param name="pag">Pagination object returned by a previous call to GetCampaigns</param> /// <returns>Returns a ResultSet of campaigns.</returns> public ResultSet <EmailCampaign> GetCampaigns(CampaignStatus?status, int?limit, DateTime?modifiedSince, Pagination pag) { string url = (pag == null) ? String.Concat(Settings.Endpoints.Default.BaseUrl, Settings.Endpoints.Default.Campaigns, GetQueryParameters(new object[] { "status", status, "limit", limit, "modified_since", Extensions.ToISO8601String(modifiedSince) })) : pag.GetNextUrl(); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var results = response.Get <ResultSet <EmailCampaign> >(); return(results); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
/// <summary> /// Add files using the multipart content-type /// </summary> /// <param name="fileName">The file name and extension</param> /// <param name="fileType">The file type</param> /// <param name="folderId">The id of the folder</param> /// <param name="description">The description of the file</param> /// <param name="source">The source of the original file</param> /// <param name="data">The data contained in the file being uploaded</param> /// <returns>Returns the file Id associated with the uploaded file</returns> public string AddLibraryFilesMultipart(string fileName, FileType fileType, string folderId, string description, FileSource source, byte[] data) { if (string.IsNullOrEmpty(fileName)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.FileNameNull); } var extension = Path.GetExtension(fileName).ToLowerInvariant(); string[] fileTypes = new string[5] { ".jpeg", ".jpg", ".gif", ".png", ".pdf" }; if (!((IList <string>)fileTypes).Contains(extension)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.FileTypeInvalid); } if (string.IsNullOrEmpty(folderId) || string.IsNullOrEmpty(description)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.FieldNull); } if (data == null) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.FileNull); } string result = null; string url = String.Concat(Settings.Endpoints.Default.BaseUrl, Settings.Endpoints.Default.MyLibraryFiles); byte[] content = MultipartBuilder.CreateMultipartContent(fileName, data, null, fileType.ToString(), folderId, description, source.ToString()); RawApiResponse response = RestClient.PostMultipart(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey, content); if (response.IsError) { throw new ConstantContactClientException(response.GetErrorMessage()); } if (!response.IsError && response.StatusCode == System.Net.HttpStatusCode.Accepted) { string location = response.Headers["Location"]; int idStart = location.LastIndexOf("/") + 1; result = location.Substring(idStart); } return(result); }
/// <summary> /// View all existing events /// </summary> /// <param name="limit">Specifies the number of results per page in the output, from 1 - 500, default = 50</param> /// <param name="pag">Pagination object</param> /// <returns>ResultSet containing a results array of IndividualEvents</returns> public ResultSet <IndividualEvent> GetAllEventSpots(int?limit, Pagination pag) { string url = (pag == null) ? String.Concat(Settings.Endpoints.Default.BaseUrl, Settings.Endpoints.Default.EventSpots, GetQueryParameters(new object[] { "limit", limit })) : pag.GetNextUrl(); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var individualEventSet = response.Get <ResultSet <IndividualEvent> >(); return(individualEventSet); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
/// <summary> /// Update a specific schedule for a campaign. /// </summary> /// <param name="campaignId">Campaign id to be scheduled.</param> /// <param name="schedule">Schedule to retrieve.</param> /// <returns>Returns the updated schedule object.</returns> public Schedule UpdateSchedule(string campaignId, Schedule schedule) { string url = String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.CampaignSchedule, campaignId, schedule.Id)); string json = schedule.ToJSON(); RawApiResponse response = RestClient.Put(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey, json); try { var upd = response.Get <Schedule>(); return(upd); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
/// <summary> /// Gets the status report for an activity by ID /// </summary> /// <param name="activityId">The activity ID</param> /// <returns>The StatusReport</returns> public StatusReport GetBulkActivityStatusById(string activityId) { string url = String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.Activity, activityId)); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var bulkStatusReport = response.Get <StatusReport>(); return(bulkStatusReport); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
/// <summary> /// Get an array of contacts. /// </summary> /// <param name="email">Match the exact email address.</param> /// <param name="limit">Limit the number of returned values.</param> /// <param name="modifiedSince">limit contact to contacts modified since the supplied date</param> /// <param name="status">Match the exact contact status.</param> /// <param name="pag">Pagination object.</param> /// <returns>Returns a list of contacts.</returns> private ResultSet <Contact> GetContacts(string email, int?limit, DateTime?modifiedSince, ContactStatus?status, Pagination pag) { // Construct access URL string url = (pag == null) ? ConstructUrl(Settings.Endpoints.Default.Contacts, null, new object[] { "email", email, "limit", limit, "modified_since", Extensions.ToISO8601String(modifiedSince), "status", status }) : pag.GetNextUrl(); // Get REST response RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var results = response.Get <ResultSet <Contact> >(); return(results); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
/// <summary> /// Get account summary information /// </summary> /// <returns>An AccountSummaryInformation object</returns> public AccountSummaryInformation GetAccountSummaryInformation() { // Construct access URL string url = String.Concat(Settings.Endpoints.Default.BaseUrl, Settings.Endpoints.Default.AccountSummaryInformation); // Get REST response RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var result = response.Get <AccountSummaryInformation>(); return(result); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
/// <summary> /// Create a Remove Contacts Multipart Activity /// </summary> /// <param name="fileName">The file name to be imported</param> /// <param name="fileContent">The file content to be imported</param> /// <param name="lists">Array of list's id</param> /// <returns>Returns an Activity object.</returns> public Activity RemoveContactsMultipartActivity(string fileName, byte[] fileContent, IList <string> lists) { if (string.IsNullOrEmpty(fileName)) { throw new IllegalArgumentException(CTCT.Resources.Errors.FileNameNull); } var extension = Path.GetExtension(fileName).ToLowerInvariant(); string[] fileTypes = new string[4] { ".txt", ".csv", ".xls", ".xlsx" }; if (!((IList <string>)fileTypes).Contains(extension)) { throw new IllegalArgumentException(CTCT.Resources.Errors.FileTypeInvalid); } if (fileContent == null) { throw new IllegalArgumentException(CTCT.Resources.Errors.FileNull); } if (lists == null || lists.Count.Equals(0)) { throw new IllegalArgumentException(CTCT.Resources.Errors.ActivityOrId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, Settings.Endpoints.Default.RemoveFromListsActivity); byte[] data = MultipartBuilder.CreateMultipartContent(fileName, fileContent, lists); RawApiResponse response = RestClient.PostMultipart(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey, data); try { var activity = response.Get <Activity>(); return(activity); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
/// <summary> /// Delete a specific file /// </summary> /// <param name="fileId">The id of the file</param> /// <returns>Returns true if folder was deleted successfully, false otherwise</returns> public bool DeleteLibraryFile(string fileId) { if (string.IsNullOrEmpty(fileId)) { throw new IllegalArgumentException(CTCT.Resources.Errors.MyLibraryOrId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.MyLibraryFile, fileId)); RawApiResponse response = RestClient.Delete(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { return(!response.IsError && response.StatusCode == System.Net.HttpStatusCode.NoContent); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
/// <summary> /// Delete a contact from all contact lists. /// </summary> /// <param name="contactId">Contact id to be removed from lists.</param> /// <returns>Returns true if operation succeeded.</returns> public bool DeleteContactFromLists(string contactId) { if (string.IsNullOrEmpty(contactId)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.ContactOrId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.ContactLists, contactId)); RawApiResponse response = RestClient.Delete(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { return(!response.IsError && response.StatusCode == System.Net.HttpStatusCode.NoContent); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
/// <summary> /// Get a summary of reporting data for a given campaign. /// </summary> /// <param name="campaignId">Campaign id.</param> /// <returns>Tracking summary.</returns> public TrackingSummary GetSummary(string campaignId) { if (string.IsNullOrEmpty(campaignId)) { throw new IllegalArgumentException(CTCT.Resources.Errors.CampaignTrackingOrId); } string url = ConstructUrl(Settings.Endpoints.Default.CampaignTrackingSummary, new object[] { campaignId }, null); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var summary = response.Get <TrackingSummary>(); return(summary); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
public Lists CreateList(Lists lists) { if (lists == null) { throw new IllegalArgumentException(Resources.Errors.GeneralId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, Settings.Endpoints.Default.Lists); RawApiResponse response = RestClient.Post(url, UserServiceContext.ApiKey, lists.ToJSON()); try { Lists list = response.Get <Lists>(); return(list); } catch (Exception ex) { throw new KlaviyoException(ex.ToString()); } }
public Lists GetList(string listId = null) { if (listId == null) { throw new IllegalArgumentException(Resources.Errors.GeneralId); } string url = string.Concat(Settings.Endpoints.Default.BaseUrl, string.Format(Settings.Endpoints.Default.Lists, listId)); RawApiResponse response = RestClient.Get(url, UserServiceContext.ApiKey); try { Lists lists = response.Get <Lists>(); return(lists); } catch (Exception ex) { throw new KlaviyoException(ex.ToString()); } }
public Dictionary <string, object> AddPersonToList(string listId, KeyValuePair <string, string> personEmail) { if (personEmail.Key != "email") { throw new IllegalArgumentException(Resources.Errors.GeneralId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, string.Format(Settings.Endpoints.Default.ListMembers, listId)); RawApiResponse response = RestClient.PostXwwwFormUrlEncoded(url, UserServiceContext.ApiKey, personEmail.Key + "=" + personEmail.Value); try { Dictionary <string, object> person = response.Get <Dictionary <string, object> >(); return(person); } catch (Exception ex) { throw new KlaviyoException(ex.ToString()); } }
/// <summary> /// Get campaign details for a specific campaign. /// </summary> /// <param name="campaignId">Campaign id.</param> /// <returns>Returns a campaign.</returns> public EmailCampaign GetCampaign(string campaignId) { if (string.IsNullOrEmpty(campaignId)) { throw new IllegalArgumentException(CTCT.Resources.Errors.EmailCampaignOrId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.Campaign, campaignId)); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var campaign = response.Get <EmailCampaign>(); return(campaign); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
/// <summary> /// Get status for an upload file /// </summary> /// <param name="fileId">The id of the file</param> /// <returns>Returns a list of FileUploadStatus objects</returns> public IList <FileUploadStatus> GetLibraryFileUploadStatus(string fileId) { if (string.IsNullOrEmpty(fileId)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.MyLibraryOrId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, string.Format(Settings.Endpoints.Default.MyLibraryFileUploadStatus, fileId)); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var lists = response.Get <IList <FileUploadStatus> >(); return(lists); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
/// <summary> /// Get files from a specific folder /// </summary> /// <param name="folderId">The id of the folder from which to retrieve files</param> /// <param name="limit">Specifies the number of results per page in the output, from 1 - 50, default = 50.</param> /// <param name="pag">Pagination object.</param> /// <returns>Returns a collection of MyLibraryFile objects.</returns> public ResultSet <MyLibraryFile> GetLibraryFilesByFolder(string folderId, int?limit, Pagination pag) { if (string.IsNullOrEmpty(folderId)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.MyLibraryOrId); } string url = (pag == null) ? String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.MyLibraryFolderFiles, folderId), GetQueryParameters(new object[] { "limit", limit })) : pag.GetNextUrl(); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var results = response.Get <ResultSet <MyLibraryFile> >(); return(results); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
/// <summary> /// Get a folder by Id /// </summary> /// <param name="folderId">The id of the folder</param> /// <returns>Returns a MyLibraryFolder object.</returns> public MyLibraryFolder GetLibraryFolder(string folderId) { if (string.IsNullOrEmpty(folderId)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.MyLibraryOrId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.MyLibraryFolder, folderId)); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var folder = response.Get <MyLibraryFolder>(); return(folder); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
/// <summary> /// Get all contacts from an individual list. /// </summary> /// <param name="listId">List id to retrieve contacts for.</param> /// <param name="limit">Specifies the number of results per page in the output, from 1 - 500, default = 500.</param> /// <param name="modifiedSince">limit contacts retrieved to contacts modified since the supplied date</param> /// <param name="pag">Pagination object.</param> /// <returns>Returns a list of contacts.</returns> public ResultSet <Contact> GetContactsFromList(string listId, int?limit, DateTime?modifiedSince, Pagination pag) { if (string.IsNullOrEmpty(listId)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.ListOrId); } string url = (pag == null) ? ConstructUrl(Settings.Endpoints.Default.ListContacts, new object[] { listId }, new object[] { "limit", limit, "modified_since", Extensions.ToISO8601String(modifiedSince) }) : pag.GetNextUrl(); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var contacts = response.Get <ResultSet <Contact> >(); return(contacts); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
public Dictionary <string, object> GetPerson(string id) { if (string.IsNullOrEmpty(id)) { throw new IllegalArgumentException(Resources.Errors.GeneralId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, string.Format(Settings.Endpoints.Default.Person, id)); RawApiResponse response = RestClient.Get(url, UserServiceContext.ApiKey); try { Dictionary <string, object> person = response.Get <Dictionary <string, object> >(); return(person); } catch (Exception ex) { throw new KlaviyoException(ex.ToString()); } }
/// <summary> /// Get an activity. /// </summary> /// <param name="activityId">The activity identification.</param> /// <returns>Returns the activity identified by its id.</returns> public Activity GetActivity(string activityId) { if (string.IsNullOrEmpty(activityId)) { throw new IllegalArgumentException(CTCT.Resources.Errors.ActivityOrId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.Activity, activityId)); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var activity = response.Get <Activity>(); return(activity); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
/// <summary> /// Get activities by email campaign for a given contact. /// </summary> /// <param name="contactId">Contact id.</param> /// <returns>ResultSet containing a results array of @link TrackingSummary</returns> public IList <TrackingSummary> GetEmailCampaignActivities(string contactId) { if (string.IsNullOrEmpty(contactId)) { throw new IllegalArgumentException(CTCT.Resources.Errors.ContactTrackingOrId); } string url = ConstructUrl(Settings.Endpoints.Default.ContactTrackingEmailCampaignActivities, new object[] { contactId }, null); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var results = response.Get <IList <TrackingSummary> >(); return(results); } catch (Exception ex) { throw new CtctException(ex.Message, ex); } }
/// <summary> /// Get a specific schedule for a campaign. /// </summary> /// <param name="campaignId">Campaign id to be get a schedule for.</param> /// <param name="scheduleId">Schedule id to retrieve.</param> /// <returns>Returns the requested schedule object.</returns> public Schedule GetSchedule(string campaignId, string scheduleId) { if (string.IsNullOrEmpty(campaignId) || string.IsNullOrEmpty(scheduleId)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.ScheduleOrId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.CampaignSchedule, campaignId, scheduleId)); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var schedule = response.Get <Schedule>(); return(schedule); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
/// <summary> /// Retrieve a list of all the account owner's email addresses /// </summary> /// <returns>list of all verified account owner's email addresses</returns> public IList <VerifiedEmailAddress> GetVerifiedEmailAddress() { IList <VerifiedEmailAddress> emails = new List <VerifiedEmailAddress>(); // Construct access URL string url = String.Concat(Settings.Endpoints.Default.BaseUrl, Settings.Endpoints.Default.AccountVerifiedEmailAddressess); // Get REST response RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var result = response.Get <IList <VerifiedEmailAddress> >(); return(result); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
public Dictionary <string, object> AddPerson(Dictionary <string, object> person) { if (person == null) { throw new IllegalArgumentException(Resources.Errors.GeneralId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, string.Format(Settings.Endpoints.Default.Person, person.Where(x => x.Key == "id"))); RawApiResponse response = RestClient.Put(url, UserServiceContext.ApiKey, JsonConvert.SerializeObject(person)); try { Dictionary <string, object> newPerson = response.Get <Dictionary <string, object> >(); return(person); } catch (Exception ex) { throw new KlaviyoException(ex.ToString()); } }
public bool ExcludeOrUnscribe(string email) { if (string.IsNullOrEmpty(email)) { throw new IllegalArgumentException(Resources.Errors.GeneralId); } string url = string.Concat(Settings.Endpoints.Default.BaseUrl, Settings.Endpoints.Default.ListsExclusions); RawApiResponse response = RestClient.PostXwwwFormUrlEncoded(url, UserServiceContext.ApiKey, HttpUtility.UrlEncode("email" + "=" + email)); try { var excludeUnsubscribeResponse = response.Get <Dictionary <string, bool> >(); return(true); } catch (Exception ex) { throw new KlaviyoException(ex.ToString()); } }
/// <summary> /// Get contact details for a specific contact. /// </summary> /// <param name="contactId">Unique contact id.</param> /// <returns>Returns a contact.</returns> public Contact GetContact(string contactId) { if (string.IsNullOrEmpty(contactId)) { throw new IllegalArgumentException(ConstantContactClient.Resources.Errors.ContactOrId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, String.Format(Settings.Endpoints.Default.Contact, contactId)); RawApiResponse response = RestClient.Get(url, UserServiceContext.AccessToken, UserServiceContext.ApiKey); try { var contact = response.Get <Contact>(); return(contact); } catch (Exception ex) { throw new ConstantContactClientException(ex.Message, ex); } }
public Lists UpdateList(KeyValuePair <string, string> listInfo) { if (listInfo.Equals(new KeyValuePair <string, string>())) { throw new IllegalArgumentException(Resources.Errors.GeneralId); } string url = String.Concat(Settings.Endpoints.Default.BaseUrl, Settings.Endpoints.Default.List); RawApiResponse response = RestClient.PostXwwwFormUrlEncoded(url, UserServiceContext.ApiKey, listInfo.Key + "=" + listInfo.Value); try { Lists list = response.Get <Lists>(); return(list); } catch (Exception ex) { throw new KlaviyoException(ex.ToString()); } }
/// <summary> /// Makes a HTTP request to the Endpoint specified in urlParam and using the HTTP method specified by httpMethod. /// </summary> /// <param name="url">Url</param> /// <param name="method">Method</param> /// <param name="contentType">ContentType</param> /// <param name="accessToken">AccessToken</param> /// <param name="apiKey">ApiKey</param> /// <param name="data">Data if any</param> /// <returns>RawApiResponse</returns> public RawApiResponse HttpRequest(string url, HttpMethod method, IContentType contentType, string accessToken, string apiKey, byte[] data) { var address = url; if (!string.IsNullOrEmpty(apiKey)) { address = string.Format("{0}{1}api_key={2}", url, url.Contains("?") ? "&" : "?", apiKey); } HttpWebRequest request = WebRequest.Create(address) as HttpWebRequest; request.Method = method.ToString(); request.Accept = JSON_CONTENT_TYPE; request.Headers[X_CTCT_REQUEST_SOURCE_HEADER] = "sdk.NET." + GetWrapperAssemblyVersion().ToString(); request.ContentType = contentType.Value; // Add token as HTTP header request.Headers.Add(AUTHORIZATION_HEADER, "Bearer " + accessToken); if (data != null) { using (var stream = request.GetRequestStream()) { stream.Write(data, 0, data.Length); } } // Initialize the response HttpWebResponse response = null; RawApiResponse rawApiResponse = new RawApiResponse(); // Now try to send the request try { response = request.GetResponse() as HttpWebResponse; // Expect the unexpected if (request.HaveResponse == true && response == null) { throw new WebException("Response was not returned or is null"); } foreach (string header in response.Headers.AllKeys) { rawApiResponse.Headers.Add(header, response.GetResponseHeader(header)); } rawApiResponse.StatusCode = response.StatusCode; if (response.StatusCode != HttpStatusCode.OK && response.StatusCode != HttpStatusCode.Created && response.StatusCode != HttpStatusCode.Accepted && response.StatusCode != HttpStatusCode.NoContent) { throw new WebException("Response with status: " + response.StatusCode + " " + response.StatusDescription); } } catch (WebException e) { response = e.Response as HttpWebResponse; rawApiResponse.IsError = true; } finally { if (response != null) { string responseText = null; // Get the response content using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8)) { responseText = reader.ReadToEnd(); } response.Close(); if (rawApiResponse.IsError && responseText.Contains("error_message")) { rawApiResponse.Info = RawApiRequestError.FromJSON<IList<RawApiRequestError>>(responseText); } else { rawApiResponse.Body = responseText; } } } return rawApiResponse; }