/// <summary>
/// </summary>
/// <param name="personModelIdRequest"></param>
/// <param name="personModelId"></param>
/// <param name="newAuthorization"></param>
/// <returns></returns>
public async Task AutorizationModify(Guid personModelIdRequest, Guid personModelId, WellknownAuthorizationLevel newAuthorization)
{
try
{
var Usr = await _context.Persons.FirstOrDefaultAsync(p => p.Id == personModelId).ConfigureAwait(false);
//in case of lowering the authorization i can do only if i'm not the only one with it, and only if thiere is at least one root
if (newAuthorization < Usr.AutorizationLevel.AuthValue && await _context.Persons.AnyAsync(p => p.AutorizationLevel.AuthValue == Usr.AutorizationLevel.AuthValue && p.Id != Usr.Id).ConfigureAwait(false) &&
await _context.Persons.AnyAsync(p => p.AutorizationLevel.AuthValue == WellknownAuthorizationLevel.Root && p.Id != Usr.Id).ConfigureAwait(false))
{
Usr.AutorizationLevel.AuthValue = newAuthorization;
await ModifySafeAut(Usr.Id, Usr.AutorizationLevel.Id, Usr.AutorizationLevel.AuthValue).ConfigureAwait(false);
}
else if (newAuthorization > Usr.AutorizationLevel.AuthValue)
{
var UsrRequest = await _context.Persons.FirstOrDefaultAsync(p => p.Id == personModelIdRequest).ConfigureAwait(false);
if (Usr.AutorizationLevel.AuthValue == WellknownAuthorizationLevel.Root)
{
Usr.AutorizationLevel.AuthValue = newAuthorization;
await ModifySafeAut(Usr.Id, Usr.AutorizationLevel.Id, Usr.AutorizationLevel.AuthValue).ConfigureAwait(false);
}
}
await _context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during AutorizationModify", MethodBase.GetCurrentMethod(), ex);
}
}
public async Task <bool> CreateCard(CardCreateModel model)
{
if (model == null)
{
return(false);
}
if (string.IsNullOrWhiteSpace(model.CardNumber))
{
return(false);
}
try
{
if (await _context.CardModels.AnyAsync(c => c.CardNumber == model.CardNumber))
{
return(false);
}
await _context.CardModels.AddAsync(_cardCreateModelToCardConverter.Map(model));
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during IsAutorized od person", MethodBase.GetCurrentMethod(), ex);
return(false);
}
}
public async Task <Guid> GetUserByInputAsync(string UserInput)
{
try
{
var user = new PersonModel();
if (string.IsNullOrEmpty(UserInput) || string.IsNullOrEmpty(UserInput.Trim()))
{
return(Guid.Empty);
}
string toFind = UserInput.Trim();
if (toFind.IsValidEmail() && await _context.Persons.AnyAsync(p => string.Equals(p.Email, UserInput, StringComparison.OrdinalIgnoreCase)).ConfigureAwait(false))
{
user = await _context.Persons.FirstOrDefaultAsync(p => string.Equals(p.Email, UserInput, StringComparison.OrdinalIgnoreCase)).ConfigureAwait(false);
}
else if (!toFind.IsValidEmail() && await _context.Persons.AnyAsync(p => string.Equals(p.UserName, UserInput, StringComparison.OrdinalIgnoreCase)).ConfigureAwait(false))
{
user = await _context.Persons.FirstOrDefaultAsync(p => string.Equals(p.UserName, UserInput, StringComparison.OrdinalIgnoreCase)).ConfigureAwait(false);
}
return(user.Id);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during Login", MethodBase.GetCurrentMethod(), ex);
throw new Exception();
}
}
public async Task <bool> ChangeCardNumber(Guid personModelId, string CardNumber)
{
if (personModelId.Equals(Guid.Empty))
{
return(false);
}
if (string.IsNullOrWhiteSpace(CardNumber))
{
return(false);
}
try
{
if (!_context.Persons.Any(p => p.Id == personModelId))
{
return(false);
}
if (!_context.CardModels.Any(c => c.CardNumber == CardNumber))
{
return(false);
}
var usr = _context.Persons.First(p => p.Id == personModelId);
usr.CardNumber = _context.CardModels.First(c => c.CardNumber == CardNumber);
var encryptedRelation = await _securLib.EncryptEntityRelation(usr, usr.AutorizationLevel);
usr.SafeAuthModel.Control = await _securLib.EncriptLine(encryptedRelation);
_context.SaveChanges();
return(true);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during IsAutorized od person", MethodBase.GetCurrentMethod(), ex);
return(false);
}
}
public List <MainMenuModel> GetMenuForUser(string personName)
{
try
{
if (string.IsNullOrEmpty(personName))
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "personName is null or empty", MethodBase.GetCurrentMethod());
return(null);
}
var user = new PersonModel();
user = _context.Persons.FirstOrDefault(p => p.UserName == personName);
if (user != null && user.AutorizationLevel != null)
{
return(GetMenuForAuthorization(user.AutorizationLevel.AuthValue.ToString()));
}
else
{
return(null);
}
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during GetMenuForUser", MethodBase.GetCurrentMethod(), ex);
return(null);
}
}
/// <summary>
/// </summary>
/// <param name="personId"></param>
/// <param name="newAuthorization"></param>
/// <param name="NewWellknownAuthorizationLevel"></param>
/// <returns></returns>
private async Task ModifySafeAut(Guid personId, Guid newAuthorization, WellknownAuthorizationLevel NewWellknownAuthorizationLevel)
{
try
{
if (await _context.Persons.AnyAsync(p => p.Id == personId))
{
if (await AuthNotModified(personId))
{
return;
}
var user = await _context.Persons.FirstAsync(p => p.Id == personId);
if (user.SafeAuthModel == null)
{
return;
}
user.SafeAuthModel.AutId = newAuthorization;
var encryptedRelation = await _securLib.EncryptEntityRelation(user, user.AutorizationLevel);
user.SafeAuthModel.Control = await _securLib.EncriptLine(encryptedRelation);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during ModifySafeAut", MethodBase.GetCurrentMethod(), ex);
}
}
public async Task <bool> UpdateAsync(NodeUpdateModel node)
{
try
{
var savenode = JToken.FromObject(node).ToObject <NodeModel>();
var any = await GetByIdAsync(node.Id);
if (any == null)
{
return(false);
}
else
{
var toUpdate = _context.Nodes.First(n => n.Id == node.Id);
toUpdate = savenode;
}
_context.SaveChanges();
return(true);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during Update", MethodBase.GetCurrentMethod(), ex);
return(false);
}
}
public async Task <Guid> GetUserByInputAsync(string UserInput)
{
try
{
return(await _accessManagerService.GetUserByInputAsync(UserInput));
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during Login", MethodBase.GetCurrentMethod(), ex);
throw new UnauthorizedAccessException($"error during Login:{ex.Message}, {ex.InnerException}");
}
}
public override async Task <SignInResult> PasswordSignInAsync(PersonModel user, string password, bool isPersistent, bool lockoutOnFailure)
{
try
{
return(await _accessManagerService.ValidateLoginAsync(user.UserName, password, isPersistent, lockoutOnFailure));
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during Login", MethodBase.GetCurrentMethod(), ex);
return(SignInResult.Failed);
}
}
/// <summary>
/// determine if the authorization of the car match the needed Authorization
/// </summary>
/// <param name="CarModelId">car anagraphic</param>
/// <param name="AuthNeeded">needed Authorization</param>
/// <returns></returns>
public async Task <bool> IsCarAutorized(string CarModelId, WellknownAuthorizationLevel AuthNeeded)
{
try
{
CarAnagraphicModel car = await _context.Cars.FirstOrDefaultAsync(ca => ca.LicencePlate == CarModelId).ConfigureAwait(false);
return(await IsAutorized(car.Owner.Id, AuthNeeded).ConfigureAwait(false));
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during IsAutorized of CAR", MethodBase.GetCurrentMethod(), ex);
return(false);
}
}
public async Task <bool> Access(AccessModel newAccess)
{
newAccess.GrantedAccess = false;
if (newAccess.personEntered.Equals(Guid.Empty) || !string.IsNullOrEmpty(newAccess.Plate) || !string.IsNullOrEmpty(newAccess.CardNumber))
{
try
{
PersonModel owner = new PersonModel();
WellknownAuthorizationLevel accessLevelNeed = WellknownAuthorizationLevel.Root;
if (newAccess.personEntered.Equals(Guid.Empty) && !string.IsNullOrEmpty(newAccess.Plate))
{
if (await _context.Cars.AnyAsync(c => c.LicencePlate == newAccess.Plate))
{
var entered = await _context.Cars.FirstAsync(c => c.LicencePlate == newAccess.Plate).ConfigureAwait(false);
owner = entered.Owner;
}
}
else if (await _context.Persons.AnyAsync(c => c.CardNumber.CardNumber == newAccess.CardNumber).ConfigureAwait(false))
{
owner = await _context.Persons.FirstAsync(a => a.CardNumber.CardNumber == newAccess.CardNumber).ConfigureAwait(false);
if (!await _context.Nodes.AnyAsync(n => n.Name == newAccess.NodeName && n.MacAddress == newAccess.MacAddress))
{
return(false);
}
var node = await _context.Nodes.FirstAsync(n => n.Name == newAccess.NodeName && n.MacAddress == newAccess.MacAddress);
accessLevelNeed = node.AuthValue;
}
if (await _autorizationManagerService.IsAutorized(owner.Id, accessLevelNeed).ConfigureAwait(false))
{
newAccess.personEntered = owner.Id;
newAccess.GrantedAccess = true;
}
await _context.Access.AddAsync(newAccess).ConfigureAwait(false);
await _context.SaveChangesAsync().ConfigureAwait(false);
//StaticEventHandler.SendMail(new MailEventArgs(ResourceString.AccessCarMailSubject, ResourceString.AccessCarMailBody, DateTime.UtcNow));
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during Card verification", MethodBase.GetCurrentMethod(), ex);
return(false);
}
}
return(newAccess.GrantedAccess);
}
public async Task <SignInResult> ValidateLoginAsync(string username, string password, bool rememberMe, bool shouldLockout)
{
try
{
var userId = await GetUserByInputAsync(username).ConfigureAwait(false);
if (userId.Equals(Guid.Empty))
{
return(SignInResult.Failed);
}
if (await _context.Persons.AnyAsync(p => p.Id == userId).ConfigureAwait(false))
{
PersonModel userSelected = await _context.Persons.Include(Auth => Auth.AutorizationLevel).Include(Card => Card.CardNumber).FirstOrDefaultAsync(p => p.Id == userId).ConfigureAwait(false);
var encrypted = await _securLib.EncriptLine(password);
if (await _securLib.CompareHash(userSelected.Password, encrypted))
{
// authentication successful so generate jwt token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_configuration["PreSharedKey"]);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, userSelected.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var secureToken = tokenHandler.WriteToken(token);
return(SignInResult.Success);
}
else
{
return(SignInResult.Failed);
}
}
return(SignInResult.Failed);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during Login", MethodBase.GetCurrentMethod(), ex);
return(SignInResult.Failed);
}
}
public async Task <List <NodeReadModel> > GetAllAsync()
{
try
{
var list = await _context.Nodes.ToListAsync();
var readedRes = new List <NodeReadModel>();
list.ForEach(l => readedRes.Add(JToken.FromObject(l).ToObject <NodeReadModel>()));
return(readedRes);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "", MethodBase.GetCurrentMethod(), ex);
return(null);
}
}
public Guid Create(NodeCreateModel node)
{
try
{
var savenode = JToken.FromObject(node).ToObject <NodeModel>();
savenode.Id = Guid.NewGuid();
savenode.CreatedAt = DateTime.UtcNow;
_context.Nodes.Add(savenode);
_context.SaveChanges();
return(savenode.Id);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during Update", MethodBase.GetCurrentMethod(), ex);
return(Guid.Empty);
}
}
public List <MainMenuModel> GetMenuForAuthorization(string Auth)
{
try
{
if (string.IsNullOrEmpty(Auth))
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "Auth is null or empty", MethodBase.GetCurrentMethod());
return(null);
}
var authlevel = (WellknownAuthorizationLevel)Convert.ToInt32(Auth);
return(_context.MainMenu.Where(c => c.AuthLevel == authlevel).ToList());
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during GetMenuForUser", MethodBase.GetCurrentMethod(), ex);
return(null);
}
}
public async Task <bool> DeleteAsync(Guid nodeId)
{
try
{
var any = await _context.Nodes.AnyAsync(n => n.Id == nodeId);
if (!any)
{
return(false);
}
_context.Nodes.Remove(_context.Nodes.First(n => n.Id == nodeId));
_context.SaveChanges();
return(true);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during Delete", MethodBase.GetCurrentMethod(), ex);
return(false);
}
}
private void SendMessage(object sender, MailEventArgs mailEvent)
{
try
{
mailMessage = new MailMessage
{
From = new MailAddress("*****@*****.**")
};
foreach (var rec in mailEvent.Recievers)
{
mailMessage.To.Add(rec);
}
mailMessage.Body = mailEvent.Message;
mailMessage.Subject = mailEvent.Subject;
client.Send(mailMessage);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "Error Sending mail", MethodBase.GetCurrentMethod(), ex);
}
}
public async Task <Guid> Create(PersonCreateModel person, AutorizationLevelCreateModel autorizationLevel)
{
try
{
if (person == null || autorizationLevel == null)
{
return(Guid.Empty);
}
var dbPerson = await _personCreateModelToPersonModelConverter.Map(person).ConfigureAwait(false);
_context.Persons.Add(dbPerson);
_context.Autorizations.Add(dbPerson.AutorizationLevel);
_context.SafeAuthModels.Add(dbPerson.SafeAuthModel);
_context.SaveChanges();
return(dbPerson.Id);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during IsAutorized od person", MethodBase.GetCurrentMethod(), ex);
return(Guid.Empty);
}
}
public async Task <NodeReadModel> GetByIdAsync(Guid nodeId)
{
try
{
if (_context.Nodes.Any(n => n.Id.Equals(nodeId)))
{
var model = await _context.Nodes.FirstAsync(n => n.Id.Equals(nodeId));
var res = JToken.FromObject(model).ToObject <NodeReadModel>();
return(res);
}
else
{
return(null);
}
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "", MethodBase.GetCurrentMethod(), ex);
return(null);
}
}
public async Task <bool> UpdateCardExpirationDate(string CardNumber, DateTime newExpirationDate)
{
if (string.IsNullOrWhiteSpace(CardNumber))
{
return(false);
}
try
{
if (!await _context.CardModels.AnyAsync(c => c.CardNumber == CardNumber).ConfigureAwait(false))
{
return(false);
}
var card = await _context.CardModels.FirstAsync(c => c.CardNumber == CardNumber).ConfigureAwait(false);
card.ExpirationDate = newExpirationDate;
_context.SaveChanges();
return(true);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during IsAutorized od person", MethodBase.GetCurrentMethod(), ex);
return(false);
}
}
/// <summary>
/// </summary>
/// <returns></returns>
public async Task CreateAdmin()
{
try
{
var card = new CardCreateModel()
{
CardNumber = "123456",
ExpirationDate = DateTime.UtcNow.AddYears(1),
};
var usr = new PersonCreateModel()
{
UserName = "******",
Email = "*****@*****.**",
Password = await _securLib.EncriptLine("Admin"),
};
var auth = new AutorizationLevelCreateModel()
{
AuthName = "ROOT",
AuthValue = WellknownAuthorizationLevel.Root,
ExpirationDate = DateTime.UtcNow.AddYears(1)
};
await Create(usr, auth);
var menu = _menuService.CreateMenuFromPages();
foreach (var vm in menu)
{
vm.AuthLevel = WellknownAuthorizationLevel.User;
}
_context.MainMenu.AddRange(menu);
_context.SaveChanges();
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during IsAutorized of person", MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// </summary>
/// <param name="personId"></param>
/// <returns></returns>
private async Task <bool> AuthNotModified(Guid personId)
{
try
{
if (await _context.Persons.AnyAsync(p => p.Id == personId).ConfigureAwait(false))
{
var user = await _context.Persons.Include(Auth => Auth.AutorizationLevel).Include(Card => Card.CardNumber).FirstAsync(p => p.Id == personId).ConfigureAwait(false);
if (user.SafeAuthModel == null)
{
return(false);
}
var encryptedRelation = await _securLib.EncryptEntityRelation(user, user.AutorizationLevel);
return(await _securLib.CompareHash(user.SafeAuthModel.Control, encryptedRelation));
}
return(false);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during AuthNotModified", MethodBase.GetCurrentMethod(), ex);
return(false);
}
}
/// <summary>
/// private member that verify the user an the autorization
/// </summary>
/// <param name="personModelId"></param>
/// <param name="AuthNeeded"></param>
/// <returns></returns>
public async Task <bool> IsAutorized(Guid personModelId, WellknownAuthorizationLevel AuthNeeded)
{
try
{
if (await _context.Persons.AnyAsync(p => p.Id == personModelId).ConfigureAwait(false))
{
PersonModel usr = await _context.Persons.FirstOrDefaultAsync(p => p.Id == personModelId).ConfigureAwait(false);
if (usr.AutorizationLevel.AuthValue >= AuthNeeded &&
await AuthNotModified(usr.Id).ConfigureAwait(false) &&
(usr.AutorizationLevel.ExpirationDate.Date >= DateTime.Today.Date || usr.AutorizationLevel.AuthValue == WellknownAuthorizationLevel.Root))
{
return(true);
}
return(false);
}
return(false);
}
catch (Exception ex)
{
StaticEventHandler.Log(System.Diagnostics.TraceLevel.Error, "error during IsAutorized of person", MethodBase.GetCurrentMethod(), ex);
return(false);
}
}