public async void Initialize()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
var list = await RoleDb.GetAllRoles();
if (list.Any())
{
Roles = new ObservableRangeCollection <SealegsUserRole>(list);
if (!String.IsNullOrEmpty(Notification.RoleId))
{
FlagSelectedRoles(Notification.RoleId);
}
}
}
catch (Exception ex)
{
Logger.Report(ex, "Method", "InitlizeRoleList");
MessagingService.Current.SendMessage(MessageKeys.Error, ex);
}
finally
{
IsBusy = false;
}
}
public AllDb()
{
this.RoleDb = new RoleDb();
this.UserDb = new UserDb();
this.AdressDb = new AdressDb();
this.PurseDb = new PurseDb();
this.ServiceTypeDb = new ServiceTypeDb();
this.ServiceDb = new ServiceDb();
this.RateDb = new RateDb();
this.SubscribeDb = new SubscribeDb();
}
public async Task <SimpleResponse> CreateUserAsync(string email, string name, string password, int roleId)
{
if (string.IsNullOrEmpty(name))
{
return(SimpleResponse.Error("Name cannot be empty"));
}
if (string.IsNullOrEmpty(email) || !IsEmailValid(email))
{
return(SimpleResponse.Error("Invalid Email format."));
}
try
{
RoleDb role = await _ivySchoolRepository.GetRoleById(roleId);
if (role == null)
{
return(SimpleResponse.Error("Invalid role id."));
}
UserDb user1 = await _ivySchoolRepository.GetUserByEmail(email);
if (user1 != null)
{
if (user1.RoleUsers.Any(u => u.RoleId == roleId))
{
return(SimpleResponse.Error("User already exists."));
}
await _ivySchoolRepository.AssignRoleToUser(user1, role);
}
else
{
UserDb user2 = new UserDb()
{
Name = name,
Email = email,
Password = password,
CreateAt = DateTime.Now,
IsDeleted = false,
};
await _ivySchoolRepository.CreateUserAsync(user2, role);
}
}
catch (DBOperationException ex)
{
return(SimpleResponse.Error(ex.Message));
}
return(SimpleResponse.Success());
}
protected void ButtonAddRole_Click(object sender, EventArgs e)
{
RoleDb role = new RoleDb()
{
RoleName = this.add_TextBoxRoleName.Text
};
this.GridViewRoles.DataSource = OperationManager.Singleton.izvrsiOperaciju(new OpRoleInsert()
{
Role = role
}).DbItems.Cast <RoleDb>().ToArray();
this.GridViewRoles.DataBind();
}
public async Task AssignRoleToUser(UserDb user, RoleDb role)
{
ProcessUserRole(user, role);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
throw new DBOperationException(ex);
}
}
public async Task CreateUserAsync(UserDb user, RoleDb role)
{
_context.Add(user);
ProcessUserRole(user, role);
try
{
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
throw new DBOperationException(ex);
}
}
protected void ButtonUpdateRole_Click(object sender, EventArgs e)
{
RoleDb role = new RoleDb()
{
IdRole = Convert.ToInt32(this.LabelRoleId.Text),
RoleName = this.tbRoleName.Text
};
this.GridViewRoles.DataSource = OperationManager.Singleton.izvrsiOperaciju(new OpRoleUpdate()
{
Role = role
}).DbItems.Cast <RoleDb>().ToArray();
this.GridViewRoles.DataBind();
this.LabelRoleId.Text = "";
}
public async Task <List <SystemRole> > GetByUserId(Guid userid)
{
var roles = RoleDb.GetList();
var userRoles = UserRoleDb.AsQueryable().Where(ur => ur.UserId == userid).Select(ur => ur);
foreach (var role in roles)
{
if (userRoles.Any(x => x.RoleId == role.RoleId))
{
role.UserId = userid;
}
}
return(roles);
}
public IEnumerable <SystemRole> Search(Expression <Func <SystemRole, bool> > whereExpressions, PageOptions page)
{
var query = whereExpressions == null?RoleDb.AsQueryable() : RoleDb.AsQueryable().Where(whereExpressions);
if (!page.IsNull() && page.IsValidate)
{
var totalCount = 0;
var results = query.ToPageList(page.PageIndex, page.PageSize, ref totalCount);
page.TotalCount = totalCount;
return(results);
}
else
{
return(query.ToList());
}
}
private void ProcessUserRole(UserDb user, RoleDb role)
{
RoleUserDb roleUser = new RoleUserDb()
{
User = user,
Role = role
};
_context.Add(roleUser);
if (role.Role == "Student")
{
_context.Add(new StudentDb()
{
User = user
});
}
}
public async Task <bool> Edit(SystemRole role)
{
var validateResults = SystemRole.Validate(role);
if (validateResults.All(r => r.IsSuccess))
{
if (role.RoleId.IsEmpty())
{
var current = RoleDb.GetSingle(r => r.RoleName == role.RoleName && r.SystemId == role.SystemId);
return(current.IsNull() ? await RoleDb.AsInsertable(role).ExecuteCommandAsync() > 0 : false);
}
else
{
return(await RoleDb.AsUpdateable(role).ExecuteCommandAsync() > 0);
}
}
return(false);
}
/// <summary>
/// 显示
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Detail(int id = 0)
{
RoleDb dbModel = new RoleDb();
RoleWebM model = new RoleWebM();
if (id > 0)
{
ViewBag.EditType = 2;
dbModel = RoleBll.Instance.GetModel(id);
ModelCopier.CopyModel(dbModel, model);
}
else
{
model.role_status = 1;
ViewBag.EditType = 1;
}
ViewBag.Tree = ModuleBll.Instance.GetModuleMacheRoleTree(id);
return(View(model));
}
public ActionResult Detail(RoleWebM model)
{
RoleBll roleBll = new RoleBll();
if (ModelState.IsValid)
{
RoleDb dbModel = new RoleDb();
ModelCopier.CopyModel(model, dbModel);
List <RoleModuleRelationDb> roleModuleRelations = new List <RoleModuleRelationDb>();
if (!string.IsNullOrEmpty(model.power))
{
string[] powerList = model.power.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
foreach (var s in powerList)
{
RoleModuleRelationDb relation = new RoleModuleRelationDb();
relation.module_code = s;
relation.creator_date = DateTime.Now;
relation.creator_name = LoginUser.user_name;
relation.role_id = model.role_id;
roleModuleRelations.Add(relation);
}
}
if (model.role_id > 0)
{
dbModel.modifi_name = LoginUser.user_name;
dbModel.modifi_date = DateTime.Now;
RoleBll.Instance.Update(dbModel, roleModuleRelations);
return(Content("<script>alert('修改角色成功!');parent.layer.closeAll('iframe');</script>"));
}
else
{
dbModel.creator_name = LoginUser.user_name;
dbModel.creator_date = DateTime.Now;
RoleBll.Instance.Add(dbModel, roleModuleRelations);
return(Content("<script>alert('添加角色成功!');parent.layer.closeAll('iframe');</script>"));
}
}
ViewBag.Tree = ModuleBll.Instance.GetModuleMacheRoleTree(model.role_id);
return(View(model));
}
public RoleBs()
{
objDb = new RoleDb();
}
public RoleBs()
{
_roleObject = new RoleDb();
}
public RoleBs()
{
objDb = new RoleDb();
}
public async Task <SystemRole> GetById(Guid id)
{
return(await RoleDb.AsQueryable().FirstAsync(r => r.RoleId == id));
}
