public static async Task AddMediaToAlbumAsync(
ApplicationDbContext dbContext,
MediaAlbum albumEntity,
UserMedia mediaEntity,
AddImageToAlbum createRequest)
{
albumEntity.UserMedias.Add(mediaEntity);
mediaEntity.MediaAlbum = albumEntity;
if (mediaEntity.State == UserMediaState.UploadedButUnused)
{
mediaEntity.State = UserMediaState.InUse;
}
mediaEntity.Title = createRequest.Title;
if (!string.IsNullOrWhiteSpace(createRequest.Description))
{
mediaEntity.Description = await TextOperations.CreateTextAsync(
dbContext, createRequest.Description);
}
await dbContext.SaveChangesAsync();
await SearchOperations.IndexMediaAsync(new[] { mediaEntity });
if (mediaEntity.Description != null)
{
await UserOperations.NotifyMentionsAsync(
dbContext, "Album Entry", mediaEntity.UserId, mediaEntity.Description);
}
}
public async Task PostImage(int albumId, AddImageToAlbum createRequest)
{
MediaAlbum albumEntity = await DbContext.MediaAlbums
.SingleOrDefaultAsync(a => a.MediaAlbumId == albumId);
if (albumEntity == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
if (albumEntity.UserId != UserId)
{
throw new HttpResponseException(HttpStatusCode.Forbidden);
}
UserMedia mediaEntity = await DbContext.UserMedias
.SingleOrDefaultAsync(um => um.UserMediaId == createRequest.MediaId);
if (mediaEntity == null)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
if (mediaEntity.UserId != UserId)
{
throw new HttpResponseException(HttpStatusCode.Forbidden);
}
await AlbumOperations.AddMediaToAlbumAsync(DbContext, albumEntity, mediaEntity, createRequest);
}
/// <param name='operations'>
/// Reference to the Rg.ClientApp.IAlbums.
/// </param>
/// <param name='albumId'>
/// Required.
/// </param>
/// <param name='createRequest'>
/// Required.
/// </param>
public static object PostImageByAlbumidAndCreaterequest(this IAlbums operations, int albumId, AddImageToAlbum createRequest)
{
return(Task.Factory.StartNew((object s) =>
{
return ((IAlbums)s).PostImageByAlbumidAndCreaterequestAsync(albumId, createRequest);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
/// <param name='operations'>
/// Reference to the Rg.ClientApp.IAlbums.
/// </param>
/// <param name='albumId'>
/// Required.
/// </param>
/// <param name='createRequest'>
/// Required.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
public static async Task <object> PostImageByAlbumidAndCreaterequestAsync(this IAlbums operations, int albumId, AddImageToAlbum createRequest, CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
Microsoft.Rest.HttpOperationResponse <object> result = await operations.PostImageByAlbumidAndCreaterequestWithOperationResponseAsync(albumId, createRequest, cancellationToken).ConfigureAwait(false);
return(result.Body);
}
/// <param name='albumId'>
/// Required.
/// </param>
/// <param name='createRequest'>
/// Required.
/// </param>
/// <param name='cancellationToken'>
/// Cancellation token.
/// </param>
public async Task <HttpOperationResponse <object> > PostImageByAlbumidAndCreaterequestWithOperationResponseAsync(int albumId, AddImageToAlbum createRequest, CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
// Validate
if (createRequest == null)
{
throw new ArgumentNullException("createRequest");
}
// Tracing
bool shouldTrace = ServiceClientTracing.IsEnabled;
string invocationId = null;
if (shouldTrace)
{
invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("albumId", albumId);
tracingParameters.Add("createRequest", createRequest);
ServiceClientTracing.Enter(invocationId, this, "PostImageByAlbumidAndCreaterequestAsync", tracingParameters);
}
// Construct URL
string url = "";
url = url + "/api/Albums/";
url = url + Uri.EscapeDataString(albumId.ToString());
url = url + "/AddImage";
string baseUrl = this.Client.BaseUri.AbsoluteUri;
// Trim '/' character from the end of baseUrl and beginning of url.
if (baseUrl[baseUrl.Length - 1] == '/')
{
baseUrl = baseUrl.Substring(0, baseUrl.Length - 1);
}
if (url[0] == '/')
{
url = url.Substring(1);
}
url = baseUrl + "/" + url;
url = url.Replace(" ", "%20");
// Create HTTP transport objects
HttpRequestMessage httpRequest = new HttpRequestMessage();
httpRequest.Method = HttpMethod.Post;
httpRequest.RequestUri = new Uri(url);
// Set Headers
// Set Credentials
if (this.Client.Credentials != null)
{
cancellationToken.ThrowIfCancellationRequested();
await this.Client.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false);
}
// Serialize Request
string requestContent = null;
JToken requestDoc = createRequest.SerializeJson(null);
requestContent = requestDoc.ToString(Newtonsoft.Json.Formatting.Indented);
httpRequest.Content = new StringContent(requestContent, Encoding.UTF8);
httpRequest.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
// Send Request
if (shouldTrace)
{
ServiceClientTracing.SendRequest(invocationId, httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
HttpResponseMessage httpResponse = await this.Client.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false);
if (shouldTrace)
{
ServiceClientTracing.ReceiveResponse(invocationId, httpResponse);
}
HttpStatusCode statusCode = httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
if (statusCode != HttpStatusCode.NoContent)
{
HttpOperationException <object> ex = new HttpOperationException <object>();
ex.Request = httpRequest;
ex.Response = httpResponse;
ex.Body = null;
if (shouldTrace)
{
ServiceClientTracing.Error(invocationId, ex);
}
throw ex;
}
// Create Result
HttpOperationResponse <object> result = new HttpOperationResponse <object>();
result.Request = httpRequest;
result.Response = httpResponse;
// Deserialize Response
object resultModel = default(object);
result.Body = resultModel;
if (shouldTrace)
{
ServiceClientTracing.Exit(invocationId, result);
}
return(result);
}
