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);
}
