public ActionResult <LGToken> Delete(int id)
{
var model = new LGToken()
{
LGTokenId = id
};
var serviceResult = _lGTokenService.Delete(model);
if (serviceResult.Status == BrashActionStatus.ERROR)
{
return(BadRequest(serviceResult.Message));
}
return(serviceResult.Model);
}
public ActionResult <LGToken> Put(int id, [FromBody] LGToken model)
{
model.LGTokenId = id;
var serviceResult = _lGTokenService.Update(model);
if (serviceResult.Status == BrashActionStatus.ERROR)
{
return(BadRequest(serviceResult.Message));
}
if (serviceResult.Status == BrashActionStatus.NOT_FOUND)
{
return(NotFound(serviceResult.Message));
}
return(serviceResult.Model);
}
public ActionResult <LGToken> Get(int id)
{
var model = new LGToken()
{
LGTokenId = id
};
var serviceResult = _lGTokenService.Fetch(model);
if (serviceResult.Status == BrashActionStatus.ERROR)
{
return(BadRequest(serviceResult.Message));
}
if (serviceResult.Status == BrashActionStatus.NOT_FOUND)
{
return(NotFound(serviceResult.Message));
}
return(serviceResult.Model);
}
public BrashActionResult <LGToken> Delete(LGToken model)
{
return(Repository.Delete(model));
}
public BrashActionResult <LGToken> Update(LGToken model)
{
return(Repository.Update(model));
}
public BrashActionResult <LGToken> Fetch(LGToken model)
{
return(Repository.Fetch(model));
}
public BrashActionResult <AccountAccess> Authenticate(AccountSignin model)
{
BrashActionResult <AccountAccess> authResult = new BrashActionResult <AccountAccess>();
authResult.Status = BrashActionStatus.UNKNOWN;
authResult.Message = "";
authResult.Model = new AccountAccess();
var userName = model.UserName.RemoveSpecialCharacters();
Logger.Information($"Authenticate -> USER: {model.UserName}, USER_STRIPPED: {userName}, PASS: {model.Password}");
var findAccountQuery = _lGAccountService.FindWhere($"WHERE UserName = '******'");
if (findAccountQuery.Status == BrashQueryStatus.SUCCESS && findAccountQuery.Models.Count == 1)
{
var foundAccount = findAccountQuery.Models[0];
// confirm password
if (Hashing.ValidatePassword(model.Password, foundAccount.Password))
{
Logger.Information($"Authenticate -> USER: {model.UserName} SUCCESS!");
// set account
foundAccount.Password = null;
authResult.Status = BrashActionStatus.SUCCESS;
authResult.Message = "Authentication successful.";
authResult.Model.Account = foundAccount;
// set role name
var fetchRoleResult = _lGRoleService.Fetch(new LGRole()
{
LGRoleId = foundAccount.RoleIdRef
});
if (fetchRoleResult.Status == BrashActionStatus.SUCCESS)
{
authResult.Model.Role = fetchRoleResult.Model.ChoiceName;
}
else
{
Logger.Error(fetchRoleResult.CaughtException, $"Failed getting the role. Why? Check this: {fetchRoleResult.Message}");
authResult.Model.Role = "Unknown";
}
// transform priviledges into dictionary (string/list of strings)
authResult.Model.Privileges = new Dictionary <string, List <string> >();
var getPrivledgesResult = _lGPrivilegeService.FindWhere($"WHERE LGAccountId = {foundAccount.LGAccountId}");
if (getPrivledgesResult.Status == BrashQueryStatus.SUCCESS)
{
var allFeatures = _lGFeatureService.FindWhere("WHERE 1 = 1").Models;
var allAbilities = _lGAbilityService.FindWhere("WHERE 1 = 1").Models;
foreach (var priviledge in getPrivledgesResult.Models)
{
// get feature
var feature = allFeatures.Where(f => f.LGFeatureId == priviledge.FeatureIdRef).FirstOrDefault();
List <string> featureAbilityList = new List <string>();
if (authResult.Model.Privileges.Keys.Contains(feature.ChoiceName))
{
featureAbilityList = authResult.Model.Privileges[feature.ChoiceName];
}
else
{
authResult.Model.Privileges.Add(feature.ChoiceName, featureAbilityList);
}
// get action
var ability = allAbilities.Where(a => a.LGAbilityId == priviledge.AbilityIdRef).FirstOrDefault();
// set values in response
featureAbilityList.Add(ability.ChoiceName);
}
}
else
{
Logger.Error(getPrivledgesResult.CaughtException, $"Failed getting user privledges. Why? Check this: {getPrivledgesResult.Message}");
authResult.Model.Privileges.Add("ERROR", new List <string>()
{
"GETTING_PRIVLEDGES"
});
}
// create token
LGToken token = new LGToken()
{
LGAccountId = authResult.Model.Account.LGAccountId,
Token = $"{Guid.NewGuid().ToString()}-{Guid.NewGuid().ToString()}-{Guid.NewGuid().ToString()}",
Created = DateTime.Now,
Expires = DateTime.Now.AddHours(1),
LastUsed = DateTime.Now
};
var createTokenResult = _lGTokenService.Create(token);
if (createTokenResult.Status != BrashActionStatus.SUCCESS)
{
authResult.Status = BrashActionStatus.ERROR;
authResult.Message = "Authentication service error (101). Contact technical support.";
}
// set token
authResult.Model.Token = token;
}
else
{
authResult.Status = BrashActionStatus.NOT_FOUND;
authResult.Message = "Inccorect password.";
}
}
else if (findAccountQuery.Status == BrashQueryStatus.NO_RECORDS)
{
authResult.Status = BrashActionStatus.NOT_FOUND;
authResult.Message = "Account not found.";
}
else
{
authResult.Status = BrashActionStatus.ERROR;
authResult.Message = "Authentication service error (100). Contact technical support.";
}
return(authResult);
}
public void CreateUpdateDeleteFetch()
{
// file system
var path = "/shop/randomsilo/modern-web/backends/LoyalGuard";
var project = "LoyalGuard";
var outputPath = $"{path}/{project}.Infrastructure.Test/TestOutput/";
var databaseFile = GetDatabase(outputPath, MethodBase.GetCurrentMethod());
// logger
ILogger logger = GetLogger($"{outputPath}/{MethodBase.GetCurrentMethod()}.log");
// database setup
// - context
IDatabaseContext databaseContext = new DatabaseContext(
$"Data Source={databaseFile}"
, "TestDb"
, "TestSchema"
, $"{path}/sql/sqlite/ALL.sql"
);
Assert.NotNull(databaseContext);
// - manager
IManageDatabase databaseManager = new DatabaseManager(databaseContext);
Assert.NotNull(databaseManager);
// - create tables
databaseManager.CreateDatabase();
// - repository
var lGTokenRepository = new LGTokenRepository(databaseManager, new LGTokenRepositorySql(), logger);
Assert.NotNull(lGTokenRepository);
// - service
var lGTokenService = new LGTokenService(lGTokenRepository, logger);
Assert.NotNull(lGTokenService);
// faker
BrashActionResult <LGToken> serviceResult = null;
var lGTokenFaker = new LGTokenFaker(databaseManager, logger);
Assert.NotNull(lGTokenFaker);
// create
var lGTokenCreateModel = lGTokenFaker.GetOne();
serviceResult = lGTokenService.Create(lGTokenCreateModel);
Assert.True(serviceResult.Status == BrashActionStatus.SUCCESS, serviceResult.Message);
Assert.True(serviceResult.Model.LGTokenId > 0);
// use model with id
lGTokenCreateModel = serviceResult.Model;
// update
var lGTokenUpdateModel = lGTokenFaker.GetOne();
lGTokenUpdateModel.LGTokenId = lGTokenCreateModel.LGTokenId;
serviceResult = lGTokenService.Update(lGTokenUpdateModel);
Assert.True(serviceResult.Status == BrashActionStatus.SUCCESS, serviceResult.Message);
// delete
serviceResult = lGTokenService.Delete(lGTokenCreateModel);
Assert.True(serviceResult.Status == BrashActionStatus.SUCCESS, serviceResult.Message);
// fetch
// - make fakes
var fakes = lGTokenFaker.GetMany(10);
// - add fakes to database
List <int?> ids = new List <int?>();
foreach (var f in fakes)
{
serviceResult = lGTokenService.Create(f);
Assert.True(serviceResult.Status == BrashActionStatus.SUCCESS, serviceResult.Message);
Assert.True(serviceResult.Model.LGTokenId >= 0);
ids.Add(serviceResult.Model.LGTokenId);
}
// - get fakes from database
foreach (var id in ids)
{
var model = new LGToken()
{
LGTokenId = id
};
serviceResult = lGTokenService.Fetch(model);
Assert.True(serviceResult.Status == BrashActionStatus.SUCCESS, serviceResult.Message);
Assert.True(serviceResult.Model.LGTokenId >= 0);
}
}
