public virtual ActionResult Delete(string[] docs, string[] folders)
        {
            var data = new JsonResultData(ModelState);
            data.RunWithTry((resultData) =>
            {
                var category = ControllerContext.RequestContext.GetRequestValue("Category");

                if (docs != null)
                {
                    foreach (var uuid in docs)
                    {
                        var label = new Label() { Site = Site, UUID = uuid };
                        Remove(label);
                    }
                }

                if (folders != null)
                {
                    foreach (var c in folders)
                    {
                        Manager.RemoveCategory(Site, c);
                    }
                }

                resultData.ReloadPage = true;
            });
            return Json(data);
        }

        public virtual ActionResult Create(TextFolder model, string folderName, string @return)
        {
            //compatible with the Folder parameter changed to FolderName.
            folderName = folderName ?? this.ControllerContext.RequestContext.GetRequestValue("Folder");

            var data = new JsonResultData(ModelState);
            if (ModelState.IsValid)
            {
                data.RunWithTry((resultData) =>
                {

                    Folder parent = null;
                    if (!string.IsNullOrEmpty(folderName))
                    {
                        parent = FolderHelper.Parse<TextFolder>(Repository, folderName);
                    }
                    model.Parent = parent;
                    model.UtcCreationDate = DateTime.UtcNow;
                    Manager.Add(Repository, model);

                    resultData.RedirectUrl = @return;
                });

            }

            return Json(data);
        }

        public virtual ActionResult Ajax(LoginModel loginModel, int redirect)
        {
            var data = new JsonResultData(ModelState);
            if (ModelState.IsValid)
            {
                data.RunWithTry((resultData) =>
                {
                    if (UserServices.ValidateUser(loginModel.UserName, loginModel.Password) != null)
                    {
                        System.Web.Security.FormsAuthentication.SetAuthCookie(loginModel.UserName, loginModel.RememberMe);
                        if (redirect == 0)
                        {
                            resultData.RedirectUrl = Request.UrlReferrer.ToString();
                        }
                        else
                        {
                            resultData.RedirectUrl = System.Web.Security.FormsAuthentication.DefaultUrl;
                        }

                    }
                    else
                    {
                        resultData.AddFieldError("UserName", "Username and/or password are incorrect.".Localize());
                    }
                });
            }
            return Json(data);
        }

 public virtual ActionResult CopyContent(string schema, string uuid)
 {
     var data = new JsonResultData(ModelState);
     data.RunWithTry((resultData) =>
     {
         var content = Kooboo.CMS.Content.Services.ServiceFactory.TextContentManager.Copy(new Schema(Repository.Current, schema), uuid);
         resultData.Model = new
         {
             uuid = content.UUID,
             schema = content.SchemaName,
             published = string.Empty,
             editUrl = Url.Action("InlineEdit", new
             {
                 controller = "TextContent",
                 Area = "Contents",
                 RepositoryName = content.Repository,
                 SiteName = Site.FullName,
                 FolderName = content.FolderName,
                 UUID = content.UUID
             }),
             summary = HttpUtility.HtmlAttributeEncode(content.GetSummary())
         };
     });
     return Json(data);
 }

        public virtual ActionResult Install(InstallModuleModel installModel, string @return)
        {
            var data = new JsonResultData(ModelState);
            if (ModelState.IsValid)
            {
                data.RunWithTry((resultData) =>
                {
                    var moduleFile = this.Request.Files["ModuleFile"];

                    StringBuilder log = new StringBuilder();
                    var moduleName = System.IO.Path.GetFileNameWithoutExtension(moduleFile.FileName);

                    var moduleInfo = Manager.Install(moduleName, moduleFile.InputStream, ref log);

                    if (moduleInfo == null && log.Length != 0)
                    {
                        data.Success = false;
                        data.AddMessage(log.ToString());
                    }
                    else
                    {
                        data.RedirectUrl = @return;
                    }
                });
            }

            return Json(data);
        }

        public virtual ActionResult Install(InstallModuleModel installModel, string @return)
        {
            var data = new JsonResultData(ModelState);
            if (ModelState.IsValid)
            {
                data.RunWithTry((resultData) =>
                {
                    var moduleFile = this.Request.Files["ModuleFile"];

                    StringBuilder log = new StringBuilder();
                    var moduleName = System.IO.Path.GetFileNameWithoutExtension(moduleFile.FileName);

                    var moduleInfo = Manager.Install(moduleName, moduleFile.InputStream, ref log);

                    if (moduleInfo == null && log.Length != 0)
                    {
                        data.Success = false;
                        data.AddMessage(log.ToString());
                    }
                    else
                    {
                        if (!string.IsNullOrEmpty(moduleInfo.InstallingTemplate))
                        {
                            data.RedirectUrl = Url.Action("OnInstalling", ControllerContext.RequestContext.AllRouteValues().Merge("ModuleName", moduleName));
                        }
                        else
                        {
                            data.RedirectUrl = @return;
                        }
                    }
                });
            }

            return Json(data);
        }

        public System.Web.Mvc.ActionResult Submit(Sites.Models.Site site, System.Web.Mvc.ControllerContext controllerContext, Sites.Models.SubmissionSetting submissionSetting)
        {
            var request = controllerContext.HttpContext.Request;
            var action = request["action"];

            var jsonResultData = new JsonResultData();
            object result = null;

            try
            {
                if (action == "get-addresses")
                {
                    result = GetAddresses(site, controllerContext);
                }

                jsonResultData.Success = true;
                jsonResultData.Model = result;
            }
            catch (Exception ex)
            {
                jsonResultData.Success = false;
                jsonResultData.AddException(ex);
            }

            return new JsonResult { Data = jsonResultData, JsonRequestBehavior = JsonRequestBehavior.AllowGet };
        }

        public virtual ActionResult Delete(string[] docs, string[] folders)
        {
            var data = new JsonResultData(ModelState);
            data.RunWithTry((resultData) =>
            {
                var category = ControllerContext.RequestContext.GetRequestValue("Category");

                if (docs != null)
                {
                    foreach (var name in docs)
                    {
                        var m = new Element() { Name = name };
                        m.Category = category;
                        Remove(m);
                    }
                }

                if (folders != null)
                {
                    foreach (var c in folders)
                    {
                        Manager.RemoveCategory(Site, c);
                    }
                }

                resultData.ReloadPage = true;
            });
            return Json(data);
        }

        public virtual ActionResult Create(string[] folderName, SendingSetting sendingSetting, string @return)
        {
            if (folderName == null || folderName.Length == 0)
            {
                ModelState.AddModelError("FolderName", "Folder name is required.".Localize());
            }
            var data = new JsonResultData(ModelState);
            data.RunWithTry((resultData) =>
            {
                if (ModelState.IsValid)
                {
                    foreach (var item in folderName)
                    {
                        if (Manager.Get(Repository, item) == null)
                        {
                            sendingSetting.FolderName = item;
                            Manager.Add(Repository, sendingSetting);
                        }

                    }
                    resultData.RedirectUrl = @return;
                }
            });
            return Json(data);
        }

 public virtual ActionResult Import(TextContentImportModel model, string @return)
 {
     var data = new JsonResultData(ModelState);
     data.RunWithTry((resultData) =>
     {
         model.TextContentExporter.Import(new TextFolder(Repository, model.FolderName), model.File.InputStream);
         data.RedirectUrl = @return;
     });
     return Json(data);
 }

        public virtual ActionResult Delete(Workflow[] model)
        {
            var data = new JsonResultData(ModelState);
            data.RunWithTry((resultData) =>
            {
                Manager.Delete(model, Repository);
            });

            return Json(data);
        }

        public virtual ActionResult CreateFolder(string folderPath, string folderName, string @return)
        {
            var data = new JsonResultData(ModelState);
            data.RunWithTry((resultData) =>
            {
                FileManager.AddDirectory(Site, folderPath, folderName);

                data.ReloadPage = true;
            });
            return Json(data);
        }

        public virtual ActionResult Copy(CopyModel copyModel, string @return)
        {
            var data = new JsonResultData(ModelState);
            data.RunWithTry((resultData) =>
            {
                Manager.Copy(Repository, copyModel.UUID, copyModel.DestinationName);
                data.RedirectUrl = @return;
            });

            return Json(data);
        }

 public ActionResult Delete(DeleteModel[] model)
 {
     var resultEntry = new JsonResultData(ModelState);
     if (ModelState.IsValid)
     {
         var uuids = model.Select(it => it.UUID).ToArray();
         this._manager.Delete(uuids);
         resultEntry.ReloadPage = true;
     }
     return Json(resultEntry);
 }

 public virtual ActionResult Index(string body)
 {
     JsonResultData data = new JsonResultData(ModelState);
     data.RunWithTry((resultData) =>
     {
         Robots_Txt robot_txt = new Robots_Txt(Site);
         robot_txt.Save(body);
         data.AddMessage("The robots.txt has been saved.".Localize());
     });
     return Json(data);
 }

        public ActionResult Index(Setting setting)
        {
            JsonResultData data = new JsonResultData(ModelState);
            data.RunWithTry((resultData) =>
            {
                SettingProvider.Update(setting, setting);
                resultData.AddMessage("The setting has been saved.".Localize());
            });

            return Json(data);
        }

        public virtual ActionResult Reject(string workflowName, string roleName, string UUID, string comment, string @return)
        {
            var data = new JsonResultData(ModelState);

            data.RunWithTry((resultData) =>
            {
                Manager.ProcessPendingWorkflowItem(Repository, workflowName, roleName, UUID, User.Identity.Name, false, comment);
                resultData.RedirectUrl = @return;
            });

            return Json(data);
        }

 public ActionResult PublishPage(RemotePagePublishingModel model, string @return)
 {
     var resultEntry = new JsonResultData(ModelState);
     if (ModelState.IsValid)
     {
         if (model.Schedule && !model.UtcTimeToPublish.HasValue && !model.UtcTimeToUnpublish.HasValue)
         {
             resultEntry.AddErrorMessage("UtcTimeToPublish and UtcTimeToUnpublish can not be both empty.".Localize());
         }
         else
         {
             foreach (string uuid in model.Pages)
             {
                 foreach (string endpoint in model.RemoteEndPoints)
                 {
                     var queue = new RemotePublishingQueue()
                     {
                         PublishingObject = PublishingObject.Page,
                         SiteName = Site.Name,
                         UserId = User.Identity.Name,
                         UtcCreationDate = DateTime.UtcNow,
                         RemoteEndpoint = endpoint,
                         ObjectUUID = uuid,
                         ObjectTitle = uuid,
                         Status = QueueStatus.Pending
                     };
                     if (model.Schedule)
                     {
                         if (model.UtcTimeToPublish.HasValue)
                         {
                             queue.UtcTimeToPublish = model.UtcTimeToPublish.Value.ToUniversalTime();
                         }
                         if (model.UtcTimeToUnpublish.HasValue)
                         {
                             queue.UtcTimeToUnpublish = model.UtcTimeToUnpublish.Value.ToUniversalTime();
                         }
                     }
                     else
                     {
                         queue.UtcTimeToPublish = DateTime.UtcNow;
                     }
                     resultEntry.RunWithTry((data) =>
                     {
                         _manager.Add(queue);
                     });
                 }
             }
             resultEntry.RedirectUrl = @return;
         }
     }
     return Json(resultEntry);
 }

 public virtual ActionResult Index(Repository model)
 {
     JsonResultData data = new JsonResultData(ModelState);
     data.RunWithTry((resultData) =>
     {
         if (ModelState.IsValid)
         {
             Manager.Update(model, Manager.Get(model.Name));
             data.ReloadPage = true;
         }
     });
     return Json(data);
 }

 public virtual ActionResult Create(CreateRepositoryModel model)
 {
     JsonResultData data = new JsonResultData(ModelState);
     data.RunWithTry((resultData) =>
     {
         if (ModelState.IsValid)
         {
             Manager.Create(model.Name, model.Template);
             resultData.RedirectUrl = Url.Action("Index", new { controller = "home", repositoryName = model.Name });
         }
     });
     return Json(data);
 }