/// <summary> /// Gets the redmine exceptions. /// </summary> /// <param name="webResponse">The web response.</param> /// <param name="mimeFormat">The MIME format.</param> /// <returns></returns> private static List <Error> GetRedmineExceptions(this WebResponse webResponse, MimeFormat mimeFormat) { using (var dataStream = webResponse.GetResponseStream()) { if (dataStream == null) { return(null); } using (var reader = new StreamReader(dataStream)) { var responseFromServer = reader.ReadToEnd(); if (string.IsNullOrEmpty(responseFromServer.Trim())) { return(null); } try { var result = RedmineSerializer.DeserializeList <Error>(responseFromServer, mimeFormat); return(result.Objects); } catch (Exception ex) { Logger.Current.Error(ex.Message); } } return(null); } }
/// <summary> /// Creates the or update wiki page asynchronous. /// </summary> /// <param name="redmineManager">The redmine manager.</param> /// <param name="projectId">The project identifier.</param> /// <param name="pageName">Name of the page.</param> /// <param name="wikiPage">The wiki page.</param> /// <returns></returns> public static async Task <WikiPage> CreateOrUpdateWikiPageAsync(this RedmineManager redmineManager, string projectId, string pageName, WikiPage wikiPage) { var uri = UrlHelper.GetWikiCreateOrUpdaterUrl(redmineManager, projectId, pageName); var data = RedmineSerializer.Serialize(wikiPage, redmineManager.MimeFormat); return(await WebApiAsyncHelper.ExecuteUpload <WikiPage>(redmineManager, uri, HttpVerbs.PUT, data, "CreateOrUpdateWikiPageAsync")); }
GetRedmineExceptions(this System.Net.WebResponse webResponse, MimeFormat mimeFormat) { using (System.IO.Stream dataStream = webResponse.GetResponseStream()) { if (dataStream == null) { return(null); } using (System.IO.StreamReader reader = new System.IO.StreamReader(dataStream)) { string responseFromServer = reader.ReadToEnd(); if (string.IsNullOrEmpty(responseFromServer.Trim())) { return(null); } try { Redmine.Net.Api.Types.PaginatedObjects <Error> result = RedmineSerializer.DeserializeList <Error>(responseFromServer, mimeFormat); return(result.Objects); } catch (System.Exception ex) { Logger.Current.Error(ex.Message); } } return(null); } }
public async Task <T> Put <T>(Uri uri, T data, MimeType mimeType) where T : class, new() { SetupCredentials(); httpClient.AddImpersonationHeaderIfSet(ImpersonateUser); var serializedData = RedmineSerializer.Serialize(data, mimeType); serializedData = sanitizeRegex.Replace(serializedData, "\r\n"); var requestContent = new StringContent(serializedData, Encoding.UTF8, $"{APPLICATION}/{UrlBuilder.mimeTypes[mimeType]}"); using (var responseMessage = await httpClient.PutAsync(uri.ToString(), requestContent).ConfigureAwait(false)) { var tc = new TaskCompletionSource <T>(); if (responseMessage.IsSuccessStatusCode) { var responseContent = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); tc.SetResult(string.IsNullOrWhiteSpace(responseContent) ? data : RedmineSerializer.Deserialize <T>(responseContent, mimeType)); } else { tc.SetException(await responseMessage.CreateExceptionAsync(mimeType).ConfigureAwait(false)); } return(await tc.Task); } }
/// <summary> /// Creates a new Redmine object. /// </summary> /// <typeparam name="T">The type of object to create.</typeparam> /// <param name="obj">The object to create.</param> /// <param name="ownerId">The owner identifier.</param> /// <returns></returns> /// <exception cref="RedmineException"></exception> /// <remarks> /// When trying to create an object with invalid or missing attribute parameters, you will get a 422 Unprocessable /// Entity response. That means that the object could not be created. /// </remarks> /// <code> /// <example> /// var project = new Project(); /// project.Name = "test"; /// project.Identifier = "the project identifier"; /// project.Description = "the project description"; /// redmineManager.CreateObject(project); /// </example> /// </code> public T CreateObject <T>(T obj, string ownerId) where T : class, new() { var url = UrlHelper.GetCreateUrl <T>(this, ownerId); var data = RedmineSerializer.Serialize(obj, MimeFormat); return(WebApiHelper.ExecuteUpload <T>(this, url, HttpVerbs.POST, data, "CreateObject")); }
internal static async Task <Exception> CreateExceptionAsync(this HttpResponseMessage responseMessage, MimeType mimeFormat) { var byteArray = await responseMessage.Content.ReadAsByteArrayAsync().ConfigureAwait(false); var responseString = Encoding.UTF8.GetString(byteArray, 0, byteArray.Length); var statusCode = (int)responseMessage.StatusCode; string exceptionMessage; switch (statusCode) { case 422: var errors = RedmineSerializer.DeserializeList <Error>(responseString, mimeFormat); var message = string.Empty; if (errors.Items != null) { message = errors.Items.Aggregate(message, (current, error) => $"{current}{error.Info}{Environment.NewLine}"); } exceptionMessage = $"Request to {responseMessage.RequestMessage.RequestUri.AbsoluteUri} failed with {message}"; return(new UnprocessableEntityException(exceptionMessage)); default: exceptionMessage = $"Request to {responseMessage.RequestMessage.RequestUri.AbsoluteUri} failed with status code {(int)responseMessage.StatusCode} ({responseMessage.ReasonPhrase})."; return(new RedmineException(exceptionMessage)); } }
/// <summary> /// Updates a Redmine object. /// </summary> /// <typeparam name="T">The type of object to be update.</typeparam> /// <param name="id">The id of the object to be update.</param> /// <param name="obj">The object to be update.</param> /// <param name="projectId">The project identifier.</param> /// <exception cref="RedmineException"></exception> /// <remarks> /// When trying to update an object with invalid or missing attribute parameters, you will get a /// 422(RedmineException) Unprocessable Entity response. That means that the object could not be updated. /// </remarks> /// <code></code> public void UpdateObject <T>(string id, T obj, string projectId) where T : class, new() { var url = UrlHelper.GetUploadUrl(this, id, obj, projectId); var data = RedmineSerializer.Serialize(obj, MimeFormat); data = Regex.Replace(data, @"\r\n|\r|\n", "\r\n"); WebApiHelper.ExecuteUpload(this, url, HttpVerbs.PUT, data, "UpdateObject"); }
/// <summary> /// Creates a new Redmine object. This method does not block the calling thread. /// </summary> /// <typeparam name="T">The type of object to create.</typeparam> /// <param name="redmineManager">The redmine manager.</param> /// <param name="obj">The object to create.</param> /// <param name="ownerId">The owner identifier.</param> /// <returns></returns> public static async Task <T> CreateObjectAsync <T>(this RedmineManager redmineManager, T obj, string ownerId) where T : class, new() { var uri = UrlHelper.GetCreateUrl <T>(redmineManager, ownerId); var data = RedmineSerializer.Serialize(obj, redmineManager.MimeFormat); return(await WebApiAsyncHelper.ExecuteUpload <T>(redmineManager, uri, HttpVerbs.POST, data, "CreateObjectAsync")); }
/// <summary> /// Updates the attachment. /// </summary> /// <param name="issueId">The issue identifier.</param> /// <param name="attachment">The attachment.</param> public void UpdateAttachment(int issueId, Attachment attachment) { var address = UrlHelper.GetAttachmentUpdateUrl(this, issueId); var attachments = new Attachments { { attachment.Id, attachment } }; var data = RedmineSerializer.Serialize(attachments, MimeFormat); WebApiHelper.ExecuteUpload(this, address, HttpVerbs.PATCH, data, "UpdateAttachment"); }
/// <summary> /// Updates the object asynchronous. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="redmineManager">The redmine manager.</param> /// <param name="id">The identifier.</param> /// <param name="obj">The object.</param> /// <param name="projectId">The project identifier.</param> /// <returns></returns> public static async Task UpdateObjectAsync <T>(this RedmineManager redmineManager, string id, T obj, string projectId = null) where T : class, new() { var uri = UrlHelper.GetUploadUrl(redmineManager, id, obj, projectId); var data = RedmineSerializer.Serialize(obj, redmineManager.MimeFormat); data = Regex.Replace(data, @"\r\n|\r|\n", "\r\n"); await WebApiAsyncHelper.ExecuteUpload <T>(redmineManager, uri, HttpVerbs.PUT, data, "UpdateObjectAsync"); }
/// <summary> /// Creates or updates a wiki page. /// </summary> /// <param name="projectId">The project id or identifier.</param> /// <param name="pageName">The wiki page name.</param> /// <param name="wikiPage">The wiki page to create or update.</param> /// <returns></returns> public WikiPage CreateOrUpdateWikiPage(string projectId, string pageName, WikiPage wikiPage) { var result = RedmineSerializer.Serialize(wikiPage, MimeFormat); if (string.IsNullOrEmpty(result)) { return(null); } var url = UrlHelper.GetWikiCreateOrUpdaterUrl(this, projectId, pageName); return(WebApiHelper.ExecuteUpload <WikiPage>(this, url, HttpVerbs.PUT, result, "CreateOrUpdateWikiPage")); }
public async Task <PaginatedResult <T> > List <T>(Uri uri, MimeType mimeType) where T : class, new() { SetupCredentials(); httpClient.AddImpersonationHeaderIfSet(ImpersonateUser); httpClient.AddContentType($"{APPLICATION}/{UrlBuilder.mimeTypes[mimeType]}"); using (var responseMessage = await httpClient.GetAsync(uri).ConfigureAwait(false)) { var tc = await responseMessage.CreateTaskCompletionSource(c => RedmineSerializer.DeserializeList <T>(c, mimeType), mimeType).ConfigureAwait(false); return(await tc.Task); } }
public static Task <User> GetCurrentUserAsync(this RedmineManager redmineManager, NameValueCollection parameters = null) { Task <User> task = delegate { using (var wc = redmineManager.CreateWebClient(parameters)) { var uri = UrlHelper.GetCurrentUserUrl(redmineManager); var response = wc.DownloadString(new Uri(uri)); return(RedmineSerializer.Deserialize <User>(response, redmineManager.MimeFormat)); } }; return(task); }
public static Task UpdateObjectAsync <T>(this RedmineManager redmineManager, string id, T obj, string projectId = null) where T : class, new() { var task = Task.Factory.StartNew(() => { var url = UrlHelper.GetUploadUrl(redmineManager, id, obj, projectId); using (var wc = redmineManager.CreateWebClient(null)) { var data = RedmineSerializer.Serialize(obj, redmineManager.MimeFormat); wc.UploadString(url, RedmineManager.PUT, data); } }, TaskCreationOptions.LongRunning); return(task); }
//public static Task<List<T>> GetObjectsAsync<T>(this RedmineManager redmineManager, NameValueCollection parameters) where T : class, new() //{ // Task<List<T>> task = delegate // { // int totalCount = 0, pageSize; // List<T> resultList = null; // if (parameters == null) parameters = new NameValueCollection(); // int offset = 0; // int.TryParse(parameters[RedmineKeys.LIMIT], out pageSize); // if (pageSize == default(int)) // { // pageSize = redmineManager.PageSize > 0 ? redmineManager.PageSize : 25; // parameters.Set(RedmineKeys.LIMIT, pageSize.ToString(CultureInfo.InvariantCulture)); // } // do // { // parameters.Set(RedmineKeys.OFFSET, offset.ToString(CultureInfo.InvariantCulture)); // var requestTask = redmineManager.GetPaginatedObjectsAsync<T>(parameters).ContinueWith(t => // { // if (t.Result != null) // { // if (resultList == null) // { // resultList = t.Result.Objects; // totalCount = t.Result.TotalCount; // } // else // resultList.AddRange(t.Result.Objects); // } // offset += pageSize; // }); // requestTask.Wait(TimeSpan.FromMilliseconds(5000)); // } while (offset < totalCount); // return resultList; // }); // return task; //} public static Task UpdateObjectAsync <T>(this RedmineManager redmineManager, string id, T obj, string projectId = null) where T : class, new() { Task task = delegate { var url = UrlHelper.GetUploadUrl(redmineManager, id, obj, projectId); using (var wc = redmineManager.CreateWebClient(null)) { var data = RedmineSerializer.Serialize(obj, redmineManager.MimeFormat); wc.UploadString(url, RedmineManager.PUT, data); } }; return(task); }
public static Task <PaginatedObjects <T> > GetPaginatedObjectsAsync <T>(this RedmineManager redmineManager, NameValueCollection parameters) where T : class, new() { var task = Task.Factory.StartNew(() => { var url = UrlHelper.GetListUrl <T>(redmineManager, parameters); using (var wc = redmineManager.CreateWebClient(parameters)) { var response = wc.DownloadString(url); return(RedmineSerializer.DeserializeList <T>(response, redmineManager.MimeFormat)); } }, TaskCreationOptions.LongRunning); return(task); }
public static Task <User> GetCurrentUserAsync(this RedmineManager redmineManager, NameValueCollection parameters = null) { var task = Task.Factory.StartNew(() => { var uri = UrlHelper.GetCurrentUserUrl(redmineManager); using (var wc = redmineManager.CreateWebClient(parameters)) { return(wc.DownloadString(uri)); } }); return(task.ContinueWith(t => RedmineSerializer.Deserialize <User>(t.Result, redmineManager.MimeFormat))); }
public static Task <List <WikiPage> > GetAllWikiPagesAsync(this RedmineManager redmineManager, NameValueCollection parameters, string projectId) { Task <List <WikiPage> > task = delegate { var uri = UrlHelper.GetWikisUrl(redmineManager, projectId); using (var wc = redmineManager.CreateWebClient(parameters)) { var response = wc.DownloadString(uri); return(RedmineSerializer.Deserialize <List <WikiPage> >(response, redmineManager.MimeFormat)); } }; return(task); }
public static Task <WikiPage> GetWikiPageAsync(this RedmineManager redmineManager, string projectId, NameValueCollection parameters, string pageName, uint version = 0) { Task <WikiPage> task = delegate { var uri = UrlHelper.GetWikiPageUrl(redmineManager, projectId, parameters, pageName, version); using (var wc = redmineManager.CreateWebClient(parameters)) { var response = wc.DownloadString(uri); return(RedmineSerializer.Deserialize <WikiPage>(response, redmineManager.MimeFormat)); } }; return(task); }
public static Task <PaginatedObjects <WikiPage> > GetAllWikiPagesAsync(this RedmineManager redmineManager, NameValueCollection parameters, string projectId) { var task = Task.Factory.StartNew(() => { var uri = UrlHelper.GetWikisUrl(redmineManager, projectId); using (var wc = redmineManager.CreateWebClient(parameters)) { var response = wc.DownloadString(uri); return(RedmineSerializer.DeserializeList <WikiPage>(response, redmineManager.MimeFormat)); } }, TaskCreationOptions.LongRunning); return(task); }
public static Task <PaginatedObjects <T> > GetPaginatedObjectsAsync <T>(this RedmineManager redmineManager, NameValueCollection parameters) where T : class, new() { Task <PaginatedObjects <T> > task = delegate { var url = UrlHelper.GetListUrl <T>(redmineManager, parameters); using (var wc = redmineManager.CreateWebClient(parameters)) { var response = wc.DownloadString(url); return(RedmineSerializer.Deserialize <PaginatedObjects <T> >(response, redmineManager.MimeFormat)); } }; return(task); }
public async Task <T> Post <T>(Uri uri, T data, MimeType mimeType) where T : class, new() { SetupCredentials(); httpClient.AddImpersonationHeaderIfSet(ImpersonateUser); var content = new StringContent(RedmineSerializer.Serialize(data, mimeType), Encoding.UTF8, $"{APPLICATION}/{UrlBuilder.mimeTypes[mimeType]}"); using (var responseMessage = await httpClient.PostAsync(uri.ToString(), content).ConfigureAwait(false)) { var tc = await responseMessage.CreateTaskCompletionSource <T>(mimeType).ConfigureAwait(false); return(await tc.Task); } }
public static Task <T> CreateObjectAsync <T>(this RedmineManager redmineManager, T obj, string ownerId) where T : class, new() { var task = Task.Factory.StartNew(() => { var url = UrlHelper.GetCreateUrl <T>(redmineManager, ownerId); var data = RedmineSerializer.Serialize(obj, redmineManager.MimeFormat); using (var wc = redmineManager.CreateWebClient(null)) { var response = wc.UploadString(url, RedmineManager.POST, data); return(RedmineSerializer.Deserialize <T>(response, redmineManager.MimeFormat)); } }, TaskCreationOptions.LongRunning); return(task); }
public static Task <Upload> UploadFileAsync(this RedmineManager redmineManager, byte[] data) { var task = Task.Factory.StartNew(() => { var uri = UrlHelper.GetUploadFileUrl(redmineManager); using (var wc = redmineManager.CreateWebClient(null, true)) { var response = wc.UploadData(uri, RedmineManager.POST, data); var responseString = Encoding.ASCII.GetString(response); return(RedmineSerializer.Deserialize <Upload>(responseString, redmineManager.MimeFormat)); } }, TaskCreationOptions.LongRunning); return(task); }
public static Task <WikiPage> CreateOrUpdateWikiPageAsync(this RedmineManager redmineManager, string projectId, string pageName, WikiPage wikiPage) { var task = Task.Factory.StartNew(() => { var uri = UrlHelper.GetWikiCreateOrUpdaterUrl(redmineManager, projectId, pageName); var data = RedmineSerializer.Serialize(wikiPage, redmineManager.MimeFormat); using (var wc = redmineManager.CreateWebClient(null)) { var response = wc.UploadString(uri, RedmineManager.PUT, data); return(RedmineSerializer.Deserialize <WikiPage>(response, redmineManager.MimeFormat)); } }, TaskCreationOptions.LongRunning); return(task); }
private PaginatedObjects <T> ExecuteDownloadList <T>(string address, string methodName, NameValueCollection parameters = null) where T : class, new() { using (var wc = CreateWebClient(parameters)) { try { var response = wc.DownloadString(address); return(RedmineSerializer.DeserializeList <T>(response, MimeFormat)); } catch (WebException webException) { webException.HandleWebException(methodName, MimeFormat); } return(null); } }
public static Task <T> CreateObjectAsync <T>(this RedmineManager redmineManager, T obj, string ownerId) where T : class, new() { Task <T> task = delegate { var url = UrlHelper.GetCreateUrl <T>(redmineManager, ownerId); var data = RedmineSerializer.Serialize(obj, redmineManager.MimeFormat); using (var wc = redmineManager.CreateWebClient(null)) { var response = wc.UploadString(url, RedmineManager.POST, data); return(RedmineSerializer.Deserialize <T>(response, redmineManager.MimeFormat)); } }; return(task); }
public static Task <Upload> UploadFileAsync(this RedmineManager redmineManager, byte[] data) { Task <Upload> task = delegate { var uri = UrlHelper.GetUploadFileUrl(redmineManager); using (var wc = redmineManager.CreateWebClient(null)) { var response = wc.UploadData(uri, RedmineManager.POST, data); var responseString = Encoding.ASCII.GetString(response); return(RedmineSerializer.Deserialize <Upload>(responseString, redmineManager.MimeFormat)); } }; return(task); }
public static Task <WikiPage> CreateOrUpdateWikiPageAsync(this RedmineManager redmineManager, string projectId, string pageName, WikiPage wikiPage) { Task <WikiPage> task = delegate { var uri = UrlHelper.GetWikiCreateOrUpdaterUrl(redmineManager, projectId, pageName); var data = RedmineSerializer.Serialize(wikiPage, redmineManager.MimeFormat); using (var wc = redmineManager.CreateWebClient(null)) { var response = wc.UploadString(uri, RedmineManager.PUT, data); return(RedmineSerializer.Deserialize <WikiPage>(response, redmineManager.MimeFormat)); } }; return(task); }
internal static async Task <TaskCompletionSource <T> > CreateTaskCompletionSource <T>(this HttpResponseMessage responseMessage, Func <string, T> func, MimeType mimeType) where T : class, new() { var tc = new TaskCompletionSource <T>(); if (responseMessage.IsSuccessStatusCode) { var content = await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false); tc.SetResult(func != null ? func.Invoke(content) : RedmineSerializer.Deserialize <T>(content, mimeType)); } else { tc.SetException(await CreateExceptionAsync(responseMessage, mimeType).ConfigureAwait(false)); } return(tc); }