public async Task <TransactionResponseModel> ChargeAuthorization(TransactionRequestModel transactionRequest)
{
string url = GetUrl("charge_authorization");
var content = await BaseClient.PostEntities(url, JsonConvert.SerializeObject(transactionRequest), this._secretKey);
return(JsonConvert.DeserializeObject <TransactionResponseModel>(content));
}
public async Task <PaymentInitalizationResponseModel> InitializeTransaction(TransactionRequestModel transactionRequest)
{
string url = GetUrl("initialize");
var content = await BaseClient.PostEntities(url, JsonConvert.SerializeObject(transactionRequest), this._secretKey);
return(JsonConvert.DeserializeObject <PaymentInitalizationResponseModel>(content));
}
/// <summary>
/// Send the transaction and notifies the customer of a new charge
/// </summary>
/// <param name="phoneNumber">Phone number of customer</param>
/// <param name="regionCode">Phone number region code</param>
public static bool Sale(TransactionRequestModel data)
{
try
{
data.ChargeByNickName = false;
var tx = connection.PostCall <TransactionResponseModel>("/api/Sale", data, Configurations.Lang);
Id = tx.TransactionId;
Console.Clear();
Console.WriteLine("Transaction Id " + tx.TransactionId);
return(true);
}
catch (PayPhoneWebException e)
{
//All call make to PayPhone need to be inside a try catch
//Verify if error returned was Unhautorized and get new token
if (RefreshToken(e))
{
//Make the same call again after restore the invalid token for new one
return(Sale(data));
}
PrintErrors(e);
return(false);
}
catch (Exception e)
{
//Always is recomended have generic exception for possibles errors generate from your code
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Exception " + e.Message);
Console.ResetColor();
return(false);
}
}
public ActionResult TransactionForConsole(TransactionRequestModel model)
{
try
{
if (model.Type == TransactionType.GetHistory)
{
var transactionHistory = "No transactions found";
var transactions = XmlDal.GetTransactionHistory(model.UserId);
transactionHistory = GetTransactionSummaryString(transactions);
return(new ContentResult {
Content = transactionHistory
});
}
var transactionModel = new TransactionViewModel
{
UserEmail = model.UserId,
Date = DateTime.UtcNow.ToString(CultureInfo.InvariantCulture),
IsWithdraw = model.Type == TransactionType.Withdraw,
IsDeposit = model.Type == TransactionType.Deposit,
Amount = model.Amount ?? 0,
};
return(new ContentResult
{
Content = XmlDal.SubmitTransaction(transactionModel)
? "Transaction was successfully tendered."
: "Transaction request denied"
});
}
catch (Exception)
{
return(new HttpStatusCodeResult(HttpStatusCode.InternalServerError));
}
}
public async Task <IActionResult> Create(TransactionRequestModel transaction)
{
await _transactions.InsertAsync(_mapper.Map <Transaction>(transaction));
await _transactions.SaveAsync();
return(Created($"transaction/{transaction}", transaction));
}
public void ProcessNewIncomingTransaction(TransactionRequestModel tranRM)
{
var newTransaction = Create(tranRM);
newTransaction.Hash = Crypto.CalculateSHA256ToString(newTransaction.AsJsonWithoutHash());
this.Validate(newTransaction);
this.pendingTransactions.Add(newTransaction);
}
public async Task <ResponseModel <bool> > RequestTransaction([FromBody] TransactionRequestModel model)
{
var result = await _transactionService.RequestTransaction(model);
Response.StatusCode = (int)HttpStatusCode.OK;
return(new ResponseBuilder <bool>().Success()
.Data(result)
.Count(1)
.build());
}
public async Task <IActionResult> Post([FromBody] TransactionRequestModel value)
{
value = await service.Create(value);
if (value == null)
{
return(BadRequest());
}
return(CreatedAtAction("Get", new { id = value.Id }, value));
}
public async Task <IActionResult> Put(int id, [FromBody] TransactionRequestModel model)
{
model = await service.Update(id, model);
if (model == null)
{
return(BadRequest());
}
return(Ok(model));
}
public async Task <ApiResponse> StockTansaction(TransactionRequestModel options)
{
ApiResponse response = new ApiResponse();
List <string> TypeList = new List <string> {
"Add", "Sale"
};
if (!TypeList.Contains(options.Type))
{
response.Message = $"type will be Add or Sale only.";
return(response);
}
var stock = await _context.Stocks.FirstOrDefaultAsync(x => x.ProductId == options.ProductId);
if (stock == null)
{
response.Message = $"No stock detail find for id: {options.ProductId}.";
return(response);
}
if (options.Type == "Add")
{
stock.AvailableQuantity += options.Quantity;
}
else if (options.Type == "Sale")
{
if (stock.AvailableQuantity < options.Quantity)
{
response.Message = $"Available quantity is less then sold quantity.";
return(response);
}
else
{
stock.AvailableQuantity -= options.Quantity;
}
}
stock.LastUpdated = DateTime.Now;
Transactions objTrans = new Transactions
{
ProductId = options.ProductId,
Type = options.Type,
Quantity = options.Quantity,
TransactionDate = DateTime.Now,
};
await _context.Transactions.AddAsync(objTrans);
await _context.SaveChangesAsync();
response.Message = $"Transaction compleated.";
response.Status = 1;
return(response);
}
/// <summary>
/// Requests the transaction.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
/// <exception cref="Exception">
/// Not Enough
/// or
/// Receiver not sharehoder Yet
/// </exception>
public async Task <bool> RequestTransaction(TransactionRequestModel model)
{
var check = _shareAccountRepository.GetById(model.ShareAccountId)?.ShareAmount;
if (check < model.Amount)
{
throw new Exception("Not Enough");
}
// kiem tra thang kia la sharehoder chua
var check2 = _shareholderRepository.GetManyAsNoTracking(x =>
x.CompanyId == model.CompanyId && x.UserProfileId == model.ReceiverProfileId).First();
if (check2 == null)
{
throw new Exception("Receiver not sharehoder Yet");
}
var reciverShareAccount = _shareAccountRepository.GetManyAsNoTracking(x =>
x.ShareholderId == check2.ShareholderId && x.ShareTypeCode == "STD02").First();
// tao 2 transaction
var transactionIn = _transactionRepository.Insert(new Transaction
{
TransactionAmount = model.Amount,
ShareAccountId = reciverShareAccount.ShareAccountId,
TransactionTypeCode = "IN",
TransactionValue = model.Value,
TransactionStatusCode = "RQ",
Message = model.Message,
TransactionDate = DateTimeOffset.Now.ToUnixTimeSeconds()
});
var transactionOut = _transactionRepository.Insert(new Transaction
{
TransactionAmount = model.Amount,
ShareAccountId = model.ShareAccountId,
TransactionTypeCode = "OUT",
TransactionValue = model.Value,
TransactionStatusCode = "RQ",
Message = model.Message,
TransactionDate = DateTimeOffset.Now.ToUnixTimeSeconds()
});
// tao transaction request
_transactionRequestRepository.Insert(new TransactionRequest
{
RequestMessage = model.Message,
TransactionInId = transactionIn.Entity.TransactionId,
TransactionOutId = transactionOut.Entity.TransactionId,
});
await _unitOfWork.CommitAsync();
return(true);
}
public async Task <IActionResult> CreateAsync(int groupId, [FromBody] TransactionRequestModel transaction)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await transactionsService.CreateAsync(groupId, User, transaction);
return(HandlePostResult($"groups/{groupId}/transactions", result));
}
public async Task <IActionResult> UpdateAsync(int groupId, int id, [FromBody] TransactionRequestModel transaction)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await transactionsService.UpdateAsync(User, groupId, id, transaction);
return(HandlePutResult(result));
}
/// <summary>
/// Makes a transaction of amount based on type
/// </summary>
/// <param name="type">Withdraw or Deposit</param>
/// <param name="amount">Transaction Amount</param>
public void MakeTransaction(TransactionRequestModel request)
{
decimal amount = request.Amount > (decimal)0.00 ? Math.Round(request.Amount, 2) : 0;
Transactions.Add(new Transaction(new TransactionInputModel
{
TransactionID = Guid.NewGuid(),
Type = request.Type,
Created = DateTime.Now,
Amount = amount,
BankID = this.BankID
}));
}
public async Task <IActionResult> StockTansaction([FromBody] TransactionRequestModel options)
{
var cat = await tansactionService.StockTansaction(options);
if (cat.Status == 1)
{
return(Ok(cat));
}
else
{
return(NotFound(cat));
}
}
//Pass invalid model
public async Task Transaction_Model_State_Test()
{
var client = _factory.CreateClient();
TransactionRequestModel objTransaction = new TransactionRequestModel
{
ProductId = 0,
Quantity = 0
};
var response = await client.PostAsync("api/Transaction/StockTansaction", new StringContent(
JsonConvert.SerializeObject(objTransaction),
Encoding.UTF8,
"application/json"));
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
}
private PendingTransaction Create(TransactionRequestModel tranRM)
{
var newTransaction = new PendingTransaction
{
From = tranRM.From,
To = tranRM.To,
SenderPublicKey = tranRM.SenderPubKey,
Value = tranRM.Value,
Fee = tranRM.Fee,
DateCreated = tranRM.DateCreated,
SenderSignature = tranRM.SenderSignature
};
return(newTransaction);
}
//Pass valid model
//Pass Sale in Type
//Pass quantity more than available quantity in stock
public async Task Transaction_Stock_Remove_Quantity_Not_Found_Test()
{
var client = _factory.CreateClient();
TransactionRequestModel objTransaction = new TransactionRequestModel
{
ProductId = 1,
Quantity = 55,
Type = "Sale"
};
var response = await client.PostAsync("api/Transaction/StockTansaction", new StringContent(
JsonConvert.SerializeObject(objTransaction),
Encoding.UTF8,
"application/json"));
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public IActionResult Send([FromBody] TransactionRequestModel transactionRM)
{
try
{
if (!ModelState.IsValid)
{
throw new Exception("Invalid input: " + ModelState.Values.FirstOrDefault().Errors.FirstOrDefault().ErrorMessage);
}
transactionService.ProcessNewIncomingTransaction(transactionRM);
}
catch (Exception ex)
{
return(BadRequest(new { errorMsg = $"Unable to add transaction to node: {ex}" }));
}
return(Ok("Transaction sucessfully added to node"));
}
private static void RunTransactionSamples()
{
output.AppendLine("\n Transaction Samples \n");
var genericOperation = new GenericTransactionOperation("KV");
genericOperation.Add("KV", new Dictionary <string, object>
{
{ "Value", "val2" },
{ "Key", "tr2" },
{ "Verb", "set" },
{ "Flags", 64 },
});
var txnRequest = new TransactionRequestModel
{
Operations = new List <ITransactionOperation>
{
new KeyValueTransactionOperation
{
KeyValueOperation = new KeyValueOperation
{
Base64EncodedValue = "raja",
Flags = 32,
Index = 2233,
Key = "tr",
Session = "abc",
Verb = OperationVerbs.Set
}
},
genericOperation
}
};
var results = _consulClient.V1.Transaction.CreateAsync(new ConsulRequest <TransactionRequestModel> {
RequestData = txnRequest
}).Result;
DisplayJson(results);
Assert.True(results.Data.Results.Count == 2);
}
//Pass valid Model
//Pass a valid category
//Pass Product Name which already exists in passing category
public async Task Same_Product_Name_In_Category_Test()
{
var client = _factory.CreateClient();
string name = TestHelpers.GetRandomString();
AddProductRequestModel objProduct = new AddProductRequestModel
{
CategoryId = 1,
Description = name,
Name = name,
Price = 100
};
//Adding Product to check same name
await client.PostAsync("api/Product/Add", new StringContent(
JsonConvert.SerializeObject(objProduct),
Encoding.UTF8,
"application/json"));
//Adding Stock in
TransactionRequestModel objTransaction = new TransactionRequestModel
{
ProductId = 1,
Quantity = 10,
Type = "Add"
};
await client.PostAsync("api/Transaction/StockTansaction", new StringContent(
JsonConvert.SerializeObject(objTransaction),
Encoding.UTF8,
"application/json"));
var response = await client.PostAsync("api/Product/Add", new StringContent(
JsonConvert.SerializeObject(objProduct),
Encoding.UTF8,
"application/json"));
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public async Task <ServiceResult <int> > CreateAsync(int groupId, ClaimsPrincipal user, TransactionRequestModel transaction)
{
var group = groupsRepository.Get(groupId);
if (group is null)
{
return(ServiceResult <int> .Error(404, "Group was not found"));
}
var authorizationResult = await authorizationService.AuthorizeAsync(user, group, GroupOperations.Read);
if (!authorizationResult.Succeeded)
{
return(ServiceResult <int> .Error(401, "Unauthorized"));
}
var authenticatedUser = await usersManager.GetUserAsync(user);
var transactionEntity = new Transaction()
{
Amount = transaction.Amount,
Description = transaction.Description,
CategoryId = transaction.CategoryId,
UserId = authenticatedUser.Id,
GroupId = groupId
};
var result = await transactionsRepository.CreateAsync(transactionEntity);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Could not create transaction"));
}
await actionService.CreateAsync(group.Id, authenticatedUser.Id, "Transaction", $"{authenticatedUser.UserName} has added transaction");
return(ServiceResult <int> .Success(TransactionViewModel.FromModel(result)));
}
public async Task <ServiceResult <int> > UpdateAsync(ClaimsPrincipal user, int groupId, int transactionId, TransactionRequestModel transaction)
{
var group = groupsRepository.Get(groupId);
if (group is null)
{
return(ServiceResult <int> .Error(404, "Group was not found"));
}
var authorizationResult = await authorizationService.AuthorizeAsync(user, group, GroupOperations.Write);
if (!authorizationResult.Succeeded)
{
return(ServiceResult <int> .Error(401, "Unauthorized"));
}
var transactionEntity = transactionsRepository.Get(transactionId);
if (transactionEntity is null || transactionEntity.GroupId != groupId)
{
return(ServiceResult <int> .Error(404, "Transaction was not found"));
}
transactionEntity.Amount = transaction.Amount;
transactionEntity.Description = transaction.Description;
transactionEntity.CategoryId = transaction.CategoryId;
var result = await transactionsRepository.UpdateAsync(transactionEntity);
if (result is null)
{
return(ServiceResult <int> .Error(500, "Could not update transaction"));
}
return(ServiceResult <int> .Success(TransactionViewModel.FromModel(result)));
}
public static void SecondaryOtions()
{
if (ServiceLayer.Id != 0)
{
//Add options to use this example
Console.WriteLine("\t 1) For get status of transaction");
Console.WriteLine("\t 2) For transaction status by appId");
Console.WriteLine("\t 7) For cancel transaction");
Console.WriteLine("\t 8) For cancel transaction by client transaction id");
//To use these options you must first obtain the status of the transaction and that it be approved
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.WriteLine("\t To use these options you must firts approve the transaction");
Console.WriteLine("\t 3) For annulment transaction");
Console.WriteLine("\t 4) For get annulment status");
Console.WriteLine("\t 5) For reimbursement transaction");
Console.WriteLine("\t 6) For reimbursement transaction by client id");
Console.ResetColor();
//End
Console.WriteLine("\t Ctrl + N) For new transaction press Ctrl + N");
ConsoleKeyInfo cky;
do
{
cky = Console.ReadKey(false);
switch (cky.Key)
{
case ConsoleKey.D1:
case ConsoleKey.NumPad1:
//Get transaction status by transaction id
ServiceLayer.GetStatusTransaction(ServiceLayer.Id);
break;
case ConsoleKey.D2:
case ConsoleKey.NumPad2:
//Get status of transaction by client transaction id
ServiceLayer.GetStatusByClientTransactionId(Data.ClientTransactionId);
break;
case ConsoleKey.D3:
case ConsoleKey.NumPad3:
//Validate if transacction was approved
if (ServiceLayer.Approved)
{
//If transaction was approved i can annulment
ServiceLayer.Annulment(ServiceLayer.Id);
}
else
{
//otherwise show a message
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The transaction must be approved");
Console.ResetColor();
}
break;
case ConsoleKey.D4:
case ConsoleKey.NumPad4:
//Check if transaction was approved
if (ServiceLayer.Approved)
{
//Get annulment status by annulment id
ServiceLayer.GetAnnulmentStatus(ServiceLayer.AnnulmentId);
}
else
{
//Otherwise show message
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The transaction must be approved");
Console.ResetColor();
}
break;
case ConsoleKey.D5:
case ConsoleKey.NumPad5:
//Get transaction id for refund
Console.Write("Enter transaction ID for refund: ");
var idTx = Console.ReadLine();
//Send refund
ServiceLayer.Reimbursemet(long.Parse(idTx));
break;
case ConsoleKey.D6:
case ConsoleKey.NumPad6:
//Request reimbursement by client transaction id
ServiceLayer.ReimbursemetByClientTransactionId(Data.ClientTransactionId);
break;
case ConsoleKey.D7:
case ConsoleKey.NumPad7:
//Request Cancel transaction
ServiceLayer.Cancel(ServiceLayer.Id);
break;
case ConsoleKey.D8:
case ConsoleKey.NumPad8:
//Request Cancel transaction
ServiceLayer.CancelByClientId(Data.ClientTransactionId);
break;
case ConsoleKey.Escape:
Environment.Exit(0);
break;
case ConsoleKey.N:
if ((cky.Modifiers & ConsoleModifiers.Control) != 0)
{
NewTransaction = true;
Data = GenerateTx();
}
break;
}
} while (cky.Key != ConsoleKey.Escape && !NewTransaction);
}
}
/// <summary>
/// Requests money from an email address.
/// https://developers.coinbase.com/api/v2?python#request-money
/// </summary>
/// <param name="client"></param>
/// <param name="accountId"></param>
/// <param name="req"></param>
/// <returns></returns>
public static TransactionModel RequestMoney(this Client client, String accountId, TransactionRequestModel req)
{
var request = new RestRequest("/accounts/{account_id}/transactions");
request.AddUrlSegment("account_id", accountId);
request.Method = Method.POST;
request.AddJsonBody2(req);
var rest = client.GetRestClient(request);
var response = rest.Execute <GetResponseModel <TransactionModel> >(request);
if (!response.IsSuccessful)
{
var error = JsonConvert.DeserializeObject <ResponseErrorModel>(response.Content);
throw new Exception(error.Errors.First().Message);
}
return(response.Data.Data.First());
}
