public async Task <Payment> ProcessPaymentAsync(Payment newPayment, Guid userId)
{
var currency = await _unitOfWork
.Currencies
.GetByIdAsync(newPayment.CurrencyId);
if (currency is null)
{
throw new HttpResponseException($"Currency of Id {newPayment.CurrencyId} could not be found.")
.BadRequest();
}
var bankPayment = new BankPayment
{
Amount = newPayment.Amount,
CardNumber = newPayment.CardNumber,
Currency = currency.Name,
Cvv = newPayment.Cvv,
ExpirationMonth = newPayment.ExpirationMonth,
ExpirationYear = newPayment.ExpirationYear,
};
var result = await _bankSerice.ProcessPayment(bankPayment);
newPayment.Id = result.Id;
newPayment.IsSuccessful = result.Status == BankPaymentStatus.Succcessful;
newPayment.CreatedAt = DateTime.Now;
newPayment.UserId = userId;
await _unitOfWork.Payments.AddAsync(newPayment);
await _unitOfWork.CommitAsync();
return(newPayment);
}
public async Task <IActionResult> ProcessBankPayment
(
string inn,
string bic,
string accountNumber,
int vat,
decimal sum
)
{
var payment = new BankPayment
{
Inn = inn,
Bic = bic,
AccountNumber = accountNumber,
Vat = vat,
Sum = sum
};
var validationResult = payment.Validate();
if (!validationResult.IsValid)
{
return(Json(WrappedResponse <string> .Fail($"Неверный формат: {validationResult.Error}")));
}
using (var buffer = new MemoryStream())
{
using (var streamWriter = new StreamWriter(buffer))
{
await streamWriter.WriteLineAsync(payment.AsBankStatement());
}
return(File(buffer.ToArray(), MediaTypeNames.Application.Octet, ""));
}
}
public ActionResult DeleteConfirmed(int id)
{
BankPayment bankPayment = db.BankPayments.Find(id);
db.BankPayments.Remove(bankPayment);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IActionResult Add(BankPayment payment)
{
var result = bankPayment.Add(payment);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public ActionResult Edit([Bind(Include = "ID,Name,TransactionDate,TransactionNumber,AmountReceived")] BankPayment bankPayment)
{
if (ModelState.IsValid)
{
db.Entry(bankPayment).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(bankPayment));
}
public ActionResult Create([Bind(Include = "ID,Name,TransactionDate,TransactionNumber,AmountReceived")] BankPayment bankPayment)
{
if (ModelState.IsValid)
{
db.BankPayments.Add(bankPayment);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(bankPayment));
}
public async Task <BankPaymentResult> ProcessPayment(BankPayment payment)
{
var paymentResult = new BankPaymentResult
{
Id = Guid.NewGuid(),
Status = BankPaymentStatus.Succcessful
};
MakePayment(paymentResult);
return(await Task.FromResult(paymentResult));
}
public void BindBankPDetails()
{
GrdBankPDetails.DataSource = BankPayment.GetBankPayment((txtbankcodep.Text.Trim()), fdt, tdt);
string page = Request.Url.Segments[Request.Url.Segments.Length - 1].ToString().ToLower();
if (page != "bankpayment.aspx")
{
GrdBankPDetails.Columns[7].Visible = false;
}
GrdBankPDetails.DataBind();
}
public void Check_Write_To_File_Success()
{
string filePath = "C:\\Github\\BankPayment\\PaymentHistory.txt";
BankPayment payment = new BankPayment("Ankita", 22222222, 345567);
ReadOrWriteFile.WriteToBinaryFile(filePath, payment, true);
BankPayment paymentTest = ReadOrWriteFile.ReadFromBinaryFile <BankPayment>(filePath);
Assert.AreEqual(payment.AccountNumber, paymentTest.AccountNumber);
Assert.AreEqual(payment.AccountName, paymentTest.AccountName);
Assert.AreEqual(payment.Bsb, paymentTest.Bsb);
}
// GET: BankPayments/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BankPayment bankPayment = db.BankPayments.Find(id);
if (bankPayment == null)
{
return(HttpNotFound());
}
return(View(bankPayment));
}
public HttpResponseMessage SubmitPayment([FromBody] BankPayment payment)
{
string filePath = ConfigurationManager.AppSettings["FileLocation"];
try
{
ReadOrWriteFile.WriteToBinaryFile(filePath, payment, true);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.BadRequest));
}
}
protected void btnget_Click(object sender, EventArgs e)
{
try
{
string BnkCode = txtbankcoder.Text.Trim();
frdate = txtFromDate.Text.Split('/')[2] + "/" + txtFromDate.Text.Split('/')[1] + "/" + txtFromDate.Text.Split('/')[0];
todate = txttoDate.Text.Split('/')[2] + "/" + txttoDate.Text.Split('/')[1] + "/" + txttoDate.Text.Split('/')[0];
tdt = Convert.ToDateTime(todate);
fdt = Convert.ToDateTime(frdate);
if (tdt >= fdt)
{
DataSet ds = new DataSet();
ds = BankPayment.GetBankPayment(BnkCode, fdt, tdt);
if (ds.Tables[0].Rows.Count > 0)
{
Session["Data"] = ds.Tables[0];
FillReport(ds.Tables[0]);
//string page = Request.Url.Segments[Request.Url.Segments.Length - 1].ToString().ToLower();
//if (page != "bankreceipt.aspx")
//{
// GrdBankRDetails.Columns[7].Visible = false;
//}
//GrdBankRDetails.DataBind();
PnlBankRDetails.Visible = true;
}
else
{
PnlBankRDetails.Visible = false;
MessageBox("Records Not Available ");
}
}
else
{
PnlBankRDetails.Visible = false;
MessageBox("From Date is greater than To Date");
}
txtbankcoder.Focus();
}
catch (Exception ex)
{
MessageBox(ex.Message.ToString());
txtbankcoder.Focus();
}
}
public IHttpActionResult Post(BankPayment bankPayment)
{
var payment = new Persistence.Model.BankPayment();
payment.BankAccount.BSB = bankPayment.BSB;
payment.BankAccount.AccountNumber = bankPayment.AccountNumber;
payment.BankAccount.AccountName = bankPayment.AccountName;
payment.Reference = bankPayment.ReferenceNumber;
payment.Amount = bankPayment.Amount;
uow.BankPayment.Add(payment);
uow.Save();
return(CreatedAtRoute("DefaultApi", new { id = bankPayment.ReferenceNumber }, bankPayment));
}
private void PrindFunction()
{
Session["Data"] = null;
string BnkCode = txtbankcoder.Text.Trim();
frdate = txtFromDate.Text.Split('/')[2] + "/" + txtFromDate.Text.Split('/')[1] + "/" + txtFromDate.Text.Split('/')[0];
todate = txttoDate.Text.Split('/')[2] + "/" + txttoDate.Text.Split('/')[1] + "/" + txttoDate.Text.Split('/')[0];
tdt = Convert.ToDateTime(todate);
fdt = Convert.ToDateTime(frdate);
if (tdt >= fdt)
{
DataSet ds = new DataSet();
ds = BankPayment.GetBankPayment(BnkCode, fdt, tdt);
if (ds.Tables[0].Rows.Count > 0)
{
if (txtsubgroup.Text.Trim() != "")
{
DataView dv = new DataView(ds.Tables[0]);
dv.RowFilter = "GR_HEAD = '" + txtsubgroup.Text.Trim() + "'";
Session["Data"] = dv;
FillReport(dv);
}
else
{
DataView dv1 = new DataView(ds.Tables[0]);
Session["Data"] = dv1;
FillReport(dv1);
}
PnlBankRDetails.Visible = true;
}
else
{
PnlBankRDetails.Visible = false;
MessageBox("Records Not Available ");
}
}
else
{
PnlBankRDetails.Visible = false;
MessageBox("From Date is greater than To Date");
}
// txtbankcoder.Focus();
//Session["Data"] = null;
}
public async Task <BaseDto <Payment_Input> > Handle(UpdatePaymentCommand request, CancellationToken cancellationToken)
{
try
{
var data = await _context.payments.FindAsync(request.id);
var inputData = request.data.attributes;
var paymentData = BankPayment.payment(inputData);
data.payment_type = paymentData.payment_type;
data.gross_amount = paymentData.gross_amount.ToString();
data.order_id = paymentData.order_id;
data.transaction_id = paymentData.transaction_id;
data.transaction_time = paymentData.transaction_time;
data.transaction_status = paymentData.transaction_status;
data.updated_at = paymentData.updated_at;
await _context.SaveChangesAsync(cancellationToken);
var ordersData = await _context.orders.FindAsync(paymentData.order_id);
Publisher.Send(ordersData.user_id.ToString(), "push");
return(new BaseDto <Payment_Input>
{
message = "Success Update Payment Data",
success = true,
data = new Payment_Input
{
order_id = data.order_id,
payment_type = data.payment_type,
gross_amount = Convert.ToInt64(data.gross_amount),
bank = inputData.bank
}
});
}
catch (Exception)
{
return(new BaseDto <Payment_Input>
{
message = "Failed Update Payment Data",
success = false,
data = null
});
}
}
void InitializeTest()
{
context = new FilePersistenceContext(filePath);
repo = new RepositoryBankPayment(context);
payment = new BankPayment()
{
BankAccount = new BankAccount()
{
BSB = 123456,
AccountNumber = 12345678,
AccountName = "David"
},
Reference = "R01",
Amount = 100
};
}
public void TestBankPaymentAddedToContextConsideresUptoTwoDigits(int bsb, int accountNumber, string name, string reference, double amount,
string expectedOutput)
{
InitializeTest();
var paymentForSmith = new BankPayment()
{
BankAccount = new BankAccount()
{
BSB = bsb,
AccountNumber = accountNumber,
AccountName = name
},
Reference = reference,
Amount = amount
};
repo.Add(paymentForSmith);
Assert.AreEqual(expectedOutput, repo.GetContextForTest().Set[0]);
}
static void Main(string[] args)
{
Console.WriteLine("Interface Demo Code: ");
BankPayment obj1 = new Payment();
Console.WriteLine("After Discount: " + obj1.DoBankPayment(25000));
UPIPayment obj2 = new Payment();
Console.WriteLine("After Discount: " + obj2.DoUpiPayment(50000));
Console.WriteLine("Interface Demo Code Using Factory Method: ");
BankPayment obj3 = Factory.create(1);
Console.WriteLine(obj3.DoBankPayment(35000));
BankPayment obj4 = Factory.create(2);
Console.WriteLine(obj4.DoBankPayment(78000));
}
public async Task <BaseDto <Payment_Input> > Handle(CreatePaymentCommand request, CancellationToken cancellationToken)
{
var data = request.data.attributes;
var paymentData = BankPayment.payment(data);
_context.payments.Add(paymentData);
await _context.SaveChangesAsync(cancellationToken);
var ordersData = await _context.orders.FindAsync(paymentData.order_id);
Publisher.Send(ordersData.user_id.ToString(), "email");
return(new BaseDto <Payment_Input>
{
message = "Success Add Payment Data",
success = true,
data = request.data.attributes
});
}
protected void btnget_Click(object sender, EventArgs e)
{
string BnkCode = txtbankcodep.Text.Trim();
frdate = txtFromDate.Text.Split('/')[2] + "/" + txtFromDate.Text.Split('/')[1] + "/" + txtFromDate.Text.Split('/')[0];
todate = txttoDate.Text.Split('/')[2] + "/" + txttoDate.Text.Split('/')[1] + "/" + txttoDate.Text.Split('/')[0];
tdt = Convert.ToDateTime(todate);
fdt = Convert.ToDateTime(frdate);
if (tdt >= fdt)
{
DataSet ds = new DataSet();
ds = BankPayment.GetBankPayment(BnkCode, fdt, tdt);
if (ds.Tables[0].Rows.Count > 0)
{
GrdBankPDetails.DataSource = BankPayment.GetBankPayment(BnkCode, fdt, tdt);
string page = Request.Url.Segments[Request.Url.Segments.Length - 1].ToString().ToLower();
if (page != "bankpayment.aspx")
{
GrdBankPDetails.Columns[7].Visible = false;
}
GrdBankPDetails.DataBind();
PnlBankPDetails.Visible = true;
}
else
{
PnlBankPDetails.Visible = false;
MessageBox("Records Not Available ");
}
}
else
{
PnlBankPDetails.Visible = false;
MessageBox("From Date is greater than To Date");
}
}
public ActionResult SaveOrder(PaymentType type)
{
var basket = GetBasket();
int orderId = CreateOrUpdateCurrentOrder(basket);
string customerId = (User as IUserPrincipal).Id;
decimal sum = basket.Sum(p => p.Price * p.Quantity);
IPaymentStrategy strategy;
switch (type)
{
case PaymentType.Bank:
_orderService.Pay(orderId);
Session[Basket] = null;
List <string> paragraphs = basket.Select(purchase => $"Game name: {purchase.GameName}\n" + $"Quantity: {purchase.Quantity}\n" + $"Price: {purchase.Price}\n\n").ToList();
paragraphs.Add($"Total price: {sum}");
strategy = new BankPayment(paragraphs.ToArray());
break;
case PaymentType.IBox:
_orderService.Pay(orderId);
Session[Basket] = null;
strategy = new IBoxPayment(customerId, orderId, sum, _iBoxPaymentResultBuilder);
break;
case PaymentType.Visa:
string currentCulture = Thread.CurrentThread.CurrentCulture.Name.Substring(0, 2);
strategy = new VisaPayment($"/{currentCulture}/Basket/Visa");
break;
default:
{
throw new UndefinedPaymentTypeException();
}
}
return(strategy.GetActionResult());
}
public BankPaymentResponse InvoicePayment(Invoice invoice, BankPayment bankPayment)
{
var response = new BankPaymentResponse();
List <string> errors = new List <string>();
if (bankPayment == null)
{
response.Errors.Add("Payment details invalid");
return(response);
}
if (bankPayment.Bank == "XYZ")
{
response.Errors.Add("Payment through bank XYZ is not allowed");
return(response);
}
invoice.ClosedOn = DateTime.Now;
invoice.Status = InvoiceStatus.Closed;
response.PaymentConfirmatitonNumber = $"{bankPayment.Bank}{DateTime.Now:ssyymmhh}";
return(response);
}
public async Task <BankResponse> CreatePaymentAsync(BankPayment payment)
{
try
{
_logger.LogInformation("Communicating with bank client");
var responseMessage = await _httpClient.PostAsJsonAsync("BankPayment", payment);
_logger.LogInformation("Ensure success in bank response");
responseMessage.EnsureSuccessStatusCode();
_logger.LogInformation("Parsing bank response to known entity");
var bankResponse = await responseMessage.Content.ReadAsAsync <BankResponse>();
_logger.LogInformation("Communication Successfull, returning response");
return(bankResponse);
}
catch (Exception)
{
_logger.LogError("Bad communication with bank client. Returning empty guid as response");
return(new BankResponse {
BankResponseId = Guid.Empty
});
}
}
public IResult Update(BankPayment payment)
{
throw new NotImplementedException();
}
public IResult Add(BankPayment payment)
{
paymentDal.Add(payment);
return(new SuccessResult(Messages.Added));
}
protected async override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
string response = await request.Content.ReadAsStringAsync();
// gather information
var json = JsonDoc.Parse(response, JsonEncoders.Base64Encoder);
var timestamp = json.GetValue <string>("TIMESTAMP");
var merchantId = json.GetValue <string>("MERCHANT_ID");
var account = json.GetValue <string>("ACCOUNT");
var orderId = json.GetValue <string>("ORDER_ID");
var amount = json.GetValue <string>("AMOUNT");
var currency = json.GetValue <string>("CURRENCY");
var autoSettle = json.GetValue <int>("AUTO_SETTLE_FLAG") == 1;
var description = json.GetValue <string>("COMMENT1");
var shaHashTagName = _shaHashType + "HASH";
var requestHash = json.GetValue <string>(shaHashTagName);
// gather additional information
var shippingCode = json.GetValue <string>("SHIPPING_CODE");
var shippingCountry = json.GetValue <string>("SHIPPING_CO");
var billingCode = json.GetValue <string>("BILLING_CODE");
var billingCountry = json.GetValue <string>("BILLING_CO");
var fraudFilterMode = json.GetValue <string>("HPP_FRAUDFILTER_MODE");
List <string> hashParam = new List <string>
{
timestamp,
merchantId,
orderId,
amount,
currency
};
//create the card/APM/LPM/OB object
if (json.Has("PM_METHODS"))
{
string[] apmTypes = json.GetValue <string>("PM_METHODS").Split("|");
string apmType = apmTypes[0];
//OB
if (apmTypes.Contains(HostedPaymentMethods.OB.ToString()))
{
var card = new BankPayment {
SortCode = json.GetValue <string>("HPP_OB_DST_ACCOUNT_SORT_CODE"),
AccountNumber = json.GetValue <string>("HPP_OB_DST_ACCOUNT_NUMBER"),
AccountName = json.GetValue <string>("HPP_OB_DST_ACCOUNT_NAME"),
BankPaymentType = (BankPaymentType)(Enum.Parse(typeof(BankPaymentType), json.GetValue <string>("HPP_OB_PAYMENT_SCHEME"))),
Iban = json.GetValue <string>("HPP_OB_DST_ACCOUNT_IBAN"),
ReturnUrl = json.GetValue <string>("MERCHANT_RESPONSE_URL"),
StatusUpdateUrl = json.GetValue <string>("HPP_TX_STATUS_URL")
};
paymentMethod = card;
if (!string.IsNullOrEmpty(card.SortCode))
{
hashParam.Add(card.SortCode);
}
if (!string.IsNullOrEmpty(card.AccountNumber))
{
hashParam.Add(card.AccountNumber);
}
if (!string.IsNullOrEmpty(card.Iban))
{
hashParam.Add(card.Iban);
}
}
else
{
AlternativePaymentMethod apm = new AlternativePaymentMethod();
apm.AlternativePaymentMethodType = (AlternativePaymentType)(Enum.Parse(typeof(AlternativePaymentType), apmType));
apm.ReturnUrl = json.GetValue <string>("MERCHANT_RESPONSE_URL");
apm.StatusUpdateUrl = json.GetValue <string>("HPP_TX_STATUS_URL");
if (apmType.Equals(AlternativePaymentType.PAYPAL.ToString()))
{
apm.CancelUrl = "https://www.example.com/failure/cancelURL";
}
apm.Country = json.GetValue <string>("HPP_CUSTOMER_COUNTRY");
apm.AccountHolderName = json.GetValue <string>("HPP_CUSTOMER_FIRSTNAME") + " " + json.GetValue <string>("HPP_CUSTOMER_LASTNAME");
paymentMethod = apm;
}
}
else
{
CreditCardData card = new CreditCardData {
Number = "4111111111111111",
ExpMonth = 12,
ExpYear = 2025,
Cvn = "123",
CardHolderName = "John Smithe"
};
paymentMethod = card;
}
//for stored card
if (json.Has("OFFER_SAVE_CARD"))
{
if (json.Has("PAYER_REF"))
{
hashParam.Add(json.GetValue <string>("PAYER_REF"));
}
if (json.Has("PMT_REF"))
{
hashParam.Add(json.GetValue <string>("PMT_REF"));
}
}
if (json.Has("HPP_FRAUDFILTER_MODE"))
{
hashParam.Add(json.GetValue <string>("HPP_FRAUDFILTER_MODE"));
}
// check hash
var newhash = GenerationUtils.GenerateHash(_sharedSecret, hashParam.ToArray());
if (!newhash.Equals(requestHash))
{
return(BadRequest("Incorrect hash. Please check your code and the Developers Documentation."));
}
// configure the container
ServicesContainer.ConfigureService(new GpEcomConfig {
MerchantId = merchantId,
AccountId = account,
SharedSecret = _sharedSecret,
RequestLogger = new RequestConsoleLogger()
}, "realexResponder");
// build request
AuthorizationBuilder gatewayRequest = null;
if (amount.ToAmount().Equals(0m) || amount == null)
{
var validate = json.GetValue <int>("VALIDATE_CARD_ONLY") == 1;
if (validate)
{
gatewayRequest = ((CreditCardData)paymentMethod).Verify();
}
else
{
gatewayRequest = ((CreditCardData)paymentMethod).Verify().WithRequestMultiUseToken(true);
}
}
else
{
if (autoSettle)
{
if (paymentMethod is CreditCardData)
{
gatewayRequest = ((CreditCardData)paymentMethod).Charge(amount.ToAmount());
}
if (paymentMethod is AlternativePaymentMethod)
{
gatewayRequest = ((AlternativePaymentMethod)paymentMethod).Charge(amount.ToAmount());
}
if (paymentMethod is BankPayment)
{
var gatewayBankRequest = AddRemittanceRef(((BankPayment)paymentMethod).Charge(amount.ToAmount())
.WithCurrency(currency)
.WithDescription(description), json);
var gatewayResponse = gatewayBankRequest.Execute();
if (gatewayResponse.BankPaymentResponse.PaymentStatus.Equals("PAYMENT_INITIATED"))
{
return(BuildResponse(HttpStatusCode.OK, ConvertResponse(json, gatewayResponse)));
}
else
{
return(BadRequest(gatewayResponse.ResponseMessage));
}
}
}
else
{
gatewayRequest = ((CreditCardData)paymentMethod).Authorize(amount.ToAmount());
}
}
try {
gatewayRequest.WithCurrency(currency).WithOrderId(orderId).WithTimestamp(timestamp);
if (billingCode != null || billingCountry != null)
{
gatewayRequest.WithAddress(new Address {
PostalCode = billingCode, Country = billingCountry
});
}
if (shippingCode != null || shippingCountry != null)
{
gatewayRequest.WithAddress(new Address {
PostalCode = shippingCode, Country = shippingCountry
}, AddressType.Shipping);
}
if (fraudFilterMode != null)
{
gatewayRequest.WithFraudFilter((FraudFilterMode)Enum.Parse(typeof(FraudFilterMode), fraudFilterMode), getFraudFilterRules(json));
}
var gatewayResponse = gatewayRequest.Execute("realexResponder");
if (gatewayResponse.ResponseCode.Equals("00") || gatewayResponse.ResponseCode.Equals("01"))
{
return(BuildResponse(HttpStatusCode.OK, ConvertResponse(json, gatewayResponse)));
}
else
{
return(BadRequest(gatewayResponse.ResponseMessage));
}
}
catch (ApiException exc) {
return(ServerError(exc.Message));
}
}
protected void btn_Save_Click(object sender, EventArgs e)
{
docdate = txtdocDate.Text.Split('/')[2] + "/" + txtdocDate.Text.Split('/')[1] + "/" + txtdocDate.Text.Split('/')[0];
ddt = Convert.ToDateTime(docdate);
string BankCode = txtbankcode.Text.Trim();
BankPayment obBnkpay = new BankPayment();
// txtdocno.Text = BankPayment.Get_BankPaymentDocNo(BankCode);
// txtdocDate.Text = DateTime.Now.ToString("dd/MM/yyyy");
if (Session["UserName"] != null)
{
try
{
obBnkpay.BankPaymentID = Convert.ToInt32(LblBankPID.Text);
obBnkpay.BankCode = txtbankcode.Text.Trim();
// obBnkpay.DocumentNo = 0;
obBnkpay.SerialNo = 1;
obBnkpay.DocumentDate = ddt;
obBnkpay.AccountCode = txtAccode.Text.Trim();;
obBnkpay.PersonInCharge = txtperson.Text.Trim();
obBnkpay.ReportCode = txtreportcode.Text.Trim();
obBnkpay.Cash_Cheque_DD = DDLCCDD.SelectedItem.Text;
// obBnkpay.Type = txtType.Text.Trim();
obBnkpay.Cheque_DD_NO = txtCCDDNo.Text.Trim();
obBnkpay.Amount = Convert.ToDecimal(txtAmt.Text.Trim());
obBnkpay.DrawnOn = txtDrawnon.Text.Trim();
obBnkpay.Remarks = txtRemark.Text.Trim();
obBnkpay.Isactive = true;
obBnkpay.IsChequeBounce = CheckActive.Checked;
obBnkpay.CreatedBy = Session["UserName"].ToString();
obBnkpay.strFY = Convert.ToInt32(strFY);
if (Session["url"] != null)
{
obBnkpay.Paymode = "Addcomision";
}
else
{
obBnkpay.Paymode = "";
}
obBnkpay.Save(out DocNo);
txtdocno.Text = Convert.ToString(DocNo);
// MessageBox("Record saved successfully");
MessageBox(Constants.save + "\\r\\n Document No: " + (txtdocno.Text));
loder("Last saved Document no. : " + txtdocno.Text);
GrdBankPDetails.DataBind();
txtbankcode.Text = "";
lblbankname.Text = "";
txtdocno.Text = "";
txtdocDate.Text = DateTime.Now.ToString("dd/MM/yyyy");
// txtsrno.Text = "";
txtAccode.Text = "";
lblaccname.Text = "";
txtperson.Text = "";
txtreportcode.Text = "";
lblacname.Text = "";
DDLCCDD.SelectedIndex = 0;
//txtType.Text = "";
txtCCDDNo.Text = "";
txtAmt.Text = "";
txtDrawnon.Text = "";
lblDrawnonname.Text = "";
txtRemark.Text = "";
Session["url"] = null;
CheckActive.Checked = false;
lblCustOS.Text = "";
btn_Save.Text = "Save";
PnlAddBankP.Visible = true;
Pnldate.Visible = false;
PnlBankPDetails.Visible = false;
}
catch
{
}
}
}
