public void SeedData()
{
// Seeding Data to db
// Add Tags
var tags = new Dictionary <string, Tag>
{
{ "c#", new Tag {
Name = "c#"
} },
{ "angularjs", new Tag {
Name = "angularjs"
} },
{ "javascript", new Tag {
Name = "javascript"
} },
{ "nodejs", new Tag {
Name = "nodejs"
} },
{ "oop", new Tag {
Name = "oop"
} },
{ "linq", new Tag {
Name = "linq"
} },
};
foreach (var tag in tags.Values)
{
_context.Tags.Add(tag);
}
_context.SaveChanges();
// Add Users
var users = new List <User>
{
new User
{
Name = "Artem Labetskiy"
},
new User
{
Name = "Johnnie Trombetta"
},
new User
{
Name = "Clair Wenz"
},
new User
{
Name = "Vladimir Hilgefort"
},
new User
{
Name = "Bob Greenway"
}
};
foreach (var user in users)
{
_context.Users.Add(user);
}
_context.SaveChanges();
// Adding post with multiple tags. Many-to-Many Relationship.
var post1 = new Post();
post1.Name = "All about OOP";
post1.UserId = 21;
post1.Description = "Digging inside OOP";
post1.Level = 2;
var tag1 = new Tag();
tag1.Name = "Test-Tag-OOP1";
var tag2 = new Tag();
tag2.Name = "Test-Tag-OOP2";
var junktion1 = new PostTag();
var junktion2 = new PostTag();
junktion1.Post = post1;
junktion1.Tag = tag1;
junktion2.Post = post1;
junktion2.Tag = tag2;
post1.Tags.Add(junktion1);
post1.Tags.Add(junktion2);
_context.Posts.Add(post1);
_context.Tags.Add(tag1);
_context.Tags.Add(tag1);
_context.SaveChanges();
//var post2 = new Post();
//post2.Name = "Explaining SignalR";
//post2.UserId = 1;
//post2.Description = "Digging inside SignalR";
//post2.Level = 2;
//var post3 = new Post();
//post3.Name = "The power of JavaScipt";
//post3.UserId = 2;
//post3.Description = "Exploring JavaScipt";
//post3.Level = 1;
//var tag1 = new Tag();
//tag1.Name = "c#";
//var tag2 = new Tag();
//tag1.Name = "javascript";
//var junktion1 = new PostTag();
//var junktion2 = new PostTag();
//junktion1.Post = post1;
//junktion1.Tag = tag1;
//junktion2.Post = post2;
//junktion2.Tag = tag1;
//tag1.Posts.Add(junktion1);
//tag1.Posts.Add(junktion2);
//_context.Tags.Add(tag1);
//_context.Posts.Add(post1);
//_context.Posts.Add(post2);
//_context.SaveChanges();
#region Posts
//var posts = new List<Post>
//{
// new Post
// {
// Id = 1,
// Name = "C# Basics",
// UserId = 1,
// Description = "Description for C# Basics",
// Level = 1,
// Tags = new Collection<Tag>()
// {
// tags["c#"]
// }
// },
// new Post
// {
// Id = 2,
// Name = "C# Intermediate",
// UserId = 1,
// Description = "Description for C# Intermediate",
// Level = 2,
// Tags = new Collection<Tag>()
// {
// tags["c#"],
// tags["oop"]
// }
// },
// new Post
// {
// Id = 3,
// Name = "C# Advanced",
// UserId = 1,
// Description = "Description for C# Advanced",
// Level = 3,
// Tags = new Collection<Tag>()
// {
// tags["c#"]
// }
// },
// new Post
// {
// Id = 4,
// Name = "Javascript: Understanding the Weird Parts",
// UserId = 2,
// Description = "Description for Javascript",
// Level = 2,
// Tags = new Collection<Tag>()
// {
// tags["javascript"]
// }
// },
// new Post
// {
// Id = 5,
// Name = "Learn and Understand Angular 73",
// UserId = 2,
// Description = "Description for Angular 73",
// Level = 2,
// Tags = new Collection<Tag>()
// {
// tags["angularjs"]
// }
// },
// new Post
// {
// Id = 6,
// Name = "Learn and Understand NodeJS",
// UserId = 2,
// Description = "Description for NodeJS",
// Level = 2,
// Tags = new Collection<Tag>()
// {
// tags["nodejs"]
// }
// },
// new Post
// {
// Id = 7,
// Name = "Programming for Complete Beginners",
// UserId = 3,
// Description = "Description for Programming for Beginners",
// Level = 1,
// Tags = new Collection<Tag>()
// {
// tags["c#"]
// }
// },
// new Post
// {
// Id = 8,
// Name = "Power of JavaScript. Callback.",
// UserId = 4,
// Description = "All about callbacks in JavaScipt",
// Level = 1,
// Tags = new Collection<Tag>()
// {
// tags["c#"]
// }
// },
// new Post
// {
// Id = 9,
// Name = "Learn MS SQL Server",
// UserId = 4,
// Description = "Be the best SQL Server Administrator",
// Level = 1,
// Tags = new Collection<Tag>()
// {
// tags["javascript"]
// }
// }
//};
#endregion
}
public void Delete(PostTag postTag)
{
_postTagDal.Delete(postTag);
}
public void AddPostTags(PostTag postTag)
{
_context.PostTags.Add(postTag);
}
public async Task <Post> GetOrNullWithTagsBy(PostTag postTag) => await _blogContext.Posts .Include(pt => pt.PostTags) .ThenInclude(t => t.Tag) .FirstOrDefaultAsync(p => p.Id == postTag.PostId);
public void Add(PostTag postTag)
{
_db.PostTags.Add(postTag);
}
public HashSet <string> UpdateValidation(PostTag entity)
{
return(ValidationMessages);
}
public ActionResult Create(PostTag posttag)
{
posttagRepo.Create(posttag);
return(RedirectToAction("Details", "Post", new { id = posttag.PostId }));
}
public void FetchManyNonRootTrackingEnabledLast()
{
var config = new CustomConfig();
var selectQuery =
new SelectQuery <PostTag>(new Mock <ISelectQueryExecutor>().Object).FetchMany(p => p.Post.Comments).ThenFetch(c => c.User) as
SelectQuery <PostTag>;
var writer = new SelectWriter(new SqlServer2012Dialect(), config);
var result = writer.GenerateSql(selectQuery);
var mapper = new SingleCollectionMapperGenerator(config);
var funcFac = mapper.GenerateCollectionMapper <PostTag>(result.FetchTree).Item1;
// setup the scenario
var tag1 = new PostTag {
PostTagId = 1
};
var tag2 = new PostTag {
PostTagId = 2
};
var tag3 = new PostTag {
PostTagId = 3
};
var post1 = new Post {
PostId = 1, Title = "Foo"
};
var anotherPost1 = new Post {
PostId = 1, Title = "Foo"
};
var post2 = new Post {
PostId = 2, Title = "Foo"
};
var post3 = new Post {
PostId = 3, Title = "Foo"
};
var post4 = new Post {
PostId = 4, Title = "Foo"
};
var comment1 = new Comment {
CommentId = 1
};
var comment2 = new Comment {
CommentId = 2
};
var comment3 = new Comment {
CommentId = 3
};
var comment4 = new Comment {
CommentId = 4
};
var comment5 = new Comment {
CommentId = 5
};
var comment6 = new Comment {
CommentId = 6
};
var user1 = new User {
UserId = 1
};
var user2 = new User {
UserId = 2
};
var user3 = new User {
UserId = 3
};
var user4 = new User {
UserId = 4
};
var user5 = new User {
UserId = 5
};
PostTag currentRoot = null;
IList <PostTag> results = new List <PostTag>();
var func = (Func <object[], PostTag>)funcFac.DynamicInvoke(currentRoot, results);
func(new object[] { tag1, post1, comment1, user1 });
func(new object[] { tag1, post1, comment2, user1 });
func(new object[] { tag1, post1, comment3, user2 });
func(new object[] { tag2, anotherPost1, comment1, user1 });
func(new object[] { tag2, anotherPost1, comment2, user1 });
func(new object[] { tag2, anotherPost1, comment3, user2 });
func(new object[] { tag3, post2, comment4, user3 });
func(new object[] { tag3, post2, comment5, user4 });
func(new object[] { tag3, post2, comment6, user5 });
Assert.False(((ITrackedEntity)results[0]).GetDirtyProperties().Any());
Assert.False(((ITrackedEntity)results[0].Post).GetDirtyProperties().Any());
Assert.False(((ITrackedEntity)results[0].Post.Comments[0]).GetDirtyProperties().Any());
Assert.False(((ITrackedEntity)results[0].Post.Comments[0].User).GetDirtyProperties().Any());
}
public void NestedMultipleOneToManyFetchingWorksTrackingEnabled()
{
// setup the factory
var config = new CustomConfig();
var selectQuery =
new SelectQuery <Blog>(new Mock <ISelectQueryExecutor>().Object).FetchMany(b => b.Posts)
.ThenFetchMany(p => p.Tags)
.ThenFetch(t => t.ElTag)
.FetchMany(b => b.Posts)
.ThenFetchMany(p => p.DeletedTags)
.ThenFetch(t => t.ElTag)
.FetchMany(p => p.Posts)
.ThenFetch(p => p.Author) as SelectQuery <Blog>;
var writer = new SelectWriter(new SqlServer2012Dialect(), config);
var result = writer.GenerateSql(selectQuery);
var mapper = new MultiCollectionMapperGenerator(config);
var funcFac = mapper.GenerateMultiCollectionMapper <Blog>(result.FetchTree).Item1;
// setup the scenario
var blog1 = new Blog {
BlogId = 1
};
var blog2 = new Blog {
BlogId = 2
};
var post1 = new Post {
PostId = 1
};
var post2 = new Post {
PostId = 2
};
var post3 = new Post {
PostId = 3
};
var posttag1 = new PostTag {
PostTagId = 1
};
var posttag2 = new PostTag {
PostTagId = 2
};
var posttag3 = new PostTag {
PostTagId = 3
};
var tag1 = new Tag {
TagId = 1
};
var tag2 = new Tag {
TagId = 2
};
var tag3 = new Tag {
TagId = 3
};
var tag4 = new Tag {
TagId = 4
};
var delPostTag1 = new PostTag {
PostTagId = 3
};
var delPostTag2 = new PostTag {
PostTagId = 4
};
var delPostTag3 = new PostTag {
PostTagId = 5
};
var author1 = new User {
UserId = 1
};
var author2 = new User {
UserId = 2
};
// act
Blog currentRoot = null;
IList <Blog> results = new List <Blog>();
var dict0 = new Dictionary <int, Post>();
var hashsetPair0 = new HashSet <Tuple <int, int> >();
var dict1 = new Dictionary <int, PostTag>();
var hashsetPair1 = new HashSet <Tuple <int, int> >();
var dict2 = new Dictionary <int, PostTag>();
var hashsetPair2 = new HashSet <Tuple <int, int> >();
var func =
(Func <object[], Blog>)funcFac.DynamicInvoke(currentRoot, results, dict0, hashsetPair0, dict1, hashsetPair1, dict2, hashsetPair2);
func(new object[] { blog1, post1, author1, null, null, posttag1, tag1 });
func(new object[] { blog1, post1, author1, null, null, posttag2, tag2 });
func(new object[] { blog1, post2, author2, delPostTag1, tag3, null, null });
func(new object[] { blog1, post2, author2, delPostTag2, tag4, null, null });
func(new object[] { blog2, post3, author1, delPostTag1, tag3, posttag1, tag1 });
func(new object[] { blog2, post3, author1, delPostTag2, tag4, posttag1, tag1 });
func(new object[] { blog2, post3, author1, delPostTag3, tag4, posttag1, tag1 });
func(new object[] { blog2, post3, author1, delPostTag1, tag3, posttag2, tag2 });
func(new object[] { blog2, post3, author1, delPostTag2, tag4, posttag2, tag2 });
func(new object[] { blog2, post3, author1, delPostTag3, tag4, posttag2, tag2 });
func(new object[] { blog2, post3, author1, delPostTag1, tag3, posttag3, tag3 });
func(new object[] { blog2, post3, author1, delPostTag2, tag4, posttag3, tag3 });
func(new object[] { blog2, post3, author1, delPostTag3, tag4, posttag3, tag3 });
Assert.True(((ITrackedEntity)results[0]).IsTrackingEnabled());
Assert.True(((ITrackedEntity)results[0].Posts[0]).IsTrackingEnabled());
Assert.True(((ITrackedEntity)results[0].Posts[0].Author).IsTrackingEnabled());
Assert.True(((ITrackedEntity)results[0].Posts[0].Tags[0]).IsTrackingEnabled());
Assert.True(((ITrackedEntity)results[0].Posts[0].Tags[0].ElTag).IsTrackingEnabled());
}
public void AddPostTags(PostTag postTag)
{
_context.PostTags.Add(postTag);
}
public void FetchManyNonRootWorks()
{
var config = new CustomConfig();
var selectQuery =
new SelectQuery <PostTag>(new Mock <ISelectQueryExecutor>().Object).FetchMany(p => p.Post.Comments).ThenFetch(c => c.User) as
SelectQuery <PostTag>;
var writer = new SelectWriter(new SqlServer2012Dialect(), config);
var result = writer.GenerateSql(selectQuery);
var mapper = new SingleCollectionMapperGenerator(config);
var funcFac = mapper.GenerateCollectionMapper <PostTag>(result.FetchTree).Item1;
// setup the scenario
var tag1 = new PostTag {
PostTagId = 1
};
var tag2 = new PostTag {
PostTagId = 2
};
var tag3 = new PostTag {
PostTagId = 3
};
var post1 = new Post {
PostId = 1, Title = "Foo"
};
var anotherPost1 = new Post {
PostId = 1, Title = "Foo"
};
var post2 = new Post {
PostId = 2, Title = "Foo"
};
var post3 = new Post {
PostId = 3, Title = "Foo"
};
var post4 = new Post {
PostId = 4, Title = "Foo"
};
var comment1 = new Comment {
CommentId = 1
};
var comment2 = new Comment {
CommentId = 2
};
var comment3 = new Comment {
CommentId = 3
};
var comment4 = new Comment {
CommentId = 4
};
var comment5 = new Comment {
CommentId = 5
};
var comment6 = new Comment {
CommentId = 6
};
var user1 = new User {
UserId = 1
};
var user2 = new User {
UserId = 2
};
var user3 = new User {
UserId = 3
};
var user4 = new User {
UserId = 4
};
var user5 = new User {
UserId = 5
};
PostTag currentRoot = null;
IList <PostTag> results = new List <PostTag>();
var func = (Func <object[], PostTag>)funcFac.DynamicInvoke(currentRoot, results);
func(new object[] { tag1, post1, comment1, user1 });
func(new object[] { tag1, post1, comment2, user1 });
func(new object[] { tag1, post1, comment3, user2 });
func(new object[] { tag2, anotherPost1, comment1, user1 });
func(new object[] { tag2, anotherPost1, comment2, user1 });
func(new object[] { tag2, anotherPost1, comment3, user2 });
func(new object[] { tag3, post2, comment4, user3 });
func(new object[] { tag3, post2, comment5, user4 });
func(new object[] { tag3, post2, comment6, user5 });
Assert.Equal(3, results.Count);
Assert.Equal(3, results.First().Post.Comments.Count);
Assert.Equal(1, results.First().Post.PostId);
Assert.Equal(1, results.First().Post.Comments.First().User.UserId);
Assert.Equal(1, results.First().Post.Comments.ElementAt(1).User.UserId);
Assert.Equal(2, results.First().Post.Comments.ElementAt(2).User.UserId);
Assert.Equal(3, results.ElementAt(1).Post.Comments.Count);
Assert.Equal(1, results.ElementAt(1).Post.PostId);
Assert.Equal(1, results.ElementAt(1).Post.Comments.First().User.UserId);
Assert.Equal(1, results.ElementAt(1).Post.Comments.ElementAt(1).User.UserId);
Assert.Equal(2, results.ElementAt(1).Post.Comments.ElementAt(2).User.UserId);
Assert.Equal(3, results.ElementAt(2).Post.Comments.Count);
Assert.Equal(2, results.ElementAt(2).Post.PostId);
Assert.Equal(4, results.ElementAt(2).Post.Comments.First().CommentId);
Assert.Equal(5, results.ElementAt(2).Post.Comments.ElementAt(1).CommentId);
Assert.Equal(6, results.ElementAt(2).Post.Comments.ElementAt(2).CommentId);
}
public void CreateTagAndPostTag(Post post, PostViewModel postVm)
{
var createdDdate = post.DateCreated;
Mapper.Map(postVm, post);
if (string.IsNullOrWhiteSpace(postVm.Url))
{
post.Url = TextHelper.ToUnsignString(postVm.Name);
}
else
{
post.Url = postVm.Url.ToLower();
}
var query = _postRepository.FirstOrDefault(x => x.Url == post.Url);
if (query != null)
{
post.Url = $"{query.Url}-{post.Code.ToLower()}";
}
post.DateCreated = createdDdate;
if (!string.IsNullOrWhiteSpace(post.Tags))
{
string[] tags = post.Tags.Split(',');
var filteredTagList = new List <string>();
foreach (string t in tags)
{
if (!string.IsNullOrWhiteSpace(t))
{
var tagId = TextHelper.ToUnsignString(t);
var listStr = new List <string>();
var listDuoi = new List <int>();
for (int i = 0; i < 15; i++)
{
var check = i == 0 ? _tagRepository.FirstOrDefault(x => x.Id == tagId) : _tagRepository.FirstOrDefault(x => x.Id == tagId + "-" + (i + 1) + "");
if (check != null)
{
listStr.Add(check.Id);
}
}
if (listStr.Count() == 0)
{
listStr.Add(tagId);
}
if (listStr.Count() > 0)
{
CreateTagId(ref tagId, ref listStr, ref listDuoi);
}
//if (!_tagRepository.GetAll().Where(x => x.Id == tagId).Any())
//{
var tagOrder = SetNewTagOrder(out var lstOrder, CommonConstants.PostTag);
Tag tag = new Tag
{
Id = tagId,
Name = t.Trim(),
//Type = Data.Enums.TagType.Product
Type = CommonConstants.PostTag,
MetaTitle = t.Trim(),
MetaDescription = t.Trim(),
MetaKeywords = t.Trim(),
SortOrder = tagOrder,
DateCreated = DateTime.Now,
DateModified = DateTime.Now
};
_tagRepository.Insert(tag);
//}
PostTag postTag = new PostTag
{
Id = Guid.NewGuid(),
PostId = post.Id,
TagId = tagId
};
_postTagRepository.Insert(postTag);
filteredTagList.Add(t.Trim());
}
}
var filteredTagsArray = filteredTagList.ToArray();
var filteredTagStr = string.Join(",", filteredTagsArray);
post.Tags = filteredTagStr;
}
_postRepository.Update(post);
}
public HashSet <string> DeleteValidation(PostTag parameters)
{
return(ValidationMessages);
}
public async Task UpdateAsync(PostTag entity)
{
await Uow.RegisterDirtyAsync(entity);
await Uow.CommitAsync();
}
internal static void SeedTags(EntertainmentSystemDbContext context)
{
if (context.PostTags.Any())
{
return;
}
var tag = new PostTag
{
Name = "Unknown",
Posts = context.Posts.ToList()
};
context.PostTags.Add(tag);
context.SaveChanges();
}
private void InsertData(ISession session)
{
var users = new List <User>();
for (var i = 0; i < 10; i++)
{
var user = new User {
Username = "******" + i
};
users.Add(user);
session.Insert(user);
}
var blogs = new List <Blog>();
for (var i = 0; i < 10; i++)
{
var blog = new Blog {
Title = "Blog_" + i
};
blogs.Add(blog);
session.Insert(blog);
}
var posts = new List <Post>();
for (var i = 0; i < 20; i++)
{
var userId = i / 2;
var blogId = i / 2;
var post = new Post {
Author = users[userId], Blog = blogs[blogId], Title = "Post_" + i
};
session.Insert(post);
posts.Add(post);
}
for (var i = 0; i < 30; i++)
{
var comment = new Comment {
Post = posts[i / 2], User = users[i / 3], Content = "Comment_" + i
};
session.Insert(comment);
}
var tags = new List <Tag>();
for (var i = 0; i < 20; i++)
{
var tag = new Tag {
Content = "Tag_" + i
};
tags.Add(tag);
session.Insert(tag);
}
for (var i = 0; i < 30; i++)
{
var postTag = new PostTag {
Post = posts[i / 2], Tag = tags[i / 2]
};
session.Insert(postTag);
}
// insert single comment with null User to check that nulls are returned properly
var nullUserComment = new Comment {
Post = posts[0], User = null, Content = "Nullable User Content"
};
session.Insert(nullUserComment);
var nullTag = new Tag {
Content = "Null Post Tag"
};
session.Insert(nullTag);
var nullPostTag = new PostTag {
Tag = nullTag
};
session.Insert(nullPostTag);
// add user for bulk update
session.Insert(new User {
Username = "******", Password = "******"
});
// add users for bulk delete
session.Insert(new User {
Username = "******", Password = "******"
}, new User {
Username = "******", Password = "******"
});
// test delete user
session.Insert(new User {
Username = "******", Password = "******"
});
// test empty collection
session.Insert(new Blog {
Title = "EmptyBlog"
});
// multiple fetch many stuff
session.Insert(new Questionnaire {
Name = "Foo"
});
session.Insert(new Question {
Questionnaire = new Questionnaire {
QuestionnaireId = 1
}, Name = "Bar"
});
session.Insert(new Booking());
session.Insert(new Room {
Name = "Room 1"
});
session.Insert(new RoomSlot {
Room = new Room {
RoomId = 1
}
});
session.Insert(new Bed {
RoomSlot = new RoomSlot {
RoomSlotId = 1
}, Booking = new Booking {
BookingId = 1
}
});
session.Insert(
new QuestionnaireResponse {
Booking = new Booking {
BookingId = 1
}, Questionnaire = new Questionnaire {
QuestionnaireId = 1
}
});
session.Insert(
new QuestionResponse {
Question = new Question {
QuestionId = 1
},
QuestionnaireResponse = new QuestionnaireResponse {
QuestionnaireResponseId = 1
}
});
}
public void Update(PostTag entity)
{
this.tags.Update(entity);
this.tags.Save();
}
public IActionResult Create([FromBody] PostTag postTag)
{
var newPostTage = _postTagService.Add(postTag);
return(CreatedAtRoute("GetPost", new { url = newPostTage.PostTagId }, newPostTage));
}
public async Task <IActionResult> Put(string slug, PostToDb update)
{
var post = await _context.Posts.Where(w => w.Slug == slug).FirstOrDefaultAsync();
if (post == null)
{
return(NotFound());
}
if (!string.IsNullOrEmpty(update.blogPost.Title))
{
var updateSlug = update.blogPost.Title;
RegexOptions options = RegexOptions.None;
Regex regex = new Regex("[ ]{2,}", options);
updateSlug = regex.Replace(updateSlug, " ");
updateSlug = updateSlug.Replace(" ", "_").ToLower();
//post.Slug = updateSlug; -- important rule of EF said that we can't change ID, so I will go in another way
Post p = new Post // create new post with new slug and title
{
Slug = updateSlug,
Body = post.Body, // update.blogPost.Body = maybe is empty so I will update body in next if statement
CreatedAt = post.CreatedAt,
Title = update.blogPost.Title,
Description = post.Description
};
await _context.Posts.AddAsync(p);
var postsTags = _context.PostTags.Include(x => x.Tag).Where(w => w.PostId == slug).ToList(); // all tags related to choosen post
foreach (var postTags in postsTags) // After I created new post, adding tags with new post slug
{
PostTag pT = new PostTag
{
PostId = p.Slug,
TagId = postTags.TagId
};
await _context.PostTags.AddAsync(pT);
}
//then delete post and related tags
var deletePostTags = _context.PostTags.Where(w => w.PostId == slug).ToList(); // find all rows in table PostTags
_context.PostTags.RemoveRange(deletePostTags); // delete all rows with wanted slug
_context.Posts.Remove(post); // last but not least, removing post
post = p; // post is global variable so I can use it further
await _context.SaveChangesAsync();
}
if (!string.IsNullOrEmpty(update.blogPost.Description))
{
post.Description = update.blogPost.Description;
}
if (!string.IsNullOrEmpty(update.blogPost.Body))
{
post.Body = update.blogPost.Body;
}
post.UpdatedAt = DateTime.Now;
_context.Attach(post); //new post is already in database
_context.Update(post);
await _context.SaveChangesAsync(); // update Description and Body if its changed
PostOut postOut = new PostOut
{
BlogPost = new PostOut.Post
{
Slug = post.Slug,
Title = post.Title,
Description = post.Description,
Body = post.Body,
CreatedAt = post.CreatedAt.ToString("yyyy-MM-ddThh:mm:ss.mmmZ"),
UpdatedAt = post.UpdatedAt != null?post.UpdatedAt.Value.ToString("yyyy-MM-ddThh:mm:ss.mmmZ") : "n/a",
Tags = await _context.PostTags.Where(w => w.PostId == post.Slug).Select(x => x.Tag.Name).ToListAsync()
}
};
return(Ok(postOut));
}
public IActionResult DeletePostTag([FromBody] PostTag postTag)
{
_postTagService.Delete(postTag);
return(new NoContentResult());
}
public ActionResult AddTagToPost(PostViewModel model)
{
var post = _blogRepository.GetPostById(model.ID);
var postTags = _blogRepository.GetPostTags(post);
List<string> pTagIds = new List<string>();
foreach (var pTag in postTags)
{
pTagIds.Add(pTag.Id);
}
var newTags = model.Tags.Where(x => x.Checked == true).ToList();
List<string> nTagIds = new List<string>();
foreach (var pTag in newTags)
{
nTagIds.Add(pTag.Id);
}
if (!pTagIds.SequenceEqual(nTagIds))
{
foreach (var pTag in postTags)
{
_blogRepository.RemovePostTags(model.ID, pTag.Id);
}
foreach (var tag in model.Tags)
{
PostTag postTag = new PostTag();
//if (tag.Checked == true)
//{
postTag.PostId = model.ID;
postTag.TagId = tag.Id;
postTag.Checked = true;
_blogRepository.AddPostTags(postTag);
//}
}
_blogRepository.Save();
}
return RedirectToAction("EditPost", new { slug = post.UrlSeo });
}
public static bool ImportPost(wpPost post)
{
Console.WriteLine("Importing post: " + post.Title);
BlogDataDataContext database = new BlogDataDataContext();
string slug = post.Link.Substring(post.Link.IndexOf("http://theprime.co/") + "http://theprime.co/".Length + 2).TrimEnd('/');
Post databasePost = database.Posts.FirstOrDefault(x => x.Slug == slug);
if (databasePost == null)
{
Post newPost = new Post();
newPost.Id = System.Guid.NewGuid();
newPost.Title = post.Title;
newPost.Body = post.Content;
newPost.Author = post.Creator;
newPost.Timestamp = post.PostDate;
if (post.CommentStatus.ToLower() == "enabled")
{
newPost.CommentsEnabled = true;
}
else
{
newPost.CommentsEnabled = false;
}
newPost.Status = post.Status;
newPost.Visibility = "Public";
newPost.Slug = slug;
database.Posts.InsertOnSubmit(newPost);
database.SubmitChanges();
foreach (var category in post.Categories)
{
PostCategoryMap map = new PostCategoryMap();
map.Id = System.Guid.NewGuid();
PostCategory databaseCategory = database.PostCategories.FirstOrDefault(x => x.Slug == category.Slug);
if (databaseCategory == null)
{
PostCategory newCategory = new PostCategory();
newCategory.Id = System.Guid.NewGuid();
newCategory.Slug = category.Slug;
newCategory.Name = category.Name;
database.PostCategories.InsertOnSubmit(newCategory);
map.CategoryId = newCategory.Id;
database.SubmitChanges();
}
else
{
map.CategoryId = databaseCategory.Id;
}
map.PostId = newPost.Id;
database.PostCategoryMaps.InsertOnSubmit(map);
database.SubmitChanges();
}
foreach (var tag in post.Tags)
{
PostTagMap map = new PostTagMap();
map.Id = System.Guid.NewGuid();
PostTag databaseTag = database.PostTags.FirstOrDefault(x => x.Slug == tag.Slug);
if (databaseTag == null)
{
PostTag newTag = new PostTag();
newTag.Id = System.Guid.NewGuid();
newTag.Slug = tag.Slug;
newTag.Name = tag.Name;
database.PostTags.InsertOnSubmit(newTag);
map.TagId = newTag.Id;
database.SubmitChanges();
}
else
{
map.TagId = databaseTag.Id;
}
map.PostId = newPost.Id;
database.PostTagMaps.InsertOnSubmit(map);
database.SubmitChanges();
}
foreach (var comment in post.Comments)
{
PostCommentMap map = new PostCommentMap();
map.Id = System.Guid.NewGuid();
PostComment databaseComment = database.PostComments.FirstOrDefault(x => x.Id == comment.Id);
if (databaseComment == null)
{
PostComment newComment = new PostComment();
newComment.Id = comment.Id;
if (comment.Approved.ToLower() == "true" || comment.Approved.ToLower() == "yes" ||
comment.Approved.ToLower() == "1")
{
newComment.Approved = true;
}
else
{
newComment.Approved = false;
}
newComment.Author = comment.Author;
newComment.AuthorEmail = comment.AuthorEmail;
newComment.AuthorIp = comment.AuthorIp;
newComment.AuthorUrl = comment.AuthorUrl;
newComment.Content = comment.Content;
newComment.Parent = comment.Parent;
newComment.Timestamp = comment.Date;
newComment.Type = comment.Type;
database.PostComments.InsertOnSubmit(newComment);
map.CommentId = newComment.Id;
database.SubmitChanges();
}
else
{
map.CommentId = databaseComment.Id;
}
map.PostId = newPost.Id;
database.PostCommentMaps.InsertOnSubmit(map);
database.SubmitChanges();
}
}
return(true);
}
public ActionResult Dodaj()//tagi, walidacja
{
PostTag nowy_post = new PostTag();
return(View(nowy_post));
}
public async Task <IActionResult> CreatePost([FromForm] PostForCreationDto postForCreationDto)
{
var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var userFromRepo = await _repo.GetUser(userId);
var postToCreate = new Post();
postToCreate.Title = postForCreationDto.Title;
postToCreate.Description = postForCreationDto.Description;
postToCreate.Category = postForCreationDto.Category;
postToCreate.Links = postForCreationDto.Links;
postToCreate.Created = postForCreationDto.Created;
postToCreate.Updated = postForCreationDto.Updated;
// var postToCreate = _mapper.Map<Post>(postForCreationDto);
userFromRepo.Posts.Add(postToCreate);
// _repo.Add<Post>(postToCreate);
await _repo.SaveAll();
var postFromRepo = await _repo.GetPost(postToCreate.Id);
var tags = postForCreationDto.Tags.Split(",");
for (int i = 0; i < tags.Length; i++)
{
var tag = await _repo.GetTag(tags[i]);
if (tag == null)
{
tag = new Tag {
Value = tags[i]
};
_repo.Add(tag);
await _repo.SaveAll();
// tag = await _repo.GetTag(tags[i]);
}
var postTag = new PostTag {
PostId = postFromRepo.Id,
TagId = tag.Id
};
postFromRepo.Tags.Add(postTag);
}
var files = new IFormFile[] {
postForCreationDto.Image1,
postForCreationDto.Image2,
postForCreationDto.Image3,
postForCreationDto.Image4,
postForCreationDto.Image5
};
for (int i = 0; i < files.Length; i++)
{
var file = files[i];
if (file == null || file.Length <= 0)
{
continue;
}
var uploadResult = new ImageUploadResult();
using (var stream = file.OpenReadStream())
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation().Width(500).Height(500).Crop("fill").Gravity("face")
};
uploadResult = _cloudinary.Upload(uploadParams);
}
var postImage = new PostImage();
postImage.DateAdded = DateTime.Now;
postImage.Url = uploadResult.Uri.ToString();
postImage.PublicId = uploadResult.PublicId;
// _repo.Add<PostImage>(postImageToCreate);
if (i == postForCreationDto.MainImage)
{
postImage.IsMain = true;
}
postFromRepo.PostImages.Add(postImage);
}
// if(userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
// return Unauthorized();
// var userFromRepo = await _repo.GetUser(userId);
// var file = postForCreationDto.Image1;
// var uploadResult = new ImageUploadResult();
// if(file.Length > 0){
// using (var stream = file.OpenReadStream())
// {
// var uploadParams = new ImageUploadParams()
// {
// File = new FileDescription(file.Name, stream),
// Transformation = new Transformation().Width(500).Height(500).Crop("fill").Gravity("face")
// };
// uploadResult = _cloudinary.Upload(uploadParams);
// }
// }
// postForCreationDto.Url = uploadResult.Uri.ToString();
// postForCreationDto.PublicId = uploadResult.PublicId;
// var postImage = _mapper.Map<PostImage>(postImageForCreationDto);
// if (!userFromRepo.Photos.Any(u=>u.IsMain))
// photo.IsMain = true;
// postImage.PostId = 0;
// userFromRepo.Photos.Add(photo);
// _repo.Add<PostImage>(postImage);
if (await _repo.SaveAll())
{
var postToReturn = _mapper.Map <PostForDetailsDto>(postToCreate);
return(CreatedAtRoute("GetPost", new { controller = "Posts", id = postToCreate.Id }, postToReturn));
}
return(BadRequest("Failed to create post."));
}
public PostTag Add(PostTag postTag)
{
_postTagDal.Add(postTag);
return(postTag);
}
public async Task <IActionResult> UpdatePost(int id, [FromForm] PostForUpdateDto postForUpdateDto)
{
var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var user = await _repo.GetUser(userId);
if (!user.Posts.Any(p => p.Id == id))
{
return(Unauthorized());
}
var postFromRepo = await _repo.GetPost(id);
// var postToCreate = new Post();
postFromRepo.Title = postForUpdateDto.Title;
postFromRepo.Description = postForUpdateDto.Description;
postFromRepo.Category = postForUpdateDto.Category;
// postFromRepo.Tags = postForUpdateDto.Tags;
postFromRepo.Links = postForUpdateDto.Links;
postFromRepo.Updated = postForUpdateDto.Updated;
var newTags = postForUpdateDto.Tags.Split(",").ToList();
foreach (var oldTag in postFromRepo.Tags)
{
var index = newTags.IndexOf(oldTag.Tag.Value);
if (index == -1)
{
_repo.Delete(oldTag);
}
else
{
newTags.RemoveAt(index);
}
}
foreach (var newTag in newTags)
{
var tag = await _repo.GetTag(newTag);
if (tag == null)
{
tag = new Tag {
Value = newTag
};
_repo.Add(tag);
await _repo.SaveAll();
}
var postTag = new PostTag {
PostId = postFromRepo.Id,
TagId = tag.Id
};
postFromRepo.Tags.Add(postTag);
}
var postOldMainImage = await _repo.GetPostMainImage(id);
if (postOldMainImage != null && postOldMainImage.Id != -postForUpdateDto.MainImage)
{
postOldMainImage.IsMain = false;
if (postForUpdateDto.MainImage < 0)
{
var postImageFromRepo = await _repo.GetPostImage(-postForUpdateDto.MainImage);
postImageFromRepo.IsMain = true;
}
}
if (postForUpdateDto.DeletedImages != null)
{
var deletedImageIds = postForUpdateDto.DeletedImages.Split(",");
for (int i = 0; i < deletedImageIds.Length; i++)
{
int postImageId = Int32.Parse(deletedImageIds[i]);
if (!postFromRepo.PostImages.Any(p => p.Id == postImageId))
{
return(BadRequest("Failed to update post."));
}
var postImageFromRepo = await _repo.GetPostImage(postImageId);
if (postImageFromRepo.PublicId != null)
{
var deleteParams = new DeletionParams(postImageFromRepo.PublicId);
var result = _cloudinary.Destroy(deleteParams);
if (result.Result == "ok")
{
_repo.Delete(postImageFromRepo);
}
}
else
{
_repo.Delete(postImageFromRepo);
}
}
}
var files = new IFormFile[] {
postForUpdateDto.AddedImage1,
postForUpdateDto.AddedImage2,
postForUpdateDto.AddedImage3,
postForUpdateDto.AddedImage4
};
for (int i = 0; i < files.Length; i++)
{
var file = files[i];
if (file == null || file.Length <= 0)
{
continue;
}
var uploadResult = new ImageUploadResult();
using (var stream = file.OpenReadStream())
{
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(file.Name, stream),
Transformation = new Transformation().Width(500).Height(500).Crop("fill").Gravity("face")
};
uploadResult = _cloudinary.Upload(uploadParams);
}
var postImage = new PostImage();
postImage.DateAdded = DateTime.Now;
postImage.Url = uploadResult.Uri.ToString();
postImage.PublicId = uploadResult.PublicId;
// _repo.Add<PostImage>(postImageToCreate);
if (i == postForUpdateDto.MainImage)
{
postImage.IsMain = true;
}
postFromRepo.PostImages.Add(postImage);
}
// await _repo.SaveAll();
// if(userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
// return Unauthorized();
// var userFromRepo = await _repo.GetUser(userId);
// var file = postForCreationDto.Image1;
// var uploadResult = new ImageUploadResult();
// if(file.Length > 0){
// using (var stream = file.OpenReadStream())
// {
// var uploadParams = new ImageUploadParams()
// {
// File = new FileDescription(file.Name, stream),
// Transformation = new Transformation().Width(500).Height(500).Crop("fill").Gravity("face")
// };
// uploadResult = _cloudinary.Upload(uploadParams);
// }
// }
// postForCreationDto.Url = uploadResult.Uri.ToString();
// postForCreationDto.PublicId = uploadResult.PublicId;
// var postImage = _mapper.Map<PostImage>(postImageForCreationDto);
// if (!userFromRepo.Photos.Any(u=>u.IsMain))
// photo.IsMain = true;
// postImage.PostId = 0;
// userFromRepo.Photos.Add(photo);
// _repo.Add<PostImage>(postImage);
if (await _repo.SaveAll())
{
var postToReturn = _mapper.Map <PostForDetailsDto>(postFromRepo);
return(CreatedAtRoute("GetPost", new { controller = "Posts", id = postFromRepo.Id }, postToReturn));
}
return(BadRequest("Failed to create post."));
}
public PostTag Update(PostTag postTag)
{
_postTagDal.Update(postTag);
return(postTag);
}
public void AddPostTag(PostTag postTag)
{
_context.Add(postTag);
_context.SaveChanges();
}
/// <summary>
/// Saves the given post model
/// </summary>
/// <param name="model">The post model</param>
/// <param name="isDraft">If the model should be saved as a draft</param>
private async Task Save <T>(T model, bool isDraft) where T : Models.PostBase
{
var type = App.PostTypes.GetById(model.TypeId);
var lastModified = DateTime.MinValue;
if (type != null)
{
// Ensure category
var category = await _db.Categories
.FirstOrDefaultAsync(c => c.Id == model.Category.Id)
.ConfigureAwait(false);
if (category == null)
{
if (!string.IsNullOrWhiteSpace(model.Category.Slug))
{
category = await _db.Categories
.FirstOrDefaultAsync(c => c.BlogId == model.BlogId && c.Slug == model.Category.Slug)
.ConfigureAwait(false);
}
if (category == null && !string.IsNullOrWhiteSpace(model.Category.Title))
{
category = await _db.Categories
.FirstOrDefaultAsync(c => c.BlogId == model.BlogId && c.Title == model.Category.Title)
.ConfigureAwait(false);
}
if (category == null)
{
category = new Category
{
Id = model.Category.Id != Guid.Empty ? model.Category.Id : Guid.NewGuid(),
BlogId = model.BlogId,
Title = model.Category.Title,
Slug = Utils.GenerateSlug(model.Category.Title),
Created = DateTime.Now,
LastModified = DateTime.Now
};
await _db.Categories.AddAsync(category).ConfigureAwait(false);
}
model.Category.Id = category.Id;
model.Category.Title = category.Title;
model.Category.Slug = category.Slug;
}
// Ensure tags
foreach (var t in model.Tags)
{
var tag = await _db.Tags
.FirstOrDefaultAsync(tg => tg.Id == t.Id)
.ConfigureAwait(false);
if (tag == null)
{
if (!string.IsNullOrWhiteSpace(t.Slug))
{
tag = await _db.Tags
.FirstOrDefaultAsync(tg => tg.BlogId == model.BlogId && tg.Slug == t.Slug)
.ConfigureAwait(false);
}
if (tag == null && !string.IsNullOrWhiteSpace(t.Title))
{
tag = await _db.Tags
.FirstOrDefaultAsync(tg => tg.BlogId == model.BlogId && tg.Title == t.Title)
.ConfigureAwait(false);
}
if (tag == null)
{
tag = new Tag
{
Id = t.Id != Guid.Empty ? t.Id : Guid.NewGuid(),
BlogId = model.BlogId,
Title = t.Title,
Slug = Utils.GenerateSlug(t.Title),
Created = DateTime.Now,
LastModified = DateTime.Now
};
await _db.Tags.AddAsync(tag).ConfigureAwait(false);
}
t.Id = tag.Id;
}
t.Title = tag.Title;
t.Slug = tag.Slug;
}
// Ensure that we have a slug
if (string.IsNullOrWhiteSpace(model.Slug))
{
model.Slug = Utils.GenerateSlug(model.Title, false);
}
else
{
model.Slug = Utils.GenerateSlug(model.Slug, false);
}
IQueryable <Post> postQuery = _db.Posts;
if (isDraft)
{
postQuery = postQuery.AsNoTracking();
}
var post = await postQuery
.Include(p => p.Permissions)
.Include(p => p.Blocks).ThenInclude(b => b.Block).ThenInclude(b => b.Fields)
.Include(p => p.Fields)
.Include(p => p.Tags).ThenInclude(t => t.Tag)
.FirstOrDefaultAsync(p => p.Id == model.Id)
.ConfigureAwait(false);
// If not, create a new post
if (post == null)
{
post = new Post
{
Id = model.Id != Guid.Empty ? model.Id : Guid.NewGuid(),
Created = DateTime.Now,
LastModified = DateTime.Now
};
model.Id = post.Id;
if (!isDraft)
{
await _db.Posts.AddAsync(post).ConfigureAwait(false);
}
}
else
{
post.LastModified = DateTime.Now;
}
post = _contentService.Transform <T>(model, type, post);
// Set if comments should be enabled
post.EnableComments = model.EnableComments;
post.CloseCommentsAfterDays = model.CloseCommentsAfterDays;
// Update permissions
post.Permissions.Clear();
foreach (var permission in model.Permissions)
{
post.Permissions.Add(new PostPermission
{
PostId = post.Id,
Permission = permission
});
}
// Make sure foreign key is set for fields
if (!isDraft)
{
foreach (var field in post.Fields)
{
if (field.PostId == Guid.Empty)
{
field.PostId = post.Id;
await _db.PostFields.AddAsync(field).ConfigureAwait(false);
}
}
}
if (isDraft)
{
post.Category = new Category
{
Id = model.Category.Id,
BlogId = model.BlogId,
Title = model.Category.Title,
Slug = model.Category.Slug
};
}
// Transform blocks
var blockModels = model.Blocks;
if (blockModels != null)
{
var blocks = _contentService.TransformBlocks(blockModels);
var current = blocks.Select(b => b.Id).ToArray();
// Delete removed blocks
var removed = post.Blocks
.Where(b => !current.Contains(b.BlockId) && !b.Block.IsReusable && b.Block.ParentId == null)
.Select(b => b.Block);
var removedItems = post.Blocks
.Where(b => !current.Contains(b.BlockId) && b.Block.ParentId != null && removed.Select(p => p.Id).ToList().Contains(b.Block.ParentId.Value))
.Select(b => b.Block);
if (!isDraft)
{
_db.Blocks.RemoveRange(removed);
_db.Blocks.RemoveRange(removedItems);
}
// Delete the old page blocks
post.Blocks.Clear();
// Now map the new block
for (var n = 0; n < blocks.Count; n++)
{
IQueryable <Block> blockQuery = _db.Blocks;
if (isDraft)
{
blockQuery = blockQuery.AsNoTracking();
}
var block = blockQuery
.Include(b => b.Fields)
.FirstOrDefault(b => b.Id == blocks[n].Id);
if (block == null)
{
block = new Block
{
Id = blocks[n].Id != Guid.Empty ? blocks[n].Id : Guid.NewGuid(),
Created = DateTime.Now
};
if (!isDraft)
{
await _db.Blocks.AddAsync(block).ConfigureAwait(false);
}
}
block.ParentId = blocks[n].ParentId;
block.CLRType = blocks[n].CLRType;
block.IsReusable = blocks[n].IsReusable;
block.Title = blocks[n].Title;
block.LastModified = DateTime.Now;
var currentFields = blocks[n].Fields.Select(f => f.FieldId).Distinct();
var removedFields = block.Fields.Where(f => !currentFields.Contains(f.FieldId));
if (!isDraft)
{
_db.BlockFields.RemoveRange(removedFields);
}
foreach (var newField in blocks[n].Fields)
{
var field = block.Fields.FirstOrDefault(f => f.FieldId == newField.FieldId);
if (field == null)
{
field = new BlockField
{
Id = newField.Id != Guid.Empty ? newField.Id : Guid.NewGuid(),
BlockId = block.Id,
FieldId = newField.FieldId
};
if (!isDraft)
{
await _db.BlockFields.AddAsync(field).ConfigureAwait(false);
}
block.Fields.Add(field);
}
field.SortOrder = newField.SortOrder;
field.CLRType = newField.CLRType;
field.Value = newField.Value;
}
// Create the post block
var postBlock = new PostBlock
{
Id = Guid.NewGuid(),
BlockId = block.Id,
Block = block,
PostId = post.Id,
SortOrder = n
};
if (!isDraft)
{
await _db.PostBlocks.AddAsync(postBlock).ConfigureAwait(false);
}
post.Blocks.Add(postBlock);
}
}
// Remove tags
var removedTags = new List <PostTag>();
foreach (var tag in post.Tags)
{
if (!model.Tags.Any(t => t.Id == tag.TagId))
{
removedTags.Add(tag);
}
}
foreach (var removed in removedTags)
{
post.Tags.Remove(removed);
}
// Add tags
foreach (var tag in model.Tags)
{
if (!post.Tags.Any(t => t.PostId == post.Id && t.TagId == tag.Id))
{
var postTag = new PostTag
{
PostId = post.Id,
TagId = tag.Id
};
if (isDraft)
{
postTag.Tag = new Tag
{
Id = tag.Id,
BlogId = post.BlogId,
Title = tag.Title,
Slug = tag.Slug
};
}
post.Tags.Add(postTag);
}
}
if (!isDraft)
{
await _db.SaveChangesAsync().ConfigureAwait(false);
await DeleteUnusedCategories(model.BlogId).ConfigureAwait(false);
await DeleteUnusedTags(model.BlogId).ConfigureAwait(false);
}
else
{
var draft = await _db.PostRevisions
.FirstOrDefaultAsync(r => r.PostId == post.Id && r.Created > lastModified)
.ConfigureAwait(false);
if (draft == null)
{
draft = new PostRevision
{
Id = Guid.NewGuid(),
PostId = post.Id
};
await _db.PostRevisions
.AddAsync(draft)
.ConfigureAwait(false);
}
draft.Data = JsonConvert.SerializeObject(post);
draft.Created = post.LastModified;
await _db.SaveChangesAsync().ConfigureAwait(false);
}
}
}
/// <summary>
/// Delete a PostTag by compound key
/// </summary>
/// <param name="postTag">Compound Key</param>
public void Delete(PostTag postTag)
{
_postTagRepository.RemoveByCompound(Mapper.Map <PostTag, PostTagEntity>(postTag));
}
public async Task <IActionResult> Create(PostViewModel model) //создание поста
{
if (ModelState.IsValid)
{
Post post = new Post(); //создаём модель
post.PostName = model.Name;
post.CategoryId = model.Cat;
post.content = model.Text; //кладём данные из входной модели
post.PostDescr = TruncBody(post.content); //обрезаем текст лоя создания првеью
ClaimsPrincipal currentUser = this.User;
var currentUserID = currentUser.FindFirst(ClaimTypes.NameIdentifier).Value;
post.UserId = currentUserID; //автором ставим текущего пользователя
post.PostDate = DateTime.Now; //дата тоже текущая
string postslug = Slugifier.Transliterate(post.PostName); //создаётся slug-ссылка
postslug = Slugifier.Slugify(postslug);
post.PostSlug = postslug;
String[] rawtags = model.Tags.Split(','); //входная строка тегов разбивается запятыми на отдельные теги
_context.Add(post); //пост добавлне, работаем с тегами
await _context.SaveChangesAsync();
var addedpost = await _context.Posts.SingleOrDefaultAsync(m => m.PostSlug == postslug); //находим id нового поста
addedpost.PostSlug += "-" + addedpost.PostID.ToString(); //уникальность слагов
_context.Update(addedpost);
int redir = addedpost.PostID;
foreach (string separtag in rawtags) //добавление, если необходимо, тегов
{
string tagname;
if (separtag.Substring(0, 1) == " ") //Обрезает первый пробел
{
tagname = separtag.Substring(1, separtag.Length - 1);
}
else
{
tagname = separtag; //сохраняем имя тега
}
string tagtoadd = Slugifier.Transliterate(tagname);
tagtoadd = Slugifier.Slugify(tagtoadd); //подготовка слага
var tag = await _context.Tags.SingleOrDefaultAsync(m => m.TagSlug == tagtoadd);
int tagid;
if (tag == null) //добавление тега
{
Tag added = new Tag();
added.TagName = tagname;
added.TagSlug = tagtoadd;
_context.Tags.Add(added);
await _context.SaveChangesAsync();
var addedtag = await _context.Tags.SingleOrDefaultAsync(m => m.TagSlug == tagtoadd);
tagid = addedtag.TagId;
}
else
{
tagid = tag.TagId;
}
PostTag link = new PostTag(); //добавление связи "тег-пост"
link.PostId = addedpost.PostID;
link.TagId = tagid;
_context.PostTags.Add(link);
await _context.SaveChangesAsync();
//addedpost.PostTags.Add(link);
//_context.Posts.Update(addedpost);
//await _context.SaveChangesAsync();
}
var Cat = _context.Categories.SingleOrDefault(p => p.CategoryId == model.Cat);
Cat.postcount++; //увеличиваем количество постов в категории, к которой принадлежит данный пост
_context.Update(Cat);
await _context.SaveChangesAsync();
return(Redirect("/Comments/viewpost/" + redir));
}
ViewData["CategoryId"] = new SelectList(_context.Categories, "CategoryId", "CatName", model.Cat);
return(View(model));
}
public async Task <IActionResult> EditPost(int id, PostDTO data)
{
var postUser = await model.Users.FindAsync(data.AuthorId);
if (postUser == null)
{
return(NotFound("le postUser n'existe pas"));
}
var currentUser = await model.Users.SingleOrDefaultAsync(u => u.Pseudo == User.Identity.Name);
if (currentUser == null)
{
return(NotFound("L'utilisateur connecté n'existe pas"));
}
var post = await model.Posts.FindAsync(id);
if (post == null)
{
return(NotFound("Le post n'existe pas"));
}
if (currentUser.Id == postUser.Id || currentUser.Role == Role.Admin)
{
post.Title = data.Title;
post.Body = data.Body;
if (data.Tags != null)
{
while (model.PostTags.Where(pt => pt.PostId == id).Count() != 0)
{
var postTag = await model.PostTags.FirstOrDefaultAsync(p => p.PostId == id);
model.PostTags.Remove(postTag);
await model.SaveChangesAsyncWithValidation();
}
foreach (var t in data.Tags)
{
var tag = await model.Tags.SingleOrDefaultAsync(p => p.Name == t);
var newPostTag = new PostTag()
{
PostId = id,
TagId = tag.Id
};
post.PostTags.Add(newPostTag);
model.Entry(post).State = EntityState.Modified;
}
}
await model.SaveChangesAsyncWithValidation();
}
else
{
return(NotFound("You are not the owner of this post !"));
}
return(NoContent());
}
public void Create(PostTag entity)
{
this.tags.Create(entity);
this.tags.Save();
}
public async Task <CreatePostCommandVm> Handle(CreatePostCommand request, CancellationToken cancellationToken)
{
Guid.TryParse(request.DocumentGuid, out Guid DocumentGuid);
if (DocumentGuid == Guid.Empty)
{
return new CreatePostCommandVm
{
Message = "تصویر آپلود شده شناسایی نشد",
State = (int)CreatePostState.DocumentGuidProblem
}
}
;
var currentUser = await _context.User
.Where(x => x.UserGuid == Guid.Parse(_currentUser.NameIdentifier))
.SingleOrDefaultAsync(cancellationToken);
if (currentUser == null)
{
return(new CreatePostCommandVm()
{
Message = "کاربر مورد نظر یافت نشد",
State = (int)CreatePostState.UserNotFound
});
}
var document = await _context.Document
.SingleOrDefaultAsync(x => x.DocumentGuid == DocumentGuid, cancellationToken);
if (document == null)
{
return(new CreatePostCommandVm()
{
Message = "تصویر مورد نظر یافت نشد",
State = (int)CreatePostState.DocumentNotFound
});
}
var post = new Post
{
UserId = currentUser.UserId,
Title = request.Title,
Abstract = request.Abstract,
Description = request.Description,
IsShow = request.IsShow,
IsInSlider = request.IsInSlider,
IsSuggested = request.IsSuggested,
DocumentId = document.DocumentId
};
if (request.Categories != null)
{
foreach (var categoryGuid in request.Categories)
{
var category = await _context.Category
.Where(x => x.CategoryGuid == categoryGuid)
.SingleOrDefaultAsync(cancellationToken);
if (category == null)
{
continue;
}
var postCategory = new PostCategory()
{
Post = post,
CategoryId = category.CategoryId
};
_context.PostCategory.Add(postCategory);
}
}
if (request.Tags != null)
{
PostTag postTag;
foreach (var tag in request.Tags)
{
Guid.TryParse(tag, out Guid guid);
if (guid == Guid.Empty)
{
var newTag = new Tag()
{
Name = tag
};
_context.Tag.Add(newTag);
postTag = new PostTag()
{
Post = post
};
postTag.Tag = newTag;
}
else
{
var t = await _context.Tag
.Where(x => x.TagGuid == Guid.Parse(tag))
.SingleOrDefaultAsync(cancellationToken);
if (t == null)
{
continue;
}
postTag = new PostTag()
{
Post = post,
TagId = t.TagId
};
}
_context.PostTag.Add(postTag);
}
}
_context.Post.Add(post);
await _context.SaveChangesAsync(cancellationToken);
return(new CreatePostCommandVm()
{
Message = "عملیات موفق آمیز",
State = (int)CreatePostState.Success
});
}
}
public void Delete(PostTag entity)
{
this.tags.Delete(entity);
this.tags.Save();
}
public async Task AddAsync(PostTag entity)
{
await Uow.RegisterNewAsync(entity);
await Uow.CommitAsync();
}
