public async Task <IActionResult> CreateAsync([FromForm] PostCreateModel model)
{
if (!_accountDomainService.CheckIfUserExistsFromHeader(HttpContext.Request))
{
return(Unauthorized());
}
else
{
long creatorId = _accountDomainService.GetCurrentAccountIdFromHeader(HttpContext.Request);
try
{
string filePath = await SaveImage(model.File);
ResizeImage(filePath);
string appRootAddress = _configuration.GetSection("AppRootAddress").Value;
string imageUrl = Path.Combine(appRootAddress, filePath);
var post = new Post(imageUrl, creatorId);
_postRepository.Create(post);
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
}
public ResponseResult EditPost(int postId, PostCreateModel model)
{
var post = _dbContext.Posts.Find(postId);
post.Title = model.Title;
var contentFilePath = @$ "PostContent\{post.Id}.txt";
public async Task CreateAsync_WithValidData_ShouldAddToDatabase()
{
// Arrange
var context = InMemoryDbContext.Initiliaze();
var postRepository = new EfDeletableEntityRepository <Post>(context);
var postService = new PostsService(postRepository);
// Act
var model = new PostCreateModel
{
CreatorId = "creatorIdStringUnique",
Description = "descriptionrandom",
};
await postService.CreateAsync(model, "urltoimg.com", "dsahu2171dyh");
int expectedCount = postRepository.All().Count();
int actualCount = postRepository.All().Count();
var expectedPost = model;
var actualPost = postRepository.All().FirstOrDefault();
// Assert
Assert.Equal(expectedCount, actualCount);
Assert.True(expectedPost.Description == actualPost.Description);
Assert.True(expectedPost.CreatorId == actualPost.CreatorId);
}
public PostCreateModel Get(int id)
{
var tmp = rep.Get(id);
PostCreateModel result = new PostCreateModel()
{
Author = tmp.Author,
AuthorId = tmp.AuthorId,
Category = tmp.Category,
CategoryId = tmp.CategoryId,
Comments = tmp.Comments,
Content = tmp.Content,
Description = tmp.Description,
PostId = tmp.Id,
PostImage = tmp.PostImage,
PostTag = tmp.PostTag,
PublishedDate = tmp.PublishedDate,
SendDate = tmp.SendDate,
Slug = tmp.Slug,
TagId = tmp.TagId,
Title = tmp.Title,
VisitCount = tmp.VisitCount
};
return(result);
}
protected async Task CreatePost(PostCreateModel post)
{
JWTAuth auth = new JWTAuth(_config["wpuri"]);
auth.User = new JWTUser {
UserName = _config["wpuser"],
Password = _config["wppw"],
};
var httpResponseMsg = await auth.RequestJWToken();
var content = httpResponseMsg.Content.ReadAsStringAsync().Result;
var response = JsonConvert.DeserializeObject <JWTResponse>(content);
auth.Token = response.Token;
if (await auth.IsValidJWToken())
{
var result = await auth.PostAsync(post);
if (!result.IsSuccessStatusCode)
{
throw new Exception(nameof(post));
}
}
else
{
throw new Exception("invalid/expired token");
}
}
public async Task <IActionResult> Create([FromForm] PostCreateModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.ToDictionary(
kvp => kvp.Key,
kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray()
)));
}
// Upload file to Cloudinary and get the url to the media and the public id of the media.
var fileUpload = await this.cloudinaryService.UploadFileAsync(model.MediaSource, model.CreatorId);
var mediaUrl = fileUpload.SecureUri.ToString();
var publicId = fileUpload.PublicId;
var result = await this.service.CreateAsync(model, mediaUrl, publicId);
if (result == false)
{
return(BadRequest());
}
return(Ok());
}
public IHttpActionResult EditPost([FromBody] PostCreateModel post, [FromUri] Guid id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
if (!UserAuthorize(_postService.GetPostById(id).AuthorId, "Moder, Admin"))
{
return(Unauthorized());
}
var postDto = _mapper.Map <PostCreateModel, PostDTO>(post);
postDto.Id = id;
_postService.EditPost(postDto);
}
catch (Exception)
{
return(Conflict());
}
return(StatusCode(HttpStatusCode.NoContent));
}
public bool AddPost(PostCreateModel postCreate, string currentUserName)
{
var product = this.UOW.ProductRepository.List().Where(p => p.ProductTypeId == postCreate.ProductTypeId).FirstOrDefault();
var currentUser = this.UOW.UserManager.FindByNameAsync(currentUserName).Result;
if (product is null)
{
product = new Data.Models.Product
{
ProductTypeId = postCreate.ProductTypeId,
Count = postCreate.Count
};
this.UOW.ProductRepository.Save(product);
}
var post = this.Mapper.Map <PostCreateModel, Data.Models.Post>(postCreate);
post.Product = product;
post.ProductId = product.ProductId;
post.UserId = currentUser.Id;
if (post.PostType == PostType.ForSale)
{
var postList = this.UOW.PostRepository.List().Where(p => p.PostType != PostType.ForSale && p.UserId != post.UserId);
if (post.PostId != 0)
{
foreach (var p in postList)
{
var productType = this.UOW.ProductTypeRepository.List().Where(t => t.ProductTypeId == post.Product.ProductTypeId).FirstOrDefault();
var message = $"{post.PostName} postum popoxutyun e katarvel\n" +
$"Full Name: - Ars\n" +
$"Phone: - 094940708\n" +
$"Post Name: - {postCreate.PostName}\n" +
$"Price: - {postCreate.Price}\n" +
$"Post description: - I am selling {productType.ProductTypeName} {post.Product.Count}\n" +
$"Post Link: - https://localhost:44372/Post/PostView/{post.PostId}";
var userTo = UOW.UserRepository.GetByID(p.UserId);
EmailSender.SendEmailMessage("*****@*****.**", "Quick Response Soft", userTo.Email, message, "Post updated");
}
return(this.UOW.PostRepository.Update(post));
}
foreach (var p in postList)
{
var message = $"Full Name: - {currentUser.FirstName} {currentUser.LastName}\n" +
$"Phone: - {currentUser.PhoneNumber}\n" +
$"Post Name: - {postCreate.PostName}\n" +
$"Price: - {postCreate.Price}\n" +
$"Post description: - I am selling {postCreate.Body} {postCreate.Count}\n" +
$"Post Link: - https://localhost:44372/Post/PostView/{post.PostId}";;
var user = this.UOW.UserRepository.GetByID(p.UserId);
EmailSender.SendEmailMessage("*****@*****.**", "Quick Response Soft", user.Email, message, "New post");
}
}
else if (post.PostId != 0)
{
return(this.UOW.PostRepository.Update(post));
}
return(this.UOW.PostRepository.Save(post));
}
public IActionResult CreateNewPost([FromBody] PostCreateModel model)
{
var id = _postService.CreateNewPost(model);
if (id == 0)
{
return(ErrorBaseResponse(System.Net.HttpStatusCode.NotFound));
}
return(OkBaseResponse(id));
}
public IActionResult CreateNewPost([FromBody] PostCreateModel model)
{
var res = _postService.CreateNewPost(model);
if (!res.Succeeded)
{
return(NotFound());
}
return(Ok(res));
}
public IActionResult UpdatePost([FromBody] PostCreateModel model)
{
var res = _postService.UpdatePost(model);
if (res == 0)
{
return(ErrorBaseResponse(System.Net.HttpStatusCode.NoContent));
}
return(OkBaseResponse(res));
}
public async Task <IActionResult> Create(PostCreateModel postCreateModel)
{
_db.Posts.Add(new PostModel {
Name = postCreateModel.PostName, Text = postCreateModel.PostText,
User = _db.Users.FirstOrDefault(u => u.UserName == User.Identity.Name), CreateDate = DateTime.Now
});
await _db.SaveChangesAsync();
_messageSender.Send();
return(RedirectToAction("Index", "Home"));
}
public PostProfile()
{
var t = new PostCreateModel();
this.CreateMap <PostCreateModel, Post>()
.ForMember(p => p.PostId, src => src.MapFrom(i => i.PostId))
.ForMember(p => p.PostName, src => src.MapFrom(i => i.PostName))
.ForMember(p => p.PostType, src => src.MapFrom(i => i.PostType))
.ForMember(p => p.Price, src => src.MapFrom(i => i.Price))
.ForMember(p => p.PostDate, src => src.MapFrom(i => i.PostDate));
}
public IHttpActionResult Post(PostCreateModel postToCreate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = CreatePostService();
service.CreatePost(postToCreate);
return(Ok());
}
public ActionResult CreatePost(string teema, string linkId, int parentId)
{
if (teema == null || linkId == null)
{
return(PartialView("Error"));
}
//int teemaId = entities.Teemas.First(t => t.Name == teema).Id;
PostCreateModel model = new PostCreateModel(entities.Threads.First(t => t.LinkId == linkId && t.Teema.Name == teema).Id, parentId);
return(PartialView(new PostCreateModel(entities.Threads.First(t => t.LinkId == linkId && t.Teema.Name == teema).Id, parentId)));
}
public EntityAction Update(PostCreateModel entity)
{
//Todo: The Slug Has Not Exsits
var post = rep.Get(entity.PostId);
//post.CategoryId;
post.Category = null;
entity.ToPost(post);
EntityAction result = rep.Update(post);
return(result);
}
public EntityAction Create(PostCreateModel entity)
{
if (SlugExsits(entity.Slug))
{
return(EntityAction.Exception);
}
entity.PostId = rep.GetNextId();
var post = entity.ToPost();
EntityAction result = rep.Create(post);
return(result);
}
public void CreatePost(PostCreateModel postToCreate)
{
var entity = new Post()
{
UserId = _userId,
Text = postToCreate.Text,
Title = postToCreate.Title
};
_ctx.Posts.Add(entity);
_ctx.SaveChanges();
}
public ActionResult <int> CreatePost(PostCreateModel model)
{
model.UserId = _userId;
var result = _postRepository.CreatePost(model);
if (result.IsError)
{
return(BadRequest(result.Message));
}
return(Ok(result.Data.Id));
}
public async override Task <ActionResult <IEnumerable <New> > > GetTopNews([FromQuery] int quantity, [FromQuery] string subject)
{
var result = new Result();
if (quantity > 0)
{
Website bds = new CofeeLand();
if (subject == "da")
{
bds = new CofeeLandDa();
}
else if (subject == "bds")
{
bds = new CofeeLandBds();
}
var news = await bds.GetTopNews(quantity, subject);
if (news != null)
{
foreach (var n in news)
{
result.Total++;
var existed = _context.News.FirstOrDefault(e => e.Title.ToLower() == n.Title);
if (existed != null)
{
continue;
}
try
{
var post = PostCreateModel.Create(n);
if (post == null)
{
continue;
}
Wordpress.CreateAsync(post);
_context.News.Add(n);
result.Published++;
}
catch (System.Exception e)
{
continue;
}
// }
}
await _context.SaveChangesAsync();
return(Ok(result));
}
return(NotFound());
}
return(BadRequest(nameof(quantity)));
}
public ActionResult EditPost([FromHeader] int postId,
[FromBody] PostCreateModel model)
{
var access = _accessValidator.CheckPostAccess(postId);
if (!access)
{
return(Forbid());
}
var result = _postRepository.EditPost(postId, model);
return(ResponseToActionResult(result));
}
public async override Task <ActionResult <IEnumerable <New> > > GetTopNews([FromQuery] int quantity, [FromQuery] string subject)
{
if (quantity > 0)
{
Website bds = new DanTri();
var news = await bds.GetTopNews(quantity, subject);
if (news != null)
{
foreach (var n in news)
{
var existed = _context.News.FirstOrDefault(e => e.Title.ToLower() == n.Title);
if (existed != null)
{
continue;
}
try
{
var post = PostCreateModel.Create(n);
if (post == null)
{
continue;
}
Wordpress.CreateAsync(post);
_context.News.Add(n);
}
catch (System.Exception e)
{
continue;
}
// }
}
await _context.SaveChangesAsync();
// try
// {
// await _context.SaveChangesAsync();
// }
// catch (Exception e)
// {
// throw new Exception(e.Message);
// }
return(Ok(news));
}
return(NotFound());
}
return(BadRequest(nameof(quantity)));
}
public async Task <Tuple <string, Post> > Execute(PostCreateModel model)
{
var entry = _context.Posts.Add(new DbPost
{
UserId = model.UserId,
CreatedAt = DateTimeOffset.UtcNow,
Content = model.Content
});
await _context.SaveChangesAsync();
return(new Tuple <string, Post>(
entry.Entity.Id,
entry.Entity.Adapt <Post>()));
}
public IActionResult InsertPost([FromBody] PostCreateModel postViewModel)
{
var post = AutoMapper.Mapper.Map <Post>(postViewModel);
post.PostDate = DateTime.UtcNow;
if (_postRepository.Insert(post))
{
return(Ok("Post added succesfully!"));
}
else
{
return(BadRequest("Invalid post object"));
}
}
public ApiActionResult UpdatePost(PostCreateModel model)
{
try
{
var obj = _dbCMSContext.Posts.AsNoTracking().FirstOrDefault(x => x.Id == model.Id);
obj.DefaultTitle = model.DefaultTitle;
obj.TimeToRead = model.TimeToRead;
obj.IsActivated = model.IsActivated;
obj.Deleted = model.Deleted;
obj.CreatedBy = obj.CreatedBy;
obj.PostCategoryFid = model.PostCategoryFid;
obj.PostCategoryResKey = model.PostCategoryResKey;
_dbCMSContext.Update(obj);
_dbCMSContext.SaveChanges();
var objDetail = _dbCMSContext.PostDetails.AsNoTracking().FirstOrDefault(x => x.Id == model.postDetail.Id);
objDetail.KeyWord = model.postDetail.KeyWord;
objDetail.IsActivated = model.postDetail.IsActivated;
objDetail.LanguageFid = model.postDetail.LanguageFid;
objDetail.MetaDescription = model.postDetail.MetaDescription;
objDetail.Body = model.postDetail.Body;
objDetail.Deleted = model.postDetail.Deleted;
objDetail.Title = model.postDetail.Title;
objDetail.LastModifiedDate = DateTime.Now;
objDetail.FileStreamFid = model.postDetail.FileStreamFid;
objDetail.FileTypeFid = model.postDetail.FileTypeFid;
var objFileStream = _dbCMSContext.PostFileStreams.AsNoTracking().Where(x => x.PostFid == model.Id).ToList();
for (int i = 0; i < objFileStream.Count; i++)
{
if (objFileStream[i].Id == model.postFileStream[i].Id)
{
objFileStream[i].ActivatedDate = model.postFileStream[i].ActivatedDate;
objFileStream[i].FileCategoryFid = model.postFileStream[i].FileCategoryFid;
objFileStream[i].FileCategoryResKey = model.postFileStream[i].FileCategoryResKey;
objFileStream[i].FileStreamFid = model.postFileStream[i].FileStreamFid;
objFileStream[i].FileTypeFid = model.postFileStream[i].FileTypeFid;
objFileStream[i].FileTypeResKey = model.postFileStream[i].FileTypeResKey;
objFileStream[i].LastModifiedDate = DateTime.Now;
}
}
return(ApiActionResult.Success());
}
catch (Exception ex)
{
return(ApiActionResult.Failed(ex.Message));
}
}
public IActionResult CreatePost(PostCreateModel postAdd)
{
postAdd.PostDate = DateTime.Now;
var validator = new PostCreateValidator();
if (validator.Validate(postAdd).IsValid)
{
var postBL = new PostBL(_uow, _mapper);
var currentUserName = HttpContext.User?.Identity?.Name;
if (postBL.AddPost(postAdd, currentUserName))
{
return(RedirectToAction("AccountPage", "Account"));
}
}
return(RedirectToAction(""));
}
public IActionResult UpdatePost([FromBody] PostCreateModel model)
{
try
{
var res = _postService.UpdatePost(model);
if (!res.Succeeded)
{
return(NoContent());
}
return(Ok(res));
}
catch (Exception ex)
{
return(BadRequest(ex.StackTrace.ToString()));
}
}
public async Task <bool> CreateAsync(PostCreateModel postCreateModel, string mediaUrl, string publicId)
{
var post = new Post
{
Description = postCreateModel.Description,
MediaSource = mediaUrl,
MediaPublicId = publicId,
CreatorId = postCreateModel.CreatorId,
};
await this.postRepository.AddAsync(post);
var result = await this.postRepository.SaveChangesAsync() > 0;
return(result);
}
public async Task <IActionResult> Post([FromBody] PostCreateModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(new
{
code = 400,
message = ModelState.Values.First().Errors.First().ErrorMessage
}));
}
var createQuery = new CreatePostQuery(_context);
var post = await createQuery.Execute(model);
return(new CreatedAtRouteResult("default", new { controller = Endpoint, id = post.Item1 }, post.Item2));
}
public IActionResult Create(int id)
{
var topic = _topicService.GetById(id);
if (topic != null)
{
var model = new PostCreateModel
{
TopicId = id,
TopicTitle = topic.Title,
};
return(View(model));
}
return(RedirectToAction("Index", "Forum"));
}
