public async Task <IActionResult> ChangePassword([FromBody] ChangePasswordViewModel model)
{
if (ModelState.IsValid)
{ // if model is valid
var UserName = User.Identity.Name; // get id from jwt
BlogUserIdentity _user = await _userManager.FindByNameAsync(UserName);
var result = _signInManager.CheckPasswordSignInAsync(_user, model.OldPassword, false);
if (result.Result.Succeeded)
{// password was good- change password of this account
var ChangingResult = await _userManager.ChangePasswordAsync(_user, model.OldPassword, model.NewPassword);
if (ChangingResult.Succeeded)// if it was successfull
{
return(Ok());
}
else
{
return(Conflict());
}
}
else
{
return(Unauthorized());
}
}
else
{
return(Conflict());
}
}
public async Task <IActionResult> ChangeAvatar([FromBody] ChangeAvaterViewModel model)
{
if (ModelState.IsValid)
{
var UserName = User.Identity.Name;// get id from jwt
BlogUserIdentity user = await _userManager.FindByNameAsync(UserName);
byte[] ImageBytes = Convert.FromBase64String(model.Picture);
await _filesService.AddAvatarToUserAsync(user, ImageBytes);
user.ProfilePic = "/src/profile/" + user.Id.ToString() + "/Avatar.jpg";
var result = await _userManager.UpdateAsync(user);
if (result.Succeeded)
{
return(Ok());
}
else
{
return(Conflict());
}
}
else
{
return(Conflict());
}
}
public async Task <IActionResult> GetBlog()
{
var UserName = User.Identity.Name;// get user name from jwt
BlogUserIdentity user = await _userManager.FindByNameAsync(UserName);
var UsersBlog = _appContext.Blogs.FirstOrDefault(ob => ob.BlogUserIdentity == user);
if (UsersBlog != null)
{
BlogViewModel responseBlog = new BlogViewModel()
{
BlogName = UsersBlog.BlogName,
DateOfCreated = UsersBlog.DateOfCreated,
Description = UsersBlog.Description
};
string JSONresponse = JsonConvert.SerializeObject(responseBlog);
return(Ok(JSONresponse));
}
else
{
return(Ok());
}
}
public async Task DeletePostDirectory(BlogUserIdentity user, string PostName, long NumberOfTicks)
{
string DeletePath = currentPath + "\\wwwroot\\Src\\Profile\\" + user.Id.ToString() + "\\" + PostName + NumberOfTicks.ToString();
// path to directory containing all images for post
await Task.Run(() => Directory.Delete(DeletePath, true));
}
public async Task <IActionResult> DeletePost([FromBody] SimpleString id)
{
int PostID = Int32.Parse(id.Value);
BlogUserIdentity user = await _userManager.FindByNameAsync(User.Identity.Name);
var UsersBlog = await _appContext.Blogs.FirstOrDefaultAsync(ob => ob.BlogUserIdentity == user);
var postToRemove = _appContext.Posts.FirstOrDefault(ob => ob.PostId == PostID);
if (postToRemove != null && postToRemove.Blog == UsersBlog)
{
_appContext.Posts.Remove(postToRemove);
await _appContext.SaveChangesAsync();
await _fileService.DeletePostDirectory(user, postToRemove.Title, postToRemove.DateOfPost);
return(Ok());
}
else// if post was not found or
{
return(Conflict());
}
}
/// <summary>
/// Save Thumbnail for certain post
/// </summary>
/// <param name="user"></param>
/// <param name="PostName"></param>
/// <param name="Image"></param>
/// <returns></returns>
public async Task AddThumbnailToPostAsynch(BlogUserIdentity user, string PostName, SimpleImageObject Image, long NumberOfTicks)
{
string Path = currentPath + "\\wwwroot\\Src\\Profile\\" + user.Id.ToString() + "\\" + PostName + NumberOfTicks.ToString(); // path to users folder
Directory.CreateDirectory(Path); // create needed directories
Path += "\\" + Image.name;
await File.WriteAllBytesAsync(Path, DecodeImage(Image));
}
public async Task AddAvatarToUser(BlogUserIdentity user, Byte[] ImageBytes)// creates dictionary, updates user image,
{
//string currentPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);// get current path
string PersonalPath = currentPath + "\\wwwroot\\Src\\Profile\\" + user.Id.ToString(); // add needed directories + user directory
Directory.CreateDirectory(PersonalPath); //create all needed directories- if dont exists
PersonalPath += "\\Avatar.jpg";
await File.WriteAllBytesAsync(PersonalPath, ImageBytes);
}
public async Task <IActionResult> GetNumberOfPosts()
{
BlogUserIdentity user = await _userManager.FindByNameAsync(User.Identity.Name);
var USersBlog = await _appContext.Blogs.FirstOrDefaultAsync(ob => ob.BlogUserIdentity == user);
int ammount = _appContext.Posts.Where(ob => ob.Blog == USersBlog).Count();// counts number of all posts
return(Ok(ammount));
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model)
{
if (ModelState.IsValid)
{
var NewUser = new BlogUserIdentity()
{
UserName = model.Login,
Email = model.Email,
ProfilePic = "/src/system/defaultpic.png"
};
var ValidatePassword = _userManager.PasswordValidators.First().ValidateAsync(_userManager, NewUser, model.Password);
if (ValidatePassword.Result.Succeeded) // if password is ok- create user
{
if (model.CreateBlog) // if user wants its own Blog
{
var NewBlog = new Blog()
{
BlogName = model.Blogname,
Description = model.Description,
DateOfCreated = DateTime.Now,
};
NewBlog.BlogUserIdentity = NewUser;
_appContext.Add(NewBlog);
//_appContext.SaveChanges();
// NewBlog = _appContext.Blogs.FirstOrDefault(ob => ob.BlogUserIdentity == NewUser);
NewUser.Blog = NewBlog;
//_appContext.Add(NewBlog);
}
await _userManager.CreateAsync(NewUser, model.Password);
await _appContext.SaveChangesAsync();
return(Ok());
}
else
{
return(Conflict());
}
}
else
{
return(Conflict());
}
}
public async Task AddImagesToPostAsynch(BlogUserIdentity user, string PostName, List <SimpleImageObject> Images, long NumberOfTicks)
{
string TmpPath = currentPath + "\\wwwroot\\Src\\Profile\\" + user.Id.ToString() + "\\" + PostName + NumberOfTicks.ToString();
List <Task> ListOfTasks = new List <Task>();
Directory.CreateDirectory(TmpPath);
foreach (var item in Images)
{
ListOfTasks.Add(SaveImg(TmpPath, item));
}
await Task.WhenAll(ListOfTasks);
}
public async Task <IActionResult> ChangeDescription(SimpleString NewDescription)
{
if (NewDescription.Value.Length <= 1000)
{
BlogUserIdentity user = await _userManager.FindByNameAsync(User.Identity.Name);
Blog UserBlog = user.Blog;
UserBlog.Description = NewDescription.Value;
_appContext.Blogs.Update(UserBlog);
return(Ok());
}
else
{
return(Conflict());
}
}
/// <summary>
/// Checks if certain tag exists in base, if so - create Tag element in base and save the base
/// </summary>
/// <returns></returns>
private Task CheckTag(string TagName, BlogUserIdentity creator)
{
var result = new List <Tag>();
result = _appContext.Tags.Where(ob => ob.Name == TagName.ToLower()).ToList <Tag>();
if (result.Count == 0)// if there is no tag create one and save it in database
{
Tag NewTag = new Tag()
{
Name = TagName.ToLower(),
Owner = creator,
PublicTag = true
};
_appContext.Add(NewTag);
_appContext.SaveChanges();
}
return(Task.CompletedTask);
}
public async Task <IActionResult> UserTags()
{
var UserName = User.Identity.Name;// get user name from jwt
BlogUserIdentity _user = await _userManager.FindByNameAsync(UserName);
var Tags = _appContext.Tags.Where(ob => ob.Owner == _user);// all tegs which have owner
List <string> ReturnStringTags = new List <string>();
foreach (Tag item in Tags)
{
ReturnStringTags.Add(item.Name);
}
string JsonListResult = JsonConvert.SerializeObject(ReturnStringTags);
return(Ok(JsonListResult));
}
public async Task <IActionResult> GetPartOfPosts([FromBody] RangeNumbers numbers)
{
BlogUserIdentity user = await _userManager.FindByNameAsync(User.Identity.Name);
var UsersBlog = _appContext.Blogs.FirstOrDefault(ob => ob.BlogUserIdentity == user);
//List<Post> PartOfPosts = _appContext.Posts.Where(ob => ob.Blog == UsersBlog);
List <Post> PartOfPosts = _appContext.Posts.Where(ob => ob.Blog == UsersBlog)
.Include(img => img.Images)
.Include(pt => pt.PostTags)
.ThenInclude(t => t.Tag)
.ToList();
if (PartOfPosts != null)
{
PartOfPosts.Sort((p, q) => p.DateOfPost.CompareTo(q.DateOfPost) * -1);
if (PartOfPosts.Count > numbers.end - numbers.start)// if there is more posts than can fit on site
{
if (PartOfPosts.Count > numbers.end)
{
PartOfPosts = PartOfPosts.GetRange(numbers.start, numbers.end - numbers.start + 1);
}
else
{
PartOfPosts = PartOfPosts.GetRange(numbers.start, PartOfPosts.Count - numbers.start);
}
}
// one need here simplified posts without comments and images
List <PostViewModel> SimplifiedPosts = new List <PostViewModel>();
foreach (var item in PartOfPosts)
{
var DateOfPost = new DateTime(item.DateOfPost);
PostViewModel NewPostModel = new PostViewModel()
{
BlogId = item.Blog.BlogId,
BlogName = item.Blog.BlogName,
ContentOne = item.ContentOne,
ContentTwo = item.ContentTwo,
DateOfPost = DateOfPost,
Thumbnail = item.Thumbnail,
Title = item.Title,
PostTags = new List <string>(),
PostId = item.PostId
};
foreach (var tag in item.PostTags)
{
NewPostModel.PostTags.Add(tag.Tag.Name);
}
SimplifiedPosts.Add(NewPostModel);
}
string jsonResult = JsonConvert.SerializeObject(SimplifiedPosts);
return(Ok(jsonResult));
}
else
{
return(Ok());
}
}
public async Task <IActionResult> AddPost([FromBody] AddPostModelView model)
{
var ValidationContext = new ValidationContext(model.NewPost);
if (Validator.TryValidateObject(model.NewPost, ValidationContext, null))// zamiast null można dać liste która zostanie zapełniona błędami
{
var DateNow = DateTime.Now;
BlogUserIdentity user = await _userManager.FindByNameAsync(User.Identity.Name);
var UserBlog = _appContext.Blogs.FirstOrDefault(ob => ob.BlogUserIdentity == user);
Post NewPost = new Post()
{
Title = model.NewPost.Title,
Blog = UserBlog,
ContentOne = model.NewPost.ContentOne,
ContentTwo = model.NewPost.ContentTwo,
Comments = null,
DateOfPost = DateNow.Ticks,
Images = new List <ImgPost>(),
PostTags = new List <PostTag>()
};
if (model.Thumbnail.name != "")
{
NewPost.Thumbnail = "/Src/Profile/" + user.Id.ToString() + "/" + model.NewPost.Title + DateNow.Ticks.ToString() + "/" + model.Thumbnail.name;
await _fileService.AddThumbnailToPostAsynch(user, model.NewPost.Title, model.Thumbnail, DateNow.Ticks);
}
else
{
NewPost.Thumbnail = "/Src/System/noimage.png";
}
//_appContext.Add(NewPost);// add new
//_appContext.SaveChanges();// save changes so post will get id
//NewPost = _appContext.Posts.FirstOrDefault(post => post.Title == model.NewPost.Title);// get post from database
await _fileService.AddImagesToPostAsynch(user, model.NewPost.Title, model.Images, DateNow.Ticks);
List <Task> CreatingTags = new List <Task>();
foreach (var item in model.NewPost.PostTags)
{
CreatingTags.Add(CheckTag(item, user));
}
await Task.WhenAll(CreatingTags);
// tags was created
List <Tag> TagLists = new List <Tag>();
foreach (var item in model.NewPost.PostTags)
{
var tagFromBase = _appContext.Tags.FirstOrDefault(ob => ob.Name == item.ToLower());
if (tagFromBase != null)
{
TagLists.Add(tagFromBase);
}
}
// get all tags from database
List <PostTag> PostTagConnectorList = new List <PostTag>();
foreach (var item in TagLists)
{
var NewConnector = new PostTag();
NewConnector.Post = NewPost;
NewConnector.Tag = item;
item.PostTags = new List <PostTag>();
NewPost.PostTags.Add(NewConnector);
item.PostTags.Add(NewConnector);
PostTagConnectorList.Add(NewConnector);
}
// objects which connects Tags with posts (many to many connection)
//Creatng img objects
List <ImgPost> ImageList = new List <ImgPost>();
var path = "/Src/Profile/" + user.Id + "/" + model.NewPost.Title + "/";// base of all images in post
foreach (var item in model.Images)
{
var imagepath = path + item.name;
var TmpImgPost = new ImgPost();
TmpImgPost.Src = imagepath;
TmpImgPost.Post = NewPost;
NewPost.Images.Add(TmpImgPost);
ImageList.Add(TmpImgPost);// add to list which will save it to database
}
try
{
await _appContext.AddAsync(NewPost);//add post to database
await _appContext.AddRangeAsync(PostTagConnectorList);
await _appContext.AddRangeAsync(ImageList);
}
catch (Exception e) {
return(Conflict());
}
await _appContext.SaveChangesAsync();
return(Ok());
}
else
{
return(Conflict());
}
}
public Task AddAvatarToUserAsync(BlogUserIdentity user, Byte[] ImageBytes)
{
return(Task.Run(() => AddAvatarToUser(user, ImageBytes)));
}
