public async Task <IActionResult> AddAsync([FromBody] PostCreateRequest postCreateRequest)
{
var newUser = _mapper.Map <Post>(postCreateRequest);
await _postService.AddAsync(newUser);
return(CreatedAtAction(nameof(GetByIdAsync), new { id = newUser.Id }, newUser));
}
public async Task <ApiResult <bool> > Create(PostCreateRequest request)
{
var post = new Post()
{
Title = request.Title,
Summary = request.Summary,
SeoTitle = request.SeoTitle,
ViewCount = 0,
DateCreated = DateTime.Now,
DateModified = DateTime.Now,
UserId = request.UserId
};
if (request.ThumbnailImage != null)
{
post.PostImages = new List <PostImage>()
{
new PostImage()
{
Caption = "Thumbnail Image",
DateCreated = DateTime.Now,
FileSize = request.ThumbnailImage.Length,
ImagePath = await this.SaveFile(request.ThumbnailImage),
IsDefault = true,
SortOrder = 1
}
};
}
var result = await _context.Posts.AddAsync(post);
await _context.SaveChangesAsync();
return(result == null ? new ApiErrorResult <bool>("Post can't create") : new ApiSuccessResult <bool>());
}
public async Task <ActionResult> Create([FromBody] PostCreateRequest payload)
{
var createResult = await postCreator.Handle(new PostCreateParams(payload.Type, payload.Title, payload.Body, payload.Space, User !));
return(createResult.Match <ActionResult>(
newPost => Ok(newPost),
fail => BadRequest(fail)
));
}
public async Task <IActionResult> CreatePost([FromBody] PostCreateRequest request)
{
int currentUserId = this.GetCurrentUserId();
if (await _userDataSource.Read(currentUserId) == null)
{
return(NotFound());
}
Post post = await _postDataSource.Create(currentUserId, request.Text);
return(Ok(post));
}
public async Task <PostCreateResponse> SendMessage(PostCreateRequest request)
{
var messageContent = GetContent(request);
var response = await _httpClient.PostAsync("/api/chat/new-message", messageContent);
if (!HandleErrorsResponse(response))
{
return(new PostCreateResponse
{
ResponseResult = await DeserializeResponseObject <ResponseResult>(response)
});
}
return(await DeserializeResponseObject <PostCreateResponse>(response));
}
public async Task <IActionResult> Create([FromForm] PostCreateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _postService.Create(request);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
return(Ok(result));
}
/// <summary>
/// Uploads a test data file to storage and returns the name of the uploaded file.
/// </summary>
protected async Task <string> UploadFileToStorageAsync(string localName)
{
var remoteName = "TempFile_" + localName.Replace(".mpp", string.Empty) + ".mpp";
var fullName = Path.Combine(this.DataFolder, remoteName);
var directory = Path.GetDirectoryName(Path.GetDirectoryName(TestContext.CurrentContext.TestDirectory));
using (var fileStream = File.OpenRead(Path.Combine(directory, GetDataDir(), localName)))
{
var postRequest = new PostCreateRequest(fullName, fileStream, storage: "Tasks");
var response = await this.TasksApi.UploadFileAsync(postRequest);
PrepareClearingRequest(postRequest);
}
return(remoteName);
}
public async Task <IActionResult> ViewMessage(PostCreateRequest postMessage)
{
if (!ModelState.IsValid)
{
return(View(postMessage));
}
var response = await _chatService.SendMessage(postMessage);
if (ResponseHasErrors(response.ResponseResult))
{
return(View(postMessage));
}
ModelState.Clear();
return(View(new PostCreateRequest()));
}
public async Task <PostCreateResponse> PostCreate(
[FromBody] PostCreateRequest request,
[FromServices] RegistrationService registrationService
)
{
using var transaction = transactionManager.BeginTransaction();
var now = DateTimeOffset.Now;
var playerId = await registrationService.RegisterAsync(request.DeviceId, request.PlayerUid, request.Name, now);
var res = new PostCreateResponse
{
// TODO: 難読化
Id = playerId,
};
await transaction.Commit();
return(res);
}
public async Task <PostCreateResponse> SendMessage(PostCreateRequest request, UserLoginResponse userToken)
{
var loginContent = GetContent(request);
_httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", userToken.AccessToken);
using var response = await _httpClient.PostAsync("/api/chat/new-message", loginContent);
if (!HandleErrorsResponse(response))
{
return(new PostCreateResponse
{
ResponseResult = await DeserializeResponseObject <ResponseResult>(response)
});
}
return(await DeserializeResponseObject <PostCreateResponse>(response));
}
public static FileUploadResult UploadFile( System.Web.HttpPostedFileBase postedFile)
{
FileUploadResult uploadResult = null;
string fn = "";
TasksApi tasksApi = new TasksApi(Config.Configuration.AppKey, Config.Configuration.AppSID);
try
{
string folderName = Guid.NewGuid().ToString();
// Prepare a path in which the result file will be
string uploadPath = Config.Configuration.WorkingDirectory + "\\" + folderName;
// Check directroy already exist or not
if (!Directory.Exists(uploadPath))
Directory.CreateDirectory(uploadPath);
// Check if File is available.
if (postedFile != null && postedFile.ContentLength > 0)
{
fn = System.IO.Path.GetFileName(postedFile.FileName);
postedFile.SaveAs(uploadPath + "\\" + fn);
}
PostCreateRequest request = new PostCreateRequest(fn,File.OpenRead(uploadPath + "\\" + fn), null);
// Upload original document to Cloud Storage
tasksApi.UploadFile(request);
// Create response
return new FileUploadResult
{
FileName = fn,
FolderId = folderName
};
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
return uploadResult;
}
public IActionResult Create([FromBody] PostCreateRequest request)
{
try
{
var userId = _authenticationService.GetAuthenticatedUserId(User);
var postType = (PostType)Enum.ToObject(typeof(PostType), request.Type);
var postId = _postService.Create(request.ParentId, request.Content, userId, postType);
return(new ObjectResult(new
{
StatusCode = ResponseConstants.Success,
PostId = postId
}));
}
catch (Exception)
{
return(new ObjectResult(new Result {
StatusCode = ResponseConstants.Unknown
}));
}
}
public async Task <IActionResult> AddMessage(PostCreateRequest message)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var result = new PostCreateResponse {
Succeeded = true
};
var user = _aspNetUser.GetUserEmail();
var post = new Post(message.Message, user);
if (!post.IsCommand())
{
var response = await _postService.PostMessage(post);
if (!response.Succeeded)
{
foreach (var error in response.ResponseResult.Errors.Messages)
{
AddOperationError(error);
}
}
result = response;
}
var posts = await _postService.GetPosts();
await _hub.Clients.All.SendAsync("ReceiveMessage", posts);
if (post.IsCommand())
{
_producerService.Produce(post).ConfigureAwait(false);
}
return(CustomResponse(result));
}
public async Task <IActionResult> Create([FromBody] PostCreateRequest postRequest)
{
var userId = this.HttpContext.GetUserId();
if (!userId.HasValue)
{
return(this.BadRequest("The User Id is epsent"));
}
var newPostId = Guid.NewGuid();
var post = new Post {
Id = newPostId,
Name = postRequest.Name,
UserId = userId.Value,
Tags = postRequest.Tags?.Select(t => new PostTag {
PostId = newPostId,
TagName = t
}).ToList()
};
await postService.CreatePostAsync(post);
var locationUri = this.uriService.GetPostUri(post.Id.ToString());
return(this.Created(locationUri, new Response <PostResponse>(this.mapper.Map <PostResponse>(post))));
}
public async Task <ActionResult <PostResponse> > Create([FromBody] PostCreateRequest post)
{
var response = await PostBusiness.Add((Post)post, User.Account());
return(CreatedAtAction(nameof(Create), (PostResponse)response));
}
public Post NewPost(PostCreateRequest request)
{
var slug = _slugService.CreateSlugFromPostTitle(request.Title);
return(_dataProvider.CreatePost(request.Title, request.Content, request.Categories, slug, request.Username, request.Publish, request.BlogId));
}
public async Task <IActionResult> Create([FromBody] PostCreateRequest payload) => (await mediator.Command(new PostCreateCommand(payload.Space, new PostCreate(payload.Type, payload.Title, payload.Body), User !)))
private void PrepareClearingRequest(PostCreateRequest postRequest)
{
clearingRequests.Add(new DeleteRequest(postRequest.Path, postRequest.VersionId, postRequest.Storage));
}
protected async Task <Response <PostResponse> > CreatePostAsync(HttpClient client, PostCreateRequest post)
{
var(response, _) = await client.ExecuteRequest <Response <PostResponse> >(HttpMethod.Post, ApiRoutes.Posts.Create, post);
return(await response.Content.ReadAsAsync <Response <PostResponse> >());
}
