/// <summary>
/// Attach content to the specified issue
/// See: https://docs.atlassian.com/jira/REST/latest/#d2e3035
/// </summary>
/// <param name="jiraClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="issueKey">the key of the issue to attach to</param>
/// <param name="content">the content can be anything what Dapplo.HttpExtensions supports</param>
/// <param name="filename">Filename for the attachment</param>
/// <param name="contentType">content-type for the attachment</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Attachment</returns>
public static async Task <Attachment> AttachAsync <TContent>(this IAttachmentDomain jiraClient, string issueKey, TContent content, string filename,
string contentType = null,
CancellationToken cancellationToken = default(CancellationToken))
where TContent : class
{
if (issueKey == null)
{
throw new ArgumentNullException(nameof(issueKey));
}
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
Log.Debug().WriteLine("Attaching to issue {0}", issueKey);
var attachment = new AttachmentContainer <TContent>
{
Content = content,
ContentType = contentType,
FileName = filename
};
jiraClient.Behaviour.MakeCurrent();
var attachUri = jiraClient.JiraRestUri.AppendSegments("issue", issueKey, "attachments");
var response = await attachUri.PostAsync <HttpResponse <IList <Attachment>, Error> >(attachment, cancellationToken).ConfigureAwait(false);
// Return the attachment, should be only one!
return(response.HandleErrors()[0]);
}
/// <summary>
/// Delete the specified attachment
/// </summary>
/// <param name="jiraClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="attachmentId">Id from the attachment</param>
/// <param name="cancellationToken">CancellationToken</param>
public static async Task DeleteAsync(this IAttachmentDomain jiraClient, long attachmentId, CancellationToken cancellationToken = default(CancellationToken))
{
Log.Debug().WriteLine("Deleting attachment {0}", attachmentId);
jiraClient.Behaviour.MakeCurrent();
var deleteAttachmentUri = jiraClient.JiraRestUri.AppendSegments("attachment", attachmentId);
await deleteAttachmentUri.DeleteAsync(cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Delete the specified attachment
/// </summary>
/// <param name="jiraClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="attachment">The Attachment to delete</param>
/// <param name="cancellationToken">CancellationToken</param>
public static Task DeleteAsync(this IAttachmentDomain jiraClient, Attachment attachment, CancellationToken cancellationToken = default(CancellationToken))
{
if (attachment == null)
{
throw new ArgumentNullException(nameof(attachment));
}
return(jiraClient.DeleteAsync(attachment.Id, cancellationToken));
}
/// <summary>
/// Delete the specified attachment
/// </summary>
/// <param name="jiraClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="attachmentId">Id from the attachment</param>
/// <param name="cancellationToken">CancellationToken</param>
public static async Task DeleteAsync(this IAttachmentDomain jiraClient, long attachmentId, CancellationToken cancellationToken = default)
{
Log.Debug().WriteLine("Deleting attachment {0}", attachmentId);
jiraClient.Behaviour.MakeCurrent();
var deleteAttachmentUri = jiraClient.JiraRestUri.AppendSegments("attachment", attachmentId);
var response = await deleteAttachmentUri.DeleteAsync <HttpResponse>(cancellationToken).ConfigureAwait(false);
response.HandleStatusCode(HttpStatusCode.NoContent);
}
/// <summary>
/// Get the content for the specified attachment
/// </summary>
/// <typeparam name="TResponse">
/// the type which is returned, can be decided by the client and should be supported by
/// Dapplo.HttpExtensions or your own IHttpContentConverter
/// </typeparam>
/// <param name="jiraClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="attachment">the attachment</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>TResponse</returns>
public static async Task <TResponse> GetContentAsAsync <TResponse>(this IAttachmentDomain jiraClient, Attachment attachment,
CancellationToken cancellationToken = default(CancellationToken))
where TResponse : class
{
if (attachment == null)
{
throw new ArgumentNullException(nameof(attachment));
}
Log.Debug().WriteLine("Getting attachment content for {0}", attachment.Id);
return(await jiraClient.Server.GetUriContentAsync <TResponse>(attachment.ContentUri, cancellationToken).ConfigureAwait(false));
}
/// <summary>
/// Delete content (attachments are also content)
/// </summary>
/// <param name="confluenceClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="attachtmentId">ID for the content which needs to be deleted</param>
/// <param name="isTrashed">If the content is trashable, you will need to call DeleteAsyc twice, second time with isTrashed = true</param>
/// <param name="cancellationToken">CancellationToken</param>
public static async Task DeleteAsync(this IAttachmentDomain confluenceClient, long attachtmentId, bool isTrashed = false, CancellationToken cancellationToken = default)
{
var contentUri = confluenceClient.ConfluenceApiUri.AppendSegments("content", $"att{attachtmentId}");
if (isTrashed)
{
contentUri = contentUri.ExtendQuery("status", "trashed");
}
confluenceClient.Behaviour.MakeCurrent();
var response = await contentUri.DeleteAsync <HttpResponse>(cancellationToken).ConfigureAwait(false);
response.HandleStatusCode(isTrashed ? HttpStatusCode.OK : HttpStatusCode.NoContent);
}
/// <summary>
/// Retrieve the attachment for the supplied Attachment entity
/// </summary>
/// <typeparam name="TResponse">the type to return the result into. e.g. Bitmap,BitmapSource or MemoryStream</typeparam>
/// <param name="confluenceClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="attachment">Attachment</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Bitmap,BitmapSource or MemoryStream (etc) depending on TResponse</returns>
public static async Task <TResponse> GetContentAsync <TResponse>(this IAttachmentDomain confluenceClient, Content attachment,
CancellationToken cancellationToken = default)
where TResponse : class
{
if (attachment.Type != ContentTypes.Attachment)
{
throw new ArgumentException("Not an attachment", nameof(attachment));
}
confluenceClient.Behaviour.MakeCurrent();
var attachmentUri = confluenceClient.CreateDownloadUri(attachment.Links);
var response = await attachmentUri.GetAsAsync <HttpResponse <TResponse, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Update the attachment information
/// </summary>
/// <param name="confluenceClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="attachment">Attachment</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Attachment</returns>
public static async Task <Content> UpdateAsync(this IAttachmentDomain confluenceClient, Content attachment, CancellationToken cancellationToken = default(CancellationToken))
{
confluenceClient.Behaviour.MakeCurrent();
var attachmentsUri = confluenceClient.ConfluenceApiUri.AppendSegments("content", attachment.Container.Id, "child", "attachment", attachment.Id);
if (ConfluenceClientConfig.ExpandGetAttachments != null && ConfluenceClientConfig.ExpandGetAttachments.Length != 0)
{
attachmentsUri = attachmentsUri.ExtendQuery("expand", string.Join(",", ConfluenceClientConfig.ExpandGetAttachments));
}
var response = await attachmentsUri.GetAsAsync <HttpResponse <Content, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Delete attachment
/// Can't work yet, see <a href="https://jira.atlassian.com/browse/CONF-36015">CONF-36015</a>
/// </summary>
/// <param name="confluenceClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="attachment">Attachment which needs to be deleted</param>
/// <param name="cancellationToken">cancellationToken</param>
public static async Task DeleteAsync(this IAttachmentDomain confluenceClient, Content attachment,
CancellationToken cancellationToken = default)
{
if (attachment.Type != ContentTypes.Attachment)
{
throw new ArgumentException("Not an attachment", nameof(attachment));
}
confluenceClient.Behaviour.MakeCurrent();
var contentUri = confluenceClient.ConfluenceUri
.AppendSegments("json", "removeattachmentversion.action")
.ExtendQuery("pageId", attachment.Container.Id)
.ExtendQuery("fileName", attachment.Title);
await contentUri.GetAsAsync <string>(cancellationToken).ConfigureAwait(false);
}
/// <summary>
/// Update the attachment information
/// </summary>
/// <param name="confluenceClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="attachment">Attachment</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Attachment</returns>
public static async Task <Content> UpdateAsync(this IAttachmentDomain confluenceClient, Content attachment, CancellationToken cancellationToken = default)
{
confluenceClient.Behaviour.MakeCurrent();
var attachmentsUri = confluenceClient.ConfluenceApiUri.AppendSegments("content", attachment.Container.Id, "child", "attachment", attachment.Id);
var expand = string.Join(",", ConfluenceClientConfig.ExpandGetAttachments ?? Enumerable.Empty <string>());
if (!string.IsNullOrEmpty(expand))
{
attachmentsUri = attachmentsUri.ExtendQuery("expand", expand);
}
var response = await attachmentsUri.GetAsAsync <HttpResponse <Content, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Add an attachment to the specified content
/// </summary>
/// <typeparam name="TContent">The content to upload</typeparam>
/// <param name="confluenceClient">IAttachmentDomain to bind the extension method to</param>
/// <param name="contentId">content to add the attachment to</param>
/// <param name="content">content of type TContent for the attachment</param>
/// <param name="filename">Filename of the attachment</param>
/// <param name="comment">Comment in the attachments information</param>
/// <param name="contentType">Content-Type for the content, or null</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Result with Attachment</returns>
public static async Task <Result <Content> > AttachAsync <TContent>(this IAttachmentDomain confluenceClient, long contentId, TContent content, string filename, string comment = null, string contentType = null, CancellationToken cancellationToken = default)
where TContent : class
{
var attachment = new AttachmentContainer <TContent>
{
Comment = comment,
FileName = filename,
Content = content,
ContentType = contentType
};
confluenceClient.Behaviour.MakeCurrent();
var postAttachmentUri = confluenceClient.ConfluenceApiUri.AppendSegments("content", contentId, "child", "attachment");
var response = await postAttachmentUri.PostAsync <HttpResponse <Result <Content>, Error> >(attachment, cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
public static Task <Result <Content> > AttachAsync <TContent>(this IAttachmentDomain confluenceClient, string contentId, TContent content, string filename,
string comment = null, string contentType = null, CancellationToken cancellationToken = default)
where TContent : class
{
return(confluenceClient.AttachAsync(long.Parse(contentId), content, filename, comment, contentType, cancellationToken));
}
public static Task <Result <Content> > GetAttachmentsAsync(this IAttachmentDomain confluenceClient, string contentId, CancellationToken cancellationToken = default)
{
return(confluenceClient.GetAttachmentsAsync(long.Parse(contentId), cancellationToken));
}
public OrderController()
{
_orderDomain = Bootstraper.Init().Resolve <OrderDomain>();
_attachmentDomain = Bootstraper.Init().Resolve <AttachmentDomain>();
}
public AttachmentController()
{
_attachmentDomain = Bootstraper.Init().Resolve <AttachmentDomain>();
}
