public string ChangeStatus()
{
string result = "";
try
{
int id = 0;
int.TryParse(Request["id"], out id);
byte status = 0;
byte.TryParse(Request["status"], out status);
var repo = new RoleRepository();
var v = repo.GetByID(id);
if (v != null)
{
v.RecordStatus = status;
repo.SaveChanges();
}
result = JsonResult(true, Resources.Messages.StatusChanged);
}
catch (Exception ex)
{
result = JsonResult(false, ex.Message);
}
return result;
}
public ManageEmployeeDetails()
{
InitializeComponent();
empRepo = new EmployeeRepository();
roleRepo = new RoleRepository();
HideControls(false);
}
public AccountController(IUnitOfWork unitOfWork)
: base(unitOfWork)
{
_repository = new UserRepository(unitOfWork);
_departRepository= new DepartRepository(unitOfWork);
_roleRepository = new RoleRepository(unitOfWork);
}
public static IRepositoryService<Role> Create()
{
IDatabaseFactory databaseFactory = new DatabaseFactory();
IUnitOfWork unitOfWork = new UnitOfWork(databaseFactory);
IRepository<Role> roleRepository = new RoleRepository(databaseFactory);
return new RoleEntityService((IRoleRepository)roleRepository, unitOfWork);
}
public override string[] GetRolesForUser(string login)
{
string[] role = new string[] { };
using (IModelRepository<User> _user = new UserRepository())
{
try
{
IModelRepository<Role> _role = new RoleRepository();
// Get User
var user = (from u in _user.Items
where u.Login == login
select u).FirstOrDefault();
if (user != null)
{
// Get role
var userRole = _role.Items.FirstOrDefault(x=>x.Id==user.RoleId);
if (userRole != null)
{
role = new string[] { userRole.Name };
}
}
}
catch
{
role = new string[] { };
}
}
return role;
}
public void CreateUser()
{
var connectionString = ConfigurationManager.AppSettings["localConnection"];
using (IDbConnection connection = new SqlConnection(connectionString))
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
using(var userRepository = new UserDatabaseRepository(connection))
using (var roleRepository = new RoleRepository(connection))
{
// To create a USER you MUST first have already created a ROLE!
var role = new Role { Name = "User" };
var createdRole = roleRepository.Create(role, _ => Task.FromResult(0)).Result;
createdRole.Match(r =>
{
var user = new User
{
Email = "*****@*****.**",
FirstName = "John",
LastName = "Doe",
Roles = new List<Role> { r },
Username = "******"
};
var created = userRepository.Create(user, _ => Task.FromResult(0)).Result;
Assert.True(created.HasValue);
},
() =>
{
Assert.True(false, "Role has not been created!");
});
}
}
public RBACHelper()
{
permissionAssigmentRepository = new PermissionAssigmentRepository();
userAssigmentRepository = new UserAssigmentRepository();
userRepository = new UserRepository();
roleRepository = new RoleRepository();
}
public void RoleInheritRelationService_AddRelation_Test()
{
var roleId = 3;
var inheritRoleId = 4;
//初始化
var unit = EntityUnitOfWorkFactory.CreateUnitOfWork();
var roleInheritRelationService = new RoleInheritRelationService(unit);
var roleRepository = new RoleRepository(unit);
var role = roleRepository.Get(roleId);
var inheritRole = roleRepository.Get(inheritRoleId);
var inheritRoles = roleInheritRelationService.GetInheritRolesOfRole(role, false);
Assert.IsFalse(inheritRoles.Contains(inheritRole));
//启动事务进行测试，并不提交
using (var ts = new TransactionScope())
{
roleInheritRelationService.AddRelation(role, inheritRole);
unit.SaveChanges();
inheritRoles = roleInheritRelationService.GetInheritRolesOfRole(role, false);
Assert.IsTrue(inheritRoles.Contains(inheritRole));
}
}
public void Sould_GetUsersInRole_Return_Succefully()
{
var roleRepository = new RoleRepository<MjrAppRole, User>();
var result = roleRepository.GetUsersInRole("MjrAdmin");
Assert.IsNotNull(result);
}
public PermissionAssigment(Int32 roleId, Int32 permissionId)
{
this.roleId = roleId;
this.permissionId = permissionId;
this.roleRepository = new RoleRepository();
this.permissionRepository = new PermissionRepository();
}
public void RoleRepository_LoadAll()
{
RoleRepository roleRepository = new RoleRepository();
List<Role> roles = roleRepository.LoadAll();
Assert.AreEqual(12, roles.Count);
}
public UserAssigment(Int32 userId, Int32 roleId)
{
this.userId = userId;
this.roleId = roleId;
this.userRepository = new UserRepository();
this.roleRepository = new RoleRepository();
}
public TaskNodeFormModel(int typeid, TaskRepository taskRepositoryrepository, RoleRepository roleRepository)
{
WbsTypeId = typeid;
Repository = taskRepositoryrepository;
AvailableRoles = roleRepository.FindAll().ToList();
AvailableNodes = Repository.FindAll().Where(x => x.WbsTypeId == WbsTypeId).ToList();
Stages = StageRepository.FindStages().ToList();
}
public TenantProvisioningService(
TenantRepository tenantRepository,
UserRepository userRepository,
RoleRepository roleRepository)
{
this.RoleRepository = roleRepository;
this.TenantRepository = tenantRepository;
this.UserRepository = userRepository;
}
public AuthorizationService(
UserRepository userRepository,
GroupRepository groupRepository,
RoleRepository roleRepository)
{
this.GroupRepository = groupRepository;
this.RoleRepository = roleRepository;
this.UserRepository = userRepository;
}
//
// GET: /Usuario/Edit/5
public ActionResult Edit(int id)
{
Usuario usuario = _Rep.GetById(id);
RoleRepository _RepRole = new RoleRepository();
ViewBag.RoleId = new SelectList(_RepRole.GetAll(), "Id", "Nombre",usuario.RoleId);
return View(usuario);
}
public static void init()
{
RoleRepository repo = new RoleRepository();
repo.Create(new Role { name = "Ejer" });
repo.Create(new Role { name = "Admin" });
repo.Create(new Role { name = "Redaktør" });
repo.Create(new Role { name = "Basis" });
}
public void WhenGetAllFromEmptyDatabase_ThenReturnsEmptyCollection()
{
var repository = new RoleRepository(new DatabaseFactory());
IEnumerable<Roles> actual = repository.GetAll();
Assert.NotNull(actual);
var actualList = new List<Roles>(actual);
Assert.Equal(0, actualList.Count);
}
public AuthenticationController()
{
string connString = ConfigurationManager.ConnectionStrings["OnlineSurveyDbConn"].ToString();
var dbContext = new OnlineSurveyContext(connString);
var roleRepo = new RoleRepository(dbContext);
var userRepo = new UserRepository(dbContext);
_roleService = new RoleService(roleRepo);
_userService = new UserService(userRepo);
}
/// <summary>
/// Initializes a new instance of the RoleService class.
/// </summary>
/// <param name="unitOfWork">UnitOfWork information</param>
public RoleService(UnitOfWork unitOfWork)
{
if (unitOfWork == null)
{
throw new ArgumentNullException(UnitOfWorkConst);
}
this.unitOfWork = unitOfWork;
this.roleRepository = new RoleRepository(this.unitOfWork);
}
public bool addRole(Role role)
{
RoleRepository repository = new RoleRepository();
if(role != null)
{
repository.Add(role);
return true;
}
return false;
}
public ServiceUser(
UserRepository userRepo,
RoleRepository roleRepo,
AuthRepository authRepo,
UnitOfWork unit)
: base(unit)
{
this.user_repo = userRepo;
this.role_repo = roleRepo;
this.auth_repo = authRepo;
}
public SqlDAL()
{
DBContext = new AlbumsDBModel();
_albumRepository = new AlbumRepository(DBContext);
_roleRepository = new RoleRepository(DBContext);
_userRepository = new UserRepository(DBContext);
_commentRepository = new CommentRepository(DBContext);
_likeRepository = new LikeRepository(DBContext);
_albumsPhotoRepository = new AlbumsPhotoRepository(DBContext);
_photoRepository = new PhotoRepository(DBContext);
}
public AppSettingController(IUnitOfWork unitOfWork)
: base(unitOfWork)
{
_departRepository= new DepartRepository(unitOfWork);
_roleRepository = new RoleRepository(unitOfWork);
_wbsTaskRepository = new WBSTaskRepository(unitOfWork);
_taskRepository = new TaskRepository(unitOfWork);
_categoryRepostitory = new CategoryRepostitory(unitOfWork);
_stateCategoryRepostitory = new StateCategoryRepostitory(unitOfWork);
_nodeDocTypeRepository = new NodeDocTypeRepository(unitOfWork);
}
public void RoleRepository_LoadById()
{
Int32 roleId = 1;
RoleRepository roleRepository = new RoleRepository();
Role role = roleRepository.LoadById(roleId);
Assert.IsNotNull(role);
Assert.AreEqual(roleId, role.Id);
}
public static bool IsOptionInUserRoles(IList<UserRole> roles, string option)
{
IRepository<Role> repoRole = new RoleRepository();
foreach (UserRole item in roles)
{
if (ConfigurationManager.AppSettings[repoRole.GetById(item.Role.Id).Name].Contains(option))
{
return true;
}
}
return false;
}
public OperationResult CreateRole(Model.Role model)
{
using (IUnitOfWork unitofwork = new EntityFrameworkContext())
{
IRoleRepository roleRepository = new RoleRepository(unitofwork);
if (roleRepository.GetEntity.Count(m => m.RoleName == model.RoleName) <= 0)
{
roleRepository.Insert(model);
unitofwork.Commit();
return new OperationResult(OperationResultType.Success, "角色添加成功.");
}
return new OperationResult(OperationResultType.NoChanged, "角色名已存在.");
}
}
public DonationInformation()
{
//dtpDate.MinDate = DateTime.Now;
this.MaximizeBox = false;
InitializeComponent();
dtpEnglishDateType.Format = DateTimePickerFormat.Custom;
dtpEnglishDateType.CustomFormat = "dd/MM";
donorRepo = new DonorRepository();
datetypeRepo = new DateTypeRepository();
desigRepo = new DesignationRepository();
employeeRepo = new EmployeeRepository();
prefixRepo = new PrefixesRepository();
roleRepo = new RoleRepository();
serviceNameRepo = new ServiceNameRepository();
serviceTypeRepo = new ServiceTypeRepository();
specialDayRepo = new SpecialDayRepository();
starRepo = new StarsRepository();
monthsRepo = new MonthsRepository();
pakshaRepo = new PakshaRepository();
thithiRepo = new ThidhiRepository();
monthlyAnnaRepo = new MonthlyAnnaRepository();
gothramRepo = new GothramsRepository();
transTypeRepo = new TransactionTypeRepository();
lstTokenPrint = new List<TokenPrint>();
stateRepo = new StateRepository();
lstStates = new List<State>();
prefixesRepo = new PrefixesRepository();
bindData();
btnUpdate.Visible = false;
btnCancel.Visible = false;
lblSpecialDay.Visible = false;
cmbSpecialDay.Visible = false;
lblMonth.Visible = false;
cmbMonth.Visible = false;
lblThithi.Visible = false;
cmbThithi.Visible = false;
lblMonthlyAnna.Visible = false;
cmbMonthlyAnna.Visible = false;
lblEnglishDatetype.Visible = false;
dtpEnglishDateType.Visible = false;
rbdEnglish.Checked = false;
rbdTelugu.Checked = false;
lblMonthyAnnaThithi.Visible = false;
cmbMonthyAnnaThithi.Visible = false;
}
public static void BeforeMembershipScenarios()
{
var context = new ShopAnyWareSql();
var userRepository = new UserRepository(context);
var roleRepository = new RoleRepository(context);
var profileRepository = new ProfileRepository(context);
var membershipRepository = new MembershipRepository();
var logger = new FakeLogger();
var emailService = new FakeEmailService();
ScenarioContext.Current.Set(emailService);
var membershipService = new MembershipService(logger, emailService, userRepository, roleRepository, profileRepository, membershipRepository);
ScenarioContext.Current.Set(membershipService);
}
public ActionResult Create(Usuario usuario)
{
if (ModelState.IsValid)
{
///Add object to Database
_Rep.Add(usuario);
return RedirectToAction("Index");
}
RoleRepository _RepRole = new RoleRepository();
ViewBag.RoleId = new SelectList(_RepRole.GetAll(), "Id", "Nombre");
return View(usuario);
}
public override string[] GetRolesForUser(string username)
{
using (UsersRepository objContext = new UsersRepository())
{
var objUser = objContext.GetUserByName(username);
if (objUser == null)
{
return(null);
}
else
{
var roles = objUser.UserRoles.Select(x => x.RoleID).ToList();
using (RoleRepository objRole = new RoleRepository())
{
return((from e in objRole.GetAllRoles() where roles.Contains(e.RoleID) select e.RoleName).ToArray());
}
}
}
}
public async Task EnsureGenericExceptionIsThrownWhenErrorIsUnknown()
{
var k8s = Dummy.Of <IKubernetesWrapper>();
var sut = new RoleRepository(k8s);
Mock.Get(k8s).Setup(k => k.CreateNamespacedRoleAsync(It.IsAny <V1Role>(),
It.IsAny <string>(), null, It.IsAny <CancellationToken>()))
.Throws(new HttpOperationException
{
Response =
new HttpResponseMessageWrapper(new HttpResponseMessage {
StatusCode = HttpStatusCode.BadGateway
}, "Unable to communicate")
});
var @namespace = "fancyNamespace";
await Assert.ThrowsAsync <Exception>(() => sut.CreateNamespaceFullAccessRole(@namespace));
}
public virtual async Task <ActionResult> SyncUsers()
{
string token = await ADService.GetTokenForApplication();
if (token == null)
{
return(RedirectToAction("SignIn", MVC.Account.Name));
}
var result = await ADService.GetUsers();
IEnumerable <IUser> users = result.CurrentPage.ToList();
var myId = CurrentUserId;
var defaultRole = RoleRepository.Single(x => x.Name == "User");
var currentEmployees = EmployeeRepository.Select(x => x.Id);
var appUsers = users.Where(x => x.GivenName != null).Select(x => new Employee()
{
Id = x.ObjectId,
Email = x.Mail,
Role = defaultRole,
Name = x.DisplayName,
PhoneNumber = x.Mobile,
IsInitialized = false,
VacationMessages = false,
RequestMessages = false,
MonthlyBirthdayMessages = false,
DailyBirthdayMessages = false,
VacationDays = 28
});
var newUsers = appUsers.Where(x => !currentEmployees.Contains(x.Id));
EmployeeRepository.AddRange(newUsers);
EmployeeRepository.Commit();
return(View(MVC.Admin.Views.EditEmployees, new WorkersViewModel()
{
Employees = EmployeeRepository.AsDto()
}));
}
public bool Delete(string roleID)
{
//Guid gRoleID = new Guid(roleID);
var role = RoleRepository.GetQueryable()
.FirstOrDefault(i => i.ROLE_ID == roleID);
if (role != null)
{
Del(RoleSystemRepository, role.AUTH_ROLE_SYSTEM);
Del(UserRoleRepository, role.AUTH_USER_ROLE);
RoleRepository.Delete(role);
RoleRepository.SaveChanges();
}
else
{
return(false);
}
return(true);
}
public static async Task RegisterAdmin()
{
using (var roles = new RoleRepository())
{
if (await roles.GetRoleByNameAsync("admin") == null)
{
await roles.CreateAsync(new IdentityRole("admin"));
}
if (await roles.GetRoleByNameAsync("editor") == null)
{
await roles.CreateAsync(new IdentityRole("editor"));
}
if (await roles.GetRoleByNameAsync("author") == null)
{
await roles.CreateAsync(new IdentityRole("author"));
}
if (await roles.GetRoleByNameAsync("user") == null)
{
await roles.CreateAsync(new IdentityRole("user"));
}
}
using (var users = new UserRepository())
{
var user = await users.GetUserByNameAsync("admin");
if (user == null)
{
var adminUser = new UserIdentity
{
UserName = "******",
Email = "*****@*****.**",
DisplayName = "Administrator"
};
await users.CreateAsync(adminUser, "User@1234");
}
await users.AddUserToRoleAsync(user, "admin");
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
string rid = Request.QueryString["rid"];
repo = new RoleRepository();
rr = new RegistrationRequestRepository();
RegistrationRequestTable r = rr.GetRegistrationRequestForRegistrationRequestID(Convert.ToInt64(rid));
List <RoleTable> roles = repo.GetAllRoles();
DetailsView1.DataSource = r;
DetailsView1.DataBind();
DropDownList1.DataSource = roles;
DropDownList1.DataTextField = "RoleName";
DropDownList1.DataValueField = "RoleID";
DropDownList1.DataBind();
lblAddSuc.Visible = false;
}
}
public void TestIsAdminIsTrueSaves()
{
#region Arrange
var role = GetValid(9);
role.IsAdmin = true;
#endregion Arrange
#region Act
RoleRepository.DbContext.BeginTransaction();
RoleRepository.EnsurePersistent(role);
RoleRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.IsTrue(role.IsAdmin);
Assert.IsFalse(role.IsTransient());
Assert.IsTrue(role.IsValid());
#endregion Assert
}
public void TestUsersWithEmptyListWillSave()
{
#region Arrange
Role record = GetValid(9);
#endregion Arrange
#region Act
RoleRepository.DbContext.BeginTransaction();
RoleRepository.EnsurePersistent(record);
RoleRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.IsNotNull(record.Users);
Assert.AreEqual(0, record.Users.Count);
Assert.IsFalse(record.IsTransient());
Assert.IsTrue(record.IsValid());
#endregion Assert
}
public void TestLevelWithMinIntValueSaves()
{
#region Arrange
var record = GetValid(9);
record.Level = int.MinValue;
#endregion Arrange
#region Act
RoleRepository.DbContext.BeginTransaction();
RoleRepository.EnsurePersistent(record);
RoleRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.AreEqual(int.MinValue, record.Level);
Assert.IsFalse(record.IsTransient());
Assert.IsTrue(record.IsValid());
#endregion Assert
}
public JsonResult SelRole(DRelationship _param)
{
List <Role> lRoles = RoleRepository.SelRoles(new Role {
});
if (_param.FromOID != null)
{
DRelationshipRepository.SelRelationship(new DRelationship {
Type = CommonConstant.RELATIONSHIP_ROLE, FromOID = _param.FromOID
}).ForEach(role =>
{
lRoles.FindAll(innerRole => innerRole.OID == role.ToOID).ForEach(filterRole =>
{
filterRole.IsChecked = true;
});
});
}
return(Json(lRoles));
}
public async Task <ISingleResponse <RoleModel> > GetRoleByIDAsync(int roleID)
{
Logger.Info(CreateInvokedMethodLog(MethodBase.GetCurrentMethod().ReflectedType.FullName));
var response = new SingleResponse <RoleModel>();
try
{
var userDetails = await RoleRepository.GetByIDAsync(roleID);
response.Model = Mapper.Map <RoleModel>(userDetails);
}
catch (Exception ex)
{
response.SetError(ex, Logger);
}
return(response);
}
public async Task Find_GivenUserDoesExist_ExpectMaybeWithUser()
{
var options = new DbContextOptionsBuilder <DataContext>()
.UseInMemoryDatabase($"DataContext{Guid.NewGuid()}")
.Options;
var mediator = new Mock <IMediator>();
await using var context = new DataContext(options, mediator.Object);
var role = new Role(TestVariables.RoleId, "name", new List <Guid>());
await context.Roles.AddAsync(role);
await context.SaveEntitiesAsync();
var roleRepository = new RoleRepository(context);
var maybe = await roleRepository.Find(TestVariables.RoleId);
Assert.True(maybe.HasValue);
}
public void TestGetManagementRolesForUserInApplicationReturnsExpectedValue1()
{
#region Arrange
var applicationRoleRepository = FakeRepository <ApplicationRole>();
RoleService = new RoleService(PermissionRepository, applicationRoleRepository);
ControllerRecordFakes.FakeApplications(3, ApplicationRepository);
ControllerRecordFakes.FakeUsers(3, UserRepository);
var roles = new List <Role>();
roles.Add(CreateValidEntities.Role(1));
roles.Add(CreateValidEntities.Role(2));
roles.Add(CreateValidEntities.Role(3));
roles.Add(CreateValidEntities.Role(4));
roles[0].Name = "ManageAll";
roles[1].Name = "ManageSchool";
roles[2].Name = "ManageUnit";
roles[3].Name = "ManageMe"; //Not special
ControllerRecordFakes.FakeRoles(5, RoleRepository, roles);
var permissions = new List <Permission>();
for (int i = 0; i < 6; i++)
{
permissions.Add(CreateValidEntities.Permission(i + 1));
permissions[i].Application = ApplicationRepository.GetNullableById(1);
permissions[i].User = UserRepository.GetNullableById(2);
permissions[i].Role = RoleRepository.GetNullableById(i + 1);
}
ControllerRecordFakes.FakePermissions(6, PermissionRepository, permissions);
#endregion Arrange
#region Act
var result = RoleService.GetManagementRolesForUserInApplication("Name1", "LoginId2");
#endregion Act
#region Assert
Assert.IsNotNull(result);
Assert.AreEqual(4, result.Count);
Assert.AreEqual("ManageAll", result.ElementAt(0));
Assert.AreEqual("ManageSchool", result.ElementAt(1));
Assert.AreEqual("ManageUnit", result.ElementAt(2));
Assert.AreEqual("ManageMe", result.ElementAt(3));
#endregion Assert
}
public override bool RoleExists(string roleName)
{
if (string.IsNullOrEmpty(roleName))
{
return(false);
}
Role Role = null;
Role = RoleRepository.GetAll().FirstOrDefault(Rl => Rl.RoleName == roleName);
if (Role != null)
{
return(true);
}
else
{
return(false);
}
}
public async Task CreateNamespaceFullAccessRole_IncludesCorrectPolicies()
{
var k8s = Dummy.Of <IKubernetesWrapper>();
var sut = new RoleRepository(k8s);
Mock.Get(k8s).Setup(k => k.CreateNamespacedRoleAsync(It.IsAny <V1Role>(),
It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(new V1Role()));
var @namespace = "fancyNamespace";
var result = await sut.CreateNamespaceFullAccessRole(@namespace);
Moq.Mock.Get(k8s).Verify(s => s.CreateNamespacedRoleAsync(It.Is <V1Role>(r =>
r.Metadata.NamespaceProperty == @namespace &&
r.Rules.Count == 4 &&
r.Rules.Count(rule => rule.Resources.Any(res => res.Contains("namespace"))) == 1), It.Is <string>(n => n == @namespace), It.IsAny <string>(), It.IsAny <CancellationToken>()));
}
private bool FillSolutionComponentFromSchemaName(ICollection <SolutionComponent> result, string schemaName, int?behavior)
{
if (!string.IsNullOrEmpty(schemaName) &&
Guid.TryParse(schemaName, out var roleTemplateId))
{
var repository = new RoleRepository(_service);
var entity = repository.FindRoleByTemplate(roleTemplateId, new ColumnSet(false));
if (entity != null)
{
FillSolutionComponentInternal(result, entity.Id, behavior);
return(true);
}
}
return(false);
}
//删除测试，还是对象
public void Method3()
{
var repo = new UserRepository();
var repo1 = new RoleRepository();
var users = new List <SysUser>()
{
new SysUser()
{
UserName = "******",
Password = "******"
}
};
repo.Insert(users);
var roles = new List <SysRole>()
{
new SysRole()
{
Name = "管理员3",
Description = "管理员3",
RoleType = RoleType.Admin
}
};
repo1.Insert(roles);
long userId = repo.Entities.FirstOrDefault(o => o.UserName == "user3").Id;
long roleId = repo1.Entities.FirstOrDefault(o => o.Name == "管理员3").Id;
var user = repo.Query(userId);
var role = repo1.Query(roleId);
user.Roles = new List <SysRole>()
{
role
};
repo.Update(user);
user.Roles = null;
repo.Update(user);
}
private static void CleanRoles(RoleRepository repository)
{
var entities = repository.GetAllEntities();
foreach (Role entity in entities)
{
using (var db = new ESportDbContext())
try
{
var entityToRemove = db.Role.Attach(entity);
db.Role.Remove(entityToRemove);
db.SaveChanges();
}
catch (Exception e)
{
throw new RepositoryException("Error al eliminar entidad", e);
}
}
}
public void TestNameWithLongValueSaves()
{
#region Arrange
var role = GetValid(9);
role.Name = "x".RepeatTimes(50);
#endregion Arrange
#region Act
RoleRepository.DbContext.BeginTransaction();
RoleRepository.EnsurePersistent(role);
RoleRepository.DbContext.CommitTransaction();
#endregion Act
#region Assert
Assert.AreEqual(50, role.Name.Length);
Assert.IsFalse(role.IsTransient());
Assert.IsTrue(role.IsValid());
#endregion Assert
}
public bool Delete(string roleID)
{
Guid gRoleID = new Guid(roleID);
var role = RoleRepository.GetQueryable()
.FirstOrDefault(i => i.RoleID == gRoleID);
if (role != null)
{
Del(RoleSystemRepository, role.RoleSystems);
Del(UserRoleRepository, role.UserRoles);
RoleRepository.Delete(role);
RoleRepository.SaveChanges();
}
else
{
return(false);
}
return(true);
}
public UnitOfWork(ParkingManagementContext parkingManagementContext)
{
_parkingManagementContext = parkingManagementContext;
Registers = new RegisterRepository(_parkingManagementContext);
UserRoles = new RoleRepository(_parkingManagementContext);
RequestDuationTypes = new RequestDuationTypeRepository(_parkingManagementContext);
Tower = new TowerRepository(_parkingManagementContext);
ParkingSlot = new ParkingSlotRepository(_parkingManagementContext);
RequestDetails = new RequestDetailsRepository(_parkingManagementContext);
ParkingAllocation = new ParkingAllocationRepository(_parkingManagementContext);
SurrenderHistory = new SurrenderHistoryRepository(_parkingManagementContext);
TowerParkingSlot = new TowerParkingSlotRepository(_parkingManagementContext);
TowerBlock = new TowerBlockRepository(_parkingManagementContext);
TowerBlockSlot = new TowerBlockSlotRepository(_parkingManagementContext);
slotRequestDetails = new SlotRequestDetailsRepository(_parkingManagementContext);
}
public async Task <Guid> CreateCharity(CharityCreateDto charityDto)
{
User user = new User(Guid.NewGuid(), charityDto.Login.ToLower(), charityDto.Password.ToSHA512(),
LoginType.CHARITABLE_ENTITY, Guid.NewGuid(), true);
var charitable = this.Mapper.Map <CharitableEntity>(charityDto);
charitable.Status = ApproverStatus.PENDING;
charitable.IsActive = false;
charitable.ApproverData = null;
charitable.Approver = string.Empty;
charitable.Id = Guid.NewGuid();
charitable.UserId = user.Id;
var approval = new Approval()
{
Id = Guid.NewGuid(),
CharitableEntityId = charitable.Id,
Date = DateTime.UtcNow.ToBrazilianTimeZone(),
Message = "Análise Pendente",
Status = (int)ApproverStatus.PENDING
};
var lstRole = await RoleRepository.GetWhereAsync(r => r.Name.ToLower().Equals("charitable_entity"));
if (!lstRole.Any())
{
throw new Exception("Cannot find role charitable_entity");
}
await UserRoleRepository.AddAsync(new UserRole()
{
User = user, RoleId = lstRole.First().Id
});
await this.Repository.AddAsync(charitable);
await ApprovalRepository.AddAsync(approval);
await this.Repository.SaveAsync();
return(charitable.Id);
}
public UserManageController
(UserRepository userRepository,
UserManager <Users> userManager
, UsersRoleRepository usersRoleRepository
, RoleRepository roleRepository
, SmsService smsService
, UsersAccessRepository usersAccessRepository,
UserOrganizationRepository userOrganizationRepository,
OrganizationRepository organizationRepository) : base(usersAccessRepository)
{
_userRepository = userRepository;
_userManager = userManager;
_usersRoleRepository = usersRoleRepository;
_roleRepository = roleRepository;
_smsService = smsService;
_userOrganizationRepository = userOrganizationRepository;
_organizationRepository = organizationRepository;
}
public bool UserCheckRole(int userId, int roleId)
{
var user = UserRepository.UserGetById(userId);
var role = RoleRepository.RoleGetById(roleId);
if (user == null || role == null)
{
return(false);
}
foreach (Role userRole in user.Roles)
{
if (role.Id == userRole.Id)
{
return(true);
}
}
return(false);
}
/// <summary>
/// 编辑用户角色映射信息
/// </summary>
/// <param name="dto">用户角色映射信息输入DTO</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> UpdateUserRoleMapAsync(TUserRoleMapInputDto dto)
{
dto.CheckNotNull("dto");
dto.ThrowIfTimeInvalid();
Expression <Func <TUserRoleMap, bool> > predicate = m => m.User.Id.Equals(dto.UserId) && m.Role.Id.Equals(dto.RoleId);
predicate = predicate.And(GetUserRoleMapUnexpireExpression(dto));
TUserRoleMap map = (await UserRoleMapRepository.GetByPredicateAsync(predicate)).FirstOrDefault();
if (map != null && !map.Id.Equals(dto.Id))
{
return(new OperationResult(OperationResultType.Error,
"“{0}{1}”存在的时间区间[{2}→{3}]包含当前时间段，不能重复添加"
.FormatWith(map.User.NickName, map.Role.Name, GetTimeString(map.BeginTime), GetTimeString(map.EndTime))));
}
if (map == null || !map.Id.Equals(dto.Id))
{
map = await UserRoleMapRepository.GetByKeyAsync(dto.Id);
}
map = dto.MapTo(map);
if (!map.User.Id.Equals(dto.UserId))
{
TUser user = UserRepository.GetByKey(dto.UserId);
if (user == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的用户信息不存在"));
}
map.User = user;
}
if (!map.Role.Id.Equals(dto.RoleId))
{
TRole role = RoleRepository.GetByKey(dto.RoleId);
if (role == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的角色信息不存在"));
}
map.Role = role;
}
await UserRoleMapRepository.UpdateAsync(map);
return(OperationResult.Success);
}
/// <summary>
/// Gets the role ID from the user.
/// </summary>
/// <returns>Returns an integer for the selected role ID.</returns>
private static int GetRoleId()
{
_roleRepository = new RoleRepository(context);
int? roleId = null;
IList <Role> roles = _roleRepository.GetList();
// While the role ID is null, prompt the user to select a role ID
// from the provided list.
while (roleId == null)
{
ConsoleHelper.OutputBlankLine();
foreach (Role r in roles)
{
ConsoleHelper.OutputLine("{0}) {1}", roles.IndexOf(r) + 1, r.Name);
}
// Get the line number for the selected role.
string lineNumberInput = ConsoleHelper.ReadInput(
"Enter the line number of the role that the artist had on this comic book: ");
// Attempt to parse the user's input to a line number.
int lineNumber = 0;
if (int.TryParse(lineNumberInput, out lineNumber))
{
if (lineNumber > 0 && lineNumber <= roles.Count)
{
roleId = roles[lineNumber - 1].Id;
}
}
// If we weren't able to parse the provided line number
// to an role ID then display an error message.
if (roleId == null)
{
ConsoleHelper.OutputLine("Sorry, but that wasn't a valid line number.");
}
}
context.Dispose();
return(roleId.Value);
}
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
foreach (string rolename in roleNames)
{
if (!RoleExists(rolename))
{
throw new ProviderException(String.Format("Role name {0} not found.", rolename));
}
}
foreach (string username in usernames)
{
if (username.Contains(","))
{
throw new ArgumentException(String.Format("User names {0} cannot contain commas.", username));
}
//is user not exiting //throw exception
foreach (string rolename in roleNames)
{
if (IsUserInRole(username, rolename))
{
throw new ProviderException(String.Format("User {0} is already in role {1}.", username, rolename));
}
}
}
List <User> Users = UserRepository.GetAll().Where(Usr => usernames.Contains(Usr.Username)).ToList();
List <Role> Roles = RoleRepository.GetAll().Where(Rl => roleNames.Contains(Rl.RoleName)).ToList();
foreach (User user in Users)
{
foreach (Role role in Roles)
{
if (!user.Roles.Contains(role))
{
user.Roles.Add(role);
UserRepository.SaveOrUpdate(user);
RoleRepository.SaveOrUpdate(role);
}
}
}
}
public string Edit(FormDataCollection form)
{
string retVal = string.Empty;
string operation = form.Get("oper");
int id = ConvertHelper.ToInt32(form.Get("RoleId"));
RoleInfo info = null;
if (!string.IsNullOrEmpty(operation))
{
switch (operation)
{
case "edit":
info = RoleRepository.GetInfo(id);
if (info != null)
{
info.Name = form.Get("Name");
info.Description = form.Get("Description");
info.ChangedBy = UserRepository.GetCurrentUserInfo().UserID;
RoleRepository.Update(info);
}
break;
case "add":
info = new RoleInfo
{
Name = form.Get("Name"),
Description = form.Get("Description"),
CreatedBy = UserRepository.GetCurrentUserInfo().UserID
};
RoleRepository.Insert(info);
break;
case "del":
RoleRepository.Delete(id, UserRepository.GetCurrentUserInfo().UserID);
break;
default:
break;
}
}
return(retVal);
}
public UserContextLoader(
ApplicationDbContext dbContext,
UserContext userContext,
AccountRepository accountRepository,
RoleRepository roleRepository,
IHubContext <ForumHub> forumHub,
SignInManager <DataModels.ApplicationUser> signInManager,
UserManager <DataModels.ApplicationUser> userManager,
IHttpContextAccessor httpContextAccessor
)
{
DbContext = dbContext;
UserContext = userContext;
RoleRepository = roleRepository;
AccountRepository = accountRepository;
ForumHub = forumHub;
SignInManager = signInManager;
UserManager = userManager;
HttpContextAccessor = httpContextAccessor;
}
public HttpResponseMessage Put(RoleDto dto)
{
try
{
if (dto != null)
{
RoleRepository.Update(dto);
return(Request.CreateResponse(HttpStatusCode.OK));
}
return(Request.CreateResponse(HttpStatusCode.BadRequest));
}
catch (ElementNotFoundException e)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, e.Message));
}
catch (Exception)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Generic error happened."));
}
}
