public async Task <IActionResult> Accounts(AccountsRequest req)
{
var user = await _userManager.FindByEmailAsync(req.username);
if (user == null)
{
return(Redirect("/api/Home/Index?error=User not found"));
}
var accounts = await _accountRepo.GetUserAccountsAsync(user.Id);
var account = accounts.FirstOrDefault(x => x.DisplayName.Equals(req.accountname, StringComparison.CurrentCultureIgnoreCase));
if (account == null)
{
account = new AccountInfo {
AccountId = IdGenerator.GenerateIdForAccount(user.Id),
DisplayName = req.accountname
};
await _accountRepo.AddAccountsToUserAsync(user.Id, new [] { account });
}
if (req.file != null && req.file.Length > 0)
{
try {
await _timeseriesRepo.UploadSeriesToAccountAsync(account.AccountId, await ParseFileContent(req.file));
}
catch (Exception ex) {
return(Redirect("/api/Home/Index?error=Account is created, but series won't upload|" + ex.Message));
}
}
return(Redirect("/api/Home/Index?success"));
}
public async Task <ActionResult> GetAccounts()
{
var token = this.Session["userTokenData"] as TokenModel;
this._tlsCertificate.Import(ReadFile(this.tlsCertPath), "millennium", X509KeyStorageFlags.DefaultKeySet);
this._signCertificate.Import(ReadFile(this.signCertPath), "millennium", X509KeyStorageFlags.DefaultKeySet);
var httpHandler = new WebRequestHandler();
httpHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
httpHandler.ClientCertificates.Add(this._tlsCertificate);
var api = new PolishAPI(httpHandler, new RequestSigningHandler(this._signCertificate));
var request = new AccountsRequest(
new RequestHeaderAIS(token.accessToken, Guid.NewGuid().ToString(), sendDate: DateTime.Now.ToString(), tppId: "*****@*****.**", isDirectPsu: true),
true,
null,
0);
api.BaseUri = new Uri("https://bm-devportal-testwebapp02.azurewebsites.net");
api.AcceptLanguage = "pl-PL";
api.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", "Bearer " + token.accessToken);
api.XJWSSIGNATURE = JWT.Encode(JsonConvert.SerializeObject(request), this._signCertificate.GetRSAPrivateKey(),
JwsAlgorithm.RS256);
;
var result = await api.GetAccountsWithHttpMessagesAsync(request);
var model = result.Body as AccountsResponse;
return(View(model.Accounts));
}
public static async Task <IActionResult> CreateTransaction([HttpTrigger(AuthorizationLevel.Function, "put", Route = "transaction")] HttpRequest request,
[CosmosDB(
databaseName: "Rodrap50",
collectionName: "Financials",
ConnectionStringSetting = "CosmosDBConnection")] DocumentClient client,
ILogger logger
)
{
logger.LogInformation("C# HTTP CreateTransaction trigger function processed a request.");
string requestBody = await new StreamReader(request.Body).ReadToEndAsync();
var input = JsonConvert.DeserializeObject <TransactionCreateModel>(requestBody);
var transaction = input.GenerateTransaction();
StoredProcedureResponse <ReserveNextTransactionResponse> sprocResponse = await client.ExecuteStoredProcedureAsync <ReserveNextTransactionResponse>(
"/dbs/Rodrap50/colls/Financials/sprocs/ReserveNextTransaction/", new RequestOptions { PartitionKey = new PartitionKey("account") }, transaction.GeneralAccountId);
transaction.RecordId = sprocResponse.Response.TransactionRecordId;
Document document = await client.CreateDocumentAsync("/dbs/Rodrap50/colls/Financials/", transaction);
StoredProcedureResponse <AccountResponse[]> sprocResponse2 = await client.ExecuteStoredProcedureAsync <AccountResponse[]>(
"/dbs/Rodrap50/colls/Financials/sprocs/AddAccountTransaction/", new RequestOptions { PartitionKey = new PartitionKey("account") }, transaction);
AccountsRequest summaryRequest = new AccountsRequest();
summaryRequest.accounts = sprocResponse2.Response;
StoredProcedureResponse <AccountsResponse> sprocResponse3 = await client.ExecuteStoredProcedureAsync <AccountsResponse>(
"/dbs/Rodrap50/colls/Financials/sprocs/UpdateAccountSummary/", new RequestOptions { PartitionKey = new PartitionKey("accountsummary") }, summaryRequest);
return(new OkObjectResult(document));
}
// UPDATE ACCOUNT
public void Update(AccountsRequest model, string userId)
{
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Accounts_Update"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@UserId", userId);
paramCollection.AddWithValue("@AvatarUrl", model.AvatarUrl);
paramCollection.AddWithValue("@Handle", model.Handle);
paramCollection.AddWithValue("@FirstName", model.FirstName);
paramCollection.AddWithValue("@MiddleInitial", model.MiddleInitial);
paramCollection.AddWithValue("@LastName", model.LastName);
paramCollection.AddWithValue("@GenderId", model.GenderId);
paramCollection.AddWithValue("@DOB", model.DOB);
paramCollection.AddWithValue("@Highlight", model.Highlight);
paramCollection.AddWithValue("@Bio", model.Bio);
paramCollection.AddWithValue("@CreatedBy", userId);
paramCollection.AddWithValue("@ModifiedBy", userId);
}
);
if (_cacheService.Contains(globalKey))
{
_cacheService.Remove(globalKey);
_cacheService.Add(globalKey, new object());
}
}
public async Task <IActionResult> Get([FromBody] AccountsRequest request)
{
if (request == null)
{
return(BadRequest("Invalid request"));
}
var result = await _accountsAppService.GetAccountsByCustomerIds(request);
return(result.OnBoth(ParseResult(result)));
}
public HttpResponseMessage Insert(AccountsRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
ItemResponse <int> response = new ItemResponse <int>();
string userId = _userService.GetCurrentUserId();
response.Item = _accountsService.Insert(model, userId);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public HttpResponseMessage UpdateVideo(AccountsRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, ModelState));
}
SuccessResponse r = new SuccessResponse();
string userId = _userService.GetCurrentUserId();
_accountsService.UpdateVideo(model, userId);
return(Request.CreateResponse(HttpStatusCode.OK, r));
}
// UPDATE VideoUrl
public void UpdateVideo(AccountsRequest model, string userId)
{
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Accounts_UpdateVideoUrl"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@UserId", userId);
paramCollection.AddWithValue("@VideoUrl", model.VideoUrl);
});
if (_cacheService.Contains(globalKey))
{
_cacheService.Remove(globalKey);
_cacheService.Add(globalKey, new object());
}
}
public static async Task <IActionResult> CreateAccount(
[HttpTrigger(AuthorizationLevel.Function, "put", Route = "account")] HttpRequest request,
[CosmosDB(
databaseName: "Rodrap50",
collectionName: "Financials",
ConnectionStringSetting = "CosmosDBConnection")] DocumentClient client,
ILogger logger
)
{
logger.LogInformation("C# HTTP CreateAccount trigger function processed a request.");
string requestBody = await new StreamReader(request.Body).ReadToEndAsync();
var input = JsonConvert.DeserializeObject <AccountCreateModel>(requestBody);
var account = input.GenerateAccount();
StoredProcedureResponse <ReserveNextAccountResponse> sprocResponse = await client.ExecuteStoredProcedureAsync <ReserveNextAccountResponse>(
"/dbs/Rodrap50/colls/Financials/sprocs/ReserveNextAccount/", new RequestOptions { PartitionKey = new PartitionKey("accountsummary") });
account.RecordId = sprocResponse.Response.AccountId;
StoredProcedureResponse <AccountResponse> sprocResponse1 = await client.ExecuteStoredProcedureAsync <AccountResponse>("/dbs/Rodrap50/colls/Financials/sprocs/AddAccount/", new RequestOptions { PartitionKey = new PartitionKey("account") }, account);
AccountsRequest summaryRequest = new AccountsRequest();
summaryRequest.accounts = new Account[] { account };
StoredProcedureResponse <AccountsResponse> sprocResponse2 = await client.ExecuteStoredProcedureAsync <AccountsResponse>(
"/dbs/Rodrap50/colls/Financials/sprocs/UpdateAccountSummary/", new RequestOptions { PartitionKey = new PartitionKey("accountsummary") }, summaryRequest);
Account generalAccount = null;
if (sprocResponse1.Response.SoftAccount)
{
var docUri = UriFactory.CreateDocumentUri("Rodrap50", "Financials", sprocResponse1.Response.GeneralAccountId);
generalAccount = await client.ReadDocumentAsync <Account>(docUri, new RequestOptions { PartitionKey = new PartitionKey("account") });
}
else
{
generalAccount = sprocResponse1.Response;
}
StoredProcedureResponse <ListingsResponse> sprocResponse3 = await client.ExecuteStoredProcedureAsync <ListingsResponse>(
"/dbs/Rodrap50/colls/Financials/sprocs/UpdateAccountListing/", new RequestOptions { PartitionKey = new PartitionKey("accountsummary") }, generalAccount);
return(new OkObjectResult(sprocResponse1.Response));
}
// CREATE ACCOUNT
public int Insert(AccountsRequest model, string userId)
{
int id = 0;
DataProvider.ExecuteNonQuery(GetConnection, "dbo.Accounts_Insert"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@AvatarUrl", model.AvatarUrl);
paramCollection.AddWithValue("@Handle", model.Handle);
paramCollection.AddWithValue("@FirstName", model.FirstName);
paramCollection.AddWithValue("@MiddleInitial", model.MiddleInitial);
paramCollection.AddWithValue("@LastName", model.LastName);
paramCollection.AddWithValue("@GenderId", model.GenderId);
paramCollection.AddWithValue("@DOB", model.DOB);
paramCollection.AddWithValue("@Highlight", model.Highlight);
paramCollection.AddWithValue("@Bio", model.Bio);
paramCollection.AddWithValue("@CreatedBy", userId);
paramCollection.AddWithValue("@CreatedDate", null);
SqlParameter p = new SqlParameter("@UserId", SqlDbType.NVarChar);
p.Direction = ParameterDirection.InputOutput;
p.Value = userId;
paramCollection.Add(p);
}, returnParameters : delegate(SqlParameterCollection param)
{
int.TryParse(param["@UserId"].Value.ToString(), out id);
}
);
if (_cacheService.Contains(globalKey))
{
_cacheService.Remove(globalKey);
_cacheService.Add(globalKey, new object());
}
return(id);
}
public async Task <AccountsResponse> GetAccountsAsync(AccountsRequest accountsRequest)
{
return(await _mediator.ExecuteAsync <AccountsRequest, AccountsResponse>(accountsRequest));
}
// GET: UserLogged
public async Task <ActionResult> Logged(string code, string state, string error, string redirect)
{
if (redirect == null)
{
return(new EmptyResult());
}
var client = new HttpClient();
var payload = new Dictionary <string, string>()
{
{ "sub", "*****@*****.**" }
};
this._signCertificate.Import(ReadFile(this.signCertPath), "millennium", X509KeyStorageFlags.DefaultKeySet);
string tokenSigned = JWT.Encode(payload, this._signCertificate.GetRSAPrivateKey(), JwsAlgorithm.RS256);
var link = string.Format(
"https://bm-devportal-testwebapp03.azurewebsites.net/tokens?code={0}&redirect_uri={1}&client_id={2}&client_assertion={3}",
code, "http://*****:*****@bankmillennium.pl", tokenSigned);
var result = await client.GetAsync(link);
var token = await result.Content.ReadAsAsync <TokenModel>();
this.Session["userTokenData"] = token;
this._tlsCertificate.Import(ReadFile(this.tlsCertPath), "millennium", X509KeyStorageFlags.DefaultKeySet);
this._signCertificate.Import(ReadFile(this.signCertPath), "millennium", X509KeyStorageFlags.DefaultKeySet);
var httpHandler = new WebRequestHandler();
httpHandler.ClientCertificateOptions = ClientCertificateOption.Manual;
httpHandler.ClientCertificates.Add(this._tlsCertificate);
var api = new PolishAPI(httpHandler, new RequestSigningHandler(this._signCertificate));
var request = new AccountsRequest(
new RequestHeaderAIS(token.accessToken, Guid.NewGuid().ToString(), sendDate: DateTime.Now.ToString(), tppId: "*****@*****.**", isDirectPsu: true),
true,
null,
0);
api.BaseUri = new Uri("https://bm-devportal-testwebapp02.azurewebsites.net");
api.AcceptLanguage = "pl-PL";
api.HttpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", "Bearer " + token.accessToken);
api.XJWSSIGNATURE = JWT.Encode(JsonConvert.SerializeObject(request), this._signCertificate.GetRSAPrivateKey(),
JwsAlgorithm.RS256);
var result2 = await api.GetAccountsWithHttpMessagesAsync(request);
var model = result2.Body as AccountsResponse;
var account = model.Accounts.First();
var request2 = new AccountInfoRequest
{
AccountNumber = account.AccountNumber,
RequestHeader =
new RequestHeaderAIS(token.accessToken, Guid.NewGuid().ToString(),
sendDate: DateTime.Now.ToString(), tppId: "*****@*****.**", isDirectPsu: true)
};
var result3 = await api.GetAccountWithHttpMessagesAsync(request2);
var accountInfo = result3.Body as AccountResponse;
return(View(accountInfo.Account));
}
public IActionResult AccountsPost([FromHeader]string secret, [FromHeader]string token, [FromBody]AccountsRequest accountsRequest)
{
string exampleJson = null;
var example = exampleJson != null
? JsonConvert.DeserializeObject<List<Account>>(exampleJson)
: default(List<Account>);
return new ObjectResult(example);
}
public async Task <Result <AccountsResponse> > GetAccountsByCustomerIds(AccountsRequest request)
{
var accounts = await _accountRepository.GetByCustomerIds(request.CustomerIds);
return(Result.Ok(Map(accounts)));
}
/// <summary>
/// Get information about all user's payment account
/// </summary>
/// <remarks>
/// User identification based on access token
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='getAccountsRequest'>
/// Data for Accounts Request
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> GetAccountsAsync(this IPolishAPI operations, AccountsRequest getAccountsRequest, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.GetAccountsWithHttpMessagesAsync(getAccountsRequest, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Get information about all user's payment account
/// </summary>
/// <remarks>
/// User identification based on access token
/// </remarks>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='getAccountsRequest'>
/// Data for Accounts Request
/// </param>
public static object GetAccounts(this IPolishAPI operations, AccountsRequest getAccountsRequest)
{
return(operations.GetAccountsAsync(getAccountsRequest).GetAwaiter().GetResult());
}
public async Task <IEnumerable <AccountsResponse> > Handle(AccountsRequest request, CancellationToken cancellationToken)
{
return(await Task.FromResult <IEnumerable <AccountsResponse> >(accounts));
}
