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 virtual ActionResult Revert(string uuid, int version, string @return)
{
var data = new JsonResultData(ModelState);
var htmlBlock = new HtmlBlock(Site, uuid);
data.RunWithTry((resultData) =>
{
VersionManager.Revert <HtmlBlock>(htmlBlock, version);
data.RedirectUrl = @return;
});
return(Json(data));
}
public virtual ActionResult Import(bool @override, string @return)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
var file = Request.Files[0];
Manager.Import(Repository, file.InputStream, @override);
data.RedirectUrl = @return;
});
return(Json(data));
}
public virtual ActionResult Publish(string uuid, string folderName, bool published)
{
var folder = FolderManager.Get(Repository, folderName);
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
ContentManager.Update(folder, uuid, new string[] { "Published" }, new object[] { published });
});
return(Json(data));
}
/// <summary>
/// Renames the specified folder name.
/// </summary>
/// <param name="folderName">Name of the folder.</param>
/// <param name="uuid">The UUID.</param>
/// <param name="name">The name.</param>
/// <returns></returns>
public virtual ActionResult RenameFile(string folderName, string uuid, string name, string @return)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
ServiceFactory.MediaContentManager.Move(Repository, folderName, uuid, folderName, name);
resultData.RedirectUrl = @return;
});
return(Json(data));
}
public override ActionResult Unlocalize(Page o, string @return)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
o.Site = Site;
Manager.Unlocalize(o);
resultData.RedirectUrl = @return;
});
return(Json(data));
}
public virtual ActionResult CreateEx(Page model, bool?setPublished, string @return, string PageOrders)
{
var data = new JsonResultData()
{
RedirectUrl = @return
};
if (ModelState.IsValid)
{
data.RunWithTry((resultData) =>
{
var parentPage = ControllerContext.RequestContext.GetRequestValue("parentPage");
Page parent = null;
if (!string.IsNullOrWhiteSpace(parentPage))
{
parent = PageHelper.Parse(Site, parentPage);
}
model.Parent = parent;
SavePosition(model);
model.UserName = User.Identity.Name;
if (setPublished.HasValue && setPublished.Value == true)
{
model.Published = true;
}
else
{
model.Published = false;
}
Manager.Add(Site, parentPage, model);
if (!string.IsNullOrEmpty(PageOrders))
{
var pageOrders = PageOrders.Split(new[] { "|" }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < pageOrders.Length - 1; i++)
{
if (pageOrders[i] == "!NEWPAGE!")
{
pageOrders[i] = model.FullName;
}
}
Manager.SortPages(Site, parent == null ? "" : parent.FullName, pageOrders);
}
resultData.RedirectUrl = @return;
});
}
return(Json(data));
}
public virtual ActionResult Delete(Workflow[] model)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
Manager.Delete(model, Repository);
resultData.ReloadPage = true;
});
return(Json(data));
}
public async Task <ActionResult> CreateRentalMessageAsync([FromBody] CreateRentalMessageDto message)
{
BuildUserPrincipal();
message.UserId = ApiUser.Id;
var result = await _rentalMessageService.CreateRentalMessageAsync(message);
_backgroundJobClient.Enqueue(() => _rentalMessageService.SendEmailAsync(message, CancellationToken.None));
return(StatusCode((int)HttpStatusCode.Created, Json(JsonResultData.Success(result))));
}
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 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(Site, Kooboo.UniqueIdGenerator.GetInstance().GetBase32UniqueId(10))
{
PublishingObject = PublishingObject.Page,
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 ActionResult PublishPage(LocalPagePublishingModel 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 if (model.Schedule)
{
foreach (string uuid in model.Pages)
{
var queue = new LocalPublishingQueue()
{
PublishingObject = PublishingObject.Page,
SiteName = Site.Name,
UserId = User.Identity.Name,
UtcCreationDate = DateTime.UtcNow,
ObjectUUID = uuid,
ObjectTitle = uuid,
Status = QueueStatus.Pending
};
if (model.UtcTimeToPublish.HasValue)
{
queue.UtcTimeToPublish = model.UtcTimeToPublish.Value.ToUniversalTime();
}
if (model.UtcTimeToUnpublish.HasValue)
{
queue.UtcTimeToUnpublish = model.UtcTimeToUnpublish.Value.ToUniversalTime();
}
resultEntry.RunWithTry((data) =>
{
_manager.Add(queue);
});
}
resultEntry.RedirectUrl = @return;
}
else
{
foreach (string uuid in model.Pages)
{
var page = new Page(Site, uuid);
Kooboo.CMS.Sites.Services.ServiceFactory.PageManager.Publish(page, false, false, false, DateTime.UtcNow, DateTime.UtcNow, User.Identity.Name);
}
resultEntry.RedirectUrl = @return;
}
}
return(Json(resultEntry));
}
public virtual ActionResult AddMonthlyReport(MonthlyReportModel model)
{
JsonResultData response = null;
try
{
if (!model.IsValid())
{
response = new JsonResultData
{
Code = HttpStatusCode.BadRequest,
Message = new MessageBox
{
Message = Texts.Error_InputInvalid,
Title = Texts.ErrorInValidation,
Type = MessageBoxType.danger.ToString()
}
};
return(Json((object)response));
}
//var result = _goalService.Validate(model.StartDate, model.EndDate,
// 0f, model.Amount, model.TimeType);
//if (result.Errors.Any())
//{
// response = new JsonResultData
// {
// Code = JsonResultDataCode.Error,
// Messages = new MessageBox
// {
// Messages = String.Join(" ", result.Errors),
// Title = "Error",
// Type = MessageBoxType.danger.ToString()
// }
// };
//}
//else
//{
// response = null;
//}
}
catch (Exception ex)
{
response = new JsonResultData
{
Code = HttpStatusCode.InternalServerError,
Message = new ValidationUIException(ex.Message).MessageBox
};
}
return(Json((object)response));
}
public virtual ActionResult SaveFile(string siteName, string filePath, string fileContent, bool?_draft_)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
// save content
filePath = Server.MapPath(filePath);
System.IO.File.WriteAllText(filePath, fileContent, System.Text.Encoding.UTF8);
ThemeManager.FlushWebResourceCache(Site, null);
});
return(Json(data));
}
public virtual ActionResult Revert(string uuid, int version, string @return)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
var page = new Page(Site, uuid);
Manager.VersiongLogger.Revert(page, version, User.Identity.Name);
resultData.RedirectUrl = @return;
});
return(Json(data));
}
public virtual ActionResult Delete1(Page model, string @return)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
Remove(model);
data.RedirectUrl = @return;
});
return(Json(data));
}
public IActionResult GetManipulations([FromBody] ManipulationsFilterParams filterParams)
{
UserDto user = User.GetUserModel();
if (user.FacilityId.HasValue)
{
filterParams.FacilityId = user.FacilityId.Value;
}
var items = _manipulationService.GetManipulationsByParams(filterParams);
return(Json(JsonResultData.Success(items)));
}
public virtual ActionResult Revert(View view, int version, string @return)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
view.Site = Site;
VersionManager.Revert <View>(view, version);
resultData.RedirectUrl = @return;
});
return(Json(data));
}
public async Task <ActionResult> GetRentalsAsync([FromQuery] RentalFilterParamsDto filterParams)
{
BuildUserPrincipal();
if (ApiUser.Role == Role.User)
{
filterParams.UserId = ApiUser.Id;
}
var rentals = await _rentalService.GetRentalsByFilterParamsAsync(filterParams);
return(Json(JsonResultData.Success(rentals)));
}
public IActionResult GetDepartments([FromBody] DepartmentsFilterParams filterParams)
{
var userModel = User.GetUserModel();
if (userModel.FacilityId.HasValue)
{
filterParams.FacilityId = userModel.FacilityId.Value;
}
var items = _departmentService.GetDepartmentsByParams(filterParams);
return(Json(JsonResultData.Success(items)));
}
public IActionResult GetDoctors([FromBody] DoctorsFilterParams filterParams)
{
var userModel = User.GetUserModel();
if (userModel.FacilityId.HasValue)
{
filterParams.FacilityId = userModel.FacilityId.Value;
}
var doctors = _doctorService.GetDoctorsByParams(filterParams);
return(Json(JsonResultData.Success(doctors)));
}
public virtual ActionResult Revert(string uuid, int version, string @return)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
var layout = new Layout(Site, uuid);
Kooboo.CMS.Sites.Versioning.VersionManager.Revert(layout, version, User.Identity.Name);
resultData.RedirectUrl = @return;
});
return(Json(data, JsonRequestBehavior.AllowGet));
}
public async Task <JsonResultData> UpdateUserAsync([FromBody] UpdateUserModel data)
{
var user = await _userManager.FindByIdAsync(data.Id);
user.FirstName = data.FirstName;
user.LastName = data.LastName;
user.Interests = data.Interests;
user.PhoneNumber = data.PhoneNumber;
await _userManager.UpdateAsync(user);
return(JsonResultData.Success());
}
public JsonResult Edit(BF_DATABASE.Entity entity)
{
JsonResultData result = new JsonResultData();
int i = 0;
try
{
CheckInput(entity);
if (entity.ID < 0)
{
result.Message = "数据库不存在，不可编辑";
return(Json(result, JsonRequestBehavior.AllowGet));
}
//对密码进行aes加密
string password = CS.Base.Encrypt.BAES.Encrypt(entity.PASSWORD);
entity.PASSWORD = password;
entity.UPDATE_UID = SystemSession.UserID;
entity.UPDATE_TIME = DateTime.Now;
if (entity.ID == 0)
{
entity.CREATE_UID = SystemSession.UserID;
entity.CREATE_TIME = DateTime.Now;
i = BF_DATABASE.Instance.Add(entity);
}
else
{
BF_DATABASE.Entity oldEntity = BF_DATABASE.Instance.GetEntityByKey <BF_DATABASE.Entity>(entity.ID);
entity.CREATE_UID = oldEntity.CREATE_UID;
entity.CREATE_TIME = oldEntity.CREATE_TIME;
i = BF_DATABASE.Instance.UpdateByKey <BF_DATABASE.Entity>(entity, entity.ID);
}
if (i < 1)
{
result.Message = "出现了未知错误";
return(Json(result, JsonRequestBehavior.AllowGet));
}
result.IsSuccess = true;
result.Message = "保存成功";
}
catch (Exception ex)
{
result.IsSuccess = false;
result.Message = ex.Message;
BLog.Write(BLog.LogLevel.WARN, "编辑数据库配置出错：" + ex.ToString());
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
public virtual ActionResult Create(CreateUserModel model, string @return)
{
var data = new JsonResultData(ModelState);
if (ModelState.IsValid)
{
data.RunWithTry((resultData) =>
{
UserManager.Add(model.ToUser());
data.RedirectUrl = @return;
});
}
return(Json(data));
}
public virtual ActionResult ResetPassword(ResetPasswordModel password, string @return)
{
var data = new JsonResultData(ModelState);
if (ModelState.IsValid)
{
data.RunWithTry((resultData) =>
{
UserManager.ChangePassword(password.UserName, password.NewPassword);
data.RedirectUrl = @return;
});
}
return(Json(data));
}
public virtual ActionResult Delete(User[] model)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
foreach (var user in model)
{
UserManager.Delete(user.UserName);
}
resultData.ReloadPage = true;
});
return(Json(data));
}
public virtual ActionResult Localize(HtmlBlock[] model)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
foreach (var item in model)
{
Manager.Localize(item.UUID, Site);
}
data.ReloadPage = true;
});
return(Json(data));
}
public virtual ActionResult Import(bool @override, string @return)
{
var data = new JsonResultData(ModelState);
data.RunWithTry((resultData) =>
{
if (Request.Files.Count > 0 && Request.Files[0].ContentLength > 0)
{
Manager.Provider.Import(Site, Request.Files[0].InputStream, @override);
}
data.RedirectUrl = @return;
});
return(Json(data, "text/plain", System.Text.Encoding.UTF8));
}
public static ActionResult ReturnActionResult(ControllerContext controllerContext, object model, Exception exception)
{
var jsonResult = controllerContext.RequestContext.GetRequestValue("JsonResult");
string redirectUrl = "";
if (exception == null)
{
redirectUrl = controllerContext.RequestContext.GetRequestValue("SuccessedUrl");
}
else
{
controllerContext.HttpContext.Session["Exception"] = exception;
redirectUrl = controllerContext.RequestContext.GetRequestValue("FailedUrl");
}
if (jsonResult.EqualsOrNullEmpty("true", StringComparison.OrdinalIgnoreCase))
{
var data = new JsonResultData()
{
Model = model, RedirectUrl = redirectUrl
};
if (exception != null)
{
data.AddException(exception);
if ((exception is RuleViolationException))
{
((RuleViolationException)exception).FillIssues(controllerContext.Controller.ViewData.ModelState);
data.AddModelState(controllerContext.Controller.ViewData.ModelState);
}
}
return(new JsonResult()
{
Data = data
});
}
if (exception != null && string.IsNullOrEmpty(redirectUrl))
{
throw exception;
}
if (!string.IsNullOrEmpty(redirectUrl))
{
return(new RedirectResult(redirectUrl));
}
if (controllerContext.HttpContext.Request.UrlReferrer != null)
{
return(new RedirectResult(controllerContext.HttpContext.Request.UrlReferrer.OriginalString));
}
return(new EmptyResult());
}
