/// <summary>
/// 保存权限
/// </summary>
/// <param name="savePermissionDto">权限保存信息</param>
/// <returns>返回执行结果</returns>
public Result <PermissionDto> SavePermission(SavePermissionDto savePermissionDto)
{
using (var businessWork = WorkManager.Create())
{
if (savePermissionDto == null)
{
return(Result <PermissionDto> .FailedResult("没有指定任何要保存的权限信息"));
}
#region 保存权限数据
var authSaveResult = permissionService.Save(savePermissionDto.Permission.MapTo <Permission>());
if (!authSaveResult.Success)
{
return(Result <PermissionDto> .FailedResult(authSaveResult.Message));
}
#endregion
var commitVal = businessWork.Commit();
Result <PermissionDto> result = null;
if (commitVal.EmptyResultOrSuccess)
{
result = Result <PermissionDto> .SuccessResult("保存成功");
result.Data = authSaveResult.Data.MapTo <PermissionDto>();
}
else
{
result = Result <PermissionDto> .FailedResult("保存失败");
}
return(result);
}
}
/// <summary>
/// 保存权限
/// </summary>
/// <param name="saveInfo">权限对象</param>
/// <returns>执行结果</returns>
public Result <AuthorityDto> SaveAuthority(SaveAuthorityCmdDto saveInfo)
{
using (var businessWork = WorkManager.Create())
{
if (saveInfo == null)
{
return(Result <AuthorityDto> .FailedResult("没有指定任何要保存的权限信息"));
}
#region 保存权限数据
var authSaveResult = authorityService.SaveAuthority(saveInfo.Authority.MapTo <Authority>());
if (!authSaveResult.Success)
{
return(Result <AuthorityDto> .FailedResult(authSaveResult.Message));
}
#endregion
var commitVal = businessWork.Commit();
Result <AuthorityDto> result = null;
if (commitVal.EmptyResultOrSuccess)
{
result = Result <AuthorityDto> .SuccessResult("保存成功");
result.Data = authSaveResult.Data.MapTo <AuthorityDto>();
}
else
{
result = Result <AuthorityDto> .FailedResult("保存失败");
}
return(result);
}
}
/// <summary>
/// 保存权限分组
/// </summary>
/// <param name="savePermissionGroupDto">权限分组保存信息</param>
/// <returns>返回执行结果</returns>
public Result <PermissionGroupDto> SavePermissionGroup(SavePermissionGroupDto savePermissionGroupDto)
{
if (savePermissionGroupDto?.PermissionGroup == null)
{
return(Result <PermissionGroupDto> .FailedResult("分组信息不完整"));
}
using (var businessWork = WorkManager.Create())
{
var saveResult = permissionGroupService.Save(savePermissionGroupDto.PermissionGroup.MapTo <PermissionGroup>());
if (!saveResult.Success)
{
return(Result <PermissionGroupDto> .FailedResult(saveResult.Message));
}
var commitResult = businessWork.Commit();
Result <PermissionGroupDto> result = null;
if (commitResult.EmptyResultOrSuccess)
{
result = Result <PermissionGroupDto> .SuccessResult("保存成功");
result.Data = saveResult.Data.MapTo <PermissionGroupDto>();
}
else
{
result = Result <PermissionGroupDto> .FailedResult("保存失败");
}
return(result);
}
}
/// <summary>
/// 修改分组排序
/// </summary>
/// <param name="sortInfo">排序修改信息</param>
/// <returns></returns>
public Result ModifyAuthorityGroupSort(ModifyAuthorityGroupSortCmdDto sortInfo)
{
using (var businessWork = WorkManager.Create())
{
#region 参数判断
if (sortInfo == null || sortInfo.AuthorityGroupSysNo <= 0)
{
return(Result.FailedResult("没有指定要修改的分组"));
}
#endregion
#region 修改分组状态信息
var modifyResult = authorityGroupService.ModifyAuthorityGroupSort(sortInfo.AuthorityGroupSysNo, sortInfo.NewSort);
if (!modifyResult.Success)
{
return(modifyResult);
}
#endregion
var executeVal = businessWork.Commit();
return(executeVal.ExecutedSuccess ? Result.SuccessResult("排序修改成功") : Result.FailedResult("排序修改失败"));
}
}
/// <summary>
/// 修改授权操作状态
/// </summary>
/// <param name="statusInfo">状态信息</param>
/// <returns>执行结果</returns>
public Result ModifyAuthorityOperationStatus(ModifyAuthorityOperationStatusCmdDto statusInfo)
{
if (statusInfo == null || statusInfo.StatusInfo == null || statusInfo.StatusInfo.Count <= 0)
{
return(Result.FailedResult("没有指定任何要修改的状态信息"));
}
using (var businessWork = WorkManager.Create())
{
#region 修改状态信息
List <ModifyAuthorityOperationStatus> newStatusList = new List <ModifyAuthorityOperationStatus>();
foreach (var statusItem in statusInfo.StatusInfo)
{
newStatusList.Add(new ModifyAuthorityOperationStatus()
{
OperationId = statusItem.Key,
Status = statusItem.Value
});
}
var modifyResult = authorityOperationService.ModifyStatus(newStatusList.ToArray());
if (!modifyResult.Success)
{
return(modifyResult);
}
#endregion
var commitVal = businessWork.Commit();
return(commitVal.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 保存角色
/// </summary>
/// <param name="saveRoleDto">角色保存信息</param>
/// <returns>返回角色保存执行结果</returns>
public Result <RoleDto> SaveRole(SaveRoleDto saveRoleDto)
{
if (saveRoleDto?.Role == null)
{
return(Result <RoleDto> .FailedResult("没有指定任何要保存的信息"));
}
using (var businessWork = WorkManager.Create())
{
var roleResult = roleService.Save(saveRoleDto.Role.MapTo <Role>());
if (!roleResult.Success)
{
return(Result <RoleDto> .FailedResult(roleResult.Message));
}
var commitResult = businessWork.Commit();
Result <RoleDto> result;
if (commitResult.EmptyResultOrSuccess)
{
result = Result <RoleDto> .SuccessResult("保存成功");
result.Data = roleResult.Data.MapTo <RoleDto>();
}
else
{
result = Result <RoleDto> .FailedResult("保存失败");
}
return(result);
}
}
/// <summary>
/// 修改权限状态
/// </summary>
/// <param name="statusInfo">状态信息</param>
/// <returns>执行结果</returns>
public Result ModifyAuthorityStatus(ModifyAuthorityStatusCmdDto statusInfo)
{
using (var businessWork = WorkManager.Create())
{
if (statusInfo == null || statusInfo.AuthorityStatusInfo == null)
{
return(Result.FailedResult("没有指定任何要修改的权限信息"));
}
List <ModifyAuthorityStatus> modifyStatusList = new List <ModifyAuthorityStatus>();
foreach (var statusItem in statusInfo.AuthorityStatusInfo)
{
modifyStatusList.Add(new ModifyAuthorityStatus()
{
Code = statusItem.Key,
Status = statusItem.Value
});
}
var modifyResult = authorityService.ModifyAuthorityStatus(modifyStatusList.ToArray());
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitVal = businessWork.Commit();
return(commitVal.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 保存用户
/// </summary>
/// <param name="saveUserDto">用户保存信息</param>
/// <returns>返回用户保存结果</returns>
public Result <UserDto> SaveUser(SaveUserDto saveUserDto)
{
if (saveUserDto?.User == null)
{
return(Result <UserDto> .FailedResult("没有指定任何要保存的用户信息"));
}
using (var businessWork = WorkManager.Create())
{
var user = saveUserDto.User.MapTo <User>();
var userSaveResult = userService.Save(user);
if (!userSaveResult.Success)
{
return(Result <UserDto> .FailedResult(userSaveResult.Message));
}
var commitResult = businessWork.Commit();
Result <UserDto> result;
if (commitResult.EmptyResultOrSuccess)
{
result = Result <UserDto> .SuccessResult("保存成功");
result.Data = userSaveResult.Data.MapTo <UserDto>();
}
else
{
result = Result <UserDto> .FailedResult("保存失败");
}
return(result);
}
}
/// <summary>
/// 修改分组排序
/// </summary>
/// <param name="modifyPermissionGroupSortDto">权限分组排序修改信息</param>
/// <returns>返回执行结果</returns>
public Result ModifyPermissionGroupSort(ModifyPermissionGroupSortDto modifyPermissionGroupSortDto)
{
#region 参数判断
if (modifyPermissionGroupSortDto?.Id < 1)
{
return(Result.FailedResult("没有指定要修改的分组"));
}
#endregion
using (var businessWork = WorkManager.Create())
{
#region 修改分组状态信息
var modifyResult = permissionGroupService.ModifySort(modifyPermissionGroupSortDto.Id, modifyPermissionGroupSortDto.NewSort);
if (!modifyResult.Success)
{
return(modifyResult);
}
#endregion
var executeVal = businessWork.Commit();
return(executeVal.ExecutedSuccess ? Result.SuccessResult("排序修改成功") : Result.FailedResult("排序修改失败"));
}
}
/// <summary>
/// 保存授权操作
/// </summary>
/// <param name="saveInfo">授权操作对象</param>
/// <returns>执行结果</returns>
public Result <AuthorityOperationDto> SaveAuthorityOperation(SaveAuthorityOperationCmdDto saveInfo)
{
if (saveInfo == null)
{
return(Result <AuthorityOperationDto> .FailedResult("授权操作信息不完整"));
}
using (var businessWork = WorkManager.Create())
{
var saveResult = authorityOperationService.SaveAuthorityOperation(saveInfo.AuthorityOperation.MapTo <AuthorityOperation>());
if (!saveResult.Success)
{
return(Result <AuthorityOperationDto> .FailedResult(saveResult.Message));
}
var commitResult = businessWork.Commit();
Result <AuthorityOperationDto> result = null;
if (commitResult.EmptyResultOrSuccess)
{
result = Result <AuthorityOperationDto> .SuccessResult("保存成功");
result.Data = saveResult.Data.MapTo <AuthorityOperationDto>();
}
else
{
result = Result <AuthorityOperationDto> .SuccessResult("保存失败");
}
return(result);
}
}
/// <summary>
/// 初始化操作功能
/// </summary>
/// <param name="initializeOperationDto">操作功能初始化信息</param>
/// <returns>返回执行结果</returns>
public Result Initialize(InitializeOperationDto initializeOperationDto)
{
using (var work = WorkManager.Create())
{
var initResult = operationService.Initialize(initializeOperationDto.MapTo <InitializeOperationParameter>());
if (!initResult.Success)
{
return(initResult);
}
var commitResult = work.Commit();
return(commitResult.EmptyResultOrSuccess ? Result.SuccessResult("初始化成功") : Result.FailedResult("初始化失败"));
}
}
/// <summary>
/// 修改用户绑定角色
/// </summary>
/// <param name="modifyUserRoleDto">用户角色修改信息</param>
/// <returns>返回用户角色修改结果</returns>
public Result ModifyUserRole(ModifyUserRoleDto modifyUserRoleDto)
{
using (var businessWork = WorkManager.Create())
{
var result = userRoleService.Modify(modifyUserRoleDto.MapTo <ModifyUserRoleParameter>());
if (!result.Success)
{
return(result);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 清除操作授权的权限
/// </summary>
/// <param name="operationIds">操作功能编号</param>
/// <returns>返回执行结果</returns>
public Result ClearOperationPermission(IEnumerable <long> operationIds)
{
using (var work = WorkManager.Create())
{
var clearResult = permissionOperationService.ClearByOperation(operationIds);
if (!clearResult.Success)
{
return(clearResult);
}
var commitResult = work.Commit();
return(commitResult.EmptyResultOrSuccess ? Result.SuccessResult("清除成功") : Result.FailedResult("清除失败"));
}
}
/// <summary>
/// 修改用户授权
/// </summary>
/// <param name="modifyUserPermissionDto">用户授权修改信息</param>
/// <returns>返回执行结果</returns>
public Result ModifyUserPermission(ModifyUserPermissionDto modifyUserPermissionDto)
{
if (modifyUserPermissionDto?.UserPermissions.IsNullOrEmpty() ?? true)
{
return(Result.FailedResult("没有指定任何要修改的用户授权信息"));
}
using (var businessWork = WorkManager.Create())
{
var modifyResult = userPermissionService.Modify(modifyUserPermissionDto.MapTo <ModifyUserPermissionParameter>());
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 修改用户状态
/// </summary>
/// <param name="modifyUserStatusDto">用户状态修改信息</param>
/// <returns>返回状态修改执行结果</returns>
public Result ModifyStatus(ModifyUserStatusDto modifyUserStatusDto)
{
if (modifyUserStatusDto?.StatusInfos.IsNullOrEmpty() ?? true)
{
return(Result.FailedResult("没有指定要修改状态的用户信息"));
}
using (var businessWork = WorkManager.Create())
{
var modifyResult = userService.ModifyStatus(modifyUserStatusDto.MapTo <ModifyUserStatusParameter>());
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitVal = businessWork.Commit();
return(commitVal.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 删除用户
/// </summary>
/// <param name="deleteUserDto">删除用户信息</param>
/// <returns>返回用户删除结果</returns>
public Result RemoveUser(RemoveUserDto deleteUserDto)
{
if (deleteUserDto?.Ids.IsNullOrEmpty() ?? true)
{
return(Result.FailedResult("没有指定任何要删除的用户信息"));
}
using (var businessWork = WorkManager.Create())
{
var deleteResult = userService.Remove(deleteUserDto.Ids);
if (!deleteResult.Success)
{
return(deleteResult);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("删除成功") : Result.FailedResult("删除失败"));
}
}
/// <summary>
/// 删除用户
/// </summary>
/// <param name="deleteInfo">删除信息</param>
/// <returns></returns>
public Result DeleteUser(DeleteUserCmdDto deleteInfo)
{
if (deleteInfo == null || deleteInfo.UserIds.IsNullOrEmpty())
{
return(Result.FailedResult("没有指定任何要删除的用户信息"));
}
using (var businessWork = WorkManager.Create())
{
var deleteResult = userService.DeleteUser(deleteInfo.UserIds);
if (!deleteResult.Success)
{
return(deleteResult);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("删除成功") : Result.FailedResult("删除失败"));
}
}
/// <summary>
/// 修改分组排序
/// </summary>
/// <param name="modifyOperationGroupSortDto">操作分组排序修改信息</param>
/// <returns>返回执行结果</returns>
public Result ModifyOperationGroupSort(ModifyOperationGroupSortDto modifyOperationGroupSortDto)
{
if (modifyOperationGroupSortDto == null)
{
return(Result.FailedResult("没有指定任何要修改的信息"));
}
using (var businessWork = WorkManager.Create())
{
var modifyResult = operationGroupService.ModifySort(modifyOperationGroupSortDto.Id, modifyOperationGroupSortDto.NewSort);
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 修改分组排序
/// </summary>
/// <param name="sortInfo">排序信息</param>
/// <returns>执行结果</returns>
public Result ModifyAuthorityOperationGroupSort(ModifyAuthorityOperationGroupSortCmdDto sortInfo)
{
if (sortInfo == null)
{
return(Result.FailedResult("没有指定任何要修改的信息"));
}
using (var businessWork = WorkManager.Create())
{
var modifyResult = authorityOperationGroupService.ModifySort(sortInfo.AuthorityOperationGroupSysNo, sortInfo.NewSort);
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 修改用户授权
/// </summary>
/// <param name="authorizeInfo">用户授权信息</param>
/// <returns></returns>
public Result ModifyUserAuthorize(ModifyUserAuthorizeCmdDto authorizeInfo)
{
if (authorizeInfo == null || authorizeInfo.UserAuthorizes.IsNullOrEmpty())
{
return(Result.FailedResult("没有指定任何要修改的用户授权信息"));
}
using (var businessWork = WorkManager.Create())
{
var modifyResult = authorizeService.ModifyUserAuthorize(authorizeInfo.UserAuthorizes.Select(c => c.MapTo <UserAuthorize>()));
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 修改角色授权
/// </summary>
/// <param name="modifyRolePermissionDto">角色授权修改信息</param>
/// <returns>返回执行结果</returns>
public Result ModifyRolePermission(ModifyRolePermissionDto modifyRolePermissionDto)
{
if (modifyRolePermissionDto == null)
{
return(Result.FailedResult("没有指定任何要修改的角色授权信息"));
}
using (var businessWork = WorkManager.Create())
{
var modifyResult = rolePermissionService.Modify(modifyRolePermissionDto.MapTo <ModifyRolePermissionParameter>());
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 修改角色授权
/// </summary>
/// <param name="authInfo">授权信息</param>
/// <returns></returns>
public Result ModifyRoleAuthorize(ModifyRoleAuthorizeCmdDto authInfo)
{
if (authInfo == null)
{
return(Result.FailedResult("没有指定任何要修改的角色授权信息"));
}
using (var businessWork = WorkManager.Create())
{
var modifyResult = authorizeService.ModifyRoleAuthorize(authInfo.MapTo <ModifyRoleAuthorize>());
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 修改权限及权限操作绑定
/// </summary>
/// <param name="bindInfo">绑定信息</param>
/// <returns></returns>
public Result ModifyAuthorityOperationBindAuthority(ModifyAuthorityBindAuthorityOperationCmdDto bindInfo)
{
if (bindInfo == null)
{
return(Result.FailedResult("没有指定任何要修改的信息"));
}
using (var businessWork = WorkManager.Create())
{
var modifyResult = authorityBindAuthorityOperationService.ModifyAuthorityAndAuthorityOperationBind(bindInfo.MapTo <ModifyAuthorityAndAuthorityOperationBind>());
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitResult = businessWork.Commit();
return(commitResult.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 删除角色
/// </summary>
/// <param name="deleteInfo">删除信息</param>
/// <returns>执行结果</returns>
public Result DeleteRole(DeleteRoleCmdDto deleteInfo)
{
using (var businessWork = WorkManager.Create())
{
#region 参数判断
if (deleteInfo == null || deleteInfo.RoleIds.IsNullOrEmpty())
{
return(Result.FailedResult("没有指定要删除的角色"));
}
#endregion
roleService.RemoveRole(deleteInfo.RoleIds);
var exectVal = businessWork.Commit();
return(exectVal.ExecutedSuccess ? Result.SuccessResult("删除成功") : Result.FailedResult("删除失败"));
}
}
/// <summary>
/// 删除权限
/// </summary>
/// <param name="removePermissionDto">权限删除信息</param>
/// <returns>返回执行结果</returns>
public Result RemovePermission(RemovePermissionDto removePermissionDto)
{
using (var businessWork = WorkManager.Create())
{
#region 参数判断
if (removePermissionDto?.Ids.IsNullOrEmpty() ?? true)
{
return(Result.FailedResult("没有指定要删除的权限"));
}
#endregion
permissionService.Remove(removePermissionDto.Ids);
var exectVal = businessWork.Commit();
return(exectVal.ExecutedSuccess ? Result.SuccessResult("删除成功") : Result.FailedResult("删除失败"));
}
}
/// <summary>
/// 删除授权操作
/// </summary>
/// <param name="deleteInfo">删除信息</param>
/// <returns>执行结果</returns>
public Result DeleteAuthorityOperation(DeleteAuthorityOperationCmdDto deleteInfo)
{
using (var businessWork = WorkManager.Create())
{
#region 参数判断
if (deleteInfo == null || deleteInfo.AuthorityOperationIds.IsNullOrEmpty())
{
return(Result.FailedResult("没有指定要删除的授权操作"));
}
#endregion
authorityOperationService.DeleteAuthorityOperation(deleteInfo.AuthorityOperationIds);
var exectVal = businessWork.Commit();
return(exectVal.ExecutedSuccess ? Result.SuccessResult("删除成功") : Result.FailedResult("删除失败"));
}
}
/// <summary>
/// 修改用户状态
/// </summary>
/// <param name="statusInfo">状态信息</param>
/// <returns>执行结果</returns>
public Result ModifyStatus(ModifyUserStatusCmdDto statusInfo)
{
using (var businessWork = WorkManager.Create())
{
if (statusInfo == null || statusInfo.UserId <= 0)
{
return(Result.FailedResult("没有指定要修改状态的用户信息"));
}
var modifyResult = userService.ModifyStatus(new UserStatusInfo()
{
UserId = statusInfo.UserId,
Status = statusInfo.Status
});
if (!modifyResult.Success)
{
return(modifyResult);
}
var commitVal = businessWork.Commit();
return(commitVal.ExecutedSuccess ? Result.SuccessResult("修改成功") : Result.FailedResult("修改失败"));
}
}
/// <summary>
/// 清除用户授权
/// </summary>
/// <param name="userIds">用户系统编号</param>
/// <returns>返回执行结果</returns>
public Result ClearUserPermission(IEnumerable <long> userIds)
{
if (userIds.IsNullOrEmpty())
{
return(Result.FailedResult("没有指定任何用户信息"));
}
using (var work = WorkManager.Create())
{
var result = userPermissionService.ClearByUser(userIds);
if (!result.Success)
{
return(result);
}
var commitResult = work.Commit();
if (!commitResult.EmptyResultOrSuccess)
{
result = Result.FailedResult("修改失败");
}
return(result);
}
}
/// <summary>
/// 清除角色下所有的用户
/// </summary>
/// <param name="roleIds">角色编号</param>
/// <returns>返回清除用户执行结果</returns>
public Result ClearUser(IEnumerable <long> roleIds)
{
if (roleIds.IsNullOrEmpty())
{
return(Result.FailedResult("没有任何要操作的角色"));
}
using (var work = WorkManager.Create())
{
var result = userRoleService.ClearByRole(roleIds);
if (!result.Success)
{
return(result);
}
var commitResult = work.Commit();
if (!commitResult.EmptyResultOrSuccess)
{
result = Result.FailedResult("修改失败");
}
return(result);
}
}
/// <summary>
/// 清除角色授权
/// </summary>
/// <param name="roleSysNos">角色系统编号</param>
/// <returns>执行结果</returns>
public Result ClearRoleAuthorize(IEnumerable <long> roleSysNos)
{
if (roleSysNos.IsNullOrEmpty())
{
return(Result.FailedResult("没有指定任何角色信息"));
}
using (var work = WorkManager.Create())
{
var result = authorizeService.ClearRoleAuthorize(roleSysNos);
if (!result.Success)
{
return(result);
}
var commitResult = work.Commit();
if (!commitResult.EmptyResultOrSuccess)
{
result = Result.FailedResult("修改失败");
}
return(result);
}
}
