public async Task <Result <Accounts> > RegisterAsync(int customerID, RegisterAccountOptions options)
{
if (string.IsNullOrWhiteSpace(options.AccountNumber))
{
return(null);
}
if (string.IsNullOrWhiteSpace(options.AccountDescr))
{
return(null);
}
if (string.IsNullOrWhiteSpace(options.Currency))
{
return(null);
}
var result = await _customer.GetCustomerbyIDAsync(customerID);
if (result.Code != ResultCodes.Success)
{
return new Result <Accounts>()
{
Code = result.Code,
Message = result.Message
}
}
;
//if (customer == null)
// return null;
var account = new Accounts()
{
AccountDescription = options.AccountDescr,
AccountNumber = options.AccountNumber,
Currency = options.Currency,
};
result.Data.Accounts.Add(account);
await _dBContext.SaveChangesAsync();
return(new Result <Accounts>()
{
Code = result.Code,
Message = $"New Account ID {account.AccountsId} added for Customer ID {customerID}",
Data = account
});
}
public async Task <Result <Card> > RegisterAsync(RegisterCardOptions options)
{
var validations = BasicValidations(options);
if (validations.Code != ResultCodes.Success)
{
return(new Result <Card>()
{
Code = validations.Code,
Message = validations.Message
});
}
var account = await _account.GetAccountbyNumberAsync(options.AccountNumber);
var card = new Card()
{
Active = options.Active,
CardNumber = options.CardNumber,
AvailableBalance = options.AvailableBalance,
Type = options.Type
};
account.Data.Cards.Add(card);
try
{
await _dbContext.SaveChangesAsync();
}
catch (Exception ex)
{
return(new Result <Card>()
{
Code = ResultCodes.InternalServerError,
Message = $"Fail to create new Card\n" +
$"Details: {ex.Message}\n" +
$"StackTrace: {ex.StackTrace}\n" +
$"{((ex.InnerException != null) ? "Inner Exception: " : "")}{((ex.InnerException != null) ? ex.InnerException.Message : "")}"
});
}
return(new Result <Card>()
{
Code = ResultCodes.Success,
Message = $"New Card {card.CardNumber} added successfully",
Data = _mapper.Map <Card>(options)
});
}
/// <summary>
/// Adds a new customer using with Async support
/// </summary>
/// <param name="options">RegisterCustomerOptions</param>
/// <returns>
/// Result.Code should be Success(200)
/// Check Result.Code and Result.Message to get more details about possible errors
/// </returns>
public async Task <Result <Customer> > RegisterAsync(RegisterCustomerOptions options)
{
if (string.IsNullOrWhiteSpace(options.Name))
{
return new Result <Customer>()
{
Code = ResultCodes.BadRequest,
Message = "Customer name is empty"
}
}
;
if (string.IsNullOrWhiteSpace(options.SureName))
{
return new Result <Customer>()
{
Code = ResultCodes.BadRequest,
Message = "Customer sure name is empty"
}
}
;
var validVatNumber = IsValidVatNumber(options.CountryCode, options.VATNumber);
if (!validVatNumber.IsSuccess())
{
return(new Result <Customer>()
{
Code = validVatNumber.Code,
Message = validVatNumber.Message
});
}
if (await _dbContext.Set <Customer>()
.AnyAsync(c => c.VatNumber == options.VATNumber))
{
return(new Result <Customer>()
{
Code = ResultCodes.BadRequest,
Message = $"Specific Vat Number {options.VATNumber} already exists!"
});
}
var customer = new Customer()
{
Name = options.Name,
SureName = options.SureName,
VatNumber = options.VATNumber,
CustBankID = options.CustomerBankID,
CustType = options.CustType,
Address = options.Address
};
try
{
await _dbContext.AddAsync <Customer>(customer);
await _dbContext.SaveChangesAsync();
}
catch (Exception ex)
{
return(new Result <Customer>()
{
Code = ResultCodes.InternalServerError,
Message = $"Cannot save customer info. Details: {ex.Message}"
});
}
return(new Result <Customer>()
{
Code = ResultCodes.Success,
Data = customer
});
}
public async Task <Result <Transaction> > RegisterAsync(int accountID, RegisterTransactionOptions options)
{
var result = await _account.GetAccountbyIDAsync(accountID);
if (result.Code != ResultCodes.Success)
{
return new Result <Transaction>()
{
Code = ResultCodes.BadRequest,
Message = $"Could not find Account ID {accountID}"
}
}
;
if (result.Data.State == Model.Types.AccountStateTypes.Inactive ||
result.Data.State == Model.Types.AccountStateTypes.Inactive)
{
return(new Result <Transaction>()
{
Code = ResultCodes.BadRequest,
Message = $"Cannot create Transaction on Account Number {result.Data.AccountNumber} because its state is {result.Data.State}"
});
}
// check account balance. Must be >= options.Type * options.Amount
if (options.Type == Model.Types.TransactionType.Credit && result.Data.Balance + (int)options.Type * options.Amount < 0)
{
return new Result <Transaction>()
{
Code = ResultCodes.BadRequest,
Message = $"Not enough balance for Account ID {accountID} !"
}
}
;
var transaction = new Transaction()
{
Amount = options.Amount,
Type = options.Type,
TransDescr = options.TransDescr
};
// update account balance
result.Data.Balance += (int)options.Type * options.Amount;
result.Data.Transactions.Add(transaction);
try
{
await _dBContext.SaveChangesAsync();
return(new Result <Transaction>()
{
Code = ResultCodes.Success,
Message = $"New Transaction amount {options.Amount} {((options.Type == Model.Types.TransactionType.Credit) ? "Deducted" : "Added")} for Acount {result.Data.AccountNumber}",
Data = transaction
});
}
catch (Exception ex)
{
return(new Result <Transaction>()
{
Code = ResultCodes.InternalServerError,
Message = $"Fail to save Transaction for account ID {accountID}. Details: {ex.Message}"
});
}
}
}
}