public async Task <JResponseEntity <UserEntity> > SignUpUserAsync(UserEntity Entity)
{
JResponseEntity <UserEntity> RObj = new JResponseEntity <UserEntity>();
if (Entity != null &&
!string.IsNullOrWhiteSpace(Entity.username) &&
!string.IsNullOrWhiteSpace(Entity.email) &&
!string.IsNullOrWhiteSpace(Entity.password))
{
JResponseEntity <UserEntity> UsrByName = null;
UsrByName = await _UserService.ReadOneAsync(0, Entity.username);
if (UsrByName.Status && UsrByName.Data != null)
{
RObj.Message = "Username already exists.";
}
else
{
Users _entity = new Users()
{
Email = Entity.email,
Username = Entity.username,
FirstName = Entity.first_name,
LastName = Entity.last_name,
Password = PasswordHash.Hash(Entity.password)
};
RObj = await _UserService.CreateAsync(_entity);
RObj.Message = "User Created Successfully!";
}
}
return(RObj);
}
public async Task <JResponseEntity <UserEntity> > SignInUserAsync(string username, string password)
{
JResponseEntity <UserEntity> RObj = new JResponseEntity <UserEntity>();
if (!string.IsNullOrWhiteSpace(username) &&
!string.IsNullOrWhiteSpace(password))
{
JResponseEntity <UserEntity> UsrByName = null;
UsrByName = await _UserService.ReadOneAsync(0, username);
if (UsrByName.Status)
{
bool isPwdValid = PasswordHash.IsPasswordValid(UsrByName.Data.password, password);
if (isPwdValid)
{
RObj.Message = "Login success.";
RObj.Status = true;
RObj.Data = UsrByName.Data;
}
else
{
RObj.Message = "Wrong password.";
}
}
else
{
RObj.Message = "User doesn\'t exists.";
}
}
else
{
RObj.Message = "Invalid form.";
}
return(RObj);
}
public Task <JResponseEntity <IEnumerable <ProductsEntity> > > ReadByAbbvAsync(string Abbv)
{
JResponseEntity <IEnumerable <ProductsEntity> > Result = new JResponseEntity <IEnumerable <ProductsEntity> >();
try
{
List <Products> ProductsByAbbv
= _context.Products.Where(x => x.Abbv.ToLower().Contains(Abbv.ToLower())).ToList();
if (ProductsByAbbv != null && ProductsByAbbv.Count > 0)
{
Result.Data = ProductsByAbbv.Select(x => new ProductsEntity()
{
id = x.Id,
abbv = x.Abbv,
company = x.Company,
current_price = x.CurrentPrice.Value,
market_cap = x.MarketCap,
sector = x.Sector,
industry = x.Industry,
href = x.Href,
index_traded = x.Exchange.Designation,
currency = x.Currency
}).ToList();
}
Result.Status = true;
}
catch (Exception e)
{
Result.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
}
return(Task.FromResult(Result));
}
public Task <JResponseEntity <IEnumerable <UserOperationHistoryEntity> > > GetMultipleByIdAsync(int Id)
{
JResponseEntity <IEnumerable <UserOperationHistoryEntity> > RObj = new JResponseEntity <IEnumerable <UserOperationHistoryEntity> >();
try
{
//List<UserOperationHistories> Data
// = _context.UserOperationHistories
// .Where(x => x.UserId == Id).ToList();
//if (Data != null && Data.Count > 0)
//{
// RObj.Data = Data.Select(x => new UserOperationHistoryEntity()
// {
// amount = x.Amount,
// Products = new ProductsEntity()
// {
// abbv = x.Products.Abbv,
// company = x.Products.Company,
// current_price = x.Products.CurrentPrice
// },
// buyPrice = x.BuyPrice,
// conversionUSD = x.ConversionValue,
// total = x.Total,
// totalConverted = x.TotalConverted,
// feeValue = x.FeeValue
// }).ToList();
//}
//RObj.Status = true;
}
catch (Exception e)
{
RObj.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
}
return(Task.FromResult(RObj));
}
public Task <JResponseEntity <UserOperationHistoryEntity> > CreateAsync(UserOperationHistories Entity)
{
JResponseEntity <UserOperationHistoryEntity> ResponseObj = new JResponseEntity <UserOperationHistoryEntity>();
try
{
//_context.UserOperationHistories.Add(Entity);
//_context.SaveChanges();
//ResponseObj.Status = true;
//ResponseObj.Data = new UserOperationHistoryEntity()
//{
// id = Entity.Id,
// buyPrice = Entity.BuyPrice,
// conversionUSD = Entity.ConversionValue,
// amount = Entity.Amount,
// totalConverted = Entity.TotalConverted,
// total = Entity.Total,
// userId = Entity.User.Id,
// ProductId = Entity.Product.Id
//};
}
catch (Exception e)
{
ResponseObj.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
}
return(Task.FromResult(ResponseObj));
}
public async Task <IActionResult> SignIn([FromBody] UserEntity entity)
{
JResponseEntity <UserEntity> JResponseEntity = await _UserBLL.SignInUserAsync(entity.username, entity.password);
if (JResponseEntity.Status)
{
JResponseEntity.AccessToken = this.LoginToken(new GenerateTokenModel()
{
Username = JResponseEntity.Data.username, Password = JResponseEntity.Data.password
});
}
return(Ok(JResponseEntity));
}
public async Task <JResponseEntity <IEnumerable <ProductsEntity> > > FindByTextAsync(string input)
{
JResponseEntity <IEnumerable <ProductsEntity> > RObj = new JResponseEntity <IEnumerable <ProductsEntity> >();
if (!string.IsNullOrWhiteSpace(input))
{
RObj = await _ProductsService.ReadByAbbvAsync(input);
}
else
{
RObj.Message = "Invalid term.";
}
return(RObj);
}
public async Task <JResponseEntity <IEnumerable <UserOperationHistoryEntity> > > GetUserOperations(int UserId)
{
JResponseEntity <IEnumerable <UserOperationHistoryEntity> > RObj = new JResponseEntity <IEnumerable <UserOperationHistoryEntity> >();
if (UserId != 0)
{
RObj = await _UserOperationsService.GetMultipleByIdAsync(UserId);
RObj.Message = "Data returned with success.";
}
else
{
RObj.Message = "Invalid User Id.";
}
return(RObj);
}
public JResponseEntity <string> UpdatePrices()
{
JResponseEntity <string> Result = new JResponseEntity <string>();
HttpClient client = new HttpClient();
// private static readonly HttpClient client = new HttpClient();
try
{
client.GetStreamAsync("");
}
catch (Exception e)
{
Result.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
}
return(Result);
}
public Task <JResponseEntity <ProductsEntity> > CreateMultipleAsync(List <Products> Data)
{
JResponseEntity <ProductsEntity> RObj = new JResponseEntity <ProductsEntity>();
try
{
_context.Products.AddRange(Data);
_context.SaveChanges();
RObj.Status = true;
}
catch (Exception e)
{
RObj.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
}
return(Task.FromResult(RObj));
}
public Task <JResponseEntity <UserEntity> > ReadOneAsync(int Id, string Name)
{
JResponseEntity <UserEntity> ResponseObj = new JResponseEntity <UserEntity>();
Users usr = null;
try
{
if (!string.IsNullOrWhiteSpace(Name) && Id != 0)
{
usr = _context.Users.Where(x => x.Username == Name && x.Id == Id).FirstOrDefault();
}
else if (string.IsNullOrWhiteSpace(Name) && Id != 0)
{
usr = _context.Users.Where(x => x.Id == Id).FirstOrDefault();
}
else if (!string.IsNullOrWhiteSpace(Name) && Id == 0)
{
usr = _context.Users.Where(x => x.Username == Name).FirstOrDefault();
}
if (usr != null)
{
ResponseObj.Data = new UserEntity()
{
id = usr.Id,
username = usr.Username,
email = usr.Email,
first_name = usr.FirstName,
last_name = usr.LastName,
password = usr.Password
}
}
;
ResponseObj.Status = true;
}
catch (Exception e)
{
ResponseObj.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
}
return(Task.FromResult(ResponseObj));
}
public async Task <JResponseEntity <UserOperationHistoryEntity> > AddOperation(UserOperationHistoryEntity Entity)
{
JResponseEntity <UserOperationHistoryEntity> RObj = new JResponseEntity <UserOperationHistoryEntity>();
if (Entity.amount != 0 && Entity.buyPrice != 0 && Entity.total != 0 && Entity.totalConverted != 0)
{
UserOperationHistories UserOpEntity = null; // (UserOperationHistories)Entity;
UserOpEntity.UserId = Entity.userId;
//UserOpEntity.ProductsId = Entity.ProductsId;
RObj = await _UserOperationsService.CreateAsync(UserOpEntity);
RObj.Message = "Added with success.";
}
else
{
RObj.Message = "Fields are missing.";
}
return(RObj);
}
public Task <JResponseEntity <WalletEntity> > ReadOneAsync(int Id, string Name)
{
JResponseEntity <WalletEntity> ResponseObj = new JResponseEntity <WalletEntity>();
try
{
//Wallet Wallet = _context.Wallets
//.Include(o => o.Currency)
//.Include(o => o.WalletDeposits)
//.Where(x => x.UserId == Id).FirstOrDefault();
//if (Wallet != null)
//{
// ResponseObj.Status = true;
// ResponseObj.Data = new WalletEntity()
// {
// id = Wallet.Id,
// amount = Wallet.Amount,
// deposits = Wallet.WalletDeposits != null ? Wallet.WalletDeposits.Select(y => new WalletDepositsEntity()
// {
// amount = y.Amount
// }).ToList() : null,
// currency = Wallet.Currency != null ? new CurrencyEntity()
// {
// designation = Wallet.Currency.Designation,
// symbol = Wallet.Currency.Symbol
// } : null
// };
//}else
//{
// ResponseObj.Data = new WalletEntity();
//}
}
catch (Exception e)
{
ResponseObj.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
}
return(Task.FromResult(ResponseObj));
}
public Task <JResponseEntity <UserEntity> > CreateAsync(Users Entity)
{
JResponseEntity <UserEntity> ResponseObj = new JResponseEntity <UserEntity>();
try
{
_context.Users.Add(Entity);
_context.SaveChanges();
ResponseObj.Status = true;
ResponseObj.Data = new UserEntity()
{
id = Entity.Id,
username = Entity.Username,
email = Entity.Email,
first_name = Entity.FirstName,
last_name = Entity.LastName
};;
}
catch (Exception e)
{
ResponseObj.Message = e.InnerException != null ? e.InnerException.Message : e.Message;
}
return(Task.FromResult(ResponseObj));
}
public async Task <IActionResult> AddOperation([FromBody] UserOperationHistoryEntity UsrOEntity)
{
JResponseEntity <UserOperationHistoryEntity> RObj = await _UserOperationBLL.AddOperation(UsrOEntity);
return(Ok(RObj));
}
public async Task <IActionResult> GetOperations(string userId)
{
JResponseEntity <IEnumerable <UserOperationHistoryEntity> > RObj = await _UserOperationBLL.GetUserOperations(Int32.Parse(userId));
return(Ok(RObj));
}
public async Task <IActionResult> GetWallet(string userId)
{
JResponseEntity <WalletEntity> RObj = await _WalletBLL.GetWalletData(Int32.Parse(userId));
return(Ok(RObj));
}
public async Task <IActionResult> GetByAbbv([FromRoute] string term)
{
JResponseEntity <IEnumerable <ProductsEntity> > Response = await _ProductsBLL.FindByTextAsync(term);
return(Ok(Response));
}
