private async Task CreateSubCorporation(CreateCorporationInput input)
{
var parentCorporation = await _corporationRepository.SingleAsync(p => p.OrgId == input.ParentId.Value);
if (parentCorporation.Mold == Shared.CorporationMold.Monomer)
{
throw new BusinessException("单体公司不允许增加子公司");
}
var parentOrg = await _organizationRepository.GetAsync(input.ParentId.Value);
var corporation = input.MapTo <Corporation>();
var orgInfo = input.MapTo <Organization>();
var orgCode = string.Empty;
var maxLevelOrg = (await _organizationRepository.GetAllAsync(p => p.ParentId == parentOrg.Id)).OrderByDescending(p => p.Id).FirstOrDefault();
if (maxLevelOrg == null)
{
orgCode = "1".PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
}
else
{
orgCode = (Convert.ToInt32(maxLevelOrg.Code.Split(HeroConstants.CodeRuleRestrain.CodeSeparator).Last().TrimStart('0')) + 1).ToString().PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
}
orgInfo.Code = parentOrg.Code + HeroConstants.CodeRuleRestrain.CodeSeparator + orgCode;
orgInfo.Level = parentOrg.Level + 1;
await UnitOfWorkAsync(async (conn, trans) =>
{
var orgId = await _organizationRepository.InsertAndGetIdAsync(orgInfo, conn, trans);
corporation.OrgId = orgId;
await _corporationRepository.InsertAsync(corporation, conn, trans);
}, Connection);
}
public async virtual Task <TEntityDto> Insert(TInsertInput input)
{
var entity = MapToEntity(input);
var primaryKey = await Repository.InsertAndGetIdAsync(entity);
return(MapToEntityDto(entity));
}
public async Task Create(CreateRoleInput input)
{
var exsitRole = await _roleRepository.FirstOrDefaultAsync(p => p.Name == input.Name);
if (exsitRole != null)
{
throw new BusinessException($"系统中已经存在{input.Name}的角色");
}
var role = input.MapTo <Role>();
await UnitOfWorkAsync(async (conn, trans) =>
{
var roleId = await _roleRepository.InsertAndGetIdAsync(role, conn, trans);
var queryOperationSql = "SELECT o.* FROM `Operation` as o LEFT JOIN Permission as p ON o.PermissionId = p.Id AND p.IsDeleted = 0 AND o.IsDeleted = 0 WHERE o.PermissionId IN @PermissionIds";
var operations = await conn.QueryAsync <Operation>(queryOperationSql, new { PermissionIds = input.PermissionIds }, transaction: trans);
if (!operations.Any(p => p.Mold == Shared.Operations.OperationMold.Query || p.Mold == Shared.Operations.OperationMold.Look))
{
throw new BusinessException($"分配的权限至少要包含查询或是查看类型操作");
}
await _rolePermissionRepository.DeleteAsync(p => p.RoleId == roleId, conn, trans);
foreach (var permissionId in input.PermissionIds)
{
var permission = await _permissionRepository.SingleOrDefaultAsync(p => p.Id == permissionId);
if (permission == null)
{
throw new BusinessException($"不存在Id为{permissionId}的权限信息");
}
await _rolePermissionRepository.InsertAsync(new RolePermission()
{
PermissionId = permissionId, RoleId = roleId
}, conn, trans);
}
}, Connection);
}
public async Task <string> Create(CreateTenantInput input)
{
var exsitTenant = await _tenantRepository.FirstOrDefaultAsync(p => p.Name == input.Name.Trim());
if (exsitTenant != null)
{
throw new BusinessException($"已经存在{input.Name}的租户");
}
var corporationAppServiceProxy = GetService <ICorporationAppService>();
await UnitOfWorkAsync(async (conn, trans) =>
{
var tenantId = await _tenantRepository.InsertAndGetIdAsync(input.MapTo <Tenant>(), conn, trans);
if (input.CreateSuper)
{
await CreateAdminAndRole(tenantId, input, conn, trans);
}
await corporationAppServiceProxy.CreateByTenant(new CreateCorporationByTenantInput()
{
Name = input.Name,
Identification = input.Identification,
ParentId = 0,
OpenDate = DateTime.Now,
RegisterDate = DateTime.Now,
Mold = CorporationMold.Group,
TenantId = tenantId
});
}, Connection);
return("新增租户成功");
}
public async Task Create(CreateMenuInput input)
{
var menu = input.MapTo <Menu>();
var thisLevelMenuCount = await _menuRepository.GetCountAsync(p => p.ParentId == input.ParentId);
if (menu.Mold == MenuMold.Top)
{
menu.Code = (thisLevelMenuCount + 1).ToString().PadRight(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
menu.Level = 1;
}
else
{
var parentMenu = await _menuRepository.SingleOrDefaultAsync(p => p.Id == input.ParentId);
if (parentMenu == null)
{
throw new BusinessException($"不存在Id为{input.ParentId}的菜单信息");
}
menu.Code = parentMenu.Code + HeroConstants.CodeRuleRestrain.CodeSeparator + (thisLevelMenuCount + 1).ToString().PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
menu.Level = parentMenu.Level + 1;
}
var permission = input.MapTo <Permission>();
await UnitOfWorkAsync(async (conn, trans) => {
var permissionId = await _permissionRepository.InsertAndGetIdAsync(permission, conn, trans);
menu.PermissionId = permissionId;
await _menuRepository.InsertAsync(menu, conn, trans);
}, Connection);
}
public async Task CreateMenu(Menu menu, Permission permission)
{
await UnitOfWorkAsync(async (conn, trans) => {
var permissionId = await _permissionRepository.InsertAndGetIdAsync(permission, conn, trans);
menu.PermissionId = permissionId;
await _menuRepository.InsertAsync(menu, conn, trans);
}, Connection);
}
public async Task execute_method_for_void_sqls_should_work()
{
int blogId = await _blogDapperRepository.InsertAndGetIdAsync(new Blog("Oguzhan_Blog", "wwww.aspnetboilerplate.com"));
await _blogDapperRepository.ExecuteAsync("Update Blogs Set Name = @name where Id =@id", new { id = blogId, name = "Oguzhan_New_Blog" });
(await _blogDapperRepository.GetAsync(blogId)).Name.ShouldBe("Oguzhan_New_Blog");
(await _blogRepository.GetAsync(blogId)).Name.ShouldBe("Oguzhan_New_Blog");
}
public async Task <long> Create(CreateUserInput input, long?tenanId = null)
{
var userInfo = await CheckUserInfo(input, tenanId);
userInfo.Password = _passwordHelper.EncryptPassword(userInfo.UserName, userInfo.Password);
using (var locker = await _lockerProvider.CreateLockAsync("CreateUser"))
{
return(await locker.Lock(async() =>
{
await UnitOfWorkAsync(async(conn, trans) =>
{
var userId = await _userRepository.InsertAndGetIdAsync(userInfo, conn, trans);
foreach (var roleId in input.RoleIds)
{
var role = await _roleRepository.SingleOrDefaultAsync(p => p.Id == roleId, conn, trans);
if (role == null)
{
throw new BusinessException($"系统中不存在Id为{roleId}的角色信息");
}
await _userRoleRepository.InsertAsync(new UserRole {
UserId = userId, RoleId = roleId, TenantId = userInfo.TenantId
}, conn,
trans);
}
foreach (var userGroupId in input.UserGroupIds)
{
var userGroup = await _userGroupRepository.SingleOrDefaultAsync(p => p.Id == userGroupId);
if (userGroup == null)
{
throw new BusinessException($"系统中不存在Id为{userGroupId}的用户组信息");
}
await _userUserGroupRelationRepository.InsertAsync(
new UserUserGroupRelation {
UserId = userId, UserGroupId = userGroupId, TenantId = userInfo.TenantId
}, conn, trans);
}
}, Connection);
return userInfo.Id;
}));
}
}
public async Task inline_sql_with_dapper_should_rollback_when_uow_fails()
{
Resolve <IEventBus>().Register <EntityCreatingEventData <Blog> >(eventData =>
{
eventData.Entity.Name.ShouldBe("Oguzhan_Same_Uow");
});
var blogId = 0;
using (var uow = Resolve <IUnitOfWorkManager>().Begin())
{
blogId = await _blogDapperRepository.InsertAndGetIdAsync(
new Blog("Oguzhan_Same_Uow", "www.aspnetboilerplate.com")
);
var person = await _blogRepository.GetAsync(blogId);
person.ShouldNotBeNull();
await uow.CompleteAsync();
}
try
{
using (IUnitOfWorkCompleteHandle uow = Resolve <IUnitOfWorkManager>()
.Begin(new UnitOfWorkOptions {
IsTransactional = true
}))
{
await _blogDapperRepository.ExecuteAsync(
"Update Blogs Set Name = @name where Id =@id",
new
{
id = blogId, name = "Oguzhan_New_Blog"
}
);
throw new Exception("uow rollback");
// Unreachable code.
// await uow.CompleteAsync();
}
}
catch (Exception)
{
//no handling.
}
(await _blogDapperRepository.FirstOrDefaultAsync(x => x.Name == "Oguzhan_New_Blog")).ShouldBeNull();
(await _blogRepository.FirstOrDefaultAsync(x => x.Name == "Oguzhan_New_Blog")).ShouldBeNull();
(await _blogDapperRepository.FirstOrDefaultAsync(x => x.Name == "Oguzhan_Same_Uow")).ShouldNotBeNull();
(await _blogRepository.FirstOrDefaultAsync(x => x.Name == "Oguzhan_Same_Uow")).ShouldNotBeNull();
}
public async Task <CreateOperationOutput> Create(CreateOperationInput input)
{
var exsitOperation = await _operationRepository.FirstOrDefaultAsync(p => p.Name == input.Name);
if (exsitOperation != null)
{
throw new BusinessException($"系统中已经存在{input.Name}的操作,请勿重复添加");
}
var menu = await _menuRepository.SingleOrDefaultAsync(p => p.PermissionId == input.PermissionId);
if (menu == null)
{
throw new BusinessException($"不存在PermissionId为{input.PermissionId}的菜单信息");
}
var operation = input.MapTo <Operation>();
var permission = input.MapTo <Permission>();
var operationCount = await _operationRepository.GetCountAsync(p => p.MenuId == input.PermissionId);
operation.Code = menu.Code + HeroConstants.CodeRuleRestrain.CodeSeparator + (operationCount + 1).ToString().PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
operation.Level = menu.Level + 1;
await UnitOfWorkAsync(async (conn, trans) =>
{
var permissionId = await _permissionRepository.InsertAndGetIdAsync(permission, conn, trans);
operation.PermissionId = permissionId;
operation.MenuId = menu.Id;
var operationId = await _operationRepository.InsertAndGetIdAsync(operation, conn, trans);
if (input.ActionIds != null && input.ActionIds.Any())
{
foreach (var actionId in input.ActionIds)
{
var action = await _actionRepository.SingleOrDefaultAsync(p => p.Id == actionId);
if (action == null)
{
throw new BusinessException($"系统中不存在Id为{actionId}的方法");
}
var operationAction = new OperationActionRelation()
{
ActionId = actionId, OperationId = operationId, ServiceId = action.ServiceId
};
await _operationActionRepository.InsertAsync(operationAction, conn, trans);
}
}
}, Connection);
return(new CreateOperationOutput()
{
Id = operation.Id, PermissionId = operation.PermissionId, Tips = "新增操作成功"
});
}
public async Task Create(CreateUserGroupInput input)
{
var userGroup = input.MapTo <UserGroup>();
var thisLevelUserGroupCount = await _userGroupRepository.GetCountAsync(p => p.ParentId == input.ParentId);
if (input.ParentId == 0)
{
userGroup.Level = 1;
userGroup.Code = (thisLevelUserGroupCount + 1).ToString().PadRight(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
}
else
{
var parentUserGroup = await _userGroupRepository.SingleOrDefaultAsync(p => p.Id == input.ParentId);
if (parentUserGroup == null)
{
throw new BusinessException($"不存在Id为{input.ParentId}的用户组信息");
}
userGroup.Level = parentUserGroup.Level + 1;
userGroup.Code = parentUserGroup.Code + HeroConstants.CodeRuleRestrain.CodeSeparator + (thisLevelUserGroupCount + 1).ToString().PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
}
await UnitOfWorkAsync(async (conn, trans) =>
{
var userGroupId = await _userGroupRepository.InsertAndGetIdAsync(userGroup, conn, trans);
foreach (var userId in input.UserIds)
{
var userInfo = await _userRepository.SingleOrDefaultAsync(p => p.Id == userId);
if (userInfo == null)
{
throw new BusinessException($"不存在用户Id为{userId}的用户信息");
}
await _userUserGroupRelationRepository.InsertAsync(new UserUserGroupRelation()
{
UserGroupId = userGroupId, UserId = userId
}, conn, trans);
}
foreach (var roleId in input.RoleIds)
{
var roleInfo = await _roleRepository.SingleOrDefaultAsync(p => p.Id == roleId);
if (roleInfo == null)
{
throw new BusinessException($"不存在用户Id为{roleId}的角色信息");
}
await _userGroupRoleRepository.InsertAsync(new UserGroupRole()
{
UserGroupId = userGroupId, RoleId = roleId
}, conn, trans);
}
}, Connection);
}
public async Task CreateOperation(Permission operation, IEnumerable <long> functionIds)
{
await UnitOfWorkAsync(async (conn, trans) => {
var permissionId = await _permissionRepository.InsertAndGetIdAsync(operation, conn, trans);
foreach (var funcId in functionIds)
{
var permissionFunc = new PermissionFunction()
{
FunctionId = funcId,
PermissionId = permissionId,
};
await _permissionFunctionRepository.InsertAsync(permissionFunc, conn, trans);
}
}, Connection);
}
public async Task <CreateMenuOutput> Create(CreateMenuInput input)
{
var menu = input.MapTo <Menu>();
long menuParentId = 0;
var exsitMenu = await _menuRepository.FirstOrDefaultAsync(p => p.Name == input.Name);
if (exsitMenu != null)
{
throw new BusinessException($"系统中已经存在{input.Name}的菜单,请勿重复添加");
}
if (menu.Mold == MenuMold.Top)
{
var thisLevelMenuCount = await _menuRepository.GetCountAsync(p => p.Mold == MenuMold.Top);
menu.Code = (thisLevelMenuCount + 1).ToString().PadRight(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
menu.Level = 1;
}
else
{
var parentMenu = await _menuRepository.SingleOrDefaultAsync(p => p.PermissionId == input.ParentPermissionId);
if (parentMenu == null)
{
throw new BusinessException($"不存在PermissionId为{input.ParentPermissionId}的菜单信息");
}
menuParentId = parentMenu.Id;
var thisLevelMenuCount = await _menuRepository.GetCountAsync(p => p.Mold == MenuMold.SubMenu && p.ParentId == parentMenu.Id);
menu.Code = parentMenu.Code + HeroConstants.CodeRuleRestrain.CodeSeparator + (thisLevelMenuCount + 1).ToString().PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
menu.Level = parentMenu.Level + 1;
}
var permission = input.MapTo <Permission>();
await UnitOfWorkAsync(async (conn, trans) => {
var permissionId = await _permissionRepository.InsertAndGetIdAsync(permission, conn, trans);
menu.PermissionId = permissionId;
menu.ParentId = menuParentId;
await _menuRepository.InsertAsync(menu, conn, trans);
}, Connection);
return(new CreateMenuOutput()
{
Id = menu.Id, PermissionId = menu.PermissionId, Tips = "新增菜单成功"
});
}
public async Task <bool> CreateAsync(UserInfo user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(UserInfo));
}
UnitOfWork((conn, trans) => {
var userId = _userRepository.InsertAndGetIdAsync(user, conn, trans).Result;
if (user.Roles.Any())
{
foreach (var role in user.Roles)
{
role.UserId = userId;
_userRoleRepository.InsertAsync(role, conn, trans).Wait();
}
}
}, Connection);
return(true);
}
/// <summary>
/// 保存
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task <AjaxResponse> SaveFormDapperModel(TempTableDto model)
{
if (model.Id == null)
{
model.Id = await _dapperRepositoryTableInfo.InsertAndGetIdAsync(ObjectMapper.Map <TempTable>(model));
}
else
{
//获取需要更新的数据
var data = _dapperRepositoryTableInfo.Get(model.Id.Value);
//映射需要修改的数据对象
var m = ObjectMapper.Map(model, data);
//提交修改
await _dapperRepositoryTableInfo.UpdateAsync(m);
}
return(new AjaxResponse {
Success = true, Result = model.Id
});
}
public async Task InitActions(ICollection <InitActionActionInput> actions)
{
await UnitOfWorkAsync(async (conn, trans) => {
foreach (var action in actions)
{
var actionEntity = await _actionRepository.SingleOrDefaultAsync(p => p.ServiceId == action.ServiceId);
if (actionEntity == null)
{
actionEntity = action.MapTo <Action>();
var actionId = await _actionRepository.InsertAndGetIdAsync(actionEntity, conn, trans);
var operationActionRelations = await _operationActionRelationRepository.GetAllAsync(p => p.ServiceId == action.ServiceId);
if (operationActionRelations.Any())
{
foreach (var operationActionRelation in operationActionRelations)
{
operationActionRelation.ActionId = actionId;
await _operationActionRelationRepository.UpdateAsync(operationActionRelation, conn, trans);
}
}
}
else
{
actionEntity = action.MapTo(actionEntity);
await _actionRepository.UpdateAsync(actionEntity, conn, trans);
var operationActionRelations = await _operationActionRelationRepository.GetAllAsync(p => p.ServiceId == action.ServiceId);
if (operationActionRelations.Any())
{
foreach (var operationActionRelation in operationActionRelations)
{
if (operationActionRelation.ActionId != actionEntity.Id)
{
operationActionRelation.ActionId = actionEntity.Id;
await _operationActionRelationRepository.UpdateAsync(operationActionRelation, conn, trans);
}
}
}
}
}
}, Connection);
}
public async Task Create(CreateUserInput input)
{
var userInfo = input.MapTo <UserInfo>();
var departAppServiceProxy = GetService <IDepartmentAppService>();
if (userInfo.OrgId.HasValue)
{
if (!await departAppServiceProxy.Check(userInfo.OrgId.Value))
{
throw new BusinessException($"不存在Id为{userInfo.OrgId}的部门信息");
}
}
var positionAppServiceProxy = GetService <IPositionAppService>();
if (userInfo.PositionId.HasValue)
{
if (!await positionAppServiceProxy.Check(userInfo.PositionId.Value))
{
throw new BusinessException($"不存在Id为{userInfo.PositionId}的职位信息");
}
}
userInfo.Password = _passwordHelper.EncryptPassword(userInfo.UserName, userInfo.Password);
await UnitOfWorkAsync(async (conn, trans) => {
var userId = await _userRepository.InsertAndGetIdAsync(userInfo, conn, trans);
foreach (var roleId in input.RoleIds)
{
var role = await _roleRepository.SingleOrDefaultAsync(p => p.Id == roleId);
if (role == null)
{
throw new BusinessException($"系统中不存在Id为{roleId}的角色信息");
}
await _userRoleRepository.InsertAsync(new UserRole()
{
UserId = userId, RoleId = roleId
}, conn, trans);
}
}, Connection);
}
public async Task <long> Create(CreateRoleInput input, long?tenantId = null)
{
using (var locker = await _lockerProvider.CreateLockAsync("CreateRole"))
{
return(await locker.Lock(async() =>
{
var exsitRole =
await _roleRepository.FirstOrDefaultAsync(p => p.Identification == input.Identification, false);
if (exsitRole != null)
{
throw new BusinessException($"系统中已经存在{input.Identification}的角色");
}
CheckUserDefinedDataPermission(input.DataPermissionType, input.DataPermissionOrgIds);
var role = input.MapTo <Role>();
role.TenantId = _session.TenantId;
if (tenantId.HasValue)
{
role.TenantId = tenantId.Value;
}
await UnitOfWorkAsync(async(conn, trans) =>
{
var roleId = await _roleRepository.InsertAndGetIdAsync(role, conn, trans);
await _rolePermissionRepository.DeleteAsync(p => p.RoleId == role.Id, conn, trans);
var insertSql =
"INSERT INTO RolePermission(PermissionId,RoleId,CreateTime,CreateBy,TenantId) VALUES(@PermissionId,@RoleId,@CreationTime,@CreatorUserId,@TenantId)";
var rolePermissions = new List <RolePermission>();
foreach (var permissionId in input.PermissionIds)
{
rolePermissions.Add(new RolePermission
{
PermissionId = permissionId,
RoleId = roleId,
CreationTime = DateTime.Now,
CreatorUserId = _session.UserId,
TenantId = role.TenantId
});
}
await conn.ExecuteAsync(insertSql, rolePermissions, trans);
if (!input.IsAllOrg)
{
foreach (var orgId in input.OrgIds)
{
var roleOrg = new RoleOrganization()
{
RoleId = roleId, OrgId = orgId, TenantId = role.TenantId
};
await _roleOrganizationRepository.InsertAsync(roleOrg, conn, trans);
}
}
if (input.DataPermissionType == DataPermissionType.UserDefined)
{
var insertDataPermissionOrgSql =
"INSERT INTO RoleDataPermissionOrgRelation(RoleId,OrgId,CreateTime,CreateBy,TenantId) VALUES(@RoleId,@OrgId,@CreationTime,@CreatorUserId,@TenantId)";
var dataPermissionOrgDatas = new List <RoleDataPermissionOrgRelation>();
foreach (var orgId in input.DataPermissionOrgIds)
{
dataPermissionOrgDatas.Add(new RoleDataPermissionOrgRelation()
{
RoleId = roleId,
OrgId = orgId,
CreationTime = DateTime.Now,
CreatorUserId = _session.UserId,
TenantId = role.TenantId
});
}
await conn.ExecuteAsync(insertDataPermissionOrgSql, dataPermissionOrgDatas, trans);
}
}, Connection);
return role.Id;
}));
}
}
public async Task InitActions(ICollection <InitActionActionInput> actions)
{
using (var locker = await _lockerProvider.CreateLockAsync("InitActions"))
{
await locker.Lock(async() =>
{
foreach (var action in actions)
{
await UnitOfWorkAsync(async(conn, trans) =>
{
try
{
var actionEntity =
await _actionRepository.SingleOrDefaultAsync(p => p.ServiceId == action.ServiceId);
if (actionEntity == null)
{
actionEntity = action.MapTo <Action>();
var actionId =
await _actionRepository.InsertAndGetIdAsync(actionEntity, conn, trans);
var operationActionRelations =
await _operationActionRelationRepository.GetAllAsync(
p => p.ServiceId == action.ServiceId, conn, trans);
if (operationActionRelations.Any())
{
foreach (var operationActionRelation in operationActionRelations)
{
operationActionRelation.ActionId = actionId;
await _operationActionRelationRepository.UpdateAsync(
operationActionRelation, conn, trans);
}
}
}
else
{
actionEntity = action.MapTo(actionEntity);
await _actionRepository.UpdateAsync(actionEntity, conn, trans);
var operationActionRelations =
await _operationActionRelationRepository.GetAllAsync(p =>
p.ServiceId == action.ServiceId);
if (operationActionRelations.Any())
{
foreach (var operationActionRelation in operationActionRelations)
{
if (operationActionRelation.ActionId != actionEntity.Id)
{
operationActionRelation.ActionId = actionEntity.Id;
await _operationActionRelationRepository.UpdateAsync(
operationActionRelation, conn, trans);
}
}
}
}
}
catch (Exception e)
{
trans.Rollback();
throw e;
}
}, Connection);
}
});
}
}
public async Task <CreateDepartmentOutput> CreateDepartment(CreateDepartmentInput input)
{
var parentOrg = await _organizationRepository.SingleOrDefaultAsync(p => p.Id == input.ParentId);
if (parentOrg == null)
{
throw new BusinessException($"不存在Id为{input.ParentId}的上级信息");
}
if (input.DeptTypeKey.IsNullOrEmpty())
{
throw new BusinessException("请选择部门类型");
}
var exsitOrg =
await _organizationRepository.SingleOrDefaultAsync(p => p.Identification == input.Identification);
if (exsitOrg != null)
{
throw new BusinessException($"系统中已经存在标识为{input.Identification}的组织机构");
}
var workbookAppServiceProxy = GetService <IWordbookAppService>();
var checkDeptTypeResult = await workbookAppServiceProxy.Check(new CheckWordbookInput
{ WordbookCode = SystemPresetWordbookCode.Organization.DeptType, WordbookItemKey = input.DeptTypeKey });
if (!checkDeptTypeResult)
{
throw new BusinessException("指定的部门类型Key不正确,请选择正确的部门类型");
}
var department = input.MapTo <Department>();
var orgInfo = input.MapTo <Organization>();
var orgCode = string.Empty;
var maxLevelOrg = (await _organizationRepository.GetAllAsync(p => p.ParentId == parentOrg.Id))
.OrderByDescending(p => p.Id).FirstOrDefault();
if (maxLevelOrg == null)
{
orgCode = "1".PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit,
HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
}
else
{
orgCode =
(Convert.ToInt32(maxLevelOrg.Code.Split(HeroConstants.CodeRuleRestrain.CodeCoverSymbol).Last()
.TrimStart('0')) + 1).ToString().PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit,
HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
}
orgInfo.Level = parentOrg.Level + 1;
orgInfo.Code = parentOrg.Code + HeroConstants.CodeRuleRestrain.CodeSeparator + orgCode;
await UnitOfWorkAsync(async (conn, trans) =>
{
var orgId = await _organizationRepository.InsertAndGetIdAsync(orgInfo, conn, trans);
department.OrgId = orgId;
var deptId = await _departmentRepository.InsertAndGetIdAsync(department, conn, trans);
if (input.Positions != null && input.Positions.Any())
{
if (input.Positions.Count(p => p.IsLeadingOfficial) > 1)
{
throw new BusinessException("部门只允许设置一个负责人岗位");
}
var sort = 1;
foreach (var positionInput in input.Positions)
{
var position = positionInput.MapTo <Position>();
position.DeptId = deptId;
position.CheckDataAnnotations().CheckValidResult();
var positionCode = orgInfo.Code + HeroConstants.CodeRuleRestrain.CodeSeparator + sort.ToString()
.PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit,
HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
position.Code = positionCode;
await _positionRepository.InsertAsync(position, conn, trans);
sort++;
}
}
}, Connection);
return(new CreateDepartmentOutput
{
OrgId = orgInfo.Id,
DeptId = department.Id,
Tips = "新增部门信息成功"
});
}
public async Task Create(CreateUserGroupInput input)
{
CheckUserDefinedDataPermission(input.DataPermissionType, input.DataPermissionOrgIds);
using (var locker = await _lockerProvider.CreateLockAsync("CreateUserGroup"))
{
await locker.Lock(async() =>
{
var exsitUserGroup = await _userGroupRepository.FirstOrDefaultAsync(p => p.Identification == input.Identification, false);
if (exsitUserGroup != null)
{
throw new BusinessException($"系统中已经存在{input.Identification}的用户组");
}
var userGroup = input.MapTo <UserGroup>();
await UnitOfWorkAsync(async(conn, trans) =>
{
var userGroupId = await _userGroupRepository.InsertAndGetIdAsync(userGroup, conn, trans);
foreach (var roleId in input.RoleIds)
{
await _userGroupRoleRepository.InsertAsync(
new UserGroupRole {
UserGroupId = userGroupId, RoleId = roleId
}, conn, trans);
}
if (!input.IsAllOrg)
{
foreach (var orgId in input.OrgIds)
{
var userGroupOrg = new UserGroupOrganization()
{
UserGroupId = userGroupId, OrgId = orgId
};
await _userGroupOrganizationRepository.InsertAsync(userGroupOrg, conn, trans);
}
}
var insertSql =
"INSERT INTO UserGroupPermission(PermissionId,UserGroupId,CreateTime,CreateBy,TenantId) VALUES(@PermissionId,@UserGroupId,@CreationTime,@CreatorUserId,@TenantId)";
var userGroupPermissions = new List <UserGroupPermission>();
foreach (var permissionId in input.PermissionIds)
{
userGroupPermissions.Add(new UserGroupPermission
{
PermissionId = permissionId,
UserGroupId = userGroupId,
CreationTime = DateTime.Now,
CreatorUserId = _session.UserId,
TenantId = _session.TenantId
});
}
await conn.ExecuteAsync(insertSql, userGroupPermissions, trans);
if (input.DataPermissionType == DataPermissionType.UserDefined)
{
var insertDataPermissionOrgSql =
"INSERT INTO UserGroupDataPermissionOrgRelation(UserGroupId,OrgId,CreateTime,CreateBy,TenantId) VALUES(@UserGroupId,@OrgId,@CreationTime,@CreatorUserId,@TenantId)";
var dataPermissionOrgDatas = new List <UserGroupDataPermissionOrgRelation>();
foreach (var orgId in input.DataPermissionOrgIds)
{
dataPermissionOrgDatas.Add(new UserGroupDataPermissionOrgRelation()
{
UserGroupId = userGroupId,
OrgId = orgId,
CreationTime = DateTime.Now,
CreatorUserId = _session.UserId,
TenantId = _session.TenantId
});
}
await conn.ExecuteAsync(insertDataPermissionOrgSql, dataPermissionOrgDatas, trans);
}
}, Connection);
});
}
}
public async Task Dapper_Repository_Tests()
{
using (IUnitOfWorkCompleteHandle uow = _unitOfWorkManager.Begin())
{
//---Insert operation should work and tenant, creation audit properties must be set---------------------
await _productDapperRepository.InsertAsync(new Product("TShirt"));
Product insertedProduct = await _productDapperRepository.FirstOrDefaultAsync(x => x.Name == "TShirt");
insertedProduct.ShouldNotBeNull();
insertedProduct.TenantId.ShouldBe(AbpSession.TenantId);
((DateTime?)insertedProduct.CreationTime).ShouldNotBe(null);
insertedProduct.CreatorUserId.ShouldBe(AbpSession.UserId);
//----Update operation should work and Modification Audits should be set---------------------------
await _productDapperRepository.InsertAsync(new Product("TShirt"));
Product productToUpdate = await _productDapperRepository.FirstOrDefaultAsync(x => x.Name == "TShirt");
productToUpdate.Name = "Pants";
await _productDapperRepository.UpdateAsync(productToUpdate);
productToUpdate.ShouldNotBeNull();
productToUpdate.TenantId.ShouldBe(AbpSession.TenantId);
((DateTime?)productToUpdate.CreationTime).ShouldNotBe(null);
productToUpdate.LastModifierUserId.ShouldBe(AbpSession.UserId);
//---Get method should return single-------------------------------------------------------------------
await _productDapperRepository.InsertAsync(new Product("TShirt"));
Action getAction = () => _productDapperRepository.Single(x => x.Name == "TShirt");
getAction.ShouldThrow <InvalidOperationException>("Sequence contains more than one element");
//----Select * from syntax should work---------------------------------
var queryResult = await _productDapperRepository.QueryAsync("select * from Products");
IEnumerable <Product> products = queryResult;
products.Count().ShouldBeGreaterThan(0);
//------------Ef and Dapper should work under same transaction---------------------
Product productFromEf = await _productRepository.FirstOrDefaultAsync(x => x.Name == "TShirt");
Product productFromDapper = await _productDapperRepository.SingleAsync(productFromEf.Id);
productFromDapper.Name.ShouldBe(productFromEf.Name);
productFromDapper.TenantId.ShouldBe(productFromEf.TenantId);
//------Soft Delete should work for Dapper--------------
await _productDapperRepository.InsertAsync(new Product("SoftDeletableProduct"));
Product toSoftDeleteProduct = await _productDapperRepository
.SingleAsync(x => x.Name == "SoftDeletableProduct");
await _productDapperRepository.DeleteAsync(toSoftDeleteProduct);
toSoftDeleteProduct.IsDeleted.ShouldBe(true);
toSoftDeleteProduct.DeleterUserId.ShouldBe(AbpSession.UserId);
toSoftDeleteProduct.TenantId.ShouldBe(AbpSession.TenantId);
Product softDeletedProduct = await _productRepository
.FirstOrDefaultAsync(x => x.Name == "SoftDeletableProduct");
softDeletedProduct.ShouldBeNull();
Product softDeletedProductFromDapper = await _productDapperRepository
.FirstOrDefaultAsync(x => x.Name == "SoftDeletableProduct");
softDeletedProductFromDapper.ShouldBeNull();
using (_unitOfWorkManager.Current.DisableFilter(AbpDataFilters.SoftDelete))
{
Product softDeletedProductWhenFilterDisabled = await _productRepository
.FirstOrDefaultAsync(x => x.Name == "SoftDeletableProduct");
softDeletedProductWhenFilterDisabled.ShouldNotBeNull();
Product softDeletedProductFromDapperWhenFilterDisabled = await _productDapperRepository
.SingleAsync(x => x.Name == "SoftDeletableProduct");
softDeletedProductFromDapperWhenFilterDisabled.ShouldNotBeNull();
}
using (AbpSession.Use(2, 266))
{
int productWithTenant2Id = await _productDapperRepository
.InsertAndGetIdAsync(new Product("ProductWithTenant2"));
var productWithTenant2 = await _productRepository.GetAsync(productWithTenant2Id);
productWithTenant2.TenantId
.ShouldBe(1); //Not sure about that?,Because we changed TenantId to 2 in this scope !!! Abp.TenantId = 2 now NOT 1 !!!
}
using (_unitOfWorkManager.Current.SetTenantId(3))
{
int productWithTenant3Id = await _productDapperRepository
.InsertAndGetIdAsync(new Product("ProductWithTenant3"));
Product productWithTenant3 = await _productRepository.GetAsync(productWithTenant3Id);
productWithTenant3.TenantId.ShouldBe(3);
}
Product productWithTenantId3FromDapper = await _productDapperRepository
.FirstOrDefaultAsync(x => x.Name == "ProductWithTenant3");
productWithTenantId3FromDapper.ShouldBeNull();
Product p = await _productDapperRepository.FirstOrDefaultAsync(x => x.Status == Status.Active);
p.ShouldNotBeNull();
using (_unitOfWorkManager.Current.SetTenantId(3))
{
Product productWithTenantId3FromDapperInsideTenantScope = await _productDapperRepository
.FirstOrDefaultAsync(x => x.Name == "ProductWithTenant3");
productWithTenantId3FromDapperInsideTenantScope.ShouldNotBeNull();
}
//About issue-#2091
using (_unitOfWorkManager.Current.SetTenantId(AbpSession.TenantId))
{
int productWithTenantId40 = await _productDapperRepository
.InsertAndGetIdAsync(new Product("ProductWithTenantId40"));
Product productWithTenant40 = await _productRepository.GetAsync(productWithTenantId40);
productWithTenant40.TenantId.ShouldBe(AbpSession.TenantId);
productWithTenant40.CreatorUserId.ShouldBe(AbpSession.UserId);
}
//Second DbContext tests
var productDetailId = await _productDetailRepository
.InsertAndGetIdAsync(new ProductDetail("Woman"));
(await _productDetailDapperRepository.GetAsync(productDetailId)).ShouldNotBeNull();
await uow.CompleteAsync();
}
}
