/// <summary>
/// 设置用户角色（批量设置）
/// </summary>
/// <param name="userIds">用户主键，多个逗号隔开</param>
/// <param name="roleIds">角色id，多个逗号隔开</param>
public bool SetRoleBatch(string userIds, string roleIds)
{
List <UserRoleEntity> role_addList = new List <UserRoleEntity>(); //需要插入角色的sql语句集合
List <UserRoleEntity> role_deleteList = new List <UserRoleEntity>(); //需要删除角色的sql语句集合
string[] str_userid = userIds.Trim(',').Split(',');
string[] str_role = roleIds.Trim(',').Split(',');
UserRoleEntity userroledelete = null;
UserRoleEntity userroleadd = null;
for (int i = 0; i < str_userid.Length; i++)
{
//批量设置先删除当前用户的所有角色
userroledelete = new UserRoleEntity();
userroledelete.UserId = Convert.ToInt32(str_userid[i]);
role_deleteList.Add(userroledelete);
if (!string.IsNullOrEmpty(roleIds))
{
//再添加设置的角色
for (int j = 0; j < str_role.Length; j++)
{
userroleadd = new UserRoleEntity();
userroleadd.UserId = Convert.ToInt32(str_userid[i]);
userroleadd.RoleId = Convert.ToInt32(str_role[j]);
role_addList.Add(userroleadd);
}
}
}
return(dal.SetRoleBatch(role_addList, role_deleteList));
}
public static UserRoleEntity ToAssignmentDataModel(this Role source)
{
var result = new UserRoleEntity();
result.RoleId = source.Id;
return(result);
}
public int CreateUserRole(UserRoleEntity userRoleEntity)
{
var existingUserRoles = _unitOfWork.UserRoleRepository.GetManyQueryable(x =>
x.UserId == userRoleEntity.UserId &&
x.RoleId == userRoleEntity.RoleId &&
x.RegionId == userRoleEntity.RegionId &&
x.CountryId == userRoleEntity.CountryId &&
x.IndustryId == userRoleEntity.IndustryId);
if (existingUserRoles.Any())
{
return(0);
}
// TODO: Mapper
var userRoleToBeAdded = new UserRole
{
UserId = userRoleEntity.UserId,
RoleId = userRoleEntity.RoleId,
RegionId = userRoleEntity.RegionId,
CountryId = userRoleEntity.CountryId,
IndustryId = userRoleEntity.IndustryId
};
try
{
_unitOfWork.UserRoleRepository.Insert(userRoleToBeAdded);
_unitOfWork.Save();
return(1);
}
catch (Exception exc)
{
return(-1);
}
}
public async Task <bool> ReportServiceUser(UserDto dto)
{
//bug
var userEntity = await _context.Users.FirstOrDefaultAsync(u => u.UserQq == dto.UserQq);
if (userEntity == null)
{
userEntity = _mapper.Map <UserDto, UserEntity>(dto);
userEntity.Password = "******".ToMd5();
userEntity.Init();
userEntity.DepartmentId = "a017f0614a7244baaf29abca15c28a94";//客服部门id
userEntity.Department = await _context.Departments.FirstOrDefaultAsync(c => c.Id == userEntity.DepartmentId);
userEntity.UserRoles = new List <UserRoleEntity>();
var roleEntity = new UserRoleEntity {
CreateUserId = "e71969cc6fca4c818b80a94185892169" /*超级管理员id*/, UserId = userEntity.Id, RoleId = "cf62aa55cd2043f0a053242cc94c3910"
};
roleEntity.Init();
userEntity.UserRoles.Add(roleEntity);
_context.Users.Add(userEntity);
await _context.SaveChangesAsync();
return(true);
}
return(false);
}
public async Task <IResponseOutput> AddAsync(TenantAddInput input)
{
var entity = Mapper.Map <TenantEntity>(input);
var tenant = await _tenantRepository.InsertAsync(entity);
var tenantId = tenant.Id;
//添加角色
var role = new RoleEntity {
TenantId = tenantId, Code = "plat_admin", Name = "平台管理员", Enabled = true
};
await _roleRepository.InsertAsync(role);
//添加用户
var pwd = MD5Encrypt.Encrypt32("111111");
var user = new UserEntity {
TenantId = tenantId, UserName = input.Phone, NickName = input.RealName, Password = pwd, Status = 0
};
await _userRepository.InsertAsync(user);
//添加用户角色
var userRole = new UserRoleEntity()
{
TenantId = tenantId, UserId = user.Id, RoleId = role.Id
};
await _userRoleRepository.InsertAsync(userRole);
//更新租户用户
tenant.UserId = user.Id;
await _tenantRepository.UpdateAsync(tenant);
return(ResponseOutput.Ok());
}
public async Task <BaseResult <bool> > UpdateSetRole(string user_id, List <string> role_ids)
{
try
{
//首先删除掉所有用户的角色信息然后再添加
var isDeleteUserDetrue = await userRoleRepository.DeleteByUserId(user_id);
if (role_ids.Count > 0)
{
List <UserRoleEntity> userRoleEntitys = new List <UserRoleEntity>();
foreach (string role_id in role_ids)
{
UserRoleEntity userRoleEntity = new UserRoleEntity();
userRoleEntity.user_id = user_id;
userRoleEntity.role_id = role_id;
userRoleEntitys.Add(userRoleEntity);
}
var isUserDepartmentTrue = await userRoleRepository.AddListAsync(userRoleEntitys, false);
if (unitOfWork.SaveCommit())
{
return(new BaseResult <bool>(200, true));
}
}
return(new BaseResult <bool>(200, true));
}
catch (Exception)
{
return(new BaseResult <bool>(201, false));
}
}
/// <summary>
/// 设置用户角色
/// </summary>
/// <param name="UserID"></param>
/// <param name="RoleID"></param>
/// <param name="IsHas">ture设置 false移除</param>
public void SetUserRole(string UserID, string RoleID)
{
using (var factory = new BaseAccess())
{
//如果传入的roleid为空的话移除改用户对对应的所有角色
if (string.IsNullOrWhiteSpace(RoleID))
{
var entity = factory.GetAll <UserRoleEntity>(Specification <UserRoleEntity> .Create(c => c.UserID == UserID));
factory.Delete <UserRoleEntity>(entity);
}
else
{
var entity = factory.GetAll <UserRoleEntity>(Specification <UserRoleEntity> .Create(c => c.UserID == UserID));
factory.Delete <UserRoleEntity>(entity);
var Rids = RoleID.Split(',');
foreach (var item in Rids)
{
var spec = Specification <UserRoleEntity> .Create(c => c.UserID == UserID && c.RoleID == item);
bool bl = factory.IsExists <UserRoleEntity>(spec);
if (!bl)
{
var userRole = new UserRoleEntity()
{
RoleID = item, UserID = UserID
};
factory.Insert <UserRoleEntity>(userRole);
}
}
}
}
}
public void TestGoodRequest()
{
var principal = AccessTokenResult.Success(new System.Security.Claims.ClaimsPrincipal());
tokenProvider.Setup(t => t.ValidateToken(It.IsAny <HttpRequest>())).Returns(principal);
var userEntity = new UserRoleEntity()
{
UserId = "TEST",
RoleName = "TestRole",
};
var tableResult = new TableResult();
tableResult.Result = userEntity;
tableResult.HttpStatusCode = StatusCodes.Status201Created;
userRoleRepository.Setup(t => t.Add(It.IsAny <UserRoleEntity>())).Returns(Task.FromResult(tableResult));
var request = TestFactory.CreateHttpRequest("{\"userId\": \"TEST\",\"roleName\": \"TestRole\",}");
var response = (CreatedResult)_fixture.Run(request, testLogger);
Assert.AreEqual(StatusCodes.Status201Created, response.StatusCode);
var returnEntity = (UserRoleEntity)((TableResult)response.Value).Result;
Assert.AreEqual(userEntity.UserId, returnEntity.UserId);
Assert.AreEqual(userEntity.RoleName, returnEntity.RoleName);
}
public List <UserRoleEntity> Read(int minId = DefValInt, int maxId = DefValInt, int minUserId = DefValInt, int maxUserId = DefValInt, int minRoleId = DefValInt, int maxRoleId = DefValInt)
{
string stringWithWhere = CreateWherePartForReadQuery(minId, maxId, minUserId, maxUserId, minRoleId, maxRoleId);
MySqlCommand command = new MySqlCommand(readString + stringWithWhere);
command.Connection = connection;
connection.Open();
List <UserRoleEntity> result = new List <UserRoleEntity>();
try
{
MySqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
object idFromDb = reader["Id"];
object userIdFromDb = reader["UserId"];
object roleIdFromDb = reader["RoleId"];
UserRoleEntity userRole = new UserRoleEntity
{
Id = System.Convert.ToInt32(idFromDb),
UserId = System.Convert.ToInt32(userIdFromDb),
RoleId = System.Convert.ToInt32(roleIdFromDb)
};
result.Add(userRole);
}
}
finally
{
connection.Close();
}
return(result);
}
public void TestGoodRequest()
{
var principal = AccessTokenResult.Success(new System.Security.Claims.ClaimsPrincipal());
tokenProvider.Setup(t => t.ValidateToken(It.IsAny <HttpRequest>())).Returns(principal);
var userRoleEntity = new UserRoleEntity()
{
UserId = "TEST",
RoleName = "TestRole",
PartitionKey = "TestRole",
RowKey = "TEST"
};
var ctor = typeof(TableQuerySegment <UserRoleEntity>)
.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)
.FirstOrDefault(c => c.GetParameters().Count() == 1);
var mockQuerySegment = ctor.Invoke(new object[] { new List <UserRoleEntity>()
{
userRoleEntity
} }) as TableQuerySegment <UserRoleEntity>;
userRoleRepository.Setup(t => t.Get(It.IsAny <String>())).Returns(Task.FromResult(mockQuerySegment));
var request = TestFactory.CreateHttpRequest("{\"userId\": \"TEST\",\"roleName\": \"TestRole\",}");
var response = (OkObjectResult)_fixture.Run(request, userId, testLogger);
Assert.AreEqual(StatusCodes.Status200OK, response.StatusCode);
var returnEntityList = (TableQuerySegment <UserRoleEntity>)response.Value;
var returnEntity = returnEntityList.FirstOrDefault();
Assert.AreEqual(userRoleEntity.UserId, returnEntity.UserId);
Assert.AreEqual(userRoleEntity.RoleName, returnEntity.RoleName);
}
public BaseObject UpdateUserRole(UserRoleEntity param)
{
using (UserLogic logic = new UserLogic())
{
return(logic.UpdateUserRole(param));
}
}
public UserRoleDto(UserRoleEntity userRole)
{
UserId = userRole.UserId;
RoleId = userRole.RoleId;
User = new UserDto(userRole.User);
Role = new RoleDto(userRole.Role);
}
public void Create(UserRoleEntity userRole)
{
connection.Open();
MySqlCommand command = new MySqlCommand(addString);
MySqlParameter titleParam = new MySqlParameter("@UserId", userRole.UserId);
MySqlParameter contactInfoParam = new MySqlParameter("@RoleId", userRole.RoleId);
command.Parameters.Add(titleParam);
command.Parameters.Add(contactInfoParam);
command.Connection = connection;
object obj = null;
try
{
obj = command.ExecuteScalar();
}
finally
{
connection.Close();
}
int id = Convert.ToInt32(obj);
userRole.Id = id;
}
public static DalUserRole ToDalUserRole(this UserRoleEntity userRoleEntity)
{
return(new DalUserRole
{
UserId = userRoleEntity.UserId,
RoleId = userRoleEntity.RoleId
});
}
public void UserRoleEntitiesHaveACreatedAt()
{
var entity = new UserRoleEntity();
var date = new DateTime(2019, 02, 21);
entity.CreatedAt = date;
entity.CreatedAt.Should().BeSameDateAs(date);
}
public void UserRoleEntitiesHaveARoleId()
{
var entity = new UserRoleEntity();
var roleId = 1;
entity.RoleId = roleId;
entity.RoleId.Should().Be(roleId);
}
public bool Delete(UserRoleEntityViewModel dt, int id)
{
UserRoleEntity dr = db.UserRoleEntities.Where(i => i.ureID == id).FirstOrDefault();
db.UserRoleEntities.Remove(dr);
var Result = db.SaveChanges();
return(Result == 1);
}
public bool Insert(UserRoleEntity userRole)
{
string sql = @"insert into SJUserRole(UserId,RoleId) values(@UserId,@RoleId)";
using (var connection = SqlDb.UpdateConnection)
{
return(connection.Execute(sql, userRole) > 0);
}
}
public async Task <TableResult> Update(UserRoleEntity entity)
{
var table = await GetTable("UserRoles");
entity.ETag = "*";
var updatedEntity = await table.ExecuteAsync(TableOperation.Merge(entity));
return(updatedEntity);
}
public static DalUserRole ToDalUserRole(this UserRoleEntity userRole)
{
return(new DalUserRole
{
UserId = userRole.UserId,
Id = userRole.Id,
UserRoleId = userRole.UserRoleId
});
}
public static void Patch(this UserRoleEntity source, UserRoleEntity target)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
target = Mapper.Map <UserRoleEntity, UserRoleEntity>(source);
}
private async Task CreateTribunalRole(IServiceCollection services)
{
var builder = services.BuildServiceProvider();
var roleManager = builder.GetService <RoleManager <UserRoleEntity> >();
var userManager = builder.GetService <UserManager <UserEntity> >();
if (!await roleManager.RoleExistsAsync("Tribunal"))
{
var role = new UserRoleEntity
{
Name = "Tribunal"
};
await roleManager.CreateAsync(role);
}
//Add any other user who will NEED Admin privileges
var user1 = await userManager.FindByEmailAsync("*****@*****.**"); //me
var user2 = await userManager.FindByEmailAsync("*****@*****.**"); //me
var user3 = await userManager.FindByEmailAsync("*****@*****.**"); //spanish teacher
var user4 = await userManager.FindByEmailAsync("*****@*****.**"); //amo
var user5 = await userManager.FindByEmailAsync("*****@*****.**"); //ultimate ace
var user6 = await userManager.FindByEmailAsync("*****@*****.**"); //aileronroll
var user7 = await userManager.FindByEmailAsync("*****@*****.**"); //eidocles
var user8 = await userManager.FindByEmailAsync("*****@*****.**"); //ttu phoenix
var user9 = await userManager.FindByEmailAsync("*****@*****.**"); //dragon ryder
var user10 = await userManager.FindByEmailAsync("*****@*****.**"); //tundra
var users = new List <UserEntity>
{
user1,
user2,
user3,
user4,
user5,
user6,
user7,
user8,
user9,
user10
};
foreach (var user in users)
{
if (!await userManager.IsInRoleAsync(user, "Tribunal"))
{
await userManager.AddToRoleAsync(user, "Tribunal");
}
}
}
public bool Update(UserRoleEntity userRole)
{
string sql = @"update SJUserRole set UserId=@UserId,RoleId=@RoleId where Id=@Id";
using (var connection = SqlDb.UpdateConnection)
{
return(connection.Execute(sql, userRole) > 0);
}
}
/// <summary>
/// Cria uma role para o usuário
/// </summary>
/// <param name="userId"></param>
/// <param name="role"></param>
/// <returns></returns>
public UserRoleEntity GetUserRoleById(int userId)
{
using (ModelContext context = new ModelContext())
{
var query = from c in context.Roles where c.UserId == userId select c;
UserRoleEntity entity = query.FirstOrDefault();
return(entity);
}
}
private static UserRole CreateUserRoleFrom(UserRoleEntity userRoleEntity)
{
// TODO: Reuse domain factory classes when created.
return(new UserRole
{
Id = userRoleEntity.Id,
RoleId = userRoleEntity.RoleId,
CreatedAt = userRoleEntity.CreatedAt
});
}
public void AddRole(long userId, string role)
{
var entity = new UserRoleEntity
{
UserId = userId,
Role = role,
};
_context.AddToUserRoles(entity);
_context.SaveChanges();
}
public bool Update(UserRoleEntityViewModel dt, int id)
{
UserRoleEntity dr = db.UserRoleEntities.Where(i => i.ureID == id).FirstOrDefault();
dr.ureID = dt.ID;
dr.ureUserID = dt.UserID;
dr.ureUserRoleID = dt.UserRoleID;
var Result = db.SaveChanges();
return(Result == 1);
}
public int Insert(UserRoleEntityViewModel dt)
{
UserRoleEntity dr = new UserRoleEntity();
dr.ureUserID = dt.UserID;
dr.ureUserRoleID = dt.UserRoleID;
db.UserRoleEntities.Add(dr);
var Result = db.SaveChanges();
return(dr.ureID);
}
/// <summary>
/// 保存职位表单（新增、修改）
/// </summary>
/// <param name="keyValue">主键值</param>
/// <param name="jobEntity">职位实体</param>
/// <returns></returns>
public void SaveForm(string keyValue, UserRoleEntity userRoleEntity)
{
try
{
InstanceDAL.SaveForm(keyValue, userRoleEntity);
CacheFactory.Cache().RemoveCache(cacheKey);
}
catch (Exception)
{
throw;
}
}
public static MangoUserRole UserRoleE2M(UserRoleEntity userRoleEntity)
{
if (userRoleEntity == null)
{
throw new ArgumentNullException(nameof(userRoleEntity));
}
return(new MangoUserRole
{
Id = userRoleEntity.Id,
RoleName = userRoleEntity.RoleName
});
}
public void PrepareUserSession(int userId, HttpContext context)
{
var roles = UserRoleEntity.GetUserRoles(userId);
var role = roles.First();
var userCntxt = new UserContext();
userCntxt.UserId = userId;
userCntxt.RoleId = role.Get("id", -1);
userCntxt.EntityAccessData = UserRoleEntity.GetEntityAccessData(userCntxt.MasterId, userCntxt.RoleId);
context.Session.SetString("USER_CONTEXT", JsonConvert.SerializeObject(userCntxt));
}
/// <summary>
/// 5.4.3 用户角色修改
/// </summary>
/// <param name="loginID">登录标识ID</param>
/// <param name="roleID">角色ID</param>
/// <param name="userID">用户ID</param>
/// <returns>ErrType</returns>
public ErrType UpdateUserRole(string loginID, string roleID, string userID)
{
try
{
UserRoleEntity userRoleEntity = new UserRoleEntity();
userRoleEntity.RoleID = roleID;
userRoleEntity.UserId = userID;
EntityBase result = ManagerService.UpdateUserRole(loginID, userRoleEntity);
if (!result.Result)
return new ErrType(ERR.SERVICE, result.Desc);
return GeneralErr.Success;
}
catch (TimeoutException te)
{
FileLog.WriteLog("", Assembly.GetExecutingAssembly().GetName().Name, this.GetType().Name, new StackTrace().GetFrame(0).GetMethod().Name, te.Message); return new ErrType(ERR.EXEPTION, ErrorText.TimeoutException);
}
catch (Exception ex)
{
FileLog.WriteLog("", Assembly.GetExecutingAssembly().GetName().Name, this.GetType().Name,
new StackTrace().GetFrame(0).GetMethod().Name, ex.Message);
return new ErrType(ERR.EXEPTION, ErrorText.OperationError);
}
}
