//[RequiredLogin]
public async Task<JsonResult> UpointTelkomselVoucher(UPointTelkomselVoucherViewModel model)
{
var api = GoPlayApi.Instance;
if (!ModelState.IsValid)
{
return Json(new { errors = Errors(ModelState) });
}
var result = api.UpointAPI(new APIUpointParamModel()
{
enumAction = EUpointAction.GetTicketTelkomsel,
}).Result;
if (!result.HasData || result.Data.code != "201")
return FailResult("hrn", !result.HasData ? ErrorCodes.ServerError.ToErrorMessage() : result.Data.info);
model.hrn = model.hrn.Replace(" ", "");
var transaction = GenerateCoinTransaction();
var transactionUUID = Guid.Parse(transaction.order_id);
transaction.telkom_order_id = result.Data.ticket;
transaction.payment_method = Helper.GetDescription(PaymentMethod.UPoint_TelkomselVoucher);
transaction.description = "HRN: " + model.hrn;
transaction.status = Helper.GetDescription(TransactionStatus.Telkomsel_voucher_pending);
transaction = api.CreateCoinTransaction(transaction).Data;
if (transaction == null)
return FailResult("hrn", ErrorCodes.ServerError.ToErrorMessage());
string err = null;
var upointParam = new APIUpointParamModel(transaction, "GToken")
{
enumAction = EUpointAction.TelkomselVoucher,
amount = -1,
hrn = model.hrn,
ticket = result.Data.ticket
};
for (int i = 0; i < 5; i++)
{
result = api.UpointAPI(upointParam).Result;
if (!result.HasData)
{
err = ErrorCodes.ServerError.ToErrorCode();
break;
}
if (result.Data.code == "200")
{
err = null;
break;
}
err = result.Data.info;
Thread.Sleep(5000);//5s
//# For result code of 100 - Voucher burning is still on progress
//# Retry 5 times max
}
if (err != null)
{
UpdateTransactionFail(transaction, err);
return FailResult("hrn", err);
}
if (result.Data.trx_id != transactionUUID.ToString("N"))
{
var errorMessage = "UPoint incorrect transaction order id: " + result.Data.trx_id;
UpdateTransactionFail(transaction, errorMessage);
return FailResult("hrn", errorMessage);
}
var voucherValue = result.Data.nominal.HasValue ? result.Data.nominal.Value : 0;
var gtokenPackage = api.GetGTokenPackage(voucherValue, "IDR").Data;
if (gtokenPackage == null)
{
var errorMessage = "UPoint incorrect transaction amount: " + voucherValue;
UpdateTransactionFail(transaction, errorMessage);
return FailResult("hrn", errorMessage);
}
var user = api.GetUserById(transaction.customer_account_id).Data;// require login first, user cannot null
bool debug = false;
bool.TryParse(ConfigurationManager.AppSettings["UPOINT_DEBUG"], out debug);
decimal? totalAmount = 0;
decimal? gtokenAmount = 0;
if (!debug)
{
gtokenAmount = gtokenPackage.GetPlayToken(user);
totalAmount = gtokenPackage.price;
}
transaction.gtoken_package_id = gtokenPackage.id;
transaction.description += "; GToken Package: " + gtokenPackage.name;
if (user.HasDiscount())
{
transaction.description += "; Extra 10% on GoPlay Token amount.";
user.is_discount_permanent = true;
api.UpdateCustomerAccount(user.id, true);
if (transaction.amount.HasValue)
transaction.amount = transaction.amount.Value / decimal.Parse("1.1");
}
//# Add view invoice permission for user
//identity = Identity(transaction.customerAccount.id)
//identity.provides.add(ItemNeed('action', 'view_invoice', transaction.order_id))
transaction.status = Helper.GetDescription(TransactionStatus.Success);
api.UpdateCoinTransaction(transaction.id, transaction.status, transaction.description, transaction.telkom_order_id);
var invoiceTemplate = new InvoiceViewModel()
{
transaction = transaction,
payer = user,
package = gtokenPackage,
topupCard = transaction.topup_card_id.HasValue ? api.GetTopUpCard(transaction.topup_card_id.Value).Data : null
};
if (!(await EmailHelper.SendMailInvoice(invoiceTemplate)))
{
var errorMessage = "This guy purchased GToken with an improper email " + user.id + " " + user.email;
return FailResult("hrn", errorMessage);
}
return Json(new { correct = true });
}
//[RequiredLogin]
public async Task<JsonResult> UpointSpeedy(UPointSpeedyViewModel model)
{
if (!ModelState.IsValid)
{
return Json(new { errors = Errors(ModelState) });
}
var api = GoPlayApi.Instance;
var gtokenPackage = GoPlayApi.Instance.GetGTokenPackage(model.GtokenPackageSKU).Data;
if (gtokenPackage == null)
return FailResult("GtokenPackageSKU", ErrorCodes.INVALID_PACKAGE_ID.ToErrorMessage());
var transaction = GenerateCoinTransaction(gtokenPackage);
bool debug = false;
bool.TryParse(ConfigurationManager.AppSettings["UPOINT_DEBUG"], out debug);
if (debug)//# Speedy API doesn't accept amount of 0...
{
transaction.amount = decimal.Parse("0.04");
transaction.price = decimal.Parse("0.04");
}
transaction.payment_method = Helper.GetDescription(PaymentMethod.UPoint_Speedy);
transaction.status = Helper.GetDescription(TransactionStatus.Speedy_pending);
transaction = api.CreateCoinTransaction(transaction).Data;
if (transaction == null)
return FailResult("GtokenPackageSKU", ErrorCodes.ServerError.ToErrorMessage());
var result = api.UpointAPI(new APIUpointParamModel(transaction)
{
enumAction = EUpointAction.Speedy,
phone_number = model.phoneNumber,
speedy_number = model.speedyNumber,
ip = Request.UserHostAddress
}).Result;
if (!result.HasData)
{
return FailResult("GtokenPackageSKU", ErrorCodes.ServerError.ToErrorMessage());
}
if (!result.Data.result)
{
UpdateTransactionFail(transaction, result.Data.error_info);
return FailResult("phoneNumber", result.Data.error_info);
}
var transactionUUID = Guid.Parse(transaction.order_id);
if (result.Data.trx_id != transactionUUID.ToString("N"))
{
var errorMessage = "UPoint incorrect transaction order id: " + result.Data.trx_id;
UpdateTransactionFail(transaction, errorMessage);
return FailResult("phoneNumber", errorMessage);
}
decimal GtokenRate = 0;
decimal.TryParse(ConfigurationManager.AppSettings["IDR_PER_GTOKEN_RATE"], out GtokenRate);
if (result.Data.amount / GtokenRate != transaction.amount)
{
var errorMessage = "UPoint incorrect transaction amount " + result.Data.amount;
UpdateTransactionFail(transaction, errorMessage);
return FailResult("phoneNumber", errorMessage);
}
//TODO
// # Add view invoice permission for user
//identity = Identity(transaction.customerAccount.id)
//identity.provides.add(ItemNeed('action', 'view_invoice', transaction.order_id))
transaction.telkom_order_id = result.Data.t_id;
transaction.status = Helper.GetDescription(TransactionStatus.Success);
api.UpdateCoinTransaction(transaction.id, transaction.status, transaction.description, transaction.telkom_order_id);
var invoiceTemplate = new InvoiceViewModel()
{
transaction = transaction,
payer = api.GetUserById(transaction.customer_account_id).Data,
package = gtokenPackage,
topupCard = transaction.topup_card_id.HasValue ? api.GetTopUpCard(transaction.topup_card_id.Value).Data : null
};
if (!(await EmailHelper.SendMailInvoice(invoiceTemplate)))
{
string customer_account_id = string.Empty;
string email = string.Empty;
if (invoiceTemplate.payer != null)
{
customer_account_id = invoiceTemplate.payer.id.ToString();
email = invoiceTemplate.payer.email;
}
var errorMessage = "This guy purchased GToken with an improper email " + customer_account_id + " " + email;
return FailResult("phoneNumber", errorMessage);
}
return Json(new { success = true, redirect = "transaction/invoice", order_id = transaction.order_id });
}
//[RequiredLogin]
public async Task<JsonResult> UpointCallback(APIUpointModel model)
{
var api = GoPlayApi.Instance;
Guid order_id = default(Guid);
Guid.TryParse(model.trx_id, out order_id);//hex to guid
coin_transaction transaction = api.GetCoinTransactionByOderId(order_id.ToString()).Data;
if (transaction == null)
{
var err = "UPoint incorrect transaction order id: " + model.trx_id;
return FailResult("errors", err);
}
var user = api.GetUserById(transaction.customer_account_id).Data;
if (!model.result)
{
UpdateTransactionFail(transaction, model.error_info);
string errorMessage = model.error_info;
if (user == null || !(await EmailHelper.SendUpointCallBack(model.error_info, user.email)))
errorMessage = "This guy purchased GToken with an improper email " + user.id + " " + user.email;
return FailResult("phoneNumber", errorMessage);
}
decimal GtokenRate = 0;
decimal.TryParse(ConfigurationManager.AppSettings["IDR_PER_GTOKEN_RATE"], out GtokenRate);
if (model.amount / GtokenRate != transaction.amount)
{
var errorMessage = "UPoint incorrect transaction amount " + model.amount;
return FailResult("phoneNumber", errorMessage);
}
//# Add view invoice permission for user
//identity = Identity(transaction.customerAccount.id)
//identity.provides.add(ItemNeed('action', 'view_invoice', transaction.order_id))
if (user.HasDiscount())
{
transaction.description += "; Extra 10% on GoPlay Token amount.";
user.is_discount_permanent = true;
api.UpdateCustomerAccount(user.id, true);
if (transaction.amount.HasValue)
transaction.amount = transaction.amount.Value / decimal.Parse("1.1");
}
transaction.telkom_order_id = model.t_id;
transaction.status = Helper.GetDescription(TransactionStatus.Success);
api.UpdateCoinTransaction(transaction.id, transaction.status, transaction.description, transaction.telkom_order_id);
var invoiceTemplate = new InvoiceViewModel()
{
transaction = transaction,
payer = user,
package = transaction.gtoken_package_id.HasValue?api.GetGTokenPackage(transaction.gtoken_package_id.Value).Data:null,
topupCard = transaction.topup_card_id.HasValue ? api.GetTopUpCard(transaction.topup_card_id.Value).Data : null
};
if (!(await EmailHelper.SendMailInvoice(invoiceTemplate)))
{
var errorMessage = "This guy purchased GToken with an improper email " + user.id + " " + user.email;
return FailResult("hrn", errorMessage);
}
return Json(new { result = true });
}
public static async Task<bool> SendMailInvoice(InvoiceViewModel data)
{
try
{
var client = new SmtpClient();
client.DeliveryMethod = SmtpDeliveryMethod.Network;
client.EnableSsl = true;
var supportEmail = ConfigurationManager.AppSettings["CUSTOMER_SUPPORT_EMAIL_SENDER"];
// var email_temp = ConfigurationManager.AppSettings["CUSTOMER_SUPPORT_EMAIL_SENDER_TEST"];// TODO: have to replace to data.payer.email when deploy
var displayName = ConfigurationManager.AppSettings["CUSTOMER_SUPPORT_EMAIL_NAME"];
var from = new MailAddress(supportEmail, displayName);
var to = new MailAddress(data.payer.email);//data.payer.email
var mailMessage = new MailMessage(from, to)
{
Subject = "PlayToken - Electronic Receipt",
Body = GetEmailBody(ConfigurationManager.AppSettings["InvoiceTemplate"], data),
IsBodyHtml = true
};
await client.SendMailAsync(mailMessage);
return true;
}
catch
{
return false;
}
}
public async Task<JsonResult> topupCard(TopupCardForm form)
{
if (!ModelState.IsValid)
{
return Json(new { errors = Errors(ModelState) });
}
var api = GoPlayApi.Instance;
var card = api.GetTopUpCard(form.cardNumber, form.cardPassword);
dynamic transaction = new ExpandoObject();
if (card.Data.is_free.HasValue && card.Data.is_free.Value)
{
transaction = CreateFreeCoinTrans(CurrentUser, card.Data);
}
else
{
transaction = CreateCoinTrans(CurrentUser, card.Data);
}
api.UpdateTopupCard(card.Data.id, CurrentUser.Id, "used", DateTime.UtcNow);
var user = api.GetUserById(CurrentUser.Id);
if (user.Data.HasDiscount())
{
user.Data.is_discount_permanent = true;
}
api.UpdateCustomerAccount(user.Data.id, user.Data.is_discount_permanent);
// Not use since March 1st 2015
//if not card.is_free and card.is_bv:
// # Send a request to Venvici to update their database with the payment
// # So there are 3 types of topup cards now
// # - standard card, not free and has bv value
// # - free card, free and has no bv value
// # - no-bv card, not free and has no bv value
// venvici.pushBv(transaction.customerAccount, transaction.amount / 2)
// #Venici - from 15/3/2015
//#if not card.is_free and card.is_bv:
// #venvici.updateVenviciBalance(user,transaction)
if (!card.Data.is_free.HasValue || !card.Data.is_free.Value)
{
var gTokenTransaction = GoPlayApi.Instance.CreateGTokenTransaction(new GTokenTransaction
{
username = CurrentUser.UserName,
order_id = transaction.order_id,
original_price = card.Data.amount,
original_final_amount = card.Data.amount,
original_currency = ConstantCommon.DEFAULT_PAYPAL_CURRENCY,
discount_percentage = 0,
payment_method = Helper.GetDescription(PaymentMethod.TopUpCard),
description = transaction.description,
status = ConstantValues.S_SUCCESS,
is_venvici_applicable = card.Data.is_bv.HasValue ? card.Data.is_bv.HasValue : false,
revenue_percentage = decimal.Parse(ConfigurationManager.AppSettings["REVENUE_PERCENTAGE"].ToString())
});
}
var payer = api.GetUserById(user.Data.id).Data;
if (!string.IsNullOrEmpty(payer.email))
{
if (transaction is free_coin_transaction)
{
Mapper.CreateMap<free_coin_transaction, coin_transaction>();
transaction = Mapper.Map<coin_transaction>(transaction);
}
var invoiceTemplate = new InvoiceViewModel()
{
transaction = transaction,
payer = payer,
package = null,
topupCard = card.Data
};
await EmailHelper.SendMailInvoice(invoiceTemplate);
}
var message = String.Empty;
if (card.Data.is_free.HasValue && card.Data.is_free.Value)
{
message = String.Format(Resources.Resources.You_topped_up_Free_Play_Token, Helper.displayDecimal(card.Data.amount));
}
else
{
message = String.Format(Resources.Resources.You_topped_up_Play_Token, Helper.displayDecimal(card.Data.amount));
}
return Json(new { success = true, message = message, is_free = (card.Data.is_free.Value && card.Data.is_free.Value), amount = card.Data.amount });
}
public async Task<ActionResult> PaypalExcecute()
{
string payerId = Request.Params["PayerID"];
var order_id = Request.Params["order_id"];
var api = GoPlayApi.Instance;
var transaction = api.GetCoinTransactionByOderId(order_id.ToLower());
var helper = new PaypalHelper();
var payment = helper.Find(helper.GetGetAPIContext(), transaction.Data.paypal_payment_id);
// Rechecks the total amount and currency of PayPal payment
decimal paypalTotalAmount = Decimal.Parse(payment.transactions[0].amount.total);
string paypalCurrency = payment.transactions[0].amount.currency;
if (paypalTotalAmount != transaction.Data.price || paypalCurrency != ConstantCommon.DEFAULT_PAYPAL_CURRENCY)
{
transaction.Data.status = "failure";
transaction.Data.description = "PayPal Error: Invalid currency or total amount.";
api.UpdateCoinTransactionStatus(transaction.Data.id, transaction.Data.status, transaction.Data.description);
await api.updateGTokenTransactionStatus(transaction.Data.order_id, "failure");
return RedirectToAction("index", "transaction");
}
var executedPayment = payment.Execute(helper.GetGetAPIContext(), new PaymentExecution() { payer_id = payerId });
if (executedPayment.state.ToLower() != "approved")
{
//when executedPayment is not approved
//---------------------------------------------
api.UpdateCoinTransactionStatus(transaction.Data.id, "failure", executedPayment.failed_transactions[0].message);
await api.updateGTokenTransactionStatus(transaction.Data.order_id, "failure");
try
{
if (Int32.Parse(executedPayment.failed_transactions[0].code) == 400)
{
api.UpdateCoinTransactionStatus(transaction.Data.id, "pending");
}
try
{
string customerEmail = ConfigurationManager.AppSettings["ADMINS"];//should change
string subject = "PlayToken - Topup transaction notification";
string from = ConfigurationManager.AppSettings["CUSTOMER_SUPPORT_EMAIL_SENDER"];
string to = customerEmail;
string body = String.Format("Thank you for your business. Your payment {0} was under review by Paypal service and could take up to 24 hours to release. Once the transaction is completed, the system will update your Play Token automatically.", transaction.Data.paypal_payment_id);
var message = new MailMessage(from, to, subject, body);
EmailHelper.SendMail(message);
}
catch (Exception)
{
string adminEmail = ConfigurationManager.AppSettings["ADMINS"];
string subject = "PlayToken wrong email";
string from = ConfigurationManager.AppSettings["CUSTOMER_SUPPORT_EMAIL_SENDER"];
string to = adminEmail;
string body = String.Format("This guy purchased Play Token with a proper email {0} {1} but the payment was under review by Paypal.", CurrentUser.Id, CurrentUser.Email);
var message = new MailMessage(from, to, subject, body);
EmailHelper.SendMail(message);
}
}
catch (Exception e)
{
logger.Fatal(e.StackTrace.ToString());
}
}
else
{
try
{
//State of transaction is approved
//---------------------------------------------
transaction.Data.status = "pending";
api.UpdateCoinTransactionStatus(transaction.Data.id, transaction.Data.status);
//Not use since March 1st 2015
//Send a request to Venvici to update their database with the payment
//venvici.pushBv(transaction.customerAccount, transaction.amount / 2)
try
{
var invoiceTemplate = new InvoiceViewModel()
{
transaction = transaction.Data,
payer = api.GetUserById(transaction.Data.customer_account_id).Data,
package = api.GetGTokenPackage(transaction.Data.gtoken_package_id.Value).Data,
topupCard = transaction.Data.topup_card_id.HasValue ? api.GetTopUpCard(transaction.Data.topup_card_id.Value).Data : null
};
await EmailHelper.SendMailInvoice(invoiceTemplate);
}
catch (Exception)
{
string adminEmail = ConfigurationManager.AppSettings["ADMINS"];
string subject = "PlayToken wrong email";
string from = ConfigurationManager.AppSettings["CUSTOMER_SUPPORT_EMAIL_SENDER"];
string to = adminEmail;
string body = String.Format("This guy purchased Play Token with a proper email {0} {1}", CurrentUser.Id, CurrentUser.Email);
var message = new MailMessage(from, to, subject, body);
EmailHelper.SendMail(message);
}
return RedirectToAction("invoice", "transaction", new { order_id = transaction.Data.order_id });
}
catch (Exception ex)
{
api.UpdateCoinTransactionStatus(transaction.Data.id, ex.Message.ToString());
}
}
return RedirectToAction("index", "transaction");
}
public ActionResult Invoice(string order_id)
{
var api = GoPlayApi.Instance;
InvoiceViewModel model = new InvoiceViewModel();
if (!string.IsNullOrEmpty(order_id))
{
GeneralTransaction trans = GetGeneralTransaction(order_id);
if (trans != null && trans.customer_account_id == CurrentUser.Id)
{
model.generalTrans = trans;
model.package = trans.gtoken_package_id.HasValue ? api.GetGTokenPackage(trans.gtoken_package_id.Value).Data : null;
model.topupCard = trans.topup_card_id.HasValue ? api.GetTopUpCard(trans.topup_card_id.Value).Data : null;
}
}
return View(model);
}
