public ActionResult Add(PostEditModel postEditModel)
{
if (!ModelState.IsValid)
return View("Edit", postEditModel);
this.Repository.AddPost(postEditModel.Post);
return RedirectToAction("Index", new { Id = postEditModel.Post.PostId });
}
public ActionResult Edit(PostEditModel postEditModel)
{
if (!ModelState.IsValid)
return View("Edit", postEditModel);
var originalPostPoco = WebUtils.Utils.FromJson<Post>(postEditModel.OriginalPostSerialized);
this.Repository.UpdatePost(originalPostPoco, postEditModel.Post);
return RedirectToAction("Index", new { Id = postEditModel.Post.PostId });
}
public ActionResult Add()
{
var postEditModel = new PostEditModel()
{
AllTags = AppCache.Tags.ToArray(),
Post = new Post(),
OriginalPostSerialized = null
};
return View("Edit", postEditModel);
}
public ActionResult Edit(int postId)
{
var post = this.Repository.GetPost(postId, true);
if (post == null)
return HttpNotFound("Post ID '{0}' was not found".FormatEx(postId));
var postPoco = (Post) post;
var postEditModel = new PostEditModel()
{
AllTags = AppCache.Tags.ToArray(),
Post = postPoco,
OriginalPostSerialized = WebUtils.Utils.ToJson(postPoco)
};
return View(postEditModel);
}
public async Task <ActionResult> CopyPost(ObjectId id)
{
SetTitle("Copy bài viết");
var post = await _blogService.GetByIdAsync(id);
if (post == null)
{
return(NotFound());
}
post.Id = ObjectId.GenerateNewId();
var model = new PostEditModel
{
Entity = _mapper.Map <PostModel>(post)
};
await PopulatePostDetailPageAsync(model);
return(View("PostDetail", model));
}
public ActionResult Edit(int postId)
{
var post = this.Repository.GetPost(postId, true);
if (post == null)
{
return(HttpNotFound("Post ID '{0}' was not found".FormatEx(postId)));
}
var postPoco = (Post)post;
var postEditModel = new PostEditModel()
{
AllTags = AppCache.Tags.ToArray(),
Post = postPoco,
OriginalPostSerialized = WebUtils.Utils.ToJson(postPoco)
};
return(View(postEditModel));
}
public IActionResult Edit(int id)
{
var post = _postService.GetById(id);
if (post != null)
{
var model = new PostEditModel
{
Content = post.Content,
AuthorName = post.User.UserName,
Created = post.Created,
TopicTitle = post.Topic.Title,
TopicId = post.Topic.Id
};
return(View(model));
}
return(RedirectToAction("Index", "Forum"));
}
public async Task <ReturnValue> Save(PostEditModel postEditModel)
{
logger.LogDebug("PostService > Save(PostEditModel: {0})", postEditModel.ToString());
var returnValue = new ReturnValue($"Post '{postEditModel.Title}' saved.");
try
{
if (postEditModel.IsNew)
{
logger.LogDebug("New post");
var post = postEditModel.MapToModel();
post.WebsiteId = Instance.Id;
await PrepareRelatedPropertiesAsync(postEditModel, post);
await unitOfWork.Posts.Insert(post);
}
else
{
logger.LogDebug("Update post");
var post = postEditModel.MapToModel(await unitOfWork.Posts.GetForSavingById(postEditModel.VanityId));
post.WebsiteId = Instance.Id;
_unitOfWork.Posts.RemoveRelatedItems(post);
await PrepareRelatedPropertiesAsync(postEditModel, post);
_unitOfWork.Posts.Update(post);
}
await _unitOfWork.Save();
logger.LogDebug("Post saved");
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
returnValue.SetErrorMessage("An error has occurred while saving the post");
}
return(returnValue);
}
public async Task <PostEditModel> EditAsync([FromBody] PostEditModel model)
{
if (model.Id > 0)
{
var entity = await _postService.GetByIdAsync(model.Id, new PostIncludeOptions()
{
IncludeTags = true,
IncludeCategory = true,
});
if (entity == null)
{
return(null);
}
entity = _postFactory.ToEntity(model, entity);
var categories = await GetPostCategoriesAsync(entity, model);
var tags = await GetPostTagsAsync(entity, model);
await _postService.UpdateAsync(entity, categories, tags);
}
else
{
var entity = _postFactory.ToEntity(model);
var categories = await GetPostCategoriesAsync(entity, model);
var tags = await GetPostTagsAsync(entity, model);
entity.Categories = categories.ToList();
entity.Tags = tags.ToList();
await _postService.InsertAsync(entity);
model.Id = entity.Id;
}
return(model);
}
private async Task PrepareRelatedPropertiesAsync(PostEditModel postEditModel, Post post)
{
post.PostCategories.Clear();
if (postEditModel.SelectedCategories != null)
{
var categoryIds = await _unitOfWork.Categories.GetIdsByMultipleGuidsAsync(postEditModel.SelectedCategories.ToList().ConvertAll(Guid.Parse));
foreach (int categoryId in categoryIds)
{
post.PostCategories.Add(new PostCategory
{
PostId = post.Id,
CategoryId = categoryId
});
}
}
post.PostTags.Clear();
if (postEditModel.SelectedTags != null)
{
var tagIds = await _unitOfWork.Tags.GetIdsByMultipleGuidsAsync(postEditModel.SelectedTags.ToList().ConvertAll(Guid.Parse));
foreach (int tagId in tagIds)
{
post.PostTags.Add(new PostTag
{
PostId = post.Id,
TagId = tagId
});
}
}
var user = await GetCurrentUserAsync();
post.PostApplicationUsers.Clear();
post.PostApplicationUsers.Add(new PostApplicationUser
{
PostId = post.Id,
ApplicationUserId = user.Id
});
}
public IActionResult Create(PostEditModel model)
{
if (ModelState.IsValid)
{
var newPost = new Post
{
TitleOfPost = model.TitleOfPost,
DescriptionOfPost = model.DescriptionOfPost,
Tags = model.Tags
};
newPost = _postData.Add(newPost);
return(RedirectToAction(nameof(Details), new { id = newPost.Id }));
}
else
{
return(View());
}
}
public PostEditModel GetById(int id)
{
var post = _db.BlogPosts.SingleIncluded(p => p.Id == id).Result;
if (id < 1)
{
post = _db.BlogPosts.SingleIncluded(p => p.Profile.IdentityName == User.Identity.Name).Result;
}
var model = new PostEditModel
{
Id = post.Id,
Slug = post.Slug,
Title = post.Title,
Content = post.Content,
Published = post.Published,
Image = post.Image,
Categories = _db.Categories.PostCategories(post.Id)
};
return(model);
}
public ActionResult Edit(int?id)
{
ViewBag.Categories = new SelectList(repo.GetCategories(), "Category");
if (id == null)
{
return(HttpNotFound());
}
int b = (int)id;
PostDTO postDto = repo.GetPost(b);
PostEditModel post = Mapper.Map <PostDTO, PostEditModel>(postDto);
if (post != null)
{
return(View(post));
}
return(HttpNotFound());
}
public IActionResult Edit(string id)
{
var existsPost = this.postsService
.Exists(x => x.Id == id);
if (!existsPost)
{
return(this.NotFound());
}
var post = new PostEditModel()
{
Id = id,
PostInput = this.postsService
.GetSingle <PostInputModel>(x => x.Id == id),
};
this.SetSelectListItems(post);
return(this.View(post));
}
public async Task <ActionResult> EditPost(ObjectId id)
{
SetTitle("Cập nhật bài viết");
var post = await _blogService.GetByIdAsync(id);
if (post == null)
{
return(NotFound());
}
var model = new PostEditModel
{
Entity = _mapper.Map <PostModel>(post),
IsEdit = true
};
model.Entity.PostUrl = $"https://{Request.Host}/blog/{model.Entity.Slug}";
await PopulatePostDetailPageAsync(model);
return(View("PostDetail", model));
}
private async Task <PostEditModel> GetCreatePostModelAsync()
{
var view = new PostEditModel
{
PostId = Guid.NewGuid(),
IsPublished = true,
EnableComment = true,
ExposedToSiteMap = true,
FeedIncluded = true
};
var catList = await _categoryService.GetAllCategoriesAsync();
if (null != catList.Item && catList.Item.Any())
{
var cbCatList = catList.Item.Select(p =>
new CheckBoxViewModel(p.DisplayName, p.Id.ToString(), false)).ToList();
view.CategoryList = cbCatList;
}
return(view);
}
/// <summary>
/// Saves the given model
/// </summary>
/// <param name="model">The model</param>
/// <param name="draft">If the page should be saved as a draft</param>
/// <returns>The result of the operation</returns>
private async Task <PostEditModel> Save(PostEditModel model, bool draft = false)
{
try
{
await _service.Save(model, draft);
}
catch (ValidationException e)
{
model.Status = new StatusMessage
{
Type = StatusMessage.Error,
Body = e.Message
};
return(model);
}
/*
* catch
* {
* return new StatusMessage
* {
* Type = StatusMessage.Error,
* Body = "An error occured while saving the page"
* };
* }
*/
var ret = await _service.GetById(model.Id);
ret.Status = new StatusMessage
{
Type = StatusMessage.Success,
Body = draft ? _localizer.Post["The post was successfully saved"]
: string.IsNullOrEmpty(model.Published) ? _localizer.Post["The post was successfully unpublished"] : _localizer.Page["The post was successfully published"]
};
return(ret);
}
public async Task <ActionResult> EditAsync(PostEditModel model, HttpPostedFileBase image = null)
{
if (ModelState.IsValid)
{
if (image != null)
{
model.ImageMimeType = image.ContentType;
model.ImageData = new byte[image.ContentLength];
model.WrittenDate = DateTime.Now;
model.ShortDescription = model.Text.Substring(0, 500);
model.AuthorId = Convert.ToInt32(Session["user"]);
image.InputStream.Read(model.ImageData, 0, image.ContentLength);
}
await _dbContext.SavePostAsync(model);
return(RedirectToAction("Index"));
}
else
{
return(View(model));
}
}
public PostEditModel GetById(int id)
{
if (id < 1)
{
return(new PostEditModel());
}
var profile = GetProfile();
var post = _db.BlogPosts.SingleIncluded(p => p.Id == id).Result;
// its possible that there are no posts
if (post == null)
{
return(null);
}
var postImg = post.Image == null ? profile.Image : post.Image;
if (string.IsNullOrEmpty(postImg))
{
postImg = ApplicationSettings.PostImage;
}
var model = new PostEditModel
{
Id = post.Id,
Slug = post.Slug,
Title = post.Title,
Content = post.Content,
Published = post.Published,
Image = postImg,
PostViews = post.PostViews,
Categories = _db.Categories.PostCategories(post.Id)
};
return(model);
}
public async Task <PostEditModel> CreateNewEditModelAsync(Post post, PersonView person)
{
if (post == null)
{
throw new ArgumentNullException(nameof(post));
}
PostEditModel model = await CreateNewEditModelAsync(post.PostType, person);
using (var work = this.dbFactory.StartWork())
{
List <Tag> tags = await work.PostTag.GetTagsByPostAsync(post);
PostData postData = await work.PostData.GetPostDataAsync(post);
model.Content = postData.HtmlContent;
model.Title = post.Title;
model.TopicId = post.TopicId;
model.Id = post.Id;
model.UseTags = work.Tag.ToStringList(tags);
model.UseTagSelectItems = work.Tag.ToSelectListItems(tags);
}
return(model);
}
public async Task <IActionResult> Create()
{
var view = new PostEditModel
{
IsPublished = false,
Featured = false,
EnableComment = true,
ExposedToSiteMap = true,
FeedIncluded = true,
LanguageCode = _blogConfig.ContentSettings.DefaultLangCode
};
var cats = await _catService.GetAll();
if (cats.Count > 0)
{
var cbCatList = cats.Select(p =>
new CheckBoxViewModel(p.DisplayName, p.Id.ToString(), false));
view.CategoryList = cbCatList;
}
return(View("CreateOrEdit", view));
}
protected async Task <IEnumerable <PostTags> > GetPostTagsAsync(Post post, PostEditModel model)
{
if (model.Tags?.Any() == true)
{
var tags = new List <Tags>();
foreach (var item in model.Tags)
{
var tag = await _tagsService.GetOrCreateAsync(item);
tags.Add(tag);
}
var newList = tags.Select(t => new PostTags()
{
TagsId = t.Id,
PostId = post.Id,
});
return(newList);
}
return(Enumerable.Empty <PostTags>());
}
public ActionResult Edit(PostEditModel model)
{
if (model != null && this.ModelState.IsValid)
{
var userId = this.User.Identity.GetUserId();
var post = this.Data.Posts.GetById(model.Id);
if (post.AuthorId != userId)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
post.Title = model.Title;
post.Content = model.Content;
this.Data.Posts.Update(post);
this.Data.SaveChanges();
return(this.RedirectToAction("Details", "Posts", new { area = string.Empty, id = post.Id }));
}
return(this.View(model));
}
public Task <bool> EditPostAsync(string postid, string username, string password, Post post, bool publish)
{
EnsureUser(username, password);
return(TryExecuteAsync(async() =>
{
if (!Guid.TryParse(postid.Trim(), out var id))
{
throw new ArgumentException("Invalid ID", nameof(postid));
}
var cids = await GetCatIds(post.categories);
if (cids.Length == 0)
{
throw new ArgumentOutOfRangeException(nameof(post.categories));
}
var req = new PostEditModel
{
Title = post.title,
Slug = post.wp_slug ?? ToSlug(post.title),
EditorContent = post.description,
Tags = post.mt_keywords,
CategoryList = cids.Select(p => new CategoryCheckBox {
Id = p, IsChecked = true
}).ToList(),
LanguageCode = "en-us",
IsPublished = publish,
EnableComment = true,
FeedIncluded = true,
PublishDate = DateTime.UtcNow
};
await _mediator.Send(new UpdatePostCommand(id, req));
return true;
}));
}
public virtual ActionResult Create(PostEditModel post)
{
if (!ModelState.IsValid)
{
return(Json(new { success = false, errors = ModelState.Where(e => e.Value.Errors.Count > 0).Select(a => a.Key) }));
}
var dbPost = _mapper.Map <Post>(post);
var categories = _posts.GetAllCategories();
foreach (var id in post.SelectedCategories)
{
dbPost.PostCategory_SDIC
.Add(categories.First(a => a.Id == id));
}
_posts.Add(dbPost);
_posts.Commit();
var model = _mapper.Map <PostViewModel>(dbPost);
model.Categories = _mapper.Map <List <PostCategoryViewModel> >(categories);
return(Json(new { success = true, data = model }));
}
public async Task <IActionResult> CreateOrEdit(PostEditModel model,
[FromServices] LinkGenerator linkGenerator,
[FromServices] IPingbackSender pingbackSender)
{
try
{
if (!ModelState.IsValid)
{
return(Conflict(ModelState));
}
var tags = string.IsNullOrWhiteSpace(model.Tags)
? Array.Empty <string>()
: model.Tags.Split(',').ToArray();
var request = new UpdatePostRequest
{
Title = model.Title.Trim(),
Slug = model.Slug.Trim(),
EditorContent = model.EditorContent,
EnableComment = model.EnableComment,
ExposedToSiteMap = model.ExposedToSiteMap,
IsFeedIncluded = model.FeedIncluded,
ContentLanguageCode = model.LanguageCode,
IsPublished = model.IsPublished,
IsSelected = model.Featured,
Tags = tags,
CategoryIds = model.SelectedCategoryIds
};
var tzDate = _tZoneResolver.NowOfTimeZone;
if (model.ChangePublishDate &&
model.PublishDate.HasValue &&
model.PublishDate <= tzDate &&
model.PublishDate.GetValueOrDefault().Year >= 1975)
{
request.PublishDate = _tZoneResolver.ToUtc(model.PublishDate.Value);
}
var postEntity = model.PostId == Guid.Empty ?
await _postService.CreateAsync(request) :
await _postService.UpdateAsync(model.PostId, request);
if (model.IsPublished)
{
_logger.LogInformation($"Trying to Ping URL for post: {postEntity.Id}");
var pubDate = postEntity.PubDateUtc.GetValueOrDefault();
var link = linkGenerator.GetUriByAction(HttpContext, "Slug", "Post",
new
{
year = pubDate.Year,
month = pubDate.Month,
day = pubDate.Day,
postEntity.Slug
});
if (_blogConfig.AdvancedSettings.EnablePingBackSend)
{
_ = Task.Run(async() => { await pingbackSender.TrySendPingAsync(link, postEntity.PostContent); });
}
}
return(Json(new { PostId = postEntity.Id }));
}
catch (Exception ex)
{
_logger.LogError(ex, "Error Creating New Post.");
Response.StatusCode = (int)HttpStatusCode.InternalServerError;
return(Json(ex.Message));
}
}
private PostEditModel Transform(DynamicPost post, bool isDraft)
{
var type = App.PostTypes.GetById(post.TypeId);
var model = new PostEditModel
{
Id = post.Id,
BlogId = post.BlogId,
TypeId = post.TypeId,
Title = post.Title,
Slug = post.Slug,
MetaKeywords = post.MetaKeywords,
MetaDescription = post.MetaDescription,
Published = post.Published.HasValue ? post.Published.Value.ToString("yyyy-MM-dd HH:mm") : null,
RedirectUrl = post.RedirectUrl,
RedirectType = post.RedirectType.ToString(),
State = GetState(post, isDraft),
UseBlocks = type.UseBlocks
};
foreach (var regionType in type.Regions)
{
var region = new RegionModel
{
Meta = new RegionMeta
{
Id = regionType.Id,
Name = regionType.Title,
Description = regionType.Description,
Placeholder = regionType.ListTitlePlaceholder,
IsCollection = regionType.Collection,
Icon = regionType.Icon,
Display = regionType.Display.ToString().ToLower()
}
};
var regionListModel = ((IDictionary <string, object>)post.Regions)[regionType.Id];
if (!regionType.Collection)
{
var regionModel = (IRegionList)Activator.CreateInstance(typeof(RegionList <>).MakeGenericType(regionListModel.GetType()));
regionModel.Add(regionListModel);
regionListModel = regionModel;
}
foreach (var regionModel in (IEnumerable)regionListModel)
{
var regionItem = new RegionItemModel();
foreach (var fieldType in regionType.Fields)
{
var appFieldType = App.Fields.GetByType(fieldType.Type);
var field = new FieldModel
{
Meta = new FieldMeta
{
Id = fieldType.Id,
Name = fieldType.Title,
Component = appFieldType.Component,
Placeholder = fieldType.Placeholder,
IsHalfWidth = fieldType.Options.HasFlag(FieldOption.HalfWidth),
Description = fieldType.Description
}
};
if (typeof(Extend.Fields.SelectFieldBase).IsAssignableFrom(appFieldType.Type))
{
foreach (var item in ((Extend.Fields.SelectFieldBase)Activator.CreateInstance(appFieldType.Type)).Items)
{
field.Meta.Options.Add(Convert.ToInt32(item.Value), item.Title);
}
}
if (regionType.Fields.Count > 1)
{
field.Model = (Extend.IField)((IDictionary <string, object>)regionModel)[fieldType.Id];
if (regionType.ListTitleField == fieldType.Id)
{
regionItem.Title = field.Model.GetTitle();
field.Meta.NotifyChange = true;
}
}
else
{
field.Model = (Extend.IField)regionModel;
field.Meta.NotifyChange = true;
regionItem.Title = field.Model.GetTitle();
}
regionItem.Fields.Add(field);
}
if (string.IsNullOrWhiteSpace(regionItem.Title))
{
regionItem.Title = "...";
}
region.Items.Add(regionItem);
}
model.Regions.Add(region);
}
foreach (var block in post.Blocks)
{
var blockType = App.Blocks.GetByType(block.Type);
if (block is Extend.BlockGroup)
{
var group = new BlockGroupModel
{
Id = block.Id,
Type = block.Type,
Meta = new BlockMeta
{
Name = blockType.Name,
Icon = blockType.Icon,
Component = "block-group",
IsGroup = true
}
};
if (blockType.Display != BlockDisplayMode.MasterDetail)
{
group.Meta.Component = blockType.Display == BlockDisplayMode.Horizontal ?
"block-group-horizontal" : "block-group-vertical";
}
foreach (var prop in block.GetType().GetProperties(App.PropertyBindings))
{
if (typeof(Extend.IField).IsAssignableFrom(prop.PropertyType))
{
var fieldType = App.Fields.GetByType(prop.PropertyType);
group.Fields.Add(new FieldModel
{
Model = (Extend.IField)prop.GetValue(block),
Meta = new FieldMeta
{
Id = prop.Name,
Name = prop.Name,
Component = fieldType.Component,
}
});
}
}
bool firstChild = true;
foreach (var child in ((Extend.BlockGroup)block).Items)
{
blockType = App.Blocks.GetByType(child.Type);
group.Items.Add(new BlockItemModel
{
IsActive = firstChild,
Model = child,
Meta = new BlockMeta
{
Name = blockType.Name,
Title = child.GetTitle(),
Icon = blockType.Icon,
Component = blockType.Component
}
});
firstChild = false;
}
model.Blocks.Add(group);
}
else
{
model.Blocks.Add(new BlockItemModel
{
Model = block,
Meta = new BlockMeta
{
Name = blockType.Name,
Title = block.GetTitle(),
Icon = blockType.Icon,
Component = blockType.Component
}
});
}
}
// Custom editors
foreach (var editor in type.CustomEditors)
{
model.Editors.Add(new EditorModel
{
Component = editor.Component,
Icon = editor.Icon,
Name = editor.Title
});
}
return(model);
}
public async Task <IActionResult> Index([FromBody] PostEditModel model)
{
BlogPost bp;
if (model.Id == 0)
{
var blog = this.db.Profiles.Single(b => b.IdentityName == User.Identity.Name);
bp = new BlogPost();
bp.ProfileId = blog.Id;
bp.Title = model.Title;
bp.Slug = GetSlug(model);
bp.Content = model.Content;
bp.Description = string.IsNullOrEmpty(model.Description) ? model.Content.ToDescription() : model.Description;
bp.Image = model.Image;
bp.LastUpdated = SystemClock.Now();
bp.Published = model.Publish ? SystemClock.Now() : DateTime.MinValue;
this.db.BlogPosts.Add(bp);
if (model.Publish)
{
if (this.email.Enabled)
{
await Notify(bp.Title, bp.Description);
}
}
}
else
{
bp = this.db.BlogPosts.Single(p => p.Id == model.Id);
bp.Title = model.Title;
bp.Slug = GetSlug(model);
bp.Content = model.Content;
bp.Description = string.IsNullOrEmpty(model.Description) ? model.Content.ToDescription() : model.Description;
bp.Image = model.Image;
bp.LastUpdated = SystemClock.Now();
// when publish button clicked, save and publish
// but do not unpublish - use unpublish/{id} for this
if (model.Publish)
{
if (bp.Published == DateTime.MinValue)
{
if (this.email.Enabled)
{
await Notify(bp.Title, bp.Description);
}
}
bp.Published = SystemClock.Now();
}
}
this.db.Complete();
if (model.Categories != null)
{
await this.db.BlogPosts.UpdatePostCategories(
bp.Id, model.Categories.Select(c => c.Value).ToList());
this.db.Complete();
}
var callback = new { Id = bp.Id, Slug = bp.Slug, Published = bp.Published, Image = bp.Image };
return(new CreatedResult("blogifier/api/posts/" + bp.Id, callback));
}
/// <summary>
/// Saves the post model.
/// </summary>
/// <param name="model">The post edit model</param>
/// <param name="alias">The suggested alias</param>
/// <param name="publish">If the post should be published</param>
/// <returns>If the post was successfully saved</returns>
public bool Save(PostEditModel model, out string alias, bool?publish = null)
{
var post = _api.Posts.GetById(model.Id);
alias = null;
if (post == null)
{
post = Piranha.Models.DynamicPost.Create(_api, model.TypeId);
}
else
{
if (model.Slug != post.Slug && model.Published.HasValue)
{
alias = post.Slug;
}
}
Module.Mapper.Map <PostEditModel, Piranha.Models.PostBase>(model, post);
SaveRegions(model, post);
SaveBlocks(model, post);
// Update category
var category = _api.Posts.GetCategoryBySlug(model.BlogId, model.SelectedCategory);
if (category != null)
{
post.Category = category;
}
else
{
post.Category = new Piranha.Models.Taxonomy
{
Title = model.SelectedCategory
};
}
// Update tags
post.Tags.RemoveAll(t => !model.SelectedTags.Contains(t.Slug));
foreach (var selectedTag in model.SelectedTags)
{
if (!post.Tags.Any(t => t.Slug == selectedTag))
{
var tag = _api.Posts.GetTagBySlug(model.BlogId, selectedTag);
if (tag != null)
{
post.Tags.Add(new Piranha.Models.Taxonomy
{
Id = tag.Id,
Title = tag.Title,
Slug = tag.Slug
});
}
else
{
post.Tags.Add(new Piranha.Models.Taxonomy
{
Title = selectedTag
});
}
}
}
if (publish.HasValue)
{
if (publish.Value && !post.Published.HasValue)
{
post.Published = DateTime.Now;
}
else if (!publish.Value)
{
post.Published = null;
}
}
_api.Posts.Save(post);
model.Id = post.Id;
return(true);
}
/// <summary>
/// Saves all of the regions from the source model into the destination.
/// </summary>
/// <param name="src">The source</param>
/// <param name="dest">The destination</param>
private void SaveRegions(PostEditModel src, Piranha.Models.DynamicPost dest)
{
var type = _api.PostTypes.GetById(src.TypeId);
var modelRegions = (IDictionary <string, object>)dest.Regions;
foreach (var region in src.Regions)
{
if (region is PageEditRegion)
{
if (!modelRegions.ContainsKey(region.Id))
{
modelRegions[region.Id] = _factory.CreateDynamicRegion(type, region.Id);
}
var reg = (PageEditRegion)region;
if (reg.FieldSet.Count == 1)
{
modelRegions[region.Id] = reg.FieldSet[0].Value;
}
else
{
var modelFields = (IDictionary <string, object>)modelRegions[region.Id];
foreach (var field in reg.FieldSet)
{
modelFields[field.Id] = field.Value;
}
}
}
else
{
if (modelRegions.ContainsKey(region.Id))
{
var list = (Piranha.Models.IRegionList)modelRegions[region.Id];
var reg = (PageEditRegionCollection)region;
// At this point we clear the values and rebuild them
list.Clear();
foreach (var set in reg.FieldSets)
{
if (set.Count == 1)
{
list.Add(set[0].Value);
}
else
{
var modelFields = (IDictionary <string, object>)_factory.CreateDynamicRegion(type, region.Id);
foreach (var field in set)
{
modelFields[field.Id] = field.Value;
}
list.Add(modelFields);
}
}
}
}
}
}
public PostEditModel ToModel(Post entity, PostEditModel model)
{
return(_mapper.Map(entity, model));
}
public async Task Save(PostEditModel model, bool draft)
{
var postType = App.PostTypes.GetById(model.TypeId);
if (postType != null)
{
if (model.Id == Guid.Empty)
{
model.Id = Guid.NewGuid();
}
var post = await _api.Posts.GetByIdAsync(model.Id);
if (post == null)
{
post = await _factory.CreateAsync <DynamicPost>(postType);
post.Id = model.Id;
}
post.BlogId = model.BlogId;
post.TypeId = model.TypeId;
post.Title = model.Title;
post.Slug = model.Slug;
post.MetaTitle = model.MetaTitle;
post.MetaKeywords = model.MetaKeywords;
post.MetaDescription = model.MetaDescription;
post.OgTitle = model.OgTitle;
post.OgDescription = model.OgDescription;
post.OgImage = model.OgImage;
post.Excerpt = model.Excerpt;
post.Published = !string.IsNullOrEmpty(model.Published) ? DateTime.Parse(model.Published) : (DateTime?)null;
post.RedirectUrl = model.RedirectUrl;
post.RedirectType = (RedirectType)Enum.Parse(typeof(RedirectType), model.RedirectType);
post.EnableComments = model.EnableComments;
post.CloseCommentsAfterDays = model.CloseCommentsAfterDays;
post.Permissions = model.SelectedPermissions;
post.PrimaryImage = model.PrimaryImage;
if (postType.Routes.Count > 1)
{
post.Route = postType.Routes.FirstOrDefault(r => r.Route == model.SelectedRoute?.Route)
?? postType.Routes.First();
}
// Save category
post.Category = new Taxonomy
{
Title = model.SelectedCategory
};
// Save tags
post.Tags.Clear();
foreach (var tag in model.SelectedTags)
{
post.Tags.Add(new Taxonomy
{
Title = tag
});
}
// Save regions
foreach (var region in postType.Regions)
{
var modelRegion = model.Regions
.FirstOrDefault(r => r.Meta.Id == region.Id);
if (region.Collection)
{
var listRegion = (IRegionList)((IDictionary <string, object>)post.Regions)[region.Id];
listRegion.Clear();
foreach (var item in modelRegion.Items)
{
if (region.Fields.Count == 1)
{
listRegion.Add(item.Fields[0].Model);
}
else
{
var postRegion = new ExpandoObject();
foreach (var field in region.Fields)
{
var modelField = item.Fields
.FirstOrDefault(f => f.Meta.Id == field.Id);
((IDictionary <string, object>)postRegion)[field.Id] = modelField.Model;
}
listRegion.Add(postRegion);
}
}
}
else
{
var postRegion = ((IDictionary <string, object>)post.Regions)[region.Id];
if (region.Fields.Count == 1)
{
((IDictionary <string, object>)post.Regions)[region.Id] =
modelRegion.Items[0].Fields[0].Model;
}
else
{
foreach (var field in region.Fields)
{
var modelField = modelRegion.Items[0].Fields
.FirstOrDefault(f => f.Meta.Id == field.Id);
((IDictionary <string, object>)postRegion)[field.Id] = modelField.Model;
}
}
}
}
// Save blocks
post.Blocks.Clear();
foreach (var block in model.Blocks)
{
if (block is BlockGroupModel blockGroup)
{
var groupType = App.Blocks.GetByType(blockGroup.Type);
if (groupType != null)
{
var postBlock = (BlockGroup)Activator.CreateInstance(groupType.Type);
postBlock.Id = blockGroup.Id;
postBlock.Type = blockGroup.Type;
foreach (var field in blockGroup.Fields)
{
var prop = postBlock.GetType().GetProperty(field.Meta.Id, App.PropertyBindings);
prop.SetValue(postBlock, field.Model);
}
foreach (var item in blockGroup.Items)
{
if (item is BlockItemModel blockItem)
{
postBlock.Items.Add(blockItem.Model);
}
else if (item is BlockGenericModel blockGeneric)
{
var transformed = ContentUtils.TransformGenericBlock(blockGeneric);
if (transformed != null)
{
postBlock.Items.Add(transformed);
}
}
}
post.Blocks.Add(postBlock);
}
}
else if (block is BlockItemModel blockItem)
{
post.Blocks.Add(blockItem.Model);
}
else if (block is BlockGenericModel blockGeneric)
{
var transformed = ContentUtils.TransformGenericBlock(blockGeneric);
if (transformed != null)
{
post.Blocks.Add(transformed);
}
}
}
// Save post
if (draft)
{
await _api.Posts.SaveDraftAsync(post);
}
else
{
await _api.Posts.SaveAsync(post);
}
}
else
{
throw new ValidationException("Invalid Post Type.");
}
}
private PostEditModel Transform(DynamicPost post, bool isDraft)
{
var config = new Config(_api);
var type = App.PostTypes.GetById(post.TypeId);
var route = type.Routes.FirstOrDefault(r => r.Route == post.Route) ?? type.Routes.FirstOrDefault();
var model = new PostEditModel
{
Id = post.Id,
BlogId = post.BlogId,
TypeId = post.TypeId,
PrimaryImage = post.PrimaryImage,
Title = post.Title,
Slug = post.Slug,
MetaTitle = post.MetaTitle,
MetaKeywords = post.MetaKeywords,
MetaDescription = post.MetaDescription,
OgTitle = post.OgTitle,
OgDescription = post.OgDescription,
OgImage = post.OgImage,
Excerpt = post.Excerpt,
Published = post.Published?.ToString("yyyy-MM-dd HH:mm"),
RedirectUrl = post.RedirectUrl,
RedirectType = post.RedirectType.ToString(),
EnableComments = post.EnableComments,
CloseCommentsAfterDays = post.CloseCommentsAfterDays,
CommentCount = post.CommentCount,
State = post.GetState(isDraft),
UseBlocks = type.UseBlocks,
UsePrimaryImage = type.UsePrimaryImage,
UseExcerpt = type.UseExcerpt,
UseHtmlExcerpt = config.HtmlExcerpt,
SelectedRoute = route == null ? null : new RouteModel
{
Title = route.Title,
Route = route.Route
},
Permissions = App.Permissions
.GetPublicPermissions()
.Select(p => new KeyValuePair <string, string>(p.Name, p.Title))
.ToList(),
SelectedPermissions = post.Permissions
};
foreach (var r in type.Routes)
{
model.Routes.Add(new RouteModel
{
Title = r.Title,
Route = r.Route
});
}
foreach (var regionType in type.Regions)
{
var region = new RegionModel
{
Meta = new RegionMeta
{
Id = regionType.Id,
Name = regionType.Title,
Description = regionType.Description,
Placeholder = regionType.ListTitlePlaceholder,
IsCollection = regionType.Collection,
Expanded = regionType.ListExpand,
Icon = regionType.Icon,
Display = regionType.Display.ToString().ToLower()
}
};
var regionListModel = ((IDictionary <string, object>)post.Regions)[regionType.Id];
if (!regionType.Collection)
{
var regionModel = (IRegionList)Activator.CreateInstance(typeof(RegionList <>).MakeGenericType(regionListModel.GetType()));
regionModel.Add(regionListModel);
regionListModel = regionModel;
}
foreach (var regionModel in (IEnumerable)regionListModel)
{
var regionItem = new RegionItemModel();
foreach (var fieldType in regionType.Fields)
{
var appFieldType = App.Fields.GetByType(fieldType.Type);
var field = new FieldModel
{
Meta = new FieldMeta
{
Id = fieldType.Id,
Name = fieldType.Title,
Component = appFieldType.Component,
Placeholder = fieldType.Placeholder,
IsHalfWidth = fieldType.Options.HasFlag(FieldOption.HalfWidth),
Description = fieldType.Description
}
};
if (typeof(SelectFieldBase).IsAssignableFrom(appFieldType.Type))
{
foreach (var item in ((SelectFieldBase)Activator.CreateInstance(appFieldType.Type)).Items)
{
field.Meta.Options.Add(Convert.ToInt32(item.Value), item.Title);
}
}
if (regionType.Fields.Count > 1)
{
field.Model = (IField)((IDictionary <string, object>)regionModel)[fieldType.Id];
if (regionType.ListTitleField == fieldType.Id)
{
regionItem.Title = field.Model.GetTitle();
field.Meta.NotifyChange = true;
}
}
else
{
field.Model = (IField)regionModel;
field.Meta.NotifyChange = true;
regionItem.Title = field.Model.GetTitle();
}
regionItem.Fields.Add(field);
}
if (string.IsNullOrWhiteSpace(regionItem.Title))
{
regionItem.Title = "...";
}
region.Items.Add(regionItem);
}
model.Regions.Add(region);
}
foreach (var block in post.Blocks)
{
var blockType = App.Blocks.GetByType(block.Type);
if (block is BlockGroup blockGroup)
{
var group = new BlockGroupModel
{
Id = block.Id,
Type = block.Type,
Meta = new BlockMeta
{
Name = blockType.Name,
Icon = blockType.Icon,
Component = "block-group",
IsGroup = true,
isCollapsed = config.ManagerDefaultCollapsedBlocks,
ShowHeader = !config.ManagerDefaultCollapsedBlockGroupHeaders
}
};
if (blockType.Display != BlockDisplayMode.MasterDetail)
{
group.Meta.Component = blockType.Display == BlockDisplayMode.Horizontal ?
"block-group-horizontal" : "block-group-vertical";
}
group.Fields = ContentUtils.GetBlockFields(block);
bool firstChild = true;
foreach (var child in blockGroup.Items)
{
blockType = App.Blocks.GetByType(child.Type);
if (!blockType.IsGeneric)
{
group.Items.Add(new BlockItemModel
{
IsActive = firstChild,
Model = child,
Meta = new BlockMeta
{
Name = blockType.Name,
Title = child.GetTitle(),
Icon = blockType.Icon,
Component = blockType.Component
}
});
}
else
{
// Generic block item model
group.Items.Add(new BlockGenericModel
{
IsActive = firstChild,
Model = ContentUtils.GetBlockFields(child),
Type = child.Type,
Meta = new BlockMeta
{
Name = blockType.Name,
Title = child.GetTitle(),
Icon = blockType.Icon,
Component = blockType.Component,
}
});
}
firstChild = false;
}
model.Blocks.Add(group);
}
else
{
if (!blockType.IsGeneric)
{
// Regular block item model
model.Blocks.Add(new BlockItemModel
{
Model = block,
Meta = new BlockMeta
{
Name = blockType.Name,
Title = block.GetTitle(),
Icon = blockType.Icon,
Component = blockType.Component,
isCollapsed = config.ManagerDefaultCollapsedBlocks
}
});
}
else
{
// Generic block item model
model.Blocks.Add(new BlockGenericModel
{
Model = ContentUtils.GetBlockFields(block),
Type = block.Type,
Meta = new BlockMeta
{
Name = blockType.Name,
Title = block.GetTitle(),
Icon = blockType.Icon,
Component = blockType.Component,
isCollapsed = config.ManagerDefaultCollapsedBlocks
}
});
}
}
}
// Custom editors
foreach (var editor in type.CustomEditors)
{
model.Editors.Add(new EditorModel
{
Component = editor.Component,
Icon = editor.Icon,
Name = editor.Title
});
}
return(model);
}
public Post ToEntity(PostEditModel model)
{
return(ToEntity(model, new Post()));
}
