public async Task <IActionResult> Login([FromForm] AccessDto data) { try { var users = await _userRepository.Get(u => !u.IsDeleted); var user = users.FirstOrDefault(u => u.Email == data.Email || u.Dni == data.Dni); if (user == null) { return(Unauthorized(new { Message = "Incorrect user or password" })); } if (!Bcrypt.Verify(data.Password, user.Password ?? string.Empty)) { return(Unauthorized(new { Message = "Incorrect user or password" })); } _httpContextAccessor.HttpContext.Session.SetString("UserId", user.Id.ToString()); _httpContextAccessor.HttpContext.Session.SetString("User_FullName", user.FullName); return(RedirectToAction(nameof(Index))); } catch (Exception e) { return(BadRequest(new { Message = "Error.", Data = e.Message })); } }
public async Task <IActionResult> Register([FromForm] AccessDto data) { try { var user = await _userRepository.Get(u => !u.IsDeleted && u.Email == data.Email || u.Dni == data.Dni); if (user.Any()) { return(BadRequest(new { Message = "Existing user" })); } await _userRepository.Insert(new User { Id = new Guid(), FullName = data.FullName, Dni = data.Dni, Role = await _roleRepository.GetById(RoleEnum.Standard), Email = data.Email, Password = Bcrypt.HashPassword(data.Password) }); await _userRepository.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } catch (Exception ex) { return(BadRequest(new { Message = "Error.", Data = ex.Message })); } }
protected override void PersistNewItem(PublicAccessEntry entity) { entity.AddingEntity(); foreach (PublicAccessRule rule in entity.Rules) { rule.AddingEntity(); } AccessDto dto = PublicAccessEntryFactory.BuildDto(entity); Database.Insert(dto); // update the id so HasEntity is correct entity.Id = entity.Key.GetHashCode(); foreach (AccessRuleDto rule in dto.Rules) { rule.AccessId = entity.Key; Database.Insert(rule); } // update the id so HasEntity is correct foreach (PublicAccessRule rule in entity.Rules) { rule.Id = rule.Key.GetHashCode(); } entity.ResetDirtyProperties(); }
protected override void PersistUpdatedItem(PublicAccessEntry entity) { entity.UpdatingEntity(); foreach (PublicAccessRule rule in entity.Rules) { if (rule.HasIdentity) { rule.UpdatingEntity(); } else { rule.AddingEntity(); } } AccessDto dto = PublicAccessEntryFactory.BuildDto(entity); Database.Update(dto); foreach (Guid removedRule in entity.RemovedRules) { Database.Delete <AccessRuleDto>("WHERE id=@Id", new { Id = removedRule }); } foreach (PublicAccessRule rule in entity.Rules) { if (rule.HasIdentity) { var count = Database.Update(dto.Rules.Single(x => x.Id == rule.Key)); if (count == 0) { throw new InvalidOperationException("No rows were updated for the access rule"); } } else { Database.Insert(new AccessRuleDto { Id = rule.Key, AccessId = dto.Id, RuleValue = rule.RuleValue, RuleType = rule.RuleType, CreateDate = rule.CreateDate, UpdateDate = rule.UpdateDate, }); // update the id so HasEntity is correct rule.Id = rule.Key.GetHashCode(); } } entity.ResetDirtyProperties(); }
public IActionResult Update([FromBody] AccessDto acs) { try { // save AcAccess acsNew = _accessService.Update(acs); return(Ok(acsNew.AcsId)); } catch (AppException ex) { // return error message if there was an exception return(BadRequest(new { message = ex.Message })); } }
public IActionResult Create([FromBody] AccessDto trgDto) { try { // if admin AcAccess acs = _accessService.Create(trgDto); return(Ok(acs.AcsId)); } catch (AppException ex) { // return error message if there was an exception return(BadRequest(new { message = ex.Message })); } }
public Access(AccessDto dto)//, Action connect) { this.ExpireIn = TimeSpan.FromSeconds(dto.ExpireInSeconds); this.Token = dto.Token; this.Scope = dto.Scope; this.Type = dto.Type; //this.connect = connect; //reconnectThread = new Thread(async () => await ReconnectIn(ExpireIn)); //triggerReconnect += (o, e) => //{ // reconnectThread.Join(); // IsConnected = false; // reconnectThread = new Thread(async () => await ReconnectIn(ExpireIn)); // reconnectThread.Start(); //}; }
public AcAccess Update(AccessDto acs) { AcAccess acsUp = new AcAccess { AcsId = acs.AcsId, AcsValidFrom = acs.ValidFrom, AcsValidTo = acs.ValidTo, AcsOpeningCounter = acs.Counter != null ? acs.Counter : -1, AcsUsrId = acs.UsrId, AcsProId = acs.ProId != null ? acs.ProId : (from pro in _context.AcProfil where pro.ProName == "guest" select pro.ProId).SingleOrDefault(), AcsObjId = acs.ObjId }; _context.AcAccess.Update(acsUp); _context.SaveChanges(); return(acsUp); }
public AcAccess Create(AccessDto acs) { AcAccess acsNew = new AcAccess { AcsValidFrom = acs.ValidFrom, AcsValidTo = acs.ValidTo, AcsOpeningCounter = acs.Counter != null ? acs.Counter : -1, AcsUsrId = acs.UsrId, AcsProId = acs.ProId != null ? acs.ProId : (from pro in _context.AcProfil where pro.ProName == "guest" select pro.ProId).SingleOrDefault(), AcsObjId = acs.ObjId }; _context.AcAccess.Add(acsNew); _context.SaveChanges(); acsNew.AcsObj = (from obj in _context.AcObject where obj.ObjId == acsNew.AcsObjId select obj) .SingleOrDefault(); return(acsNew); }
public async Task <HttpStatusCode> Connect() { async Task <HttpResponseMessage> GetOauthToken() { Dictionary <string, string> payload = new Dictionary <string, string> { { "grant_type", "client_credentials" } }; Uri url = new Uri("https://accounts.spotify.com/api/token/"); HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, url) { Content = new FormUrlEncodedContent(payload) }; try { HttpResponseMessage res = await client.SendAsync(req); return(res); } catch (Exception e) { throw e; } } HttpResponseMessage oauthResponse = await GetOauthToken(); string content = await oauthResponse.Content.ReadAsStringAsync(); AccessDto accessDto = JsonConvert.DeserializeObject <AccessDto>(content); access = new Access(accessDto); //access = new Access(accessDto, async () => //{ // client.DefaultRequestHeaders.Authorization = spotifySecret.GetBasicAuthenticationHeaderValue(); // await Connect(); // access.IsConnected = true; //}); client.DefaultRequestHeaders.Authorization = access.GetAuthentication(); return(HttpStatusCode.OK); }
public static PublicAccessEntry BuildEntity(AccessDto dto) { var entity = new PublicAccessEntry(dto.Id, dto.NodeId, dto.LoginNodeId, dto.NoAccessNodeId, dto.Rules.Select(x => new PublicAccessRule(x.Id, x.AccessId) { RuleValue = x.RuleValue, RuleType = x.RuleType, CreateDate = x.CreateDate, UpdateDate = x.UpdateDate })) { CreateDate = dto.CreateDate, UpdateDate = dto.UpdateDate }; // reset dirty initial properties (U4-1946) entity.ResetDirtyProperties(false); return(entity); }
public void Should_connect_multiple_times() { AccessDto dto = new AccessDto { ExpireInSeconds = 11, Scope = string.Empty, Token = "token", Type = "Type" }; Mock <Action> connect = new Mock <Action>(); Access access = new Access(dto); access.GetAuthentication(); Thread.Sleep(TimeSpan.FromSeconds(4)); connect.Verify(x => x.Invoke(), Times.AtLeast(3)); }
public bool Login(AccessDto accessDto) { var user = dbContext.Users.Where(x => x.Email == accessDto.Email).FirstOrDefault(); if (user == null) { return(false); } var passwordHashed = GetPasswordHashed(accessDto.Password, user.Salt); if (passwordHashed.SequenceEqual(user.Password) == false) { return(false); } var newSessionDb = GenerateSession(user); return(true); }
public PublicAccessEntry BuildEntity(AccessDto dto) { var entity = new PublicAccessEntry(dto.Id, dto.NodeId, dto.LoginNodeId, dto.NoAccessNodeId, dto.Rules.Select(x => new PublicAccessRule(x.Id, x.AccessId) { RuleValue = x.RuleValue, RuleType = x.RuleType, CreateDate = x.CreateDate, UpdateDate = x.UpdateDate })) { CreateDate = dto.CreateDate, UpdateDate = dto.UpdateDate }; //on initial construction we don't want to have dirty properties tracked // http://issues.umbraco.org/issue/U4-1946 entity.ResetDirtyProperties(false); return(entity); }
internal AccessDto Map(AccessDto a, AccessRuleDto p) { // Terminating call. Since we can return null from this function // we need to be ready for PetaPoco to callback later with null // parameters if (a == null) { return(Current); } // Is this the same AccessDto as the current one we're processing if (Current != null && Current.Id == a.Id) { // Yes, just add this AccessRuleDto to the current AccessDto's collection if (p.Id != default(Guid)) { Current.Rules.Add(p); } // Return null to indicate we're not done with this AccessDto yet return(null); } // This is a different AccessDto to the current one, or this is the // first time through and we don't have a Tab yet // Save the current AccessDto var prev = Current; // Setup the new current AccessDto Current = a; Current.Rules = new List <AccessRuleDto>(); if (p.Id != default(Guid)) { Current.Rules.Add(p); } // Return the now populated previous AccessDto (or null if first time through) return(prev); }
public static AccessDto BuildDto(PublicAccessEntry entity) { var dto = new AccessDto { Id = entity.Key, NoAccessNodeId = entity.NoAccessNodeId, LoginNodeId = entity.LoginNodeId, NodeId = entity.ProtectedNodeId, CreateDate = entity.CreateDate, UpdateDate = entity.UpdateDate, Rules = entity.Rules.Select(x => new AccessRuleDto { AccessId = x.AccessEntryId, Id = x.Key, RuleValue = x.RuleValue, RuleType = x.RuleType, CreateDate = x.CreateDate, UpdateDate = x.UpdateDate, }).ToList(), }; return(dto); }