/// <summary> /// Adds a new entry to the timeline. /// </summary> /// <param name="createMessage">The entry to add.</param> /// <returns></returns> public async Task Post(CreateTimelineEntry createMessage) { UserInfo userEntity = await GetUserInfoAsync(); HttpStatusCode result = await TimelineOperations.AddTimelineEntryAsync(createMessage, DbContext, userEntity); result.ThrowHttpResponseExceptionIfNotSuccessful(); }
/// <param name='operations'> /// Reference to the Rg.ClientApp.ITimeline. /// </param> /// <param name='createMessage'> /// Required. /// </param> public static object PostByCreatemessage(this ITimeline operations, CreateTimelineEntry createMessage) { return(Task.Factory.StartNew((object s) => { return ((ITimeline)s).PostByCreatemessageAsync(createMessage); } , operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
/// <param name='createMessage'> /// Required. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> public async Task <HttpOperationResponse <object> > PostByCreatemessageWithOperationResponseAsync(CreateTimelineEntry createMessage, CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { // Validate if (createMessage == null) { throw new ArgumentNullException("createMessage"); } // Tracing bool shouldTrace = ServiceClientTracing.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = ServiceClientTracing.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("createMessage", createMessage); ServiceClientTracing.Enter(invocationId, this, "PostByCreatemessageAsync", tracingParameters); } // Construct URL string url = ""; url = url + "/api/Timeline"; 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 = createMessage.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); }
/// <param name='operations'> /// Reference to the Rg.ClientApp.ITimeline. /// </param> /// <param name='createMessage'> /// Required. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> public static async Task <object> PostByCreatemessageAsync(this ITimeline operations, CreateTimelineEntry createMessage, CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { Microsoft.Rest.HttpOperationResponse <object> result = await operations.PostByCreatemessageWithOperationResponseAsync(createMessage, cancellationToken).ConfigureAwait(false); return(result.Body); }
public static async Task <HttpStatusCode> AddTimelineEntryAsync( CreateTimelineEntry createMessage, ApplicationDbContext dbContext, UserInfo userEntity) { if (string.IsNullOrWhiteSpace(createMessage?.Message)) { return(HttpStatusCode.BadRequest); } var text = await TextOperations.CreateTextAsync(dbContext, createMessage.Message); var timelineEntity = new TimelineEntry { UserId = userEntity.UserInfoId, Message = text }; if (createMessage.MediaIds != null && createMessage.MediaIds.Count > 0) { MediaAlbum timelineAlbum = await EnsureTimelinePhotoAlbumExistsAsync(dbContext, userEntity); timelineEntity.Media = new List <TimelineEntryMedia>(); int sequence = 0; var includedMedia = new List <UserMedia>(); foreach (int id in createMessage.MediaIds) { UserMedia mediaEntity = await dbContext.UserMedias .SingleAsync(um => um.UserMediaId == id); if (mediaEntity.UserId != userEntity.UserInfoId) { // Only allowed to post your own images here return(HttpStatusCode.BadRequest); } includedMedia.Add(mediaEntity); mediaEntity.MediaAlbum = timelineAlbum; var mediaEntry = new TimelineEntryMedia { Media = mediaEntity, Sequence = sequence++, TimelineEntry = timelineEntity }; dbContext.TimelineEntryMedia.Add(mediaEntry); timelineEntity.Media.Add(mediaEntry); } foreach (UserMedia media in includedMedia) { if (media.State == UserMediaState.UploadedButUnused) { media.State = UserMediaState.InUse; } } } dbContext.UserTexts.Add(text); dbContext.TimelineEntries.Add(timelineEntity); await dbContext.SaveChangesAsync(); await UserOperations.NotifyMentionsAsync( dbContext, "Timeline Entry", userEntity.UserInfoId, text); await SearchOperations.IndexTimelineMessageAsync(timelineEntity); return(HttpStatusCode.OK); }