public virtual ActionResult BatchUnpublish(string folderName, string parentFolder, string[] docs)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
var schema = textFolder.GetSchema().AsActual();
if (docs != null)
{
foreach (var doc in docs)
{
if (string.IsNullOrEmpty(doc))
{
continue;
}
TextContentManager.Update(Repository, schema, doc, new string[] { "Published" },
new object[] { false }, User.Identity.Name);
}
}
resultData.ReloadPage = true;
});
return(Json(data));
}
public virtual ActionResult CrossPageSort(ContentSorter sourceContent, string folderName, int?page, int?pageSize, bool up = true)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
var textFolder = new TextFolder(Repository, folderName);
var content = new TextFolder(Repository, folderName).CreateQuery().WhereEquals("UUID", sourceContent.UUID).FirstOrDefault();
TextContent destContent;
if (up)
{
destContent = content.Previous();
}
else
{
destContent = content.Next();
}
if (destContent != null)
{
TextContentManager.Update(textFolder, sourceContent.UUID, "Sequence", destContent["Sequence"], User.Identity.Name);
TextContentManager.Update(textFolder, destContent.UUID, "Sequence", content["Sequence"], User.Identity.Name);
}
});
return(Json(data));
}
public virtual ActionResult Copy(string folderName, string parentFolder, string[] docs)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
var schema = textFolder.GetSchema().AsActual();
if (docs != null)
{
foreach (var doc in docs)
{
if (string.IsNullOrEmpty(doc))
{
continue;
}
TextContentManager.Copy(textFolder.GetSchema(), doc);
}
}
data.ReloadPage = true;
});
return(Json(data));
}
public void AddTextContentMan(TextContentManager textMan)
{
if (this.textContentManList.ContainsKey(textMan))
{
return;
}
this.textContentManList.Add(textMan, 0);
}
public TextContentController(TextContentManager textContentManager, TextFolderManager textFolderManager,
WorkflowManager workflowManager, ITextContentBinder binder)
{
TextContentManager = textContentManager;
TextFolderManager = textFolderManager;
WorkflowManager = workflowManager;
Binder = binder;
}
public LocalPublishingQueueManager(ILocalPublishingQueueProvider localPublishingQueueProvider,
PageManager pageManager, TextContentManager textContentManager, IPublishingLogProvider publishingLogProvider)
: base(localPublishingQueueProvider)
{
this._localPublishingQueueProvider = localPublishingQueueProvider;
this._textContentManager = textContentManager;
this._pageManager = pageManager;
this._publishingLogProvider = publishingLogProvider;
}
public IncomeQueueManager(IIncomeQueueProvider incomeQueueProvider, PageManager pageManager, ITextContentProvider textContentProvider, TextContentManager textContentManager, IPublishingLogProvider publishingLogProvider)
: base(incomeQueueProvider)
{
this._incomeQueueProvider = incomeQueueProvider;
this._pageManager = pageManager;
this._textContentProvider = textContentProvider;
this._textContentManager = textContentManager;
this._publishingLogProvider = publishingLogProvider;
}
public PublishingManager(IPageProvider provider, TextContentManager textContentManager,
LocalPublishingQueueManager localPublishingQueueManager, RemotePublishingQueueManager remotePublishingQueueManager, PageManager pageManager, IPublishingLogProvider publishingLogProvider)
{
this._provider = provider;
this._textContentManager = textContentManager;
this._localPublishingQueueManager = localPublishingQueueManager;
this._remotePublishingQueueManager = remotePublishingQueueManager;
this._pageManager = pageManager;
this._publishingLogProvider = publishingLogProvider;
}
public OutgoingQueueManager(IOutgoingQueueProvider outgoingQueueProvider, ICmisSession cmisSession, IPublishingLogProvider publishingLogProvider,
PageManager pageManager, TextContentManager textContentManager)
: base(outgoingQueueProvider)
{
this._outgoingQueueProvider = outgoingQueueProvider;
this._cmisSession = cmisSession;
this._publishingLogProvider = publishingLogProvider;
this._pageManager = pageManager;
this._textContentManager = textContentManager;
}
public PublishingQueueManager(IPublishingQueueProvider publishingQueueProvider, IOutgoingQueueProvider outgoingQueueProvider,
PageManager pageManager, TextContentManager textContentManager, IPublishingLogProvider publishingLogProvider)
: base(publishingQueueProvider)
{
this._publishingQueueProvider = publishingQueueProvider;
this._textContentManager = textContentManager;
this._pageManager = pageManager;
this._outgoingQueueProvider = outgoingQueueProvider;
this._publishingLogProvider = publishingLogProvider;
}
public virtual ActionResult Top(string folderName, string uuid)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
TextContentManager.Top(Repository, folderName, uuid);
});
return(Json(data));
}
private void Awake()
{
//text = TextFiles[0].text.Split('\n');
//textMeshPro.text = text[0]; // Assign the first line to begin with.
if (Instance == null)
{
Instance = this;
}
}
public RemotePublishingQueueManager(IRemotePublishingQueueProvider remotePublishingQueueProvider, ICmisSession cmisSession,
PageManager pageManager, TextContentManager textContentManager, IPublishingLogProvider publishingLogProvider, IPageProvider pageProvider)
: base(remotePublishingQueueProvider)
{
this._remotePublishingQueueProvider = remotePublishingQueueProvider;
this._cmisSession = cmisSession;
this._textContentManager = textContentManager;
this._pageManager = pageManager;
this._publishingLogProvider = publishingLogProvider;
this._pageProvider = pageProvider;
}
public IncomingQueueManager(IIncomingQueueProvider incomeQueueProvider, PageManager pageManager, ITextContentProvider textContentProvider,
TextContentManager textContentManager, IPublishingLogProvider publishingLogProvider, IMediaPathField mediaPathField,
MediaContentManager mediaContentManager, MediaFolderManager mediaFolderManager)
: base(incomeQueueProvider)
{
this._incomeQueueProvider = incomeQueueProvider;
this._pageManager = pageManager;
this._textContentProvider = textContentProvider;
this._textContentManager = textContentManager;
this._publishingLogProvider = publishingLogProvider;
this._mediaPathField = mediaPathField;
this._mediaContentManager = mediaContentManager;
this._mediaFolderManager = mediaFolderManager;
}
public virtual ActionResult RevertTo(string folderName, string schemaName, string uuid, Kooboo.CMS.Content.Versioning.VersionInfo[] model, string @return)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
if (model.Length == 1)
{
TextContentManager.RevertTo(Repository, folderName, schemaName, uuid, model[0].Version, User.Identity.Name);
resultData.RedirectUrl = @return;
}
});
return(Json(data));
}
public virtual ActionResult Edit(string folderName, string uuid, FormCollection form, string @return, bool localize = false)
{
var data = new JsonResultData();
try
{
if (ModelState.IsValid)
{
TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
var schema = textFolder.GetSchema().AsActual();
SchemaPath schemaPath = new SchemaPath(schema);
IEnumerable <TextContent> addedCategories;
IEnumerable <TextContent> removedCategories;
ParseCategories(form, out addedCategories, out removedCategories);
ContentBase content;
TextContent previous = Session["EditableObject"] as TextContent;
TextContentManager.Update(Repository, textFolder, uuid, form,
Request.Files, DateTime.UtcNow, addedCategories, removedCategories, User.Identity.Name,
previous: previous);
if (localize == true)
{
TextContentManager.Localize(textFolder, uuid);
}
data.RedirectToOpener = true;
data.RedirectUrl = @return;
}
}
catch (RuleViolationException violationException)
{
foreach (var item in violationException.Issues)
{
ModelState.AddModelError(item.PropertyName, item.ErrorMessage);
}
data.Success = false;
}
catch (Exception e)
{
data.AddException(e);
}
data.AddModelState(ModelState);
return(Json(data));
}
public virtual ActionResult MoveContent(string folderName, string uuid, string parentUUID)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
if (uuid != parentUUID)
{
var textFolder = new TextFolder(Repository.Current, folderName);
TextContentManager.Update(textFolder, uuid, new[] { "ParentUUID", "ParentFolder" },
new[] { parentUUID, folderName }, User.Identity.Name);
}
resultData.ReloadPage = true;
});
return(Json(data));
}
public virtual ActionResult Sort(ContentSorter[] list, string folderName)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
var schema = textFolder.GetSchema().AsActual();
foreach (var c in list)
{
TextContentManager.Update(Repository, schema, c.UUID, new string[] { "Sequence" }, new object[] { c.Sequence }, User.Identity.Name);
}
resultData.ReloadPage = true;
});
return(Json(data));
}
public virtual ActionResult Delete(string folderName, string parentFolder, string[] folders, string[] docs)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
var schema = textFolder.GetSchema().AsActual();
if (docs != null)
{
foreach (var doc in docs)
{
if (string.IsNullOrEmpty(doc))
{
continue;
}
TextContentManager.Delete(Repository, textFolder, doc);
}
}
if (folders != null)
{
foreach (var f in folders)
{
if (string.IsNullOrEmpty(f))
{
continue;
}
var folderPathArr = FolderHelper.SplitFullName(f);
TextFolderManager.Remove(Repository, new TextFolder(Repository, folderPathArr));
}
}
resultData.ReloadPage = true;
});
return(Json(data));
}
public virtual ActionResult Publish(string folderName, string parentFolder, string uuid)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
var schema = textFolder.GetSchema().AsActual();
TextContent textContent = schema.CreateQuery().WhereEquals("UUID", uuid).FirstOrDefault();
var published = (bool?)textContent["Published"];
if (published.HasValue && published.Value == true)
{
TextContentManager.Update(Repository, schema, uuid, new string[] { "Published" }, new object[] { false }, User.Identity.Name);
}
else
{
TextContentManager.Update(Repository, schema, uuid, new string[] { "Published" }, new object[] { true }, User.Identity.Name);
}
});
return(Json(data));
}
public virtual ActionResult Create(string folderName, string parentFolder, string parentUUID, FormCollection form, string @return)
{
var data = new JsonResultData();
try
{
if (ModelState.IsValid)
{
TextFolder textFolder = new TextFolder(Repository, folderName).AsActual();
var schema = textFolder.GetSchema().AsActual();
SchemaPath schemaPath = new SchemaPath(schema);
IEnumerable <TextContent> addedCategories;
IEnumerable <TextContent> removedCategories;
ParseCategories(form, out addedCategories, out removedCategories);
ContentBase content;
content = TextContentManager.Add(Repository, textFolder, parentFolder, parentUUID, form, Request.Files, addedCategories, User.Identity.Name);
data.RedirectUrl = @return;
}
}
catch (RuleViolationException ruleEx)
{
foreach (var item in ruleEx.Issues)
{
data.AddFieldError(item.PropertyName, item.ErrorMessage);
}
}
catch (Exception e)
{
data.AddException(e);
}
data.AddModelState(ModelState);
return(Json(data));
}
public TextContentToXLIFF(ITextContentProvider textContentProvider, TextContentManager textContentManager)
{
_textContentProvider = textContentProvider;
_textContentManager = textContentManager;
}
public IncomeDataManager(TextContentManager textContentManager, PageManager pageManager)
{
_textContentManager = textContentManager;
_pageManager = pageManager;
}
public ModuleTextContentController(TextContentManager textContentManager, TextFolderManager textFolderManager, WorkflowManager workflowManager, ITextContentBinder binder, ITextContentProvider textContentProvider)
: base(textContentManager, textFolderManager, workflowManager, binder, textContentProvider)
{
}
