public async Task <ActionResult <EfManager> > PostManager([FromBody] Manager managerDto)
{
if (managerDto == null)
{
return(BadRequest("Data is missing"));
}
var manager = new EfManager();
manager.Email = managerDto.Email.ToLowerInvariant();
var emailExist = await _context.Accounts.Where(u => u.Email == manager.Email)
.FirstOrDefaultAsync().ConfigureAwait(false);
if (emailExist != null)
{
ModelState.AddModelError("Email", "Email already in use");
return(BadRequest(ModelState));
}
manager.FirstName = managerDto.FirstName;
manager.LastName = managerDto.LastName;
var account = new EfAccount()
{
Email = manager.Email,
IsManager = true
};
account.PwHash = HashPassword(managerDto.Password, _appSettings.BcryptWorkfactor);
manager.Account = account;
_context.Accounts.Add(account);
_context.Managers.Add(manager);
await _context.SaveChangesAsync();
return(Created(manager.EfManagerId.ToString(), manager));
}
public ActionResult <Model> PostModel(ModelDetails modelDto)
{
if (modelDto == null)
{
throw new ArgumentNullException(nameof(modelDto));
}
modelDto.Email = modelDto.Email.ToLower(CultureInfo.CurrentCulture);
var emailExist = _modelRepository.GetBy(selector: source => source,
predicate: u => u.Email == modelDto.Email).FirstOrDefault();
if (emailExist != null)
{
ModelState.AddModelError("Email", "Email already in use");
return(BadRequest(ModelState));
}
var model = _mapper.Map <EfModel>(modelDto);
var account = new EfAccount()
{
Email = model.Email,
IsManager = false,
PwHash = HashPassword(modelDto.Password, _appSettings.BcryptWorkfactor)
};
_accountRepository.Create(account);
model.Account = _accountRepository.GetBy(source => source, a => a.Email == account.Email, disableTracking: false).FirstOrDefault();
_modelRepository.Create(model);
return(_mapper.Map <Model>(model));
}
public async Task <ActionResult <EfModel> > PostModel(ModelDetails modelDto)
{
modelDto.Email = modelDto.Email.ToLower();
var emailExist = await _context.Accounts.Where(u => u.Email == modelDto.Email).FirstOrDefaultAsync();
if (emailExist != null)
{
ModelState.AddModelError("Email", "Email already in use");
return(BadRequest(ModelState));
}
// UserViewModel userViewModel = _mapper.Map<UserViewModel>(user);
var model = _mapper.Map <EfModel>(modelDto);
var account = new EfAccount()
{
Email = model.Email,
IsManager = false
};
account.PwHash = HashPassword(modelDto.Password, _appSettings.BcryptWorkfactor);
model.Account = account;
_context.Accounts.Add(account);
_context.Models.Add(model);
await _context.SaveChangesAsync();
return(Created(model.EfModelId.ToString(), model));
}
public ActionResult <Manager> PostManager(Manager managerDto)
{
if (managerDto == null)
{
return(BadRequest("Data is missing"));
}
var manager = _mapper.Map <EfManager>(managerDto);
manager.Email = manager.Email.ToLowerInvariant();
var emailExist = _managerRepository.GetBy(selector: source => source,
predicate: u => u.Email == manager.Email).FirstOrDefault();
if (emailExist != null)
{
ModelState.AddModelError("Email", "Email already in use");
return(BadRequest(ModelState));
}
var account = new EfAccount()
{
Email = manager.Email,
IsManager = true,
PwHash = HashPassword(managerDto.Password, _appSettings.BcryptWorkfactor)
};
_accountRepository.Create(account);
manager.Account = _accountRepository.GetBy(
source => source,
predicate: a => a.Email == account.Email,
disableTracking: false)
.FirstOrDefault();
_managerRepository.Create(manager);
return(_mapper.Map <Manager>(manager));
}
private static void Enumerate(DbContext db, Stack <EfAccount> accountStack, EfAccountType accountType, EfAccount parent, EfAccount account, Action <EfAccount, EfAccount, bool, bool, bool, Stack <EfAccount> > lambda)
{
/*
* We always enumate accounts in the context of an account type (the 'walking account type').
*
* If an account is "virtual", it only is used for organization and should not have entries booked to it.
*
* If an account is "contra", then (regardless of account type), it is always booked against the parent.
* Contra accounts should have the same normality as the parent, but carry an oppositer or zero balance.
* Contra accounts can be xFiled, but never XBooked.
*
* When a non-contra account's actual type doesn't match the walking account, then it is xBooked
* (parented here booked to another type). Top-level accounts (no parent) can never be xBooked.
*
* When a child account's type does match the walking type, but the parent type is different, then it is xFiled
* (booked here but parented somewhere else).
*
*/
accountStack.Push(account);
bool xFiled = false;
bool xBooked = false;
//account's type DOES match the accountType we're walking
if ((account.AccountTypeId == accountType.Id))
{
//but account's parent type DOES NOT match what we're walking
if ((account.Parent != null) && (account.Parent.AccountTypeId != accountType.Id))
{
//this can only happen for child accounts of course
xFiled = true;
}
}
else
{
//account's type DOES NOT match the accountType we're walking
//contra accounts are never 'xBooked'
if (!account.AccountType.Contra)
{
//this can only happen for child accounts because top-level accounts
//only appear when walking thier type
xBooked = true;
}
}
lambda(parent, account, xFiled, xBooked, true, accountStack);
var parentId = account?.Id;
var accounts = (from a in db.Accounts where a.ParentId == parentId select a).ToList();
foreach (var a in accounts)
{
Enumerate(db, accountStack, accountType, account, a, lambda);
}
lambda(parent, account, xFiled, xBooked, false, accountStack);
accountStack.Pop();
}
