/// <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);
}
}
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));
}
}
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 <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 <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()
{
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);
}
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 async Task <PaginatedObjects <T> > GetPaginatedObjectsAsync <T>(this RedmineManager redmineManager, NameValueCollection parameters) where T : class, new()
{
var url = UrlHelper.GetListUrl <T>(redmineManager, parameters);
using (var wc = redmineManager.CreateWebClient(parameters))
{
try
{
var response = await wc.DownloadStringTaskAsync(url).ConfigureAwait(false);
return(RedmineSerializer.DeserializeList <T>(response, redmineManager.MimeFormat));
}
catch (WebException wex)
{
wex.HandleWebException("GetPaginatedObjectsAsync", redmineManager.MimeFormat);
}
return(null);
}
}
/// <summary>
///
/// </summary>
/// <param name="redmineManager"></param>
/// <param name="parameters"></param>
/// <param name="projectId"></param>
/// <returns></returns>
public static async Task <List <WikiPage> > GetAllWikiPagesAsync(this RedmineManager redmineManager, NameValueCollection parameters, string projectId)
{
var uri = UrlHelper.GetWikisUrl(redmineManager, projectId);
using (var wc = redmineManager.CreateWebClient(parameters))
{
try
{
var response = await wc.DownloadStringTaskAsync(uri).ConfigureAwait(false);
var result = RedmineSerializer.DeserializeList <WikiPage>(response, redmineManager.MimeFormat);
return(result.Objects);
}
catch (WebException wex)
{
wex.HandleWebException("GetAllWikiPagesAsync", redmineManager.MimeFormat);
}
return(null);
}
}
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 (responseFromServer.Trim().Length > 0)
{
var errors = RedmineSerializer.DeserializeList <Error>(responseFromServer, mimeFormat);
return(errors.Objects);
}
}
return(null);
}
}
