/// <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);
}
