private static async Task <AccountDetails> CreateAccount(System.Net.Http.HttpClient client)
{
var requestData = new NewAccountRequest()
{
AccountName = "Test Account - " + Guid.NewGuid().ToString()
};
var response = await client.PostAsJsonAsync("/api/Accounts", requestData);
response.EnsureSuccessStatusCode();
var responseData = await response.Content.ReadAsJsonAsync <AccountDetails>();
return(responseData);
}
public async Task The_Account_Starts_With_The_Correct_Opening_Balance()
{
var client = _factory.CreateDefaultClient();
var requestData = new NewAccountRequest()
{
AccountName = "Test Account - " + Guid.NewGuid().ToString()
};
var response = await client.PostAsJsonAsync("/api/Accounts", requestData);
response.EnsureSuccessStatusCode();
var responseData = await response.Content.ReadAsJsonAsync <AccountDetails>();
Assert.Equal(Constants.OpeningBalance, responseData.OpeningCash);
}
public async Task The_Account_Has_No_Money_From_Transactions()
{
var client = _factory.CreateDefaultClient();
var requestData = new NewAccountRequest()
{
AccountName = "Test Account - " + Guid.NewGuid().ToString()
};
var response = await client.PostAsJsonAsync("/api/Accounts", requestData);
response.EnsureSuccessStatusCode();
var responseData = await response.Content.ReadAsJsonAsync <AccountDetails>();
Assert.Equal(0, responseData.TotalFromTransactions);
}
public async Task The_Account_Number_Is_Generated()
{
var client = _factory.CreateDefaultClient();
var requestData = new NewAccountRequest()
{
AccountName = "Test Account - " + Guid.NewGuid().ToString()
};
var response = await client.PostAsJsonAsync("/api/Accounts", requestData);
response.EnsureSuccessStatusCode();
var responseData = await response.Content.ReadAsJsonAsync <AccountDetails>();
Assert.NotEqual(Guid.Empty, responseData.AccountNumber);
}
/// <summary>
/// this function only add a master user into the db; u
/// </summary>
public async Task <NewAccountResponse> RegistrationByUser(
NewAccountRequest ptr, CancellationToken cancellationToken)
{
m_ptrLogger.LogOk("START");
Debug.Assert(ptr._usrDetails != null);
await _masterUserService.InsertMasterAccount(ptr._usrDetails, cancellationToken);
NewAccountResponse response = new NewAccountResponse()
{
_usrDetails = ptr._usrDetails,
_retCode = RC_OK
};
m_ptrLogger.LogOk("END");
Debug.Assert(response._usrDetails._login > 0);
return(response);
}
private static async Task <Guid> RegisterAccount(HttpClient httpClient, string account_name)
{
var requestData = new NewAccountRequest()
{
AccountName = account_name
};
var response = await httpClient.PostAsJsonAsync("/api/Accounts", requestData);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var responseData = await response.Content.ReadAsJsonAsync <AccountDetails>();
return(responseData.AccountNumber);
}
throw new Exception(await response.Content.ReadAsStringAsync());
}
private void CreateNewAccount()
{
NewAccountRequest r = new NewAccountRequest
{
firstname = FirstNameBox.Text,
age = Int32.Parse(AgeBox.Text),
isman = ToggleSwitch.IsOn,
lastname = LastNameBox.Text,
username = UsernameBox.Text,
password = PasswordBox.Text,
friends = new List <User>()
};
Packet p = new Packet {
PacketType = EPacketType.NewAccountRequest, Payload = JsonConvert.SerializeObject(r)
};
TcpClient.DoRequest(p, NewAccountCallback);
}
public async Task <ActionResult <AccountDetails> > Post(NewAccountRequest newAccountRequest)
{
var existingAccount = await _accountByNameQuery.Evaluate(newAccountRequest.AccountName);
if (existingAccount != null)
{
return(new BadRequestObjectResult($"An account already exists with the name {newAccountRequest.AccountName}, please choose a different name."));
}
var account = new AccountDetails()
{
AccountName = newAccountRequest.AccountName,
AccountNumber = Guid.NewGuid(),
OpeningCash = 10000,
Portfolio = new List <Investment>(),
TotalFromTransactions = 0
};
await _updateAccountAction.Execute(account);
return(account);
}
private void HandleNonLoggedInRequests()
{
while (!loggedIn)
{
req = (Request)br.Read();
if (req.SessionID != sessionID)
{
return;
}
switch (req.Type)
{
case RequestType.NewAccount:
NewAccountRequest NAReq = (NewAccountRequest)req;
(success, reason) = server.database.AddUser(NAReq.email, NAReq.username, NAReq.password);
if (success)
{
resp = new SuccessResponse(sessionID);
}
else
{
resp = new FailResponse(reason, sessionID);
}
reason = null;
break;
case RequestType.SignIn:
SignInRequest SIReq = (SignInRequest)req;
(success, reason) = server.database.SignIn(SIReq.username, SIReq.password);
if (success)
{
resp = GetAccountInfo(SIReq.username);
if (server.writersPerUsername.TryAdd(SIReq.username, bw))
{
loggedUser = SIReq.username;
server.loggedInUsers.Add(loggedUser);
loggedIn = true;
}
}
else
{
resp = new FailResponse(reason, sessionID);
}
reason = null;
break;
default:
resp = new FailResponse("Unsupported request type detected.", sessionID);
break;
}
req = null;
if (resp != null)
{
bw.Write(resp);
//resp.Send(bw);
resp = null;
if (loggedIn)
{
return;
}
}
}
}
/// <summary>
/// handleNewAccountRequest; used only by WitFX; old name was CreateAccount
/// </summary>
public async Task <NewAccountResponse> SetAccountsByProduct(
NewAccountRequest ptr, CancellationToken cancellationToken)
{
m_ptrLogger.LogOk("START");
Debug.Assert(ptr._usrDetails != null);
await _masterUserService.InsertMasterAccount(ptr._usrDetails, cancellationToken);
bool ret = true;
NewAccountResponse response;
if (ret)
{
NewAccountResponse ptrResp = new NewAccountResponse(); //MT_NewAccountResponse_ID
ptrResp._usrDetails = ptr._usrDetails;
ptrResp._retCode = RC_OK;
response = ptrResp; //m_connectionMgr.SendResponseToQueue(ptr._header._socketID, ptrResp, MT_NewAccountResponse_ID);
var ptrproductDetails = await _productService.GetProductDetails(ptr._productid, cancellationToken);
var cnt = ptrproductDetails.Count;
for (int it = 0; it < cnt; it++)
{
MT4Request ptrMT4Req = (MT4Request) new MT4Request();
//memset(ptrMT4Req, 0, sizeof(MT4Request));
ptrMT4Req.accType = ptrproductDetails[it]._accounttype;
ptrMT4Req.group = ptrproductDetails[it]._group;
ptrMT4Req.deposit = ptrproductDetails[it]._deposit;
ptrMT4Req.leverage = ptr._leverage;
ptrMT4Req.masterLogin = ptr._usrDetails._login;
ptrMT4Req.reqType = MT4REQ.MT4REQ_NEW_ACCOUNT;
ptrMT4Req.requestMode = MT4REQMODE.NEW_ACCOUNT;
//ptrMT4Req.socketID = ptr._header._socketID;
ptrMT4Req.status = ORD_STAT_RECVD;
ptrMT4Req.serverTransID = TransactionService.NewTransactionId();
//ptrMT4Req.ptrData = new MasterUser();
ptrMT4Req.ptrData = ptr._usrDetails;
if (ptrproductDetails[it]._serverid == SRV_TYPE_DEMO)
{
_mt4Manager.Demo.insertMT4Request(ptrMT4Req);
}
else
{
_mt4Manager.Live.insertMT4Request(ptrMT4Req);
}
ptrResp.MT4Requests.Add(ptrMT4Req);
}
/*MT4Request ptrMT4Req1 = (MT4Request)new MT4Request();
* //memset(ptrMT4Req1, 0, sizeof(MT4Request));
* ptrMT4Req1.accType = ACC_TYPE_FOLLOWER_DEMO;
* ptrMT4Req1.masterLogin = ptr._usrDetails._login;
* ptrMT4Req1.reqType = MT4REQ_NEW_ACCOUNT;
* ptrMT4Req1.requestMode = MT4REQMODE.NEW_ACCOUNT;
* ptrMT4Req1.socketID = ptr._header._socketID;
* ptrMT4Req1.status = ORD_STAT_RECVD;
* ptrMT4Req1.serverTransID = getUniqueRequestID();
* ptrMT4Req1.ptrData = new MasterUser();
* memcpy(out ptrMT4Req1.ptrData, &ptr._usrDetails, sizeof(MasterUser));
* m_ptrDemoMT4Manager.insertMT4Request(ptrMT4Req1);
*
* MT4Request ptrMT4Req2 = (MT4Request)new MT4Request();
* //memset(ptrMT4Req2, 0, sizeof(MT4Request));
* ptrMT4Req2.accType = ACC_TYPE_FOLLOWER_LIVE;
* ptrMT4Req2.masterLogin = ptr._usrDetails._login;
* ptrMT4Req2.reqType = MT4REQ_NEW_ACCOUNT;
* ptrMT4Req2.requestMode = MT4REQMODE.NEW_ACCOUNT;
* ptrMT4Req2.socketID = ptr._header._socketID;
* ptrMT4Req2.status = ORD_STAT_RECVD;
* ptrMT4Req2.serverTransID = getUniqueRequestID();
* ptrMT4Req2.ptrData = new MasterUser();
* memcpy(out ptrMT4Req2.ptrData, &ptr._usrDetails, sizeof(MasterUser));
* m_ptrLiveMT4Manager.insertMT4Request(ptrMT4Req2);
*
* MT4Request ptrMT4Req3 = (MT4Request)new MT4Request();
* //memset(ptrMT4Req3, 0, sizeof(MT4Request));
* ptrMT4Req3.accType = ACC_TYPE_REBATE;
* ptrMT4Req3.masterLogin = ptr._usrDetails._login;
* ptrMT4Req3.reqType = MT4REQ_NEW_ACCOUNT;
* ptrMT4Req3.requestMode = MT4REQMODE.NEW_ACCOUNT;
* ptrMT4Req3.socketID = ptr._header._socketID;
* ptrMT4Req3.status = ORD_STAT_RECVD;
* ptrMT4Req3.serverTransID = getUniqueRequestID();
* ptrMT4Req3.ptrData = new MasterUser();
* memcpy(out ptrMT4Req3.ptrData, &ptr._usrDetails, sizeof(MasterUser));
* m_ptrDemoMT4Manager.insertMT4Request(ptrMT4Req3); */
}//if (ret)
else
{
NewAccountResponse ptrResp = new NewAccountResponse(); // MT_NewAccountResponse_ID
//memcpy(ref ptrResp._usrDetails, ptr._usrDetails);
ptrResp._usrDetails = ptr._usrDetails;
ptrResp._retCode = RC_ERROR;
response = ptrResp; // m_connectionMgr.SendResponseToQueue(ptr._header._socketID, ptrResp, MT_NewAccountResponse_ID);
}//else of if (ret)
m_ptrLogger.LogOk("END");
Debug.Assert(response._usrDetails._login > 0);
//TODO: insertDBTransmitData(response._usrDetails._login, FDMT_MasterUser_ID);
//send email to user
//sendRegistrationEmail(ptr->_usrDetails._login, ptr->_usrDetails._password, ptr-
return(response);
}
private void createAccountBtn_Clicked(object sender, EventArgs e)
{
indicator.IsVisible = true;
indicator.IsRunning = true;
//Task.Run(() => {
try{
if (!client.Connected)
{
client = Connection.Connect(hostname, defaultPort, ref writer, ref reader);
sessionID = (long)reader.Read();
}
NewAccountRequest req = default;
var email = emailEntry.Text.Trim();
var username = usernameEntry.Text.Trim();
var passwd = passwordEntry.Text;
//if (username.Length <= 7)
//{
// DisplayAlert(FormatErrorTitle, UsernameFormatErrorMessage, ConnectionErrorCancel);
// return;
//}
//if (passwd.Length <= 7)
//{
// DisplayAlert(FormatErrorTitle, PasswordFormatErrorMessage, ConnectionErrorCancel);
// return;
//}
req = new NewAccountRequest(email.ToEmail(),
username.ToUsername(), passwd.ToPassword(), sessionID);
writer.Write(req);
//req.Send(writer);
Response resp = (Response)reader.Read();
if (resp.SessionID == sessionID)
{
//switch ((ResponseType)Enum.Parse(typeof(ResponseType), (string)reader.Read()))
switch (resp.Type)
{
case ResponseType.Success:
loginBtn.IsVisible = true;
emailEntry.IsVisible = false;
emailLabel.IsVisible = false;
btnGrid.IsVisible = true;
btnStack.IsVisible = false;
emailEntry.Text = "";
usernameEntry.Text = "";
passwordEntry.Text = "";
DisplayAlert(AccountCreateSuccessTitle, AccountCreateSuccessMessage, DefaultCancel);
break;
case ResponseType.Fail:
FailResponse FResp = (FailResponse)resp; //.Read(reader, sessionID);
DisplayAlert(AccountCreateFailTitle, FResp.Reason, DefaultCancel);
break;
}
}
else
{
Connection.Disconnect(ref client, ref reader, ref writer);
}
}
catch (SocketException)
{
DisplayAlert(ConnectionErrorTitle, ConnectionErrorMessage, DefaultCancel);
}
catch (FormatException)
{
DisplayAlert(FormatErrorTitle, EmailFormatErrorMessage, DefaultCancel);
}
//catch (InvalidSessionIDException)
//{
// DisplayAlert(FormatErrorTitle, EmailFormatErrorMessage, EmailFormatErrorCancel);
//}
finally
{
indicator.IsVisible = false;
indicator.IsRunning = false;
}
//});
}
