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.");
}
