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(CreateUserInput input)
{
input.CheckDataAnnotations().CheckValidResult();
var existUser = await _userRepository.FirstOrDefaultAsync(p => p.UserName == input.UserName);
if (existUser != null)
{
throw new UserFriendlyException($"已经存在用户名为{input.UserName}的用户");
}
existUser = await _userRepository.FirstOrDefaultAsync(p => p.Phone == input.Phone);
if (existUser != null)
{
throw new UserFriendlyException($"已经存在手机号码为{input.Phone}的用户");
}
existUser = await _userRepository.FirstOrDefaultAsync(p => p.Email == input.Email);
if (existUser != null)
{
throw new UserFriendlyException($"已经存在Email为{input.Email}的用户");
}
await _userDomainService.Create(input);
return("新增员工成功");
}
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 <string> CreateOperation(CreateOperationInput input)
{
var operation = await _permissionRepository.FirstOrDefaultAsync(p => p.Code == input.Code);
if (operation != null)
{
throw new BusinessException($"系统中已经存在Code为{input.Code}的操作");
}
foreach (var funcId in input.FunctionIds)
{
var funcInfo = await _functionRepository.SingleOrDefaultAsync(p => p.Id == funcId);
if (funcInfo == null)
{
throw new BusinessException($"系统中不存在{funcId}的功能");
}
}
operation = new Permission()
{
Code = input.Code,
Name = input.Name,
Memo = input.Memo,
Mold = PermissionMold.Operate,
};
await _functionManager.CreateOperation(operation, input.FunctionIds);
return($"新增{input.Name}操作成功");
}
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 _roleRepository.InsertAsync(role);
}
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 <string> Create(CreateUserInput input)
{
input.CheckDataAnnotations().CheckValidResult();
var exsitUserInfo = await _userRepository.FirstOrDefaultAsync(p => p.UserName == input.UserName ||
p.Email == input.Email ||
p.Phone == input.Phone);
if (exsitUserInfo != null)
{
throw new BusinessException("已经存在该员工信息,请检查员工账号信息");
}
var userInfo = input.MapTo <UserInfo>();
await _userManager.CreateUserInfo(userInfo);
return("新增员工成功");
}
public async Task <QueryFunctionOutput> QueryFunction(string keyworld)
{
var function = await _functionRepository.FirstOrDefaultAsync(p => p.WebApi.Equals(keyworld) || p.Code.Equals(keyworld));
if (function == null)
{
throw new UserFriendlyException($"为查询到{keyworld}的功能记录");
}
return(function.MapTo <QueryFunctionOutput>());
}
public async Task <GetMenuOutput> GetMenu(long id)
{
var menu = await _menuRepository.FirstOrDefaultAsync(p => p.Id == id);
if (menu == null)
{
throw new BusinessException($"不存在Id为{id}的菜单信息");
}
return(menu.MapTo <GetMenuOutput>());
}
public async Task CreateWordbook(CreateWordbookInput input)
{
var wordbook = await _wordbookRepository.FirstOrDefaultAsync(p => p.Code == input.Code);
if (wordbook != null)
{
throw new BusinessException($"系统中已经存在code为{input.Code}的字典类型");
}
wordbook = input.MapTo <Wordbook>();
await _wordbookRepository.InsertAsync(wordbook);
}
public async Task <string> Create(CreateRoleInput input)
{
input.CheckDataAnnotations().CheckValidResult();
var exsitRole = await _roleRepository.FirstOrDefaultAsync(p => p.Code == input.Code);
if (exsitRole != null)
{
throw new UserFriendlyException($"已经存在{input.Code}的角色信息");
}
await _roleRepository.InsertAsync(input.MapTo <Role>());
return("新增角色成功");
}
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 <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 <GetSystemConfigOutput> GetSystemConfig()
{
var sysConfig = await _systemConfigRepository.FirstOrDefaultAsync(p => p.TenantId == _session.TenantId);
if (sysConfig == null)
{
var newSysconfig = new SystemConfig()
{
SysName = HeroConstants.DefaultSysName,
NonPermissionOperationStyle = NonPermissionOperationStyle.Displayed
};
await _systemConfigRepository.InsertAsync(newSysconfig);
return(newSysconfig.MapTo <GetSystemConfigOutput>());
}
return(sysConfig.MapTo <GetSystemConfigOutput>());
}
public async Task <UpdateCorporationOutput> UpdateCorporation(UpdateCorporationInput input)
{
var corporation = await _corporationRepository.SingleOrDefaultAsync(p => p.Id == input.Id);
if (corporation == null)
{
throw new BusinessException($"系统中不存在Id为{input.Id}的公司信息");
}
var orgInfo = await _organizationRepository.SingleOrDefaultAsync(p => p.Id == corporation.OrgId);
if (orgInfo == null)
{
throw new BusinessException($"系统中不存在Id为{input.Id}的公司信息");
}
if (!input.Identification.Equals(orgInfo.Identification))
{
var exsitOrg =
await _organizationRepository.FirstOrDefaultAsync(p => p.Identification == input.Identification);
if (exsitOrg != null)
{
throw new BusinessException($"系统中已经存在标识为{input.Identification}的组织机构");
}
}
corporation = input.MapTo(corporation);
orgInfo = input.MapTo(orgInfo);
await UnitOfWorkAsync(async (conn, trans) =>
{
await _organizationRepository.UpdateAsync(orgInfo, conn, trans);
await _corporationRepository.UpdateAsync(corporation, conn, trans);
}, Connection);
return(new UpdateCorporationOutput
{
OrgId = orgInfo.Id,
CorporationId = corporation.Id,
Tips = "更新公司信息成功"
});
}
public async Task <string> Create(CreateUserGroupInput input)
{
input.CheckDataAnnotations().CheckValidResult();
if (input.ParentId != 0)
{
var parentUserGroup = await _userGroupRepository.SingleOrDefaultAsync(p => p.Id == input.ParentId);
if (parentUserGroup == null)
{
throw new BusinessException($"不存在父Id为{input.ParentId}的用户组");
}
}
var existUserGroup = await _userGroupRepository.FirstOrDefaultAsync(p => p.GroupCode == input.GroupCode);
if (existUserGroup != null)
{
throw new BusinessException($"已经存在{input.GroupCode}的用户组");
}
var userGroupEntity = input.MapTo <UserGroup>();
await _userGroupRepository.InsertAsync(userGroupEntity);
return("新增用户组成功");
}
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 Update(UpdateUserInput input)
{
var updateUser = await _userRepository.SingleOrDefaultAsync(p => p.Id == input.Id, false);
if (updateUser == null)
{
throw new BusinessException($"不存在Id为{input.Id}的账号信息");
}
if (input.Phone != updateUser.Phone)
{
var existUser = await _userRepository.FirstOrDefaultAsync(p => p.Phone == input.Phone, false);
if (existUser != null)
{
throw new UserFriendlyException($"已经存在手机号码为{input.Phone}的用户");
}
}
if (input.Email != updateUser.Email)
{
var existUser = await _userRepository.FirstOrDefaultAsync(p => p.Email == input.Email, false);
if (existUser != null)
{
throw new UserFriendlyException($"已经存在Email为{input.Email}的用户");
}
}
var departAppServiceProxy = GetService <IDepartmentAppService>();
if (input.OrgId.HasValue)
{
if (!await departAppServiceProxy.Check(input.OrgId.Value))
{
throw new BusinessException($"不存在Id为{input.OrgId}的部门信息");
}
}
var positionAppServiceProxy = GetService <IPositionAppService>();
if (input.PositionId.HasValue)
{
if (!await positionAppServiceProxy.CheckExsit(input.PositionId.Value))
{
throw new BusinessException($"不存在Id为{input.PositionId}的职位信息");
}
}
updateUser = input.MapTo(updateUser);
using (var locker = await _lockerProvider.CreateLockAsync("UpdateUser"))
{
await locker.Lock(async() =>
{
await UnitOfWorkAsync(async(conn, trans) =>
{
await _userRepository.UpdateAsync(updateUser, conn, trans);
await _userRoleRepository.DeleteAsync(p => p.UserId == updateUser.Id, conn, trans);
await _userUserGroupRelationRepository.DeleteAsync(p => p.UserId == updateUser.Id, 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 = updateUser.Id, RoleId = roleId
}, 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 = updateUser.Id, UserGroupId = userGroupId
}, conn,
trans);
}
}, Connection);
});
}
}
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---------------------
_productDapperRepository.Insert(new Product("TShirt"));
Product insertedProduct = _productDapperRepository.GetAll(x => x.Name == "TShirt").FirstOrDefault();
insertedProduct.ShouldNotBeNull();
insertedProduct.TenantId.ShouldBe(AbpSession.TenantId);
insertedProduct.CreationTime.ShouldNotBeNull();
insertedProduct.CreatorUserId.ShouldBe(AbpSession.UserId);
//----Update operation should work and Modification Audits should be set---------------------------
_productDapperRepository.Insert(new Product("TShirt"));
Product productToUpdate = _productDapperRepository.GetAll(x => x.Name == "TShirt").FirstOrDefault();
productToUpdate.Name = "Pants";
_productDapperRepository.Update(productToUpdate);
productToUpdate.ShouldNotBeNull();
productToUpdate.TenantId.ShouldBe(AbpSession.TenantId);
productToUpdate.CreationTime.ShouldNotBeNull();
productToUpdate.LastModifierUserId.ShouldBe(AbpSession.UserId);
//---Get method should return single-------------------------------------------------------------------
_productDapperRepository.Insert(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---------------------------------
IEnumerable <Product> products = _productDapperRepository.Query("select * from Products");
products.Count().ShouldBeGreaterThan(0);
//------------Ef and Dapper should work under same transaction---------------------
Product productFromEf = _productRepository.FirstOrDefault(x => x.Name == "TShirt");
Product productFromDapper = _productDapperRepository.Single(productFromEf.Id);
productFromDapper.Name.ShouldBe(productFromEf.Name);
productFromDapper.TenantId.ShouldBe(productFromEf.TenantId);
//------Soft Delete should work for Dapper--------------
_productDapperRepository.Insert(new Product("SoftDeletableProduct"));
Product toSoftDeleteProduct = _productDapperRepository.Single(x => x.Name == "SoftDeletableProduct");
_productDapperRepository.Delete(toSoftDeleteProduct);
toSoftDeleteProduct.IsDeleted.ShouldBe(true);
toSoftDeleteProduct.DeleterUserId.ShouldBe(AbpSession.UserId);
toSoftDeleteProduct.TenantId.ShouldBe(AbpSession.TenantId);
Product softDeletedProduct = _productRepository.FirstOrDefault(x => x.Name == "SoftDeletableProduct");
softDeletedProduct.ShouldBeNull();
Product softDeletedProductFromDapper = _productDapperRepository.FirstOrDefault(x => x.Name == "SoftDeletableProduct");
softDeletedProductFromDapper.ShouldBeNull();
using (_unitOfWorkManager.Current.DisableFilter(AbpDataFilters.SoftDelete))
{
Product softDeletedProductWhenFilterDisabled = _productRepository.FirstOrDefault(x => x.Name == "SoftDeletableProduct");
softDeletedProductWhenFilterDisabled.ShouldNotBeNull();
Product softDeletedProductFromDapperWhenFilterDisabled = _productDapperRepository.Single(x => x.Name == "SoftDeletableProduct");
softDeletedProductFromDapperWhenFilterDisabled.ShouldNotBeNull();
}
using (AbpSession.Use(2, 266))
{
int productWithTenant2Id = _productDapperRepository.InsertAndGetId(new Product("ProductWithTenant2"));
Product productWithTenant2 = _productRepository.Get(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 = _productDapperRepository.InsertAndGetId(new Product("ProductWithTenant3"));
Product productWithTenant3 = _productRepository.Get(productWithTenant3Id);
productWithTenant3.TenantId.ShouldBe(3);
}
Product productWithTenantId3FromDapper = _productDapperRepository.FirstOrDefault(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 = _productDapperRepository.FirstOrDefault(x => x.Name == "ProductWithTenant3");
productWithTenantId3FromDapperInsideTenantScope.ShouldNotBeNull();
}
//About issue-#2091
using (_unitOfWorkManager.Current.SetTenantId(AbpSession.TenantId))
{
int productWithTenantId40 = _productDapperRepository.InsertAndGetId(new Product("ProductWithTenantId40"));
Product productWithTenant40 = _productRepository.Get(productWithTenantId40);
productWithTenant40.TenantId.ShouldBe(AbpSession.TenantId);
productWithTenant40.CreatorUserId.ShouldBe(AbpSession.UserId);
}
//Second DbContext tests
int productDetailId = _productDetailRepository.InsertAndGetId(new ProductDetail("Woman"));
_productDetailDapperRepository.Get(productDetailId).ShouldNotBeNull();
uow.Complete();
}
}
public async Task <UpdateDepartmentOutput> UpdateDepartment(UpdateDepartmentInput input)
{
var department = await _departmentRepository.SingleOrDefaultAsync(p => p.Id == input.Id);
if (department == null)
{
throw new BusinessException($"系统中不存在Id为{input.Id}的部门信息");
}
var orgInfo = await _organizationRepository.SingleOrDefaultAsync(p => p.Id == department.OrgId);
if (orgInfo == null)
{
throw new BusinessException($"系统中不存在Id为{department.Id}的部门信息");
}
if (!input.Identification.Equals(orgInfo.Identification))
{
var exsitOrg =
await _organizationRepository.FirstOrDefaultAsync(p => p.Identification == input.Identification);
if (exsitOrg != null)
{
throw new BusinessException($"系统中已经存在标识为{input.Identification}的组织机构");
}
}
if (input.DeptTypeKey.IsNullOrEmpty())
{
throw new BusinessException("请选择部门类型");
}
var workbookAppServiceProxy = GetService <IWordbookAppService>();
var checkDeptTypeResult = await workbookAppServiceProxy.Check(new CheckWordbookInput
{ WordbookCode = SystemPresetWordbookCode.Organization.DeptType, WordbookItemKey = input.DeptTypeKey });
if (!checkDeptTypeResult)
{
throw new BusinessException("部门类型Id不正确,请选择正确的部门类型");
}
department = input.MapTo(department);
orgInfo = input.MapTo(orgInfo);
Debug.Assert(_session.UserId.HasValue, "登录用户的UserId不会为空");
await UnitOfWorkAsync(async (conn, trans) =>
{
await _organizationRepository.UpdateAsync(orgInfo, conn, trans);
await _departmentRepository.UpdateAsync(department, conn, trans);
if (input.Positions != null && input.Positions.Any())
{
if (input.Positions.Count(p => p.IsLeadingOfficial) > 1)
{
throw new BusinessException("部门只允许设置一个负责人岗位");
}
var positionIds = input.Positions.Where(p => p.Id != 0 && p.Id.HasValue).Select(p => p.Id);
var deletePositionSql =
"UPDATE `Position` SET IsDeleted=@IsDeleted,DeleteBy=@DeleteBy,DeleteTime=@DeleteTime WHERE DeptId=@DeptId AND Id NOT in @Id AND TenantId=@TenantId";
await conn.ExecuteAsync(deletePositionSql,
new
{
IsDeleted = HeroConstants.DeletedFlag, DeleteBy = _session.UserId.Value,
DeleteTime = DateTime.Now, DeptId = department.Id, Id = positionIds,
TenantId = _session.TenantId
}, trans);
var sort = 1;
foreach (var positionInput in input.Positions)
{
var positionCode = orgInfo.Code + HeroConstants.CodeRuleRestrain.CodeSeparator + sort.ToString()
.PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit,
HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
if (positionInput.Id.HasValue && positionInput.Id != 0)
{
var position = await _positionRepository.GetAsync(positionInput.Id.Value);
position.CheckDataAnnotations().CheckValidResult();
position = positionInput.MapTo(position);
position.Code = positionCode;
await _positionRepository.UpdateAsync(position, conn, trans);
}
else
{
var position = positionInput.MapTo <Position>();
position.DeptId = department.Id;
position.CheckDataAnnotations().CheckValidResult();
position.Code = positionCode;
await _positionRepository.InsertAsync(position, conn, trans);
}
sort++;
}
}
}, Connection);
return(new UpdateDepartmentOutput
{
OrgId = orgInfo.Id,
DeptId = department.Id,
Tips = "更新部门信息成功"
});
}
public Task <UserInfo> GetByOemIdAsync(long oemId, long userId)
{
return(_userDapperRepository.FirstOrDefaultAsync(s => s.OemId == oemId && s.Id == userId));
}