public IActionResult Get(int id)
{
Core.Model.User user = _userService.Get(SessionContext, id);
var userDto = _mapper.Map <Core.Model.User, DTO.User>(user);
return(Ok(userDto));
}
private string GetToken(Core.Model.User user)
{
var utcNow = DateTime.UtcNow;
var claims = new Claim[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.Id),
new Claim("companyId", user.CompanyId),
new Claim("company", user.Company.Name),
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, utcNow.ToString())
};
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_appSettings.Tokens.Key));
var signingCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
var jwt = new JwtSecurityToken(
signingCredentials: signingCredentials,
claims: claims,
notBefore: utcNow,
expires: utcNow.AddSeconds(_appSettings.Tokens.Lifetime),
audience: _appSettings.Tokens.Audience,
issuer: _appSettings.Tokens.Issuer
);
return(new JwtSecurityTokenHandler().WriteToken(jwt));
}
public async Task <string> Register(RegisterModel registerModel)
{
if (await _companyRepository.IsNameDuplicate(registerModel.CompanyName))
{
throw new Exception($"'{registerModel.CompanyName}' already exists. Please choose a different name.");
}
var company = new Core.Model.Company(registerModel.CompanyName);
_companyRepository.Add(company);
await _companyRepository.SaveChanges();
var user = new Core.Model.User(company, registerModel.Email, registerModel.Username);
var identityResult = await userManager.CreateAsync(user, registerModel.Password);
if (identityResult.Succeeded)
{
await signInManager.SignInAsync(user, isPersistent : false);
return(GetToken(user));
}
else
{
_companyRepository.Remove(company);
await _companyRepository.SaveChanges();
throw new Exception(identityResult?.Errors?.First()?.Description);
}
}
public void DefaultSetSessionOnFirstLogin(UserLogin userLogin, string token)
{
Core.Model.LoginHistory logHist = new LoginHistory();
Core.Model.User userData = new Core.Model.User();
userData = _userData.GetUserDetailByUserIDAndPassword(userLogin.UserID, userLogin.Password);
Session["UserID"] = userData.UserID;
Session["Role"] = userData.Role;
Session["Email"] = userData.EmailID;
Session["SECID"] = userData.SECID;
Session["BPID"] = userData.BPID;
Session["Partner"] = userData.Partner;
Session["BPType"] = userData.BPType;
FormsAuthentication.SetAuthCookie(userData.UserID, true);
logHist.UserID = userData.UserID;
logHist.Server = "";
_userData.LoginHistory(logHist);
// check and create directory
CreateFolder();
// Custom session management
userData.UserIPAddress = Request.UserHostAddress;
userData.UserBrowserName = Request.Browser.Browser.ToLower().Trim();
userData.SessionToken = token;
TempData["expiredate"] = DateTime.Today.Date.AddMonths(1);
_userData.InsertUpdateCustomSessionData(userData, "insert");
}
private String GetToken(Core.Model.User user)
{
var utcNow = DateTime.UtcNow;
var claims = new Claim[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.Id),
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Iat, utcNow.ToString())
};
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(this.configuration.GetValue <String>("Tokens:Key")));
var signingCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256);
var jwt = new JwtSecurityToken(
signingCredentials: signingCredentials,
claims: claims,
notBefore: utcNow,
expires: utcNow.AddSeconds(this.configuration.GetValue <int>("Tokens:Lifetime")),
audience: this.configuration.GetValue <String>("Tokens:Audience"),
issuer: this.configuration.GetValue <String>("Tokens:Issuer")
);
return(new JwtSecurityTokenHandler().WriteToken(jwt));
}
public async Task <IActionResult> Register([FromBody] RegisterModel registerModel)
{
if (ModelState.IsValid)
{
var companyId = await _companyCommand.Create(new CreateCompanyVm { Name = registerModel.CompanyName });
var company = await _companyQuery.Get(companyId);
if (company is null)
{
throw new Exception("Unable to create company.");
}
var user = new Core.Model.User(company, registerModel.Email, registerModel.Username);
var identityResult = await this.userManager.CreateAsync(user, registerModel.Password);
if (identityResult.Succeeded)
{
await signInManager.SignInAsync(user, isPersistent : false);
return(Ok(GetToken(user)));
}
else
{
return(BadRequest(identityResult.Errors));
}
}
return(BadRequest(ModelState));
}
private static Core.Model.Order NewOrder(Core.Model.User user, Order o)
{
return(new Core.Model.Order
{
User = user,
Symbol = o.Symbol,
Exchange = Exchange.Binance,
Id = o.Id.ToString(CultureInfo.InvariantCulture),
ClientOrderId = o.ClientOrderId,
Price = o.Price,
OriginalQuantity = o.OriginalQuantity,
ExecutedQuantity = o.ExecutedQuantity,
Status = (Core.Model.OrderStatus)o.Status,
TimeInForce = (Core.Model.TimeInForce)o.TimeInForce,
Type = (Core.Model.OrderType)o.Type,
Side = (Core.Model.OrderSide)o.Side,
StopPrice = o.StopPrice,
IcebergQuantity = o.IcebergQuantity,
Time = o.Time,
IsWorking = o.IsWorking,
Fills = o.Fills?.Select(f => new Core.Model.Fill
{
Price = f.Price,
Quantity = f.Quantity,
Commission = f.Commission,
CommissionAsset = f.CommissionAsset,
TradeId = f.TradeId
})
});
}
public ActionResult Logout()
{
try
{
string token = "";
//for get request
if (Request.QueryString["token"] != null)
{
token = Request.QueryString["token"];
}
//for post request
if (HttpUtility.ParseQueryString(Request.UrlReferrer.Query)["token"] != null)
{
token = HttpUtility.ParseQueryString(Request.UrlReferrer.Query)["token"];
}
// remove custom session value
Core.Model.User userData = new Core.Model.User();
userData.UserIPAddress = Request.UserHostAddress;
userData.UserBrowserName = Request.Browser.Browser.ToLower().Trim();
userData.SessionToken = token;
_userData.InsertUpdateCustomSessionData(userData, "delete");
}
catch (Exception ex)
{
DataLogger.Write("Account-Logout", ex.Message);
}
// clear session
FormsAuthentication.SignOut();
Session.Clear();
Session.Abandon();
return(RedirectToAction("SignIn", "Account"));
}
public static UserModel Map(this Core.Model.User user)
{
return(new UserModel
{
Email = user.Email,
Username = user.Username,
Id = user.Id
});
}
public static UserAuthenticatedModel Map(this Core.Model.User user, string token)
{
return(new UserAuthenticatedModel
{
Id = user.Id,
Username = user.Username,
Email = user.Email,
Token = token
});
}
public static User ConvertToDTO(this Core.Model.User user)
{
return(new User()
{
UserID = user.UserID,
Username = user.Username,
Roles = user.Roles.Select(r => r.ConvertToDTO()).ToList(),
Email = user.Email,
LoyaltyStatus = user.LoyaltyStatus
});
}
public async Task <string> Create(string companyId, CreateUserVm vm)
{
var company = await _companyRepository.GetFirstOrDefault(companyId) ?? throw new Exception($"No Company found against id:'{companyId}'");
var user = new Core.Model.User(company, vm.Email, vm.Email);
var identityResult = await _userManager.CreateAsync(user);
if (identityResult.Succeeded)
{
throw new Exception(identityResult?.Errors?.First()?.Description);
}
return(user.Id);
}
public async Task <Core.Model.Order> PlaceOrder(Core.Model.User user, Core.Model.ClientOrder clientOrder, long recWindow = 0, CancellationToken cancellationToken = default)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var binanceApi = new BinanceApi();
using var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var order = OrderHelper.GetOrder(apiUser, clientOrder);
var result = await binanceApi.PlaceAsync(order).ConfigureAwait(false);
return(NewOrder(user, result));
}
public static void ClientOrderValidationBuilderTest_Initialize(TestContext testContext)
{
apiKey = testContext.GetHashCode().ToString();
user = new Core.Model.User()
{
ApiKey = apiKey
};
var balance = new Core.Model.AccountBalance {
Asset = "TRX", Free = 300, Locked = 100
};
balances = new List <Core.Model.AccountBalance>()
{
balance
};
}
public async Task <IEnumerable <Core.Model.Order> > GetOpenOrdersAsync(Core.Model.User user, string symbol = null, long recWindow = 0, Action <Exception> exception = default, CancellationToken cancellationToken = default)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var binanceApi = new BinanceApi();
using (var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret))
{
var result = await binanceApi.GetOpenOrdersAsync(apiUser, symbol, recWindow, cancellationToken).ConfigureAwait(false);
var orders = result.Select(o => NewOrder(user, o)).ToList();
return(orders);
}
}
public async Task SubscribeAccountInfo(Core.Model.User user, Action <AccountInfoEventArgs> callback, Action <Exception> exception, CancellationToken cancellationToken)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var binanceApi = new BinanceApi();
var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var streamControl = new UserDataWebSocketStreamControl(binanceApi);
var listenKey = await streamControl.OpenStreamAsync(apiUser).ConfigureAwait(false);
var accountInfoCache = new AccountInfoCache(binanceApi, new UserDataWebSocketClient());
accountInfoCache.Subscribe(listenKey, apiUser, e =>
{
if (cancellationToken.IsCancellationRequested)
{
accountInfoCache.Unsubscribe();
streamControl.Dispose();
apiUser.Dispose();
return;
}
var accountInfo = GetAccountInfo(e.AccountInfo);
accountInfo.User = user;
try
{
callback.Invoke(new AccountInfoEventArgs {
AccountInfo = accountInfo
});
}
catch (Exception ex)
{
accountInfoCache.Unsubscribe();
streamControl.Dispose();
apiUser.Dispose();
exception.Invoke(ex);
return;
}
});
}
public async Task <Core.Model.AccountInfo> GetAccountInfoAsync(Core.Model.User user, CancellationToken cancellationToken)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var binanceApi = new BinanceApi();
using var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var result = await binanceApi.GetAccountInfoAsync(apiUser, 0, cancellationToken).ConfigureAwait(false);
var accountInfo = GetAccountInfo(result);
user.RateLimiter = new Core.Model.RateLimiter {
IsEnabled = result.User.RateLimiter.IsEnabled
};
accountInfo.User = user;
return(accountInfo);
}
public async Task <string> CancelOrderAsync(Core.Model.User user, string symbol, string orderId, string newClientOrderId = null, long recWindow = 0, CancellationToken cancellationToken = default)
{
if (orderId == null)
{
throw new ArgumentNullException(nameof(orderId));
}
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var binanceApi = new BinanceApi();
var id = Convert.ToInt64(orderId, CultureInfo.InvariantCulture);
using var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var result = await binanceApi.CancelOrderAsync(apiUser, symbol, id, newClientOrderId, recWindow, cancellationToken).ConfigureAwait(false);
return(result);
}
public ServiceResult <Core.Model.User> UpdateUser(Core.Model.User user)
{
ServiceResult <Core.Model.User> result = new ServiceResult <Core.Model.User>();
try
{
var address = user.Addresses.FirstOrDefault();
_userBO.Update(user);
_addressBO.Update(address);
result.Data = user;
}
catch (Exception ex)
{
result.HasError = true;
result.ErrorMessage = ex.Message;
}
return(result);
}
private async Task SubscribeAssets(UserAccount userAccount)
{
// 1. get assets for all accounts
var user = new Core.Model.User
{
AccountName = userAccount.AccountName,
ApiKey = userAccount.ApiKey,
ApiSecret = userAccount.ApiSecret,
ApiPassPhrase = userAccount.ApiPassPhrase,
Exchange = userAccount.Exchange
};
var account = await wpfExchangeService.GetAccountInfoAsync(exchange, user, subscribeSymbolsCxlTokenSrc.Token).ConfigureAwait(false);
// 2. convert assets to symbols
var nameDelimiter = wpfExchangeService.GetNameDelimiter(exchange);
var assets = account.Balances.Select(a => $"{a.Asset}{ nameDelimiter ?? string.Empty}{QUOTEASSET}").ToList();
// 3. subscribe symbols
await GetSymbols(assets).ConfigureAwait(false);
}
public ServiceResult <Core.Model.User> AddUser(Core.Model.User user)
{
ServiceResult <Core.Model.User> result = new ServiceResult <Core.Model.User>();
try
{
_userBO.Add(user);
var _address = user.Addresses.FirstOrDefault();
_address.UserId = user.Id;
_addressBO.Add(_address);
result.Data = user;
}
catch (Exception ex)
{
result.HasError = true;
log.Error("Erro: " + ex.Message);
}
return(result);
}
public Task <IEnumerable <Core.Model.AccountTrade> > GetAccountTradesAsync(Exchange exchange, Core.Model.User user, string symbol, DateTime startDate, DateTime endDate, long recWindow = 0, CancellationToken cancellationToken = default)
{
return(exchangeService.GetAccountTradesAsync(exchange, user, symbol, startDate, endDate, recWindow, cancellationToken));
}
public Task <string> CancelOrderAsync(Exchange exchange, Core.Model.User user, string symbol, string orderId, string newClientOrderId = null, long recWindow = 0, CancellationToken cancellationToken = default)
{
return(exchangeService.CancelOrderAsync(exchange, user, symbol, orderId, newClientOrderId, recWindow, cancellationToken));
}
public Task <Core.Model.Order> PlaceOrder(Exchange exchange, Core.Model.User user, Core.Model.ClientOrder clientOrder, long recWindow = 0, CancellationToken cancellationToken = default)
{
return(exchangeService.PlaceOrder(exchange, user, clientOrder, recWindow, cancellationToken));
}
public async Task <Account> GetAccountInfoAsync(Exchange exchange, Core.Model.User user, CancellationToken cancellationToken)
{
var accountInfo = await exchangeService.GetAccountInfoAsync(exchange, user, cancellationToken).ConfigureAwait(false);
return(new Account(accountInfo));
}
public async Task <IEnumerable <Order> > GetOpenOrdersAsync(Exchange exchange, Core.Model.User user, string symbol = null, long recWindow = 0, Action <Exception> exception = default, CancellationToken cancellationToken = default)
{
var result = await exchangeService.GetOpenOrdersAsync(exchange, user, symbol, recWindow, exception, cancellationToken).ConfigureAwait(false);
var orders = result.Select(o => o.GetViewOrder()).ToList();
return(orders);
}
public Task SubscribeAccountInfo(Exchange exchange, Core.Model.User user, Action <AccountInfoEventArgs> callback, Action <Exception> exception, CancellationToken cancellationToken)
{
return(exchangeService.SubscribeAccountInfo(exchange, user, callback, exception, cancellationToken));
}
//[AcceptVerbs(HttpVerbs.Get | HttpVerbs.Post)]
public ActionResult Login(UserLogin userLogin)
{
string checkFolder = "";
string msg = "Please fill correct user id and password.";
Core.Model.LoginHistory logHist = new LoginHistory();
Core.Model.User userData = new Core.Model.User();
userData = _userData.GetUserDetailByUserIDAndPassword(userLogin.UserID, userLogin.Password);
if (userData != null)
{
// data found
// Redirect to Dashboard with active
msg = "";
// store data in session
Session["UserID"] = userData.UserID;
Session["Role"] = userData.Role;
Session["Email"] = userData.EmailID;
Session["SECID"] = userData.SECID;
Session["BPID"] = userData.BPID;
Session["Partner"] = userData.Partner;
Session["BPType"] = userData.BPType;
FormsAuthentication.SetAuthCookie(userData.UserID, true);
logHist.UserID = userData.UserID;
logHist.Server = "";
_userData.LoginHistory(logHist);
// check and create directory
checkFolder = CreateFolder();
// Set custom session data
userData.UserIPAddress = Request.UserHostAddress;
userData.UserBrowserName = Request.Browser.Browser.ToLower().Trim();
userData.SessionToken = Guid.NewGuid().ToString();
_userData.InsertUpdateCustomSessionData(userData, "insert");
TempData["expiredate"] = userData.ExpireDate.Date;
if (userData.ExpireDate.Date >= DateTime.Today.Date && userData.IsActive && userData.ValidFrom.Date <= DateTime.Today.Date)
{
if (!string.IsNullOrWhiteSpace(checkFolder))
{
TempData["message"] = checkFolder;
return(RedirectToAction("SignIn"));
}
else
{
if (userData.Role == 2)
{
//return RedirectToAction("FilterTemplate", "FHFile");
return(RedirectToAction("ManageTag", "FHFile", new { token = userData.SessionToken }));
}
else
{
return(RedirectToAction("Individual", "FHFile", new { token = userData.SessionToken }));
}
}
}
else if (userData.ValidFrom.Date > DateTime.Today.Date)
{
// you are not active contact to admin
msg = "You are not eligible to login in system. Your start date not eligible.";
}
else if (userData.ExpireDate.Date < DateTime.Today.Date && userData.IsActive)//Expire date as ValideTo and ValideTo naver > BPValideTo
{
//msg = "You are not active user or validity date expire, please contact to admin";
return(RedirectToAction("UserProfile", "User", new { token = userData.SessionToken }));
// you are not active contact to admin
}
else if (userData.ExpireDate.Date < DateTime.Today.Date && !userData.IsActive)//Expire date as ValideTo and ValideTo naver > BPValideTo
{
// you are not active contact to admin
msg = "You are not active user or validity date expire, please contact to admin";
}
else
{
// your activation plan period or trail expire purchage new plan
msg = "You are not active user. Please contact to admin.";
}
}
TempData["message"] = msg;
TempData.Keep();
return(RedirectToAction("SignIn"));//, JsonRequestBehavior.AllowGet);
}
private WebAPI.DTO.User MapUser(Core.Model.User user)
{
return(new User {
AdminLevel = user.AdminLevel, Country = user.Country, Email = user.Email, UserName = user.UserName, Password = "******"
});
}
public async Task <IEnumerable <Core.Model.AccountTrade> > GetAccountTradesAsync(Core.Model.User user, string symbol, DateTime startDate, DateTime endDate, long recWindow = 0, CancellationToken cancellationToken = default)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
var binanceApi = new BinanceApi();
using var apiUser = new BinanceApiUser(user.ApiKey, user.ApiSecret);
var result = await binanceApi.GetAccountTradesAsync(apiUser, symbol, startDate, endDate, recWindow, cancellationToken).ConfigureAwait(false);
var accountTrades = result.Select(at => NewAccountTrade(at)).ToList();
return(accountTrades);
}
