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 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); var response = await WebApiAsyncHelper.ExecuteUpload(redmineManager, uri, HttpVerbs.PUT, data, "CreateOrUpdateWikiPageAsync").ConfigureAwait(false); return(RedmineSerializer.Deserialize <WikiPage>(response, redmineManager.MimeFormat)); }
/// <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); var response = await WebApiAsyncHelper.ExecuteUpload(redmineManager, uri, HttpVerbs.POST, data, "CreateObjectAsync").ConfigureAwait(false); return(RedmineSerializer.Deserialize <T>(response, redmineManager.MimeFormat)); }
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 <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 <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 <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 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 <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); }
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 <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); }
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 <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) { 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); }
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); }
/// <summary> /// Gets a Redmine object. This method does not block the calling thread. /// </summary> /// <typeparam name="T">The type of objects to retrieve.</typeparam> /// <param name="id">The id of the object.</param> /// <param name="parameters">Optional filters and/or optional fetched data.</param> /// <param name="redmineManager"></param> /// <returns></returns> public static async Task <T> GetObjectAsync <T>(this RedmineManager redmineManager, string id, NameValueCollection parameters) where T : class, new() { var url = UrlHelper.GetGetUrl <T>(redmineManager, id); using (var wc = redmineManager.CreateWebClient(parameters)) { string response = null; try { response = await wc.DownloadStringTaskAsync(url).ConfigureAwait(false); } catch (WebException wex) { wex.HandleWebException("GetobjectAsync", redmineManager.MimeFormat); } return(RedmineSerializer.Deserialize <T>(response, redmineManager.MimeFormat)); } }
/// <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"></param> /// <param name="obj">The object to create.</param> /// <param name="ownerId"></param> /// <returns></returns> public static async Task <T> CreateObjectAsync <T>(this RedmineManager redmineManager, T obj, string ownerId) where T : class, new() { var url = UrlHelper.GetCreateUrl <T>(redmineManager, ownerId); var data = RedmineSerializer.Serialize(obj, redmineManager.MimeFormat); using (var wc = redmineManager.CreateWebClient(null)) { string response = null; try { response = await wc.UploadStringTaskAsync(url, RedmineManager.POST, data).ConfigureAwait(false); } catch (WebException wex) { wex.HandleWebException("CreateObjectAsync", redmineManager.MimeFormat); } return(RedmineSerializer.Deserialize <T>(response, redmineManager.MimeFormat)); } }
/// <summary> /// /// </summary> /// <param name="redmineManager"></param> /// <param name="projectId"></param> /// <param name="parameters"></param> /// <param name="pageName"></param> /// <param name="version"></param> /// <returns></returns> public static async Task <WikiPage> GetWikiPageAsync(this RedmineManager redmineManager, string projectId, NameValueCollection parameters, string pageName, uint version = 0) { var uri = UrlHelper.GetWikiPageUrl(redmineManager, projectId, parameters, pageName, version); using (var wc = redmineManager.CreateWebClient(parameters)) { try { var response = await wc.DownloadStringTaskAsync(uri).ConfigureAwait(false); return(RedmineSerializer.Deserialize <WikiPage>(response, redmineManager.MimeFormat)); } catch (WebException wex) { wex.HandleWebException("GetWikiPageAsync", redmineManager.MimeFormat); } return(null); } }
/// <summary> /// /// </summary> /// <param name="redmineManager"></param> /// <param name="parameters"></param> /// <returns></returns> public static async Task <User> GetCurrentUserAsync(this RedmineManager redmineManager, NameValueCollection parameters = null) { var uri = string.Format(RedmineManager.REQUEST_FORMAT, redmineManager.Host, RedmineManager.Sufixes[typeof(User)], RedmineManager.CURRENT_USER_URI, redmineManager.MimeFormat); using (var wc = redmineManager.CreateWebClient(null)) { try { var result = await wc.DownloadStringTaskAsync(uri).ConfigureAwait(false); return(RedmineSerializer.Deserialize <User>(result, redmineManager.MimeFormat)); } catch (WebException wex) { wex.HandleWebException("GetCurrentUserAsync", redmineManager.MimeFormat); } return(null); } }
private T ExecuteDownload <T>(string address, string methodName, NameValueCollection parameters = null) where T : class, new() { using (var wc = CreateWebClient(parameters)) { try { var response = wc.DownloadString(address); if (!string.IsNullOrEmpty(response)) { return(RedmineSerializer.Deserialize <T>(response, MimeFormat)); } } catch (WebException webException) { webException.HandleWebException(methodName, MimeFormat); } return(default(T)); } }
/// <summary> /// Support for adding attachments through the REST API is added in Redmine 1.4.0. /// Upload a file to server. /// </summary> /// <param name="data">The content of the file that will be uploaded on server.</param> /// <returns>Returns the token for uploaded file.</returns> public Upload UploadFile(byte[] data) { using (var wc = CreateWebClient(null, true)) { try { var url = UrlHelper.GetUploadFileUrl(this); var response = wc.UploadData(url, data); var responseString = Encoding.ASCII.GetString(response); return(RedmineSerializer.Deserialize <Upload>(responseString, MimeFormat)); } catch (WebException webException) { webException.HandleWebException("UploadFile", MimeFormat); } } return(null); }
/// <summary> /// Support for adding attachments through the REST API is added in Redmine 1.4.0. /// Upload a file to server. This method does not block the calling thread. /// </summary> /// <param name="redmineManager"></param> /// <param name="data">The content of the file that will be uploaded on server.</param> /// <returns>.</returns> public static async Task <Upload> UploadFileAsync(this RedmineManager redmineManager, byte[] data) { var uri = UrlHelper.GetUploadFileUrl(redmineManager); using (var wc = redmineManager.CreateWebClient(null, true)) { try { var response = await wc.UploadDataTaskAsync(uri, RedmineManager.POST, data).ConfigureAwait(false); var responseString = Encoding.ASCII.GetString(response); return(RedmineSerializer.Deserialize <Upload>(responseString, redmineManager.MimeFormat)); } catch (WebException wex) { wex.HandleWebException("UploadFileAsync", redmineManager.MimeFormat); } return(null); } }
private T ExecuteUpload <T>(string address, string actionType, string data, string methodName) where T : class, new() { using (var wc = CreateWebClient(null)) { try { if (actionType == POST || actionType == DELETE || actionType == PUT) { var response = wc.UploadString(address, actionType, data); return(RedmineSerializer.Deserialize <T>(response, MimeFormat)); } } catch (WebException webException) { webException.HandleWebException(methodName, MimeFormat); } return(default(T)); } }
/// <summary> /// /// </summary> /// <param name="redmineManager"></param> /// <param name="projectId"></param> /// <param name="pageName"></param> /// <param name="wikiPage"></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); using (var wc = redmineManager.CreateWebClient(null)) { try { var response = await wc.UploadStringTaskAsync(uri, RedmineManager.PUT, data).ConfigureAwait(false); return(RedmineSerializer.Deserialize <WikiPage>(response, redmineManager.MimeFormat)); } catch (WebException wex) { wex.HandleWebException("CreateOrUpdateWikiPageAsync", redmineManager.MimeFormat); } return(null); } }
public void ShouldDeserializeFileXml() { const string response = @" <file> <id>12</id> <filename>foo-1.0-setup.exe</filename> <filesize>74753799</filesize> <content_type>application/octet-stream</content_type> <description>Foo App for Windows</description> <content_url>http://localhost:3000/attachments/download/12/foo-1.0-setup.exe</content_url> <author id=""1"" name=""Redmine Admin""/> <created_on>2017-01-04T09:12:32Z</created_on> <version id=""2"" name=""1.0""/> <digest>1276481102f218c981e0324180bafd9f</digest> <downloads>12</downloads> </file>"; var expected = new File() { Id = 12, Filesize = 74753799, ContentType = "application/octet-stream", ContentUrl = "http://localhost:3000/attachments/download/12/foo-1.0-setup.exe", Author = new IdentifiableName { Id = 1, Name = "Redmine Admin" }, CreatedOn = new DateTime(2017, 01, 04, 11, 12, 32, DateTimeKind.Utc), Digest = "1276481102f218c981e0324180bafd9f", Downloads = 12, Version = new IdentifiableName { Id = 2, Name = "1.0" }, Filename = "foo-1.0-setup.exe", Description = "Foo App for Windows" }; var actual = RedmineSerializer.Deserialize <File>(response, Net.Api.MimeType.Xml); Assert.True(actual.GetHashCode() == expected.GetHashCode(), "File deserialize error."); }
public static Task <WikiPage> GetWikiPageAsync(this RedmineManager redmineManager, string projectId, NameValueCollection parameters, string pageName, uint version = 0) { var task = Task.Factory.StartNew(() => { var uri = UrlHelper.GetWikiPageUrl(redmineManager, projectId, parameters, pageName, version); using (var wc = redmineManager.CreateWebClient(parameters)) { try { var response = wc.DownloadString(uri); return(RedmineSerializer.Deserialize <WikiPage>(response, redmineManager.MimeFormat)); } catch (WebException wex) { wex.HandleWebException("GetWikiPageAsync", redmineManager.MimeFormat); } return(null); } }, TaskCreationOptions.LongRunning); return(task); }
public static Task <T> GetObjectAsync <T>(this RedmineManager redmineManager, string id, NameValueCollection parameters) where T : class, new() { var task = Task.Factory.StartNew(() => { var url = UrlHelper.GetGetUrl <T>(redmineManager, id); using (var wc = redmineManager.CreateWebClient(parameters)) { try { var response = wc.DownloadString(url); return(RedmineSerializer.Deserialize <T>(response, redmineManager.MimeFormat)); } catch (WebException wex) { wex.HandleWebException("GetObject", redmineManager.MimeFormat); } return(null); } }, TaskCreationOptions.LongRunning); return(task); }
public void ShouldDeserializePartialFileXml() { const string response = @" <file> <token>21.01a1d7b1c2ffcbbc9ecf14debeec27d8</token> <version_id>2</version_id> <filename>foo-1.0-src.tar.tgz</filename> <description>Foo App source code</description> </file>"; var expected = new File { Token = "21.01a1d7b1c2ffcbbc9ecf14debeec27d8", Version = new IdentifiableName { Id = 2 }, Filename = "foo-1.0-src.tar.tgz", Description = "Foo App source code" }; var actual = RedmineSerializer.Deserialize <File>(response, Net.Api.MimeType.Xml); Assert.True(actual.Equals(expected), "File deserialize error."); }