public async Task <IActionResult> UpdateTransactions(NewTransactionModel transModel)
{
var updateTrans = await _context.TransactionDetails.FindAsync(transModel.ID);
if (updateTrans == null)
{
return(NotFound());
}
updateTrans.ID = transModel.ID;
updateTrans.Description = transModel.Description;
updateTrans.User_ID = transModel.User_ID;
updateTrans.Quantity = transModel.Quantity;
updateTrans.Unit_price = transModel.Unit_price;
updateTrans.Total = transModel.Total;
try
{
_context.TransactionDetails.Update(updateTrans);
await _context.SaveChangesAsync();
}
catch (Exception e)
{
throw e;
}
return(NoContent());
}
public async Task <IActionResult> AddNewTransaction([FromBody] NewTransactionModel dataModel)
{
try
{
TransactionDetails transactionDetails = new TransactionDetails()
{
RegistedDate = DateTime.Now,
IsActive = true,
Description = dataModel.Description,
User_ID = dataModel.User_ID,
Quantity = dataModel.Quantity,
Unit_price = dataModel.Unit_price,
Total = dataModel.Total,
};
_context.TransactionDetails.Add(transactionDetails);
await _context.SaveChangesAsync();
return(Ok());
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Add Transaction
/// </summary>
/// <param name="userId"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public async Task <UserScoreDetails> AddTransaction(string userId, NewTransactionModel transaction)
{
var result = await _service.UserByUserIdAddtransactionPostWithHttpMessagesAsync(userId, transaction.Map());
if (result.Response.IsSuccessStatusCode)
{
return(Mapper.Map <UserScoreDetails>(result.Body));
}
return(null);
}
// POST: api/transactions/transfer
public async Task <TransactionModel> PostTransaction(string authToken, string counteragentId, decimal transactionAmount, string description)
{
var uri = UriHelper.CombineUri(GlobalSetting.Instance.GatewayPWEndpoint, $"{ApiUrlBase}/transfer");
NewTransactionModel newTransactionModel = new NewTransactionModel()
{
CounteragentId = counteragentId,
TransactionAmount = transactionAmount,
Description = description
};
TransactionModel transaction = await _requestProvider.PostAsync <TransactionModel, NewTransactionModel>(uri, newTransactionModel, authToken);
return(transaction);
}
public async Task <IActionResult> New()
{
var currentUser = await _userManager.GetUserAsync(User);
var availableAccounts = currentUser.Accounts.ToAccountsListModels(currentUser.Currency).ToList();
if (!availableAccounts.Any())
{
return(RedirectToAction("Index",
new NotificationModel("You don't have any accounts to make a transaction from!").asError()));
}
var code = HttpContext.Request.Query["transaction_code"];
var recipientAccount = 0;
var selectedDescription = "";
var selectedAmount = 0m;
if (code != StringValues.Empty)
{
var transactionCode = await _transactionCodeRepository.GetAsync(HttpContext.Request.Query["transaction_code"]);
if (transactionCode == null)
{
code = StringValues.Empty;
ViewBag.Notification = new NotificationModel("The entered transaction code doesn't exist!").asError();
}
else
{
recipientAccount = transactionCode.Id;
selectedDescription = transactionCode.Description;
selectedAmount = transactionCode.Amount;
}
}
var model = new NewTransactionModel
{
TransactionCode = code,
TransactionRecipient = recipientAccount,
TransactionDescription = selectedDescription,
TransactionAmount = selectedAmount * currentUser.Currency.RateFromEur,
AvailableAccounts = new SelectList(currentUser.Accounts.Select(x => new SelectListItem($"{x.Id} ({x.Balance * x.User.Currency.RateFromEur} {x.User.Currency.Name})", x.Id.ToString())), "Value", "Text")
};
return(View("New", model));
}
public async Task <ActionResult> Add(NewTransactionModel model)
{
if (ModelState.IsValid)
{
Person debtor = null, creditor = null;
if (model.Creditor == model.Debtor)
{
ModelState.AddModelError("", "The debtor and creditor must not be the same person.");
}
else
{
debtor = mData.Person.Where(p => p.Id == model.Debtor).SingleOrDefault();
creditor = mData.Person.Where(p => p.Id == model.Creditor).SingleOrDefault();
if (debtor == null)
{
ModelState.AddModelError("Debtor", "Invalid debtor.");
}
if (creditor == null)
{
ModelState.AddModelError("Creditor", "Invalid creditor.");
}
}
if (creditor != null && debtor != null)
{
var trans = new Transaction();
trans.CreditorId = creditor.Id;
trans.DebtorId = debtor.Id;
trans.Description = model.Description;
trans.Amount = (int)Math.Round(model.Amount * 100d);
trans.Created = DateTime.UtcNow;
trans.Id = Guid.NewGuid();
mData.Transaction.Add(trans);
await mData.SaveChangesAsync();
return(RedirectToAction("Index", "Transaction"));
}
}
ViewBag.People = mData.ActivePeopleOrderedByName.ToList();
return(View(model));
}
public HttpResponseMessage Add(NewTransactionModel model)
{
string error;
try
{
error = _transactionService.Create(model.MapTo(new NewTransaction()));
}
catch (ServiceException e)
{
error = e.Message;
}
catch (Exception e)
{
error = "Failed create transaction";
}
return(string.IsNullOrWhiteSpace(error) ? Request.CreateResponse(HttpStatusCode.OK) : Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error));
}
public IActionResult Post(NewTransactionModel model)
{
Guid submissionId = Guid.Parse(model.Id);
var existingSubmission = _dataContext.Transactions.FirstOrDefault(s => s.Id == submissionId);
if (existingSubmission == null)
{
_dataContext.Transactions.Add(new Data.Transaction {
Id = submissionId, ExpectedFilesCount = model.ExpectedFilesCount, TransactionStatus = TransactionStatus.InProgress, TransactionDate = DateTime.Now
});
}
else
{
existingSubmission.ExpectedFilesCount = model.ExpectedFilesCount;
}
_dataContext.SaveChanges();
return(NoContent());
}
public async Task <IActionResult> Post([FromBody] NewTransactionModel model)
{
if (model == null)
{
return(this.BadRequest());
}
if (model.Script != null)
{
try
{
this.scriptRunner.Compile(model.Script);
}
catch (CompilationFailedException compilationFailed)
{
return(this.BadRequest(new
{
compilationFailed.Message,
compilationFailed.Errors
}));
}
}
var factory = new TransactionFactory(this.storage);
Guid id = model.Id.GetValueOrDefault(Guid.NewGuid());
if (!DateTimeParser.TryParseDateTime(model.Expires, out DateTime? expires))
{
return(this.BadRequest());
}
var trans = await factory.CreateTransaction(id, expires, model.Payload, model.Script, null);
var transResult = trans.ToTransactionResult();
return(this.Created(this.Url.RouteUrl("TransactionGetRevision", new { id = trans.Id, revision = trans.Revision }), transResult));
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='userId'>
/// Lykke user Id (won't be use for Chainalysis)
/// </param>
/// <param name='transaction'>
/// Transaction to be added
/// </param>
public static object UserByUserIdAddtransactionPost(this IChainalysisProxyAPI operations, string userId, NewTransactionModel transaction = default(NewTransactionModel))
{
return(operations.UserByUserIdAddtransactionPostAsync(userId, transaction).GetAwaiter().GetResult());
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='userId'>
/// Lykke user Id (won't be use for Chainalysis)
/// </param>
/// <param name='transaction'>
/// Transaction to be added
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> UserByUserIdAddtransactionPostAsync(this IChainalysisProxyAPI operations, string userId, NewTransactionModel transaction = default(NewTransactionModel), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.UserByUserIdAddtransactionPostWithHttpMessagesAsync(userId, transaction, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public async Task <IActionResult> CreateTransaction(NewTransactionModel model)
{
var currentUser = await _userManager.GetUserAsync(User);
TransactionCode transactionCode = null;
if (model.TransactionCode != null)
{
transactionCode = await _transactionCodeRepository.GetAsync(model.TransactionCode);
if (transactionCode == null)
{
return(RedirectToAction("New",
new NotificationModel("The entered transaction code doesn't exist!").asError()));
}
else
{
model.TransactionAmount = transactionCode.Amount * currentUser.Currency.RateFromEur;
model.TransactionDescription = transactionCode.Description;
model.TransactionRecipient = transactionCode.RecipientId;
}
}
if (string.IsNullOrEmpty(model.TransactionDescription))
{
return(RedirectToAction("New",
new NotificationModel("None of the fields should be empty by the way!").asError()));
}
if (model.TransactionAmount <= 0)
{
return(RedirectToAction("New",
new NotificationModel("The entered amount must be bigger than 0!").asError()));
}
var sourceAccount = currentUser.Accounts.FirstOrDefault(x => x.Id == model.TransactionSource);
if (sourceAccount == null)
{
return(RedirectToAction("New",
new NotificationModel("Thank you for using the Systems Modelling banking application, please continue to your nearest account!").asError()));
}
if (sourceAccount.UserId != currentUser.Id)
{
return(RedirectToAction("New",
new NotificationModel("Hey! That's not cool!").asError()));
}
var recipientAccount = await _accountRepository.GetAsync(model.TransactionRecipient);
if (recipientAccount == null)
{
return(RedirectToAction("New",
new NotificationModel("The recipient account wasn't found!").asError()));
}
if (sourceAccount.Id == recipientAccount.Id)
{
return(RedirectToAction("New",
new NotificationModel("You cannot transfer money to the same account!").asError()));
}
var normalizedAmount = model.TransactionAmount / currentUser.Currency.RateFromEur;
if (sourceAccount.Balance < normalizedAmount)
{
return(RedirectToAction("New",
new NotificationModel("The source account doesn't have enough money in the balance!").asError()));
}
var transaction = new Transaction
{
Description = model.TransactionDescription,
Amount = normalizedAmount,
CreationTime = DateTime.Now,
CreatorUserId = currentUser.Id,
SenderAccountId = sourceAccount.Id,
RecipientAccountId = recipientAccount.Id
};
await _transactionRepository.CreateAsync(transaction);
sourceAccount.Balance -= normalizedAmount;
sourceAccount.SentTransactions.Add(transaction);
await _accountRepository.UpdateAsync(sourceAccount);
recipientAccount.Balance += normalizedAmount;
recipientAccount.RecievedTransactions.Add(transaction);
await _accountRepository.UpdateAsync(recipientAccount);
if (transactionCode != null)
{
await _transactionCodeRepository.RemoveAsync(transactionCode);
}
_logger.Log("ClientTransactionController", $"User {currentUser.UserName} created a transaction from account {sourceAccount.Id} to account {recipientAccount.Id} with amount {normalizedAmount}€");
return(RedirectToAction("New", new NotificationModel("The transaction was successful!").asSuccess()));
}
/// <param name='userId'>
/// Lykke user Id (won't be use for Chainalisys)
/// </param>
/// <param name='transaction'>
/// Transaction to be added
/// </param>
/// <param name='customHeaders'>
/// Headers that will be added to request.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
/// <exception cref="HttpOperationException">
/// Thrown when the operation returned an invalid status code
/// </exception>
/// <exception cref="SerializationException">
/// Thrown when unable to deserialize the response
/// </exception>
/// <exception cref="ValidationException">
/// Thrown when a required parameter is null
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// Thrown when a required parameter is null
/// </exception>
/// <return>
/// A response object containing the response body and response headers.
/// </return>
public async Task <HttpOperationResponse <object> > UserByUserIdAddtransactionPostWithHttpMessagesAsync(string userId, NewTransactionModel transaction = default(NewTransactionModel), Dictionary <string, List <string> > customHeaders = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (userId == null)
{
throw new ValidationException(ValidationRules.CannotBeNull, "userId");
}
if (transaction != null)
{
transaction.Validate();
}
// Tracing
bool _shouldTrace = ServiceClientTracing.IsEnabled;
string _invocationId = null;
if (_shouldTrace)
{
_invocationId = ServiceClientTracing.NextInvocationId.ToString();
Dictionary <string, object> tracingParameters = new Dictionary <string, object>();
tracingParameters.Add("userId", userId);
tracingParameters.Add("transaction", transaction);
tracingParameters.Add("cancellationToken", cancellationToken);
ServiceClientTracing.Enter(_invocationId, this, "UserByUserIdAddtransactionPost", tracingParameters);
}
// Construct URL
var _baseUrl = BaseUri.AbsoluteUri;
var _url = new System.Uri(new System.Uri(_baseUrl + (_baseUrl.EndsWith("/") ? "" : "/")), "user/{userId}/addtransaction").ToString();
_url = _url.Replace("{userId}", System.Uri.EscapeDataString(userId));
// Create HTTP transport objects
var _httpRequest = new HttpRequestMessage();
HttpResponseMessage _httpResponse = null;
_httpRequest.Method = new HttpMethod("POST");
_httpRequest.RequestUri = new System.Uri(_url);
// Set Headers
if (customHeaders != null)
{
foreach (var _header in customHeaders)
{
if (_httpRequest.Headers.Contains(_header.Key))
{
_httpRequest.Headers.Remove(_header.Key);
}
_httpRequest.Headers.TryAddWithoutValidation(_header.Key, _header.Value);
}
}
// Serialize Request
string _requestContent = null;
if (transaction != null)
{
_requestContent = SafeJsonConvert.SerializeObject(transaction, SerializationSettings);
_httpRequest.Content = new StringContent(_requestContent, System.Text.Encoding.UTF8);
_httpRequest.Content.Headers.ContentType = System.Net.Http.Headers.MediaTypeHeaderValue.Parse("application/json-patch+json; charset=utf-8");
}
// Send Request
if (_shouldTrace)
{
ServiceClientTracing.SendRequest(_invocationId, _httpRequest);
}
cancellationToken.ThrowIfCancellationRequested();
_httpResponse = await HttpClient.SendAsync(_httpRequest, cancellationToken).ConfigureAwait(false);
if (_shouldTrace)
{
ServiceClientTracing.ReceiveResponse(_invocationId, _httpResponse);
}
HttpStatusCode _statusCode = _httpResponse.StatusCode;
cancellationToken.ThrowIfCancellationRequested();
string _responseContent = null;
if ((int)_statusCode != 200 && (int)_statusCode != 400)
{
var ex = new HttpOperationException(string.Format("Operation returned an invalid status code '{0}'", _statusCode));
if (_httpResponse.Content != null)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else
{
_responseContent = string.Empty;
}
ex.Request = new HttpRequestMessageWrapper(_httpRequest, _requestContent);
ex.Response = new HttpResponseMessageWrapper(_httpResponse, _responseContent);
if (_shouldTrace)
{
ServiceClientTracing.Error(_invocationId, ex);
}
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw ex;
}
// Create Result
var _result = new HttpOperationResponse <object>();
_result.Request = _httpRequest;
_result.Response = _httpResponse;
// Deserialize Response
if ((int)_statusCode == 200)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <IUserScoreDetails>(_responseContent, DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
// Deserialize Response
if ((int)_statusCode == 400)
{
_responseContent = await _httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
try
{
_result.Body = SafeJsonConvert.DeserializeObject <object>(_responseContent, DeserializationSettings);
}
catch (JsonException ex)
{
_httpRequest.Dispose();
if (_httpResponse != null)
{
_httpResponse.Dispose();
}
throw new SerializationException("Unable to deserialize the response.", _responseContent, ex);
}
}
if (_shouldTrace)
{
ServiceClientTracing.Exit(_invocationId, _result);
}
return(_result);
}
