/// <summary>
/// When editing or creating content, this will bind the model, check the model state errors, add appropriate notifications
/// return the error view or redirect to the correct place and also persist the data to the repository.
/// </summary>
/// <param name="model"></param>
/// <param name="entity"></param>
/// <returns></returns>
protected virtual ActionResult ProcessSubmit(TEditorModel model, Revision <TypedEntity> entity, bool isRevisional)
{
Mandate.ParameterNotNull(model, "model");
//bind it's data
model.BindModel(this);
//if there's model errors, return the view
if (!ModelState.IsValid)
{
AddValidationErrorsNotification();
return(View("Edit", model));
}
//persist the data
var success = false;
using (var uow = Hive.Create <IContentStore>())
{
//EnsureUniqueName(model);
if (entity == null)
{
//map to new entity
entity = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <TEditorModel, Revision <TypedEntity> >(model);
}
else
{
//map to existing entity
BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map(model, entity.Item);
//then create a new revision
entity = entity.CopyToNewRevision();
}
// Remove old relations
var modRelations = uow.Repositories.GetParentRelations(entity.Item.Id, FixedRelationTypes.ModifiedByRelationType);
foreach (var relationById in modRelations)
{
uow.Repositories.RemoveRelation(relationById);
}
// Add modified by relation
uow.Repositories.AddRelation(_currentUser.ProfileId,
entity.Item.Id,
FixedRelationTypes.ModifiedByRelationType);
// Try publish
if (ValueProvider.GetValue("submit.Publish") != null)
{
success = this.TryExecuteSecuredMethod(x => x.ProcessPublish(model, entity), model.Id).Success;
if (!success)
{
// Report unathorized
NotifyForProcess(NotificationState.PublishUnathorized, model);
}
}
// Try unpublish
else if (ValueProvider.GetValue("submit.Unpublish") != null)
{
success = this.TryExecuteSecuredMethod(x => x.ProcessUnpublish(model, entity), model.Id).Success;
if (!success)
{
// Report unathorized
NotifyForProcess(NotificationState.UnpublishedUnauthorized, model);
}
}
// Try save
else
{
success = this.TryExecuteSecuredMethod(x => x.ProcessSave(model, entity), model.Id).Success;
if (!success)
{
// Report unathorized
NotifyForProcess(NotificationState.SaveUnauthorized, model);
}
}
if (success)
{
if (isRevisional)
{
uow.Repositories.Revisions.AddOrUpdate(entity);
}
else
{
uow.Repositories.AddOrUpdate(entity.Item);
}
uow.Complete();
}
else
{
uow.Abandon();
}
}
if (success)
{
// Perf: use a readonly unit here rather than delaying the writer
using (var uow = ReadonlyHive.CreateReadonly <IContentStore>())
{
//need to clear the URL cache for this entry
BackOfficeRequestContext.RoutingEngine.ClearCache(clearGeneratedUrls: true, clearMappedUrls: true);
if (ValueProvider.GetValue("submit.Publish") != null)
{
var cacheRecycler = new CacheRecycler(Request.Url.GetLeftPart(UriPartial.Authority),
BackOfficeRequestContext.Application.FrameworkContext);
cacheRecycler.RecycleCacheFor(entity.Item);
}
//add path for entity for SupportsPathGeneration (tree syncing) to work
GeneratePathsForCurrentEntity(uow.Repositories.GetEntityPaths <TypedEntity>(entity.Item.Id, FixedRelationTypes.DefaultRelationType));
return(RedirectToAction("Edit", new { id = entity.Item.Id }));
}
}
return(View("Edit", model));
}
//[RebelAuthorize(Permissions = new[] { FixedPermissionIds.Publish })]
public JsonResult PublishForm(PublishModel model)
{
if (!TryValidateModel(model))
{
return(ModelState.ToJsonErrors());
}
using (var uow = Hive.Create <IContentStore>())
{
var cacheRecycler = new CacheRecycler(Request.Url.GetLeftPart(UriPartial.Authority),
BackOfficeRequestContext.Application.FrameworkContext);
var contentEntity = uow.Repositories.Revisions.GetLatestRevision <TypedEntity>(model.Id);
if (contentEntity == null)
{
throw new ArgumentException(string.Format("No entity found for id: {0} on action PublishForm", model.Id));
}
//get its children recursively
if (model.IncludeChildren)
{
// Get all descendents
var descendents = uow.Repositories.GetDescendentRelations(model.Id, FixedRelationTypes.DefaultRelationType);
foreach (var descendent in descendents)
{
//get the revision
var revisionEntity = uow.Repositories.Revisions.GetLatestRevision <TypedEntity>(descendent.DestinationId);
//publish it if it's already published or if the user has specified to publish unpublished content
if (revisionEntity != null && (revisionEntity.MetaData.StatusType.Alias == FixedStatusTypes.Published.Alias) || model.IncludeUnpublishedChildren)
{
var publishRevision = revisionEntity.CopyToNewRevision(FixedStatusTypes.Published);
uow.Repositories.Revisions.AddOrUpdate(publishRevision);
cacheRecycler.RecycleCacheFor(revisionEntity.Item);
}
}
}
//publish this node
var toPublish = contentEntity.CopyToNewRevision(FixedStatusTypes.Published);
uow.Repositories.Revisions.AddOrUpdate(toPublish);
var path = uow.Repositories.GetEntityPaths(model.Id, FixedRelationTypes.DefaultRelationType);
//save
uow.Complete();
cacheRecycler.RecycleCacheFor(toPublish.Item);
var contentViewModel = BackOfficeRequestContext.Application.FrameworkContext.TypeMappers.Map <Revision <TypedEntity>, ContentEditorModel>(toPublish);
Notifications.Add(new NotificationMessage(
model.IncludeChildren
? "Publish.ChildrenSuccess.Message".Localize(this, new { contentViewModel.Name }, encode: false)
: "Publish.SingleSuccess.Message".Localize(this, new { contentViewModel.Name }, encode: false),
"Publish.Title".Localize(this), NotificationType.Success));
return(new CustomJsonResult(new
{
success = true,
notifications = Notifications,
path = path.ToJson(),
msg = model.IncludeChildren
? "Publish.ChildrenSuccess.Message".Localize(this, new { contentViewModel.Name }, encode: false)
: "Publish.SingleSuccess.Message".Localize(this, new { contentViewModel.Name }, encode: false)
}.ToJsonString));
}
}
