예제 #1
0
 public UserOperationsController(IdentityRepository identityRepository, ILogger <UserOperationsController> logger,
                                 IHostingEnvironment environment)
 {
     _identityRepository = identityRepository;
     _environment        = environment;
     _logger             = logger;
 }
예제 #2
0
        public PrescriptionTests()
        {
            SeedData();

            IConfiguration config = new ConfigurationBuilder()
                                    .AddJsonFile("appsettings.json")
                                    .Build();

            var mockMapper = new MapperConfiguration(cfg => cfg.AddProfile(new MappingProfile()));
            var mapper     = mockMapper.CreateMapper();

            var userManager   = MockUserManager.GetMockUserManager(_fakeIdentityUsers).Object;
            var signInManager = MockSigninManager.GetSignInManager <IdentityUser>(userManager).Object;

            IdentityRepositoryFake = new IdentityRepository(userManager, signInManager, config);
            var fakeGenericRepo = MockGenericRepository.GetUserInformationMock(_fakeEntities);

            var fakeGenericRepoUserInformationMock = MockGenericRepository.GetUserInformationMock(_fakeUsersInformation);

            MockUserExtension.ExtendMock(fakeGenericRepoUserInformationMock, _fakeUsersInformation);

            var userInformationMock = MockGenericRepository.GetUserInformationMock(_patients);
            var constulatationsMock = MockGenericRepository.GetUserInformationMock(_constulatations);

            MockGenericExtension.ExtendMock(fakeGenericRepo, _fakeEntities);
            FakeController = new PrescriptionsController(IdentityRepositoryFake, fakeGenericRepo.Object, fakeGenericRepoUserInformationMock.Object, userInformationMock.Object,
                                                         constulatationsMock.Object,
                                                         mapper);

            IdentityHelper.SetUser(_fakeIdentityUsers[0], FakeController);
        }
예제 #3
0
        protected void CreateRolesAndUsersForTask()
        {
            var roles = new [] { "Employees", "USA", "Managers", "Ukraine", "Developers", "Main Office" };

            roles.ForEach(role => IdentityRepository.AddRole(role));
            IdentityRepository.AddChildrenRoles("Employees", new List <string> {
                "USA", "Managers", "Ukraine", "Developers"
            });
            IdentityRepository.AddChildrenRoles("Ukraine", new List <string> {
                "Main Office"
            });
            IdentityRepository.AddChildrenRoles("Developers", new List <string> {
                "Main Office"
            });

            CreateUserForTask("O. Cole", "*****@*****.**");
            CreateUserForTask("J. Shane", "*****@*****.**");
            CreateUserForTask("V. Petrov", "*****@*****.**");
            CreateUserForTask("M. Popov", "*****@*****.**");

            IdentityRepository.AddUserInRoles("O. Cole", new [] { "USA" });
            IdentityRepository.AddUserInRoles("J. Shane", new[] { "USA", "Managers" });
            IdentityRepository.AddUserInRoles("V. Petrov", new[] { "Main Office" });
            IdentityRepository.AddUserInRoles("M. Popov", new[] { "Main Office" });
        }
예제 #4
0
        /// <summary>
        /// Updates the status of an existing identity (whther it is disabled or not).
        /// </summary>
        /// <param name="id">ID of the identity to update.</param>
        /// <param name="disabled">Whether the identity is to be disabled.</param>
        /// <returns>Returns the updated identity.</returns>
        /// <exception cref="EntityNotFoundException">Thrown if the identity could not be found.</exception>
        public async Task <Identity> UpdateIdentityStatus(Guid id, bool disabled)
        {
            Identity identity = await GetIdentity(id);

            identity.Disabled = disabled;
            return(await IdentityRepository.UpdateIdentity(identity));
        }
        /// <summary>
        /// 获取token
        /// </summary>
        /// <returns></returns>
        public virtual TokenEntity GetToken()
        {
            var ticket = GetTokenTicket();

            if (string.IsNullOrEmpty(ticket))
            {
                return(null);
            }
            if (IdentityRepository.Get <IdentityEntity>(ticket) == null)
            {
                RemoveToken();
                RemoveTokenTimeOut();
                return(null);
            }
            if (HttpContext.Current == null)
            {
                return(null);
            }
            HttpCookie cookie = HttpContext.Current.Request.Cookies[TicketKey];

            if (cookie != null)
            {
                var token = new TokenEntity {
                    TimeOut = GetTokenTimeOut(), Ticket = cookie.Value
                };
                return(token);
            }
            return(null);
        }
예제 #6
0
        private static async System.Threading.Tasks.Task CreateAdminAccount(UserManager <AspNetUser> userManager, RoleManager <AspNetRole> roleManager)
        {
            string username = "******";
            string email    = "*****@*****.**";
            string password = "******";

            if (await userManager.FindByNameAsync(username) == null)
            {
                AspNetUser user = new AspNetUser
                {
                    UserName = username,
                    FullName = username,
                    Email    = email
                };

                IdentityResult result = await userManager.CreateAsync(user, password);

                if (result.Succeeded)
                {
                    IdentityRepository indentityRepo = new IdentityRepository(context, userManager);

                    AspNetUser aspNetUser = await userManager.FindByNameAsync(username);

                    AspNetGroup aspNetGroup = indentityRepo.GetAspNetGroup("Administrator");

                    AspNetUserGroup aspNetUserGroup = new AspNetUserGroup();
                    aspNetUserGroup.GroupId = aspNetGroup.GroupId;
                    aspNetUserGroup.UserId  = aspNetUser.Id;
                    aspNetUserGroup.Active  = true;

                    indentityRepo.AddUserToGroup(aspNetUserGroup);
                }
            }
        }
        public ReadOnlyRepositoryTests(ITestOutputHelper output) : base(output) {
            _identityRepository = new IdentityRepository(_configuration);
            _dailyRepository = new DailyLogEventRepository(_configuration);
            _employeeRepository = new EmployeeRepository(_configuration);

            RemoveDataAsync().GetAwaiter().GetResult();
        }
예제 #8
0
        public async Task DeleteUserRoleAsync()
        {
            using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
            {
                var testUserManager = GetTestUserManager(context);
                var testRoleManager = GetTestRoleManager(context);

                IIdentityRepository identityRepository = new IdentityRepository(context, testUserManager, testRoleManager);

                var localizerIdentityResource = new IdentityServiceResources();

                IIdentityService identityService = new IdentityService(identityRepository, localizerIdentityResource);

                //Generate random new user
                var userDto = IdentityDtoMock.GenerateRandomUser(Guid.NewGuid());

                await identityService.CreateUserAsync(userDto);

                //Get new user
                var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();

                userDto.Id = user.Id;

                var newUserDto = await identityService.GetUserAsync(userDto);

                //Assert new user
                userDto.ShouldBeEquivalentTo(newUserDto);

                //Generate random new role
                var roleDto = IdentityDtoMock.GenerateRandomRole(Guid.NewGuid());

                await identityService.CreateRoleAsync(roleDto);

                //Get new role
                var role = await context.Roles.Where(x => x.Name == roleDto.Name).SingleOrDefaultAsync();

                roleDto.Id = role.Id;

                var newRoleDto = await identityService.GetRoleAsync(roleDto);

                //Assert new role
                roleDto.ShouldBeEquivalentTo(newRoleDto);

                var userRoleDto = IdentityDtoMock.GenerateRandomUserRole(roleDto.Id.Value, userDto.Id.Value);

                await identityService.CreateUserRoleAsync(userRoleDto);

                //Get new role
                var userRole = await context.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();

                userRole.Should().NotBeNull();

                await identityService.DeleteUserRoleAsync(userRoleDto);

                //Get deleted role
                var userRoleDeleted = await context.UserRoles.Where(x => x.RoleId == roleDto.Id && x.UserId == userDto.Id).SingleOrDefaultAsync();

                userRoleDeleted.Should().BeNull();
            }
        }
예제 #9
0
 public virtual void SetIdentityRepository(IdentityRepository identityRepository)
 {
     lock (this)
     {
         this.identityRepository = identityRepository;
     }
 }
        // Roles in ASP.Identity
        public void CreateRolesandUsers()
        {
            // Context moet opgehaald worden uit de repository!
            // ApplicationDbContext repo = (ApplicationDbContext)(((IdentityRepository)Store).Context);
            _gebruikerMgr = new GebruikerManager();
            IdentityRepository repo = new IdentityRepository();

            var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(repo.GetContext()));

            // Bij initialisatie van het systeem wordt Admin aangemaakt
            if (!roleManager.RoleExists("SuperAdmin"))
            {
                // Aanmaken van de Admin role
                roleManager.Create(new IdentityRole
                {
                    Name = "SuperAdmin"
                });

                //        // Administrator aanmaken

                var user = new ApplicationUser
                {
                    UserName   = "******",
                    Email      = "*****@*****.**",
                    VoorNaam   = "Qwerty",
                    AchterNaam = "SuperAdmin"
                };


                string userPWD = "Password";

                var chkUser = this.Create(user, userPWD);

                // Administrator de rol van Admin toewijzen
                if (chkUser.Succeeded)
                {
                    var result1 = this.AddToRole(user.Id, "SuperAdmin");
                }
                DateTime joindate = DateTime.Now;
                _gebruikerMgr.AddGebruiker(user.UserName, user.Id, "Admin", "Qwerty", user.Email, joindate, "SuperAdmin");
            }

            // Manager role aanmaken
            if (!roleManager.RoleExists("Admin"))
            {
                roleManager.Create(new IdentityRole
                {
                    Name = "Admin"
                });
            }

            // Emloyee role aanmaken
            if (!roleManager.RoleExists("User"))
            {
                roleManager.Create(new IdentityRole
                {
                    Name = "User"
                });
            }
        }
예제 #11
0
        public async Task AddRoleAsync()
        {
            using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
            {
                var testUserManager = GetTestUserManager(context);
                var testRoleManager = GetTestRoleManager(context);

                IIdentityRepository identityRepository = new IdentityRepository(context, testUserManager, testRoleManager);

                var localizerIdentityResource = new IdentityServiceResources();

                IIdentityService identityService = new IdentityService(identityRepository, localizerIdentityResource);

                //Generate random new role
                var roleDto = IdentityDtoMock.GenerateRandomRole(Guid.NewGuid());

                await identityService.CreateRoleAsync(roleDto);

                //Get new role
                var role = await context.Roles.Where(x => x.Name == roleDto.Name).SingleOrDefaultAsync();

                roleDto.Id = role.Id;

                var newRoleDto = await identityService.GetRoleAsync(roleDto);

                //Assert new role
                roleDto.ShouldBeEquivalentTo(newRoleDto);
            }
        }
예제 #12
0
        public TotalUsersModel GetAllUsers()
        {
            var users = IdentityRepository.GetAllUsers().Select(u =>
                                                                new TotalUserListElement(u.Id, u.AccountName, u.Email, u.Description, u.Note)).ToList();

            return(new TotalUsersModel(users));
        }
        public AdditionalExaminationResultsTests()
        {
            SeedData();

            IConfiguration config = new ConfigurationBuilder()
                                    .AddJsonFile("appsettings.json")
                                    .Build();

            var mockMapper = new MapperConfiguration(cfg => cfg.AddProfile(new MappingProfile()));
            var mock       = mockMapper.CreateMapper();

            var userManager   = MockUserManager.GetMockUserManager(_fakeIdentityUsers).Object;
            var signInManager = MockSigninManager.GetSignInManager <IdentityUser>(userManager).Object;

            IdentityRepositoryFake = new IdentityRepository(userManager, signInManager, config);
            var fakeGenericRepo  = MockGenericRepository.GetUserInformationMock(_fakeEntities);
            var constulationRepo = MockGenericRepository.GetUserInformationMock(_consultations);
            var patientRepo      = MockGenericRepository.GetUserInformationMock(_fakeUsersPatient);
            var typeRepo         = MockGenericRepository.GetUserInformationMock(_types);

            MockGenericExtension.ExtendMock(fakeGenericRepo, _fakeEntities);

            FakeController = new AdditionalExaminationResultsController(IdentityRepositoryFake, fakeGenericRepo.Object,
                                                                        constulationRepo.Object,
                                                                        patientRepo.Object,
                                                                        typeRepo.Object,
                                                                        mock);

            IdentityHelper.SetUser(_fakeIdentityUsers[0], FakeController);
        }
예제 #14
0
        public IActionResult GetPersonForAgency(long id, [Required, NotNull] string agencySystemName)
        {
            var agency = IdentityRepository.GetAgency(agencySystemName);

            if (agency == null)
            {
                ModelState.AddModelError(nameof(agencySystemName), $"{agencySystemName} was not found");
            }
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            Debug.Assert(agency != null, nameof(agency) + " != null");

            var personIdentity = new PersonIdentity(id);

            if (!IdentityRepository
                .GetPeopleWithIdentifiers(new[] { personIdentity }, agency.RootIdentifierNames(), UserProvider)
                .TryGetValue(personIdentity, out var identifiers))
            {
                return(NotFound(id));
            }

            var personIdForAgency = IdentityRepository.GetPersonAgencyId(personIdentity, agency.Id);

            return(Ok(new AgencyPersonDto(personIdForAgency, IdentifierDtoMarshaller.MarshallToDtos(identifiers))));
        }
예제 #15
0
        public override Task ValidateClientAuthentication(OAuthValidateClientAuthenticationContext context)
        {
            string clientId     = string.Empty;
            string clientSecret = string.Empty;
            Client client       = null;

            if (!context.TryGetBasicCredentials(out clientId, out clientSecret))
            {
                context.TryGetFormCredentials(out clientId, out clientSecret);
            }

            if (context.ClientId == null)
            {
                //Remove the comments from the below line context.SetError, and invalidate context
                //if you want to force sending clientId/secrects once obtain access tokens.
                context.Validated();
                //context.SetError("invalid_clientId", "ClientId should be sent.");
                return(Task.FromResult <object>(null));
            }

            using (IdentityRepository _repo = new IdentityRepository())
            {
                client = _repo.FindClient(context.ClientId);
            }

            if (client == null)
            {
                context.SetError("invalid_clientId", string.Format("Client '{0}' is not registered in the system.", context.ClientId));
                return(Task.FromResult <object>(null));
            }

            if (client.ApplicationType == Scheduler.Identity.Data.Enums.ApplicationTypes.NativeConfidential)
            {
                if (string.IsNullOrWhiteSpace(clientSecret))
                {
                    context.SetError("invalid_clientId", "Client secret should be sent.");
                    return(Task.FromResult <object>(null));
                }
                else
                {
                    if (client.Secret != Helper.GetHash(clientSecret))
                    {
                        context.SetError("invalid_clientId", "Client secret is invalid.");
                        return(Task.FromResult <object>(null));
                    }
                }
            }

            if (!client.Active)
            {
                context.SetError("invalid_clientId", "Client is inactive.");
                return(Task.FromResult <object>(null));
            }

            context.OwinContext.Set <string>("as:clientAllowedOrigin", client.AllowedOrigin);
            context.OwinContext.Set <string>("as:clientRefreshTokenLifeTime", client.RefreshTokenLifeTime.ToString());

            context.Validated();
            return(Task.FromResult <object>(null));
        }
예제 #16
0
        public async Task AddUserAsync()
        {
            using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
            {
                var testUserManager = GetTestUserManager(context);
                var testRoleManager = GetTestRoleManager(context);

                IIdentityRepository identityRepository = new IdentityRepository(context, testUserManager, testRoleManager);

                var localizerIdentityResource = new IdentityServiceResources();

                IIdentityService identityService = new IdentityService(identityRepository, localizerIdentityResource);

                //Generate random new user
                var userDto = IdentityDtoMock.GenerateRandomUser(Guid.NewGuid());

                await identityService.CreateUserAsync(userDto);

                //Get new user
                var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();

                userDto.Id = user.Id;

                var newUserDto = await identityService.GetUserAsync(userDto);

                //Assert new user
                userDto.Should().BeEquivalentTo(newUserDto);
            }
        }
예제 #17
0
 protected void InitIdentity()
 {
     IdentityRepository.Initialize();
     IdentityRepository.CreateDefaultRoles();
     IdentityRepository.CreateDefaultAdministrator();
     IdentityRepository.CreateDefaultUser();
 }
예제 #18
0
 /// <summary>
 /// Конструктор
 /// </summary>
 public CustomUserManager(IUserStore <T> store, IOptions <IdentityOptions> options, IPasswordHasher <T> passwordHasher,
                          IEnumerable <IUserValidator <T> > userValidators, IEnumerable <IPasswordValidator <T> > passwordValidators,
                          ILookupNormalizer lookupNormalizer, IdentityErrorDescriber describer, IServiceProvider serviceProvider, ILogger <UserManager <T> > logger)
     : base(store, options, passwordHasher, userValidators, passwordValidators, lookupNormalizer, describer, serviceProvider, logger)
 {
     _repo  = new IdentityRepository();
     Logger = logger;
 }
예제 #19
0
        public BaseResponse UpdateRole(UpdateRoleRequest request)
        {
            var roleName  = string.IsNullOrWhiteSpace(request.RoleName) ? string.Empty : request.RoleName;
            var baseRoles = (request.BaseRoles ?? Enumerable.Empty <string>()).ToArray();

            IdentityRepository.UpdateRoleInRoles(roleName, baseRoles);
            return(BaseResponse.Ok());
        }
예제 #20
0
        private PersonIdentity FindMatchingPerson(IEnumerable <MatchSpecification> match)
        {
            var conversionContext = new MatchSpecificationConversionContext(IdentifierDtoMarshaller);

            PersonIdentity FindPerson(MatchSpecification spec) =>
            IdentityRepository.FindPersonBy(spec.ToPersonSpecification(conversionContext));

            return(match.Select(FindPerson).FirstOrDefault());
        }
 /// <summary>
 /// 得到登陆信息
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="ticket"></param>
 /// <returns></returns>
 public virtual T Get <T>(string ticket) where T : IdentityEntity
 {
     ticket = Winner.Creator.Get <ISecurity>().Decrypt3Des(ticket, DesKey);
     if (string.IsNullOrEmpty(ticket))
     {
         return(default(T));
     }
     return(IdentityRepository.Get <T>(ticket));
 }
예제 #22
0
        //public PredictionServiceTests()
        //{
        //    var predictionRepository = new Mock<IPredictionRepository>();
        //    predictionRepository.Setup(x => x.CheckTypeResult(It.IsAny<string>())).ReturnsAsync((string result) =>
        //   {
        //       if (Convert.ToInt32(result.Substring(0, 1)) > Convert.ToInt32(result.Substring(2, 1))) return TypeResult.WinTeam1;
        //       else if (Convert.ToInt32(result.Substring(0, 1)) < Convert.ToInt32(result.Substring(2, 1))) return TypeResult.WinTeam2;
        //       else if (Convert.ToInt32(result.Substring(0, 1)) == Convert.ToInt32(result.Substring(2, 1))) return TypeResult.Draw;
        //       else return TypeResult.NNB;
        //   });

        //    predictionRepository.Setup(x => x.CompareResultsAsync(It.IsAny<Game>(), It.IsAny<Prediction>())).ReturnsAsync((Game z, Prediction y) =>
        //   {
        //       if (y.PredictedResult == z.Result)
        //           return 3;
        //       else if (y.PredictedTypeResult == z.typeResult)
        //           return 1;
        //       else
        //           return 0;
        //   });
        //    _predictionService = new PredictionService(predictionRepository.Object);
        //}

        public async Task CreateDb()
        {
            var options = new DbContextOptionsBuilder <StrikeNetDbContext>()
                          .UseInMemoryDatabase(databaseName: "StrikeNetTestDb")
                          .EnableSensitiveDataLogging()
                          .UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking)
                          .Options;

            var dbContext = new StrikeNetDbContext(options);

            if (await dbContext.Predictions.CountAsync() <= 0)
            {
                Prediction p1 = new Prediction()
                {
                    Id                  = 1,
                    GameId              = 1,
                    UserId              = User1,
                    PredictedResult     = "3-0",
                    PredictedTypeResult = TypeResult.WinTeam1
                };
                Prediction p2 = new Prediction()
                {
                    Id                  = 2,
                    GameId              = 3,
                    UserId              = User2,
                    PredictedResult     = "2-0",
                    PredictedTypeResult = TypeResult.WinTeam1
                };
                Prediction p3 = new Prediction()
                {
                    Id                  = 3,
                    GameId              = 3,
                    UserId              = User3,
                    PredictedResult     = "0-1",
                    PredictedTypeResult = TypeResult.WinTeam2
                };
                Prediction p4 = new Prediction()
                {
                    Id                  = 4,
                    GameId              = 4,
                    UserId              = User4,
                    PredictedResult     = "1-1",
                    PredictedTypeResult = TypeResult.Draw
                };
                dbContext.Predictions.Add(p1);
                dbContext.Predictions.Add(p2);
                dbContext.Predictions.Add(p3);
                dbContext.Predictions.Add(p4);
                await dbContext.SaveChangesAsync();
            }

            var identityRepository   = new IdentityRepository(_userManager, _roleManager, _signInManager);
            var predictionRepository = new PredictionRepository(identityRepository, dbContext);

            _predictionService2 = new PredictionService(predictionRepository);
        }
예제 #23
0
        /// <summary>
        /// Gets an identity by its unique user-chosen identifier.
        /// </summary>
        /// <param name="identifier">The identifier of the identity to retrieve.</param>
        /// <returns>Returns the identity, if found.</returns>
        /// <exception cref="EntityNotFoundException">Thrown if the identity could not be found.</exception>
        public async Task <Identity> GetIdentity(string identifier)
        {
            Identity identity = await IdentityRepository.GetIdentity(identifier);

            if (identity == null)
            {
                throw new EntityNotFoundException("Identity", identifier);
            }
            return(identity);
        }
예제 #24
0
 public IdentityController(IdentityRepository identityRepository,
                           IHostingEnvironment environment,
                           ILogger <IdentityController> logger,
                           IPasswordHasher <AspNetUser> hasher)
 {
     _identityRepository = identityRepository;
     _enviroment         = environment;
     _logger             = logger;
     _hasher             = hasher;
 }
예제 #25
0
 public UserServices()
 {
     _userRepository      = new IdentityRepository <ApplicationUser>();
     lichSuServices       = new LichSuServices();
     _imageServices       = new ImageServices();
     _nhanvienRepository  = new IRepository <NhanViens>();
     _userRoleRepository  = new IdentityRepository <IdentityUserRole>();
     _khachhangRepository = new IRepository <KhachHang>();
     //UserManager = new ApplicationUserManager();
 }
예제 #26
0
        public IdentityServerUsersService(
            AdminRepository adminRepo,
            IdentityRepository idRepo,
            IServiceProvider serviceProvider) : base(serviceProvider)
        {
            _adminRepo = adminRepo;
            _idRepo    = idRepo;

            _userManager = (UserManager <EmbeddedIdentityServerUser>)serviceProvider.GetService(typeof(UserManager <EmbeddedIdentityServerUser>));
        }
예제 #27
0
        public IActionResult PutPerson([FromBody, Required] PersonSpecification specification)
        {
            if (!ModelState.IsValid)
            {
                return(new BadRequestObjectResult(ModelState));
            }
            var authority = IdentityRepository.GetAuthority(specification.Authority);

            if (authority == null)
            {
                ModelState.AddModelError(
                    nameof(specification.Authority),
                    $"Authority '{specification.Authority}' does not exist");
            }
            ValidateIdentifierTypes(specification.Identifiers, nameof(specification.Identifiers));
            ValidateSpecifications(specification.MatchSpecifications, nameof(specification.MatchSpecifications));
            if (!ModelState.IsValid)
            {
                return(new BadRequestObjectResult(ModelState));
            }

            //identifierChecker.EnsureHasNoInvalidDuplicates(specification.Identifiers);

            var identifiers = IdentifierDtoMarshaller.ConvertToIdentifiers(specification.Identifiers);


            var person = FindMatchingPerson(specification.MatchSpecifications);

            if (person == null)
            {
                if (specification.UpdateMode == UpdateMode.UpdateOnly)
                {
                    return(NotFound());
                }

                person = IdentityRepository.CreatePerson(identifiers, authority);
                return(CreatedAtAction("GetPerson", new { id = person.Id }, new PersonCreatedResult {
                    PersonId = person
                }));
            }

            if (specification.UpdateMode == UpdateMode.CreateOnly)
            {
                return(BadRequest(new { Message = $"Person already exists" }));
            }

            IdentityRepository.UpdatePerson(person, identifiers, authority);

            return(new SeeOtherOjectActionResult(
                       "GetPerson",
                       routeValues: new { id = person.Id },
                       result: new PersonCreatedResult {
                PersonId = person
            }));
        }
예제 #28
0
        private void CreateUserForTask(string userName, string email)
        {
            var account = new AccountModel
            {
                IsActivate  = true,
                AccountName = userName,
                Email       = email,
            };

            IdentityRepository.CreateUser(account, "!@#$%^&*()");
        }
예제 #29
0
 /// <summary>
 /// Gets all identities, optionally filtered by name.
 /// </summary>
 /// <param name="filter">A string to filter identities names with.</param>
 /// <param name="showDisabled">Whether to return disabled identities. Defaults to false.</param>
 /// <returns>Returns identities.</returns>
 public async Task <IEnumerable <Identity> > GetIdentities(string filter, bool showDisabled = false)
 {
     if (filter == null)
     {
         return(await IdentityRepository.GetIdentities(showDisabled));
     }
     else
     {
         return(await IdentityRepository.SearchIdentitiesByIdentifier(filter, showDisabled));
     }
 }
        public DetailsUserModel GetUpdateModel(string userName)
        {
            var rolesForPage = new List <BaseRoleElement>();
            var roles        = IdentityRepository.GetAllRoles();
            var account      = IdentityRepository.GetUser(userName);
            var userRoles    = IdentityRepository.GetRolesForUser(userName);

            userRoles.ForEach(ur => rolesForPage.Add(new BaseRoleElement(ur, true)));
            roles.Except(userRoles).ForEach(role => rolesForPage.Add(new BaseRoleElement(role)));
            return(new DetailsUserModel(account.AccountName, account.Description, account.Email, account.Note, true, rolesForPage));
        }
 /// <summary>
 /// 移除
 /// </summary>
 /// <param name="ticket"></param>
 /// <returns></returns>
 public virtual bool Remove(string ticket)
 {
     try
     {
         var rev = IdentityRepository.Remove(ticket);
         return(rev);
     }
     catch (Exception)
     {
         return(false);
     }
 }
예제 #32
0
파일: JSch.cs 프로젝트: LunarLanding/ngit
		public virtual void SetIdentityRepository(IdentityRepository identityRepository)
		{
			lock (this)
			{
				this.identityRepository = identityRepository;
			}
		}
예제 #33
0
파일: JSch.cs 프로젝트: LunarLanding/ngit
		public JSch()
		{
			identityRepository = new LocalIdentityRepository(this);
			try
			{
				string osname = (string)(Runtime.GetProperties()["os.name"]);
				if (osname != null && osname.Equals("Mac OS X"))
				{
					config.Put("hmac-sha1", "com.jcraft.jsch.jcraft.HMACSHA1");
					config.Put("hmac-md5", "com.jcraft.jsch.jcraft.HMACMD5");
					config.Put("hmac-md5-96", "com.jcraft.jsch.jcraft.HMACMD596");
					config.Put("hmac-sha1-96", "com.jcraft.jsch.jcraft.HMACSHA196");
				}
			}
			catch (Exception)
			{
			}
		}