/// <summary>
/// 得到一个对象实体
/// </summary>
public TransactionDetails DataRowToModel(DataRow row)
{
TransactionDetails model = new TransactionDetails();
if (row != null)
{
if (row["ID"] != null)
{
model.ID = row["ID"].ToString();
}
if (row["TRANSACTIONAMOUNT"] != null && row["TRANSACTIONAMOUNT"].ToString() != "")
{
model.TRANSACTIONAMOUNT = decimal.Parse(row["TRANSACTIONAMOUNT"].ToString());
}
if (row["TRANSACTIONDESCRIPTION"] != null)
{
model.TRANSACTIONDESCRIPTION = row["TRANSACTIONDESCRIPTION"].ToString();
}
if (row["TRANSACTIONPROPORTION"] != null && row["TRANSACTIONPROPORTION"].ToString() != "")
{
model.TRANSACTIONPROPORTION = decimal.Parse(row["TRANSACTIONPROPORTION"].ToString());
}
if (row["TRANSACTIONDATE"] != null && row["TRANSACTIONDATE"].ToString() != "")
{
model.TRANSACTIONDATE = DateTime.Parse(row["TRANSACTIONDATE"].ToString());
}
if (row["PLANDATE"] != null && row["PLANDATE"].ToString() != "")
{
model.PLANDATE = DateTime.Parse(row["PLANDATE"].ToString());
}
if (row["TRANSACTIONTYPE"] != null && row["TRANSACTIONTYPE"].ToString() != "")
{
model.TRANSACTIONTYPE = int.Parse(row["TRANSACTIONTYPE"].ToString());
}
if (row["EMPLOYEEID"] != null)
{
model.EMPLOYEEID = row["EMPLOYEEID"].ToString();
}
if (row["PROJECTID"] != null)
{
model.PROJECTID = row["PROJECTID"].ToString();
}
if (row["CREATEDATE"] != null && row["CREATEDATE"].ToString() != "")
{
model.CREATEDATE = DateTime.Parse(row["CREATEDATE"].ToString());
}
if (row["ISDELETED"] != null && row["ISDELETED"].ToString() != "")
{
if ((row["ISDELETED"].ToString() == "1") || (row["ISDELETED"].ToString().ToLower() == "true"))
{
model.ISDELETED = true;
}
else
{
model.ISDELETED = false;
}
}
}
return(model);
}
private static WalletTransaction.Output MarshalWalletTransactionOutput(TransactionDetails.Types.Output o, Transaction.Output txOutput)
{
if (o.Mine)
return new WalletTransaction.Output.ControlledOutput(txOutput.Amount, new Account(o.Account), o.Internal);
else
return new WalletTransaction.Output.UncontrolledOutput(txOutput.Amount, txOutput.PkScript);
}
/// <summary>
/// Method returns string value of TransactionDetails object
/// </summary>
/// <param name="oTransactionDetails"></param>
/// <returns>string value containing all TransactionDetails values</returns>
public static string TransactionDetailsToString(this TransactionDetails oTransactionDetails)
{
if (oTransactionDetails == null)
{
return("");
}
var items = new Dictionary <string, string>()
{
{ "Comments", oTransactionDetails.Comments },
{ "InvoiceNumber", oTransactionDetails.InvoiceNumber },
{ "DynamicMerchantName", oTransactionDetails.DynamicMerchantName },
{ "PONumber", oTransactionDetails.PONumber },
{ "OrderId", oTransactionDetails.OrderId },
{ "Ip", oTransactionDetails.Ip },
{ "ReferenceNumber", oTransactionDetails.ReferenceNumber },
{ "TDate", oTransactionDetails.TDate },
{ "TransactionOrigin", oTransactionDetails.TransactionOrigin.ToString() },
{ "TransactionOriginSpecified", oTransactionDetails.TransactionOriginSpecified.ToString() },
{ "TerminalID", oTransactionDetails.Terminal != null ? oTransactionDetails.Terminal.TerminalID : null },
{ "OfflineApprovalType", oTransactionDetails.OfflineApprovalType.ToString() },
{ "OfflineApprovalTypeSpecified", oTransactionDetails.OfflineApprovalTypeSpecified.ToString() },
{ "InquiryRateReference", InquiryRateReferenceToString(oTransactionDetails.InquiryRateReference) },
};
return(Environment.NewLine + "TransactionDetails Information : " + Environment.NewLine + items.NotNullDataToString());
}
public bool Update(TransactionDetails _ref)
{
bool rtval = false;
try
{
pEntity.trn_transactionsales_detail_Update(
_ref.sales_detail_id,
_ref.productcode,
_ref.product_id,
_ref.RetailPrice,
_ref.QTY,
_ref.TotalAmount,
_ref.isCheckedout
);
pEntity.SaveChanges();
rtval = true;
}
catch (Exception ex)
{
_err = ex.ToString();
a.logModule = "Sales Detail CS";
a.logError = ex.ToString();
a.DateCreated = DateTime.Now;
lg.InsertLog(a);
rtval = false;
}
return(rtval);
}
/// <summary>
/// Example starting the transaction with the demo basket
/// </summary>
protected void btn_StartCardPayment_Click(object sender, EventArgs e)
{
CNPMerchantWebService merchantWS = new CNPMerchantWebService();
TransactionDetails td = new TransactionDetails();
td.currencyCode = Basket.getBasket()[0].currencyCode;
td.description = "My first transaction";
td.goodsList = Basket.getBasket().ToArray();
td.merchantId = "000000000000001";
td.terminalID = "TEST TID";
td.returnURL = Request.Url.OriginalString.Replace("Checkout.aspx", "Result.aspx");
td.totalAmount = Basket.getTotalAmount().ToString();
td.currencyCodeSpecified = true;
td.languageCode = "en";
td.orderId = (new Random()).Next(10000).ToString();
td.merchantLocalDateTime = String.Format("{0:dd.MM.yyyy HH:mm:ss}", DateTime.Now);
td.purchaserName = "IVANOV IVAN";
td.purchaserEmail = "*****@*****.**";
StartTransactionResult result = merchantWS.startTransaction(td);
if (result.success)
{
Session["customerReference"] = result.customerReference;
Response.Redirect(result.redirectURL);
}
else
{
lbl_Error.Text = result.errorDescription;
}
}
public void TestTransactionDetailsToJson()
{
var details = new TransactionDetails
{
productId = "testProductId",
transactionId = "testTransactionId",
price = 90m,
currency = "USD",
receipt = "testReceipt",
extras = new Dictionary <string, object>
{
{ "testKey", "testValue" },
{ "testNumber", 56 }
}
};
var jsonDictionary = details.ToJsonDictionary();
Assert.AreEqual(new Dictionary <string, object>
{
{ "productId", "testProductId" },
{ "transactionId", "testTransactionId" },
{ "receipt", "testReceipt" },
{ "price", 90m },
{ "currency", "USD" },
{ "extras", new Dictionary <string, object>
{
{ "testKey", "testValue" },
{ "testNumber", 56 }
} }
}, jsonDictionary);
}
public ActionResult Operations()
{
try
{
if (Session["UserName"] == null)
{
return(RedirectToAction("Index", "Home"));
}
if (Session["TransferSuccess"] != null)
{
string[] Success = Session["TransferSuccess"].ToString().Split('@');
ViewBag.Success = Success[0].ToString();
ViewBag.Update = Success[1].ToString();
Session["TransferSuccess"] = null;
}
TransactionDetails transactiondetails = new TransactionDetails();
transactiondetails.TransactionDateTime = DateTime.Now;
ViewBag.TransModeList = TransactionModeList();
return(View(transactiondetails));
}
catch (Exception ex)
{
throw ex;
}
}
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;
}
}
public async Task <ProcessPaymentResult> ProcessPayment(PaymentDetails paymentDetails)
{
// Wraps the call to repo with polly policy defined above
return(await ExecuteWithRetry(async() =>
{
var paymentDetailsID =
await _paymentRepository.SavePaymentDetails(_mapper.Map <PaymentDetailsDTO>(paymentDetails));
var bankResponse = await _simulatedBankService.GetBankResponse(paymentDetails);
_logger
// ForContext - The propertyName will be displayed as a field in ElasticSearch. This is more concise and clean
.ForContext("PaymentDetailsID", paymentDetailsID)
// Example of destructing object built into Serilog
.Information("Received bank response {@BankResponse}", bankResponse);
var transactionDetails = new TransactionDetails(
bankResponse.TransactionID,
bankResponse.Status == TransactionStatus.Success,
paymentDetailsID
);
await _transactionService.SaveTransactionDetails(transactionDetails);
return new ProcessPaymentResult(transactionDetails.Success, transactionDetails.TransactionID);
}));
}
/// <summary>
/// Gets the objects for the TRANSACTION_DETAIL relationship.
/// </summary>
public TransactionDetails GetTransactionDetails()
{
TransactionDetails transactiondetails = new TransactionDetails();
TransactionDetailBase.ServiceObject.FillByLoanApplication(transactiondetails, _id);
return(transactiondetails);
}
/// <summary>
/// Attempt to process a payment (Card Details and Transaction)
/// </summary>
/// <param name="cardDetails">Card details to use for the payment</param>
/// <param name="transaction">Currency and amount to process</param>
/// <returns>Model containing the result of the Payment and, if applicable, Transaction ID</returns>
public Task <PaymentResponse> ProcessPaymentAsync(CardDetails cardDetails, TransactionDetails transaction)
{
return(Task.FromResult(new PaymentResponse
{
Successful = true,
TransactionId = Guid.NewGuid()
}));
}
public void SelectTransactionDetail(TransactionDetails details)
{
//Debug.Log("ethkeymanager:: SetTransactionDetails");
if (this.TransactionDetailsObject != null)
{
TransactionDetailsHolder detailHolder = this.TransactionDetailsObject.GetComponent <TransactionDetailsHolder>();
detailHolder.SetTransactionDetails(details);
}
}
public void Remove(ModelBase obj)
{
if (obj is Account)
{
Accounts.Remove(obj as Account);
var transactionIds = Transactions.SelectMany(t => t.Details).Where(t => t.AccountId == ((Account)obj).Id).Select(t => t.TransactionId);
foreach (var transId in transactionIds)
{
Remove(Transactions.FirstOrDefault(t => t.Id == transId));
}
foreach (var schedTrans in ScheduledTransactions.Where(t => t.FromAccountId == ((Account)obj).Id || t.ToAccountId == ((Account)obj).Id).ToList())
{
Remove(schedTrans);
}
}
else if (obj is Transaction)
{
Transactions.Remove(obj as Transaction);
foreach (var detail in TransactionDetails.Where(t => t.TransactionId == ((Transaction)obj).Id).ToList())
{
Remove(detail);
}
}
else if (obj is TransactionDetail)
{
TransactionDetails.Remove(obj as TransactionDetail);
}
else if (obj is Receipt)
{
Receipts.Remove(obj as Receipt);
}
else if (obj is ScheduledTransaction)
{
ScheduledTransactions.Remove(obj as ScheduledTransaction);
foreach (var detail in ScheduledTransactionDetails.Where(t => t.ScheduledTransactionId == ((ScheduledTransaction)obj).Id).ToList())
{
Remove(detail);
}
}
else if (obj is ScheduledTransactionDetail)
{
ScheduledTransactionDetails.Remove(obj as ScheduledTransactionDetail);
}
else if (obj is Category)
{
Categories.Remove(obj as Category);
}
else if (obj is Product)
{
Products.Remove(obj as Product);
}
}
private IEnumerable <TransactionDetail> GetTransactionDetails(DateTime upToDate, Account acct)
{
var transactionDetailsForAccount = TransactionDetails.Where(t => t.AccountId == acct.Id).ToList();
var transactionIds = transactionDetailsForAccount.Select(t => t.TransactionId).Distinct();
var transactionsForAccount = Transactions.Where(t => transactionIds.Contains(t.Id));
var priorDatesTransactionIds = transactionsForAccount.Where(t => t.Date <= upToDate).Select(t => t.Id);
return(transactionDetailsForAccount.Where(t => priorDatesTransactionIds.Contains(t.TransactionId)).ToList());
}
void SelectTransaction()
{
if (this.transactions == null || !this.transactions.HasTransactions)
{
throw new Exception("Cannot select a transaction right now");
}
selectedTransaction = this.transactions.Select(random.Next(0, this.transactions.Count));
this.editedValues = new TransactionDetails();
}
public ActionResult TransactionDetails(int id)
{
TransactionDetails objTDs = new TransactionDetails(id);
Payments objPs = new Payments(id);
Transaction objT = new Transaction(id);
Refunds objRs = new Refunds(id);
var tuple = new Tuple <TransactionDetails, Payments, Transaction, Refunds>(objTDs, objPs, objT, objRs);
return(View(tuple));
}
void DeleteSelectedTransaction()
{
if (this.transactions == null || !this.transactions.HasTransactions)
{
throw new Exception("Cannot delete a transaction right now");
}
this.transactions.Delete(random.Next(0, this.transactions.Count));
selectedTransaction = null;
this.editedValues = null;
}
private string GetMemo(TransactionDetails tx)
{
if ((StellarSdkConstants.MemoTextTypeName.Equals(tx.MemoType, StringComparison.OrdinalIgnoreCase) ||
StellarSdkConstants.MemoIdTypeName.Equals(tx.MemoType, StringComparison.OrdinalIgnoreCase)) &&
!string.IsNullOrEmpty(tx.Memo))
{
return(tx.Memo);
}
return(null);
}
public async Task SaveTransactionDetails_ShouldReturnFalse_WhenTransactionDetailsAreNotSaved()
{
var transactionDetails = new TransactionDetails(932132, true, 104);
_mockTransactionRepository.Setup(x =>
x.SaveTransactionDetails(It.IsAny <TransactionDetailsDTO>())).ReturnsAsync(false);
var actual = await _transactionService.SaveTransactionDetails(transactionDetails);
Assert.False(actual);
}
void AddNewTransaction()
{
if (this.transactions == null)
{
throw new Exception("Cannot edit a transaction right now");
}
selectedTransaction = this.transactions.AddNew();
this.editedValues = new TransactionDetails();
selectedTransaction.Select();
}
public void Must_ReturnWhateverMatchesTheMatcherReturns(
IList <Tuple <StatementEntry, TransactionDetails> > expectedMatches)
{
Setup_PrimaryItemMatcher_ToReturn(expectedMatches);
var statementEntries = new StatementEntry[] { new StatementEntry() };
var transactions = new TransactionDetails[] { new TransactionDetails() };
var matchGroups = target.Compare(statementEntries, transactions).MatchGroups;
Assert.AreSame(expectedMatches, matchGroups.First());
}
/// <summary>
/// 更新一条数据
/// </summary>
public bool Update(TransactionDetails model)
{
StringBuilder strSql = new StringBuilder();
strSql.Append("update transactiondetails set ");
strSql.Append("TRANSACTIONAMOUNT=@TRANSACTIONAMOUNT,");
strSql.Append("TRANSACTIONDESCRIPTION=@TRANSACTIONDESCRIPTION,");
strSql.Append("TRANSACTIONPROPORTION=@TRANSACTIONPROPORTION,");
strSql.Append("TRANSACTIONDATE=@TRANSACTIONDATE,");
strSql.Append("PLANDATE=@PLANDATE,");
strSql.Append("TRANSACTIONTYPE=@TRANSACTIONTYPE,");
strSql.Append("EMPLOYEEID=@EMPLOYEEID,");
strSql.Append("PROJECTID=@PROJECTID,");
strSql.Append("CREATEDATE=@CREATEDATE,");
strSql.Append("ISDELETED=@ISDELETED");
strSql.Append(" where ID=@ID ");
MySqlParameter[] parameters =
{
new MySqlParameter("@TRANSACTIONAMOUNT", MySqlDbType.Decimal, 12),
new MySqlParameter("@TRANSACTIONDESCRIPTION", MySqlDbType.VarChar, 255),
new MySqlParameter("@TRANSACTIONPROPORTION", MySqlDbType.Decimal, 3),
new MySqlParameter("@TRANSACTIONDATE", MySqlDbType.DateTime),
new MySqlParameter("@PLANDATE", MySqlDbType.DateTime),
new MySqlParameter("@TRANSACTIONTYPE", MySqlDbType.Int32, 2),
new MySqlParameter("@EMPLOYEEID", MySqlDbType.VarChar, 36),
new MySqlParameter("@PROJECTID", MySqlDbType.VarChar, 36),
new MySqlParameter("@CREATEDATE", MySqlDbType.DateTime),
new MySqlParameter("@ISDELETED", MySqlDbType.Bit),
new MySqlParameter("@ID", MySqlDbType.VarChar, 36)
};
parameters[0].Value = model.TRANSACTIONAMOUNT;
parameters[1].Value = model.TRANSACTIONDESCRIPTION;
parameters[2].Value = model.TRANSACTIONPROPORTION;
parameters[3].Value = model.TRANSACTIONDATE;
parameters[4].Value = model.PLANDATE;
parameters[5].Value = model.TRANSACTIONTYPE;
parameters[6].Value = model.EMPLOYEEID;
parameters[7].Value = model.PROJECTID;
parameters[8].Value = model.CREATEDATE;
parameters[9].Value = model.ISDELETED;
parameters[10].Value = model.ID;
int rows = DbHelperMySQL.ExecuteSql(strSql.ToString(), parameters);
if (rows > 0)
{
return(true);
}
else
{
return(false);
}
}
override public string[] GetStatements()
{
if (!_isExistingCustomer)
{
throw new Exception("Statements may only be obtained for an existing customer");
}
// send the name, 20
bool moreTransactions = true;
short transactionCount = 0;
TransactionDetails [] transactionArray;
// set up a persistent connection
_clientContextObj.ConnectionUsage = ConnectionTypes.PersistentOpen;
// set up an empty array list
ArrayList alTransactions = new ArrayList();
try
{
while (moreTransactions)
{
transactionArray = new TransactionDetails[0];
moreTransactions = _Handler.GetStatements(_name, 20, ref transactionCount, ref transactionArray, ref _clientContextObj);
foreach (TransactionDetails td in transactionArray)
{
alTransactions.Add(td);
}
}
_Handler.ClosePersistentConnection(ref _clientContextObj);
}
catch (Exception)
{
// close the persistent connection
_Handler.ClosePersistentConnection(ref _clientContextObj);
// as all of the input values should have been valid, we are not looking
// for any particular errors
throw;
}
string[] returnLines = new string[alTransactions.Count];
for (int index = 0; index < returnLines.Length; index++)
{
TransactionDetails thisTD = (TransactionDetails)alTransactions[index];
returnLines[index] = thisTD.TXN_ACCT_NUM + " " + thisTD.TXN_TYPE + " " + thisTD.TXN_DATE + " " + thisTD.TXN_AMOUNT.ToString();
}
return(returnLines);
}
private void buttonSave_Click(object sender, EventArgs e)
{
//MessageBox.Show("I am Clicked");
TransactionClass transaction = new TransactionClass();
transaction.TransactionType = labelSale.Text.Trim();
transaction.TransactioDate = DateTime.Now;
transaction.SysUser = "******";
transaction.GrandTotal = decimal.Parse(labelGrandTotal.Text);
transaction.TransactionDetails = dtTransaction;
bool success = false;
using (TransactionScope scope = new TransactionScope())
{
int transactionID = -1;
bool w = transactionDAL.Insert_Transaction(transaction, out transactionID);//Error in this section
for (int i = 0; i < dtTransaction.Rows.Count; i++)
{
int ProductID = int.Parse(dtTransaction.Rows[i][0].ToString());
//string ProductName = dtTransaction.Rows[i][1].ToString();
decimal Rate = decimal.Parse(dtTransaction.Rows[i][2].ToString());
decimal Quantity = decimal.Parse(dtTransaction.Rows[i][3].ToString());
decimal Discount = decimal.Parse(dtTransaction.Rows[i][4].ToString());
decimal Tax = decimal.Parse(dtTransaction.Rows[i][5].ToString());
decimal Total = decimal.Parse(dtTransaction.Rows[i][6].ToString());
TransactionDetails td = new TransactionDetails();
td.ProductID = ProductID;
td.Rate = Rate;
td.Quantity = Quantity;
td.Discount = Discount;
td.Tax = Tax;
td.Total = Total;
bool x = invDAL.Decrease_Inventory(ProductID, Quantity); //For Decreasing Product Quantity
bool y = transactionDAL.Insert_TransactionDetails(td);
success = w && x && y; // DO this after solving error
//success = y; //Comment this after solving error
}
if (success == true)
{
scope.Complete();
MessageBox.Show("Sale Transaction Completed.");
}
else
{
MessageBox.Show("Sale Transaction Failed.");
}
}
//Print Function Here
//MessageBox.Show("Print Me");
}
/// <summary>
/// Gets all the available objects.
/// </summary>
public virtual TransactionDetails GetAll()
{
// create a new instance of the return object
TransactionDetails objects = new TransactionDetails();
// fill the objects
this.Fill(objects);
// return the filled object from the service
return(objects);
}
public IActionResult Details(TransactionDetails details)
{
List <Transaction> transactions = new List <Transaction>();
HttpResponseMessage response = client.GetAsync(client.BaseAddress + "/Transactions/" + details.AccNumber + "/" + details.FromDate.ToString("yyyy-MM-dd") + "/" + details.ToDate.ToString("yyyy-MM-dd")).Result;
if (response.IsSuccessStatusCode)
{
string data = response.Content.ReadAsStringAsync().Result;
transactions = JsonConvert.DeserializeObject <List <Transaction> >(data);
return(View(transactions));
}
return(BadRequest());
}
private void AddButton_Click(object sender, EventArgs e)
{
// TODO: add the checks for the input fields used
Program.myController.AddTransaction((int)comboBox1.SelectedValue, DiscounttextBox.Value, ValueTextBox.Value, ReceivedValueTextBox.Value, checkBox1.Checked);
Form6_Load(sender, e);
// show the add transaction details
TransactionDetails detailsForm = new TransactionDetails(true, (int)DGV.Rows[DGV.RowCount - 1].Cells[0].Value);
detailsForm.ShowDialog(this);
DGV.ClearSelection();
}
public IActionResult Delete(TransactionDetails dee)
{
var tr = transactionService.GetTransaction(dee.TransactionID);
var link = transactionLinkService.GetTransactionLinks().Where(s => s.TransactionID == tr.Id).FirstOrDefault();
var payment = paymentService.GetPayments().Where(s => s.LinkID == link.Id).FirstOrDefault();
transactionLinkService.DeleteTransactionLink(link.Id);
transactionService.DeleteTransaction(tr.Id);
if (payment != null)
{
paymentService.DeletePayment(payment.Id);
}
return(View(nameof(Expired)));
}
public CreditCardAuthorizationResult Authorize(CreditCardPayment payment, String description, Project.MVC.Entity.Models.Address billingAddress)
{
if (billingAddress == null)
{
throw new ArgumentNullException("billingAddress");
}
if (payment == null)
{
throw new ArgumentNullException("payment");
}
var result = new CreditCardAuthorizationResult();
AuthorizeNetAuthorizationResult authResult = _authorizeNetService
.Authorize(payment.CreditCardNumber, payment.Expiration.ToString("MM/yy"), payment.CVV, payment.Amount, description, billingAddress);
if (authResult.Success)
{
result.Success = true;
CreditCardTransaction transaction = new CreditCardTransaction()
{
Amount = authResult.Amount,
AuthorizationCode = authResult.AuthorizationCode,
CardLastFour = payment.CreditCardNumber.Substring(payment.CreditCardNumber.Length - 4),
PaymentMethod = PaymentMethod.CreditCard,
TransactionDate = DateTime.Now,
TransactionType = TransactionType.Authorization
};
TransactionDetails transactionDetails = new TransactionDetails()
{
TransactionProcessor = TransactionProcessor.AuthorizeNet,
TransactionProcessorTransactionID = authResult.MerchantTransactionID
};
transaction.TransactionDetails = transactionDetails;
result.Transaction = transaction;
return(result);
}
result.Success = false;
result.Errors.AddRange(authResult.Errors);
return(result);
}
public async Task <IActionResult> RemoveTransaction([FromBody] JObject transRes)
{
TransactionDetails transaction = _context.TransactionDetails.Where(o => o.ID == Convert.ToInt32(transRes["transId"].ToString())).FirstOrDefault();
if (transaction == null)
{
return(BadRequest());
}
_context.TransactionDetails.Remove(transaction);
await _context.SaveChangesAsync();
return(Ok());
}
public static TransactionDetails Get_Transaction(string xml_content)
{
var list = new TransactionDetails();
try
{
XDocument xdoc = XDocument.Parse(xml_content);
list = (from node in xdoc.Elements(Xml_Nodes.TRANSACTION)
select new TransactionDetails
{
id = node.Element(Xml_Nodes.ID)?.Value,
prev_id = node.Element(Xml_Nodes.PREV_ID)?.Value,
init_id = node.Element(Xml_Nodes.INIT_ID)?.Value,
amount = node.Element(Xml_Nodes.AMOUNT)?.Value,
currency = node.Element(Xml_Nodes.CURRENCY)?.Value,
description = node.Element(Xml_Nodes.DECRIPTION)?.Value,
cartid = node.Element(Xml_Nodes.CARTID)?.Value,
test = node.Element(Xml_Nodes.TEST)?.Value,
auth_code = node.Element(Xml_Nodes.AUTH).Element(Xml_Nodes.CODE)?.Value,
auth_message = node.Element(Xml_Nodes.AUTH).Element(Xml_Nodes.MESSAGE)?.Value,
auth_status = node.Element(Xml_Nodes.AUTH).Element(Xml_Nodes.STATUS)?.Value,
auth_statustxt = node.Element(Xml_Nodes.AUTH).Element(Xml_Nodes.STATUS_TXT)?.Value,
card_number = node.Element(Xml_Nodes.CARD).Element(Xml_Nodes.NUMBER)?.Value,
card_type = node.Element(Xml_Nodes.CARD).Element(Xml_Nodes.TYPE)?.Value,
card_country = node.Element(Xml_Nodes.CARD).Element(Xml_Nodes.COUNTRY)?.Value,
card_country_iso = node.Element(Xml_Nodes.CARD).Element(Xml_Nodes.COUNTRY_ISO)?.Value,
billing = new Address
{
Title = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.TITLE)?.Value,
First_Name = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.FNAME)?.Value,
Last_Name = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.SNAME)?.Value,
Address_Line = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.ADDR1)?.Value,
Address_Line2 = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.ADDR2)?.Value,
Address_Line3 = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.ADDR3)?.Value,
City = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.CITY)?.Value,
State = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.REGION)?.Value,
Country = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.COUNTRY)?.Value,
ZipCode = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.ZIP)?.Value,
Mobile = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.TEL)?.Value,
Email = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.EMAIL)?.Value,
IP = node.Element(Xml_Nodes.BILLING).Element(Xml_Nodes.IP)?.Value
}
}
).FirstOrDefault();
}
catch { }
return(list);
}
public static WalletTransaction MarshalWalletTransaction(TransactionDetails tx)
{
var transaction = Transaction.Deserialize(tx.Transaction.ToByteArray());
var hash = new Sha256Hash(tx.Hash.ToByteArray());
var inputs = tx.Debits
.Select(i => new WalletTransaction.Input(i.PreviousAmount, new Account(i.PreviousAccount)))
.ToArray();
var outputs = tx.Outputs
.Select((o, index) => MarshalWalletTransactionOutput(o, transaction.Outputs[index]))
.ToArray();
var fee = inputs.Length == transaction.Inputs.Length ? (Amount?)tx.Fee : null;
var seenTime = DateTimeOffsetExtras.FromUnixTimeSeconds(tx.Timestamp);
return new WalletTransaction(transaction, hash, inputs, outputs, fee, seenTime);
}
public static WalletTransaction MarshalWalletTransaction(TransactionDetails tx)
{
var transaction = Transaction.Deserialize(tx.Transaction.ToByteArray());
var hash = new Sha256Hash(tx.Hash.ToByteArray());
var inputs = tx.Debits
.Select(i => new WalletTransaction.Input(i.PreviousAmount, new Account(i.PreviousAccount)))
.ToArray();
// There are two kinds of transactions to care about when choosing which outputs
// should be created: transactions created by other wallets (inputs.Length == 0)
// and those that spend controlled outputs from this wallet (inputs.Length != 0).
// If the transaction was created by this wallet, then all outputs (both controlled
// and uncontrolled) should be included. Otherwise, uncontrolled outputs can be
// ignored since they are not relevant (they could be change outputs for the other
// wallet or outputs created for another unrelated wallet).
var outputs = inputs.Length == 0
? tx.Credits.Select((o, i) => MarshalControlledOutput(o, transaction.Outputs[i])).ToArray()
: MarshalCombinedOutputs(transaction, tx.Credits.GetEnumerator());
var fee = inputs.Length == transaction.Inputs.Length ? (Amount?)tx.Fee : null;
var seenTime = DateTimeOffsetExtras.FromUnixTimeSeconds(tx.Timestamp);
return new WalletTransaction(transaction, hash, inputs, outputs, fee, seenTime);
}
private void button1_Click(object sender, EventArgs e)
{
if ((this.textBox1.Text==null) && (this.textBox1.Text.Length==0))
{
MessageBox.Show("Invalid TransactionId", "", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, MessageBoxOptions.DefaultDesktopOnly, false);
}
else
{
EzeResult result = EzeAPI.create().getTransaction(this.textBox1.Text);
if (result.getStatus() == Status.SUCCESS)
{
com.eze.api.TransactionDetails details = result.getResult().getTransactionDetails();
TransactionDetails td = new TransactionDetails(parent,details.getTxnId(),""+details.GetType(),""+details.getAmount(),"2015-10-23",result.getResult().getMerchant().getMerchantName(),result.getResult().getCustomer().getMobileNumber());
td.Show();
}
else
{
MessageBox.Show(result.getError().getMessage(), "", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, MessageBoxOptions.DefaultDesktopOnly, false);
}
}
}
protected override void ReadElement(XElement element)
{
element.ProcessChild(IdElement, e =>
Id = e.Value);
element.ProcessChild(AccountCodeElement, e =>
AccountCode = e.GetHrefLinkId());
element.ProcessChild(InvoiceNumberElement, e =>
InvoiceNumber = e.GetHrefLinkId(int.Parse));
element.ProcessChild(SubscriptionIdElement, e =>
SubscriptionId = e.GetHrefLinkId());
element.ProcessChild(ActionElement, e =>
{
Action = e.Value;
Type = e.ToEnum<TransactionType>();
});
element.ProcessChild(AmountInCentsElement, e =>
AmountInCents = e.ToInt());
element.ProcessChild(TaxInCentsElement, e =>
TaxInCents = e.ToInt());
element.ProcessChild(CurrencyElement, e =>
Currency = e.Value);
element.ProcessChild(StatusElement, e =>
Status = e.Value);
element.ProcessChild(ReferenceElement, e =>
Reference = e.Value);
element.ProcessChild(TestElement, e =>
Test = e.ToBool());
element.ProcessChild(VoidableElement, e =>
Voidable = e.ToBool());
element.ProcessChild(RefundableElement, e =>
Refundable = e.ToBool());
element.ProcessChild(CvvResultElement, e =>
{
CvvResultCode = e.Attribute("code").Value;
CvvResult = e.Value;
});
element.ProcessChild(AvsResultElement, e =>
{
AvsResultCode = e.Attribute("code").Value;
AvsResult = e.Value;
});
element.ProcessChild(AvsResultStreetElement, e =>
AvsResultStreet = e.Value);
element.ProcessChild(AvsResultPostalElement, e =>
AvsResultPostal = e.Value);
element.ProcessChild(CreatedAtElement, e =>
CreatedAt = e.ToDateTime());
element.ProcessChild(TransactionErrorElement, e =>
TransactionError = new RecurlyTransactionError(e));
element.ProcessChild(TransactionDetailsElement, e =>
Details = new TransactionDetails(e));
}
private static WalletTransaction.Output MarshalControlledOutput(TransactionDetails.Types.Output o, Transaction.Output txOutput) =>
new WalletTransaction.Output.ControlledOutput(txOutput.Amount, new Account(o.Account), o.Internal);
