public PayoutResponse PayoutSubmit(PayoutRequest request)
{
var jsonRequest = Util.JsonOperation.SerializeRequest(request);
var jsonResponse = _payoutService.Request(jsonRequest);
return(JsonConvert.DeserializeObject <PayoutResponse>(jsonResponse));
}
private PayoutResponse ProceedPayout(string authToken, PayoutRequest request)
{
var handler = new HttpClientHandler {
AllowAutoRedirect = false
};
using (var httpClient = new HttpClient(handler)
{
BaseAddress = new Uri(baseUrl)
})
{
httpClient.DefaultRequestHeaders.TryAddWithoutValidation("authorization", $"Bearer {authToken}");
var camelCaseSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var orderSerialized = JsonConvert.SerializeObject(request, Formatting.None, camelCaseSettings);
using (var content = new StringContent(orderSerialized, Encoding.UTF8, "application/json"))
using (var response = httpClient.PostAsync("api/v2_1/payouts/", content).Result)
{
var responseData = response.Content.ReadAsStringAsync().Result;
return(JsonConvert.DeserializeObject <PayoutResponse>(responseData));
}
}
}
public PayoutResponse PostPayout(PayoutRequest payoutRequest)
{
return(this.Process <PayoutResponse>(
PayUClientUrlBuilder.BuildPayoutsUrl(this.settings.Url, this.settings.ApiVersion),
HttpMethod.Post,
payoutRequest));
}
public void TestPayoutAsCustomer_CreateWithNewBankAccount()
{
OpenpayAPI openpayAPI = new OpenpayAPI(Constants.API_KEY, Constants.MERCHANT_ID);
BankAccount bankAccount = new BankAccount();
bankAccount.CLABE = "012212000000000019";
bankAccount.HolderName = "Testing";
bankAccount = openpayAPI.BankAccountService.Create(customer_id, bankAccount);
PayoutRequest request = new PayoutRequest();
request.Method = "bank_account";
request.DestinationId = bankAccount.Id;
request.Amount = 8.5m;
request.Description = "Payout test";
Payout payout = openpayAPI.PayoutService.Create(customer_id, request);
Assert.IsNotNull(payout.Id);
Assert.IsNotNull(payout.CreationDate);
Assert.IsNotNull(payout.BankAccount);
Payout payoutGet = openpayAPI.PayoutService.Get(customer_id, payout.Id);
Assert.AreEqual(payout.Amount, payoutGet.Amount);
Assert.AreEqual(payout.BankAccount.CLABE, payoutGet.BankAccount.CLABE);
openpayAPI.BankAccountService.Delete(customer_id, bankAccount.Id);
}
public void TestPayoutAsMerchant_CreateBankAccount()
{
OpenpayAPI openpayAPI = new OpenpayAPI(Constants.API_KEY, Constants.MERCHANT_ID);
BankAccount bankAccount = new BankAccount();
bankAccount.CLABE = "012298026516924616";
bankAccount.HolderName = "Testing";
PayoutRequest request = new PayoutRequest();
request.Method = "bank_account";
request.BankAccount = bankAccount;
request.Amount = 8.5m;
request.Description = "Payout test";
Payout payout = openpayAPI.PayoutService.Create(request);
Assert.IsNotNull(payout.Id);
Assert.IsNotNull(payout.CreationDate);
Assert.IsNotNull(payout.BankAccount);
Payout payoutGet = openpayAPI.PayoutService.Get(payout.Id);
Assert.AreEqual(payout.Amount, payoutGet.Amount);
Assert.AreEqual(payout.BankAccount.CLABE, payoutGet.BankAccount.CLABE);
}
public void TestPayoutAsCustomer_CreateCard()
{
OpenpayAPI openpayAPI = new OpenpayAPI(Constants.API_KEY, Constants.MERCHANT_ID);
Card card = new Card();
card.CardNumber = "4111111111111111";
card.BankCode = "002";
card.HolderName = "Payout User";
PayoutRequest request = new PayoutRequest();
request.Method = "card";
request.Card = card;
request.Amount = 5.5m;
request.Description = "Payout test";
Payout payout = openpayAPI.PayoutService.Create(customer_id, request);
Assert.IsNotNull(payout.Id);
Assert.IsNotNull(payout.CreationDate);
Assert.IsNotNull(payout.Card);
Assert.IsNull(payout.BankAccount);
Payout payoutGet = openpayAPI.PayoutService.Get(customer_id, payout.Id);
Assert.AreEqual(payout.Amount, payoutGet.Amount);
}
public async Task <PayoutResponse> PostPayoutAsync(PayoutRequest payoutRequest, CancellationToken ct = default(CancellationToken))
{
return(await this.ProcessAsync <PayoutResponse>(
PayUClientUrlBuilder.BuildPayoutsUrl(this.settings.Url, this.settings.ApiVersion),
HttpMethod.Post,
ct,
payoutRequest));
}
public void PayoutSuccessTest()
{
Client client = CreateMockTestClientNullRequiredFieldsRequest("Mocks/payout/payout-success.json");
Payout payout = new Payout(client);
PayoutRequest request = new PayoutRequest();
PayoutResponse result = payout.PayoutSubmit(request);
Assert.AreEqual("8814689190961342", result.PspReference);
Assert.AreEqual("12345", result.AuthCode);
}
public Task <PaymentResponse> RequestPayout(PayoutRequest payoutRequest,
string idempotencyKey = null,
CancellationToken cancellationToken = default)
{
CheckoutUtils.ValidateParams("payoutRequest", payoutRequest);
return(ApiClient.Post <PaymentResponse>(
PaymentsPath,
SdkAuthorization(),
payoutRequest,
cancellationToken,
idempotencyKey));
}
/// <summary>
/// FROM AP
/// </summary>
public static void MarkAsPaid(PayoutRequest request)
{
request.IsPaid = true;
request.Save();
//Add payment proof
Member User = new Member(request.Username);
PaymentProof.Add(User, request);
//Add history
History.AddCashout(request.Username, request.Amount);
}
public async void PostPayoutAsync_WhenCall_CorrectDeserializedResponse()
{
PayoutRequest rq = new PayoutRequest("125533", 4124);
var result = await this.client.PostPayoutAsync(rq, default(CancellationToken));
Assert.NotNull(result);
Assert.NotNull(result.Status);
Assert.NotNull(result.Payout);
Assert.False(string.IsNullOrEmpty(result.Payout.Status));
Assert.False(string.IsNullOrEmpty(result.Payout.PayoutId));
Assert.NotNull(result.Status);
Assert.Equal(expectedStatus, result.Status.StatusCode);
}
public async Task <IActionResult> Withdraw(RequestVM requestVM)
{
ApplicationUser user = await _userManager.GetUserAsync(User);
if (ModelState.IsValid)
{
decimal money = await _context.GetBalanceAsync(user.Id);
if (money >= requestVM.Money)
{
RecipientType recipient = await _context.RecipientTypes.FirstAsync(r => r.ID == requestVM.RecipientTypeID);
RecipientSettings recipientSettings = new RecipientSettings
{
Owner = user,
Receiver = requestVM.Receiver,
RecipientType = recipient
};
user.DefaultRecipientSettings = recipientSettings;
PayoutRequest payoutRequest = new PayoutRequest
{
Money = requestVM.Money,
RecipientSettings = recipientSettings,
Paid = false
};
await _context.PayoutRequests.AddAsync(payoutRequest);
user.RequestedMoney += requestVM.Money;
await _context.SaveChangesAsync();
}
else
{
ModelState.AddModelError(string.Empty, "You do not have enough money");
}
}
if (!(user.DefaultRecipientSettings is null))
{
requestVM.RecipientTypeID = user.DefaultRecipientSettings.ID;
requestVM.Receiver = user.Receiver;
}
ViewBag.RecipientTypeId = _context.RecipientSettings
.Select(rt => new SelectListItem
{
Text = rt.RecipientType.Name,
Value = rt.ID.ToString()
});
return(View(requestVM));
}
public void PayoutErrorReferenceTest()
{
Client client = CreateMockTestClientForErrors(422, "Mocks/payout/payout-error-422.json");
Payout payout = new Payout(client);
PayoutRequest request = new PayoutRequest();
try
{
payout.PayoutSubmit(request);
}
catch (HttpClient.HttpClientException e)
{
Assert.IsNotNull(e.ResponseBody);
Assert.AreEqual(422, e.Code);
}
}
public void TestEmptyConstructorsUsedForMappingFromConfigFile()
{
_ = new PaymentRequest();
_ = new SettleTransactionRequest();
_ = new VoidTransactionRequest();
_ = new RefundTransactionRequest();
_ = new GetPaymentStatusRequest();
_ = new OpenOrderRequest();
_ = new InitPaymentRequest();
_ = new Authorize3dRequest();
_ = new Verify3dRequest();
_ = new PayoutRequest();
_ = new GetCardDetailsRequest();
_ = new GetMerchantPaymentMethodsRequest();
Assert.Pass();
}
private async Task ShouldRequestPayout_IdempotencyKey()
{
var payoutRequest = new PayoutRequest();
var paymentResponse = new PaymentResponse();
_apiClient.Setup(apiClient =>
apiClient.Post <PaymentResponse>(PaymentsPath, _authorization, payoutRequest,
CancellationToken.None, "test"))
.ReturnsAsync(() => paymentResponse);
IPaymentsClient paymentsClient = new PaymentsClient(_apiClient.Object, _configuration.Object);
var response = await paymentsClient.RequestPayout(payoutRequest, "test", CancellationToken.None);
response.ShouldNotBeNull();
response.ShouldBeSameAs(paymentResponse);
}
public void MustBePossibleToGetPayouts()
{
var config = new MerchantConfig("K500746", "fia'w2ahSheahahc", Server.Playground);
PayoutRequest req = new PayoutRequest
{
CurrencyCode = "EUR",
EndDate = DateTime.Now.Date.ToShortDateString(),
StartDate = DateTime.Now.Subtract(new TimeSpan(1000, 0, 0, 0)).ToShortDateString(),
Offset = 0,
Size = 10
};
var payoutsGetter = new Payouts();
var listOfPayouts = payoutsGetter.GetPayouts(req, config);
Assert.IsNotNull(listOfPayouts);
}
public void TestGetAndSetModelPayoutRequest()
{
_ = new PayoutRequest(
merchantInfo,
sessionToken,
null,
null,
null,
null,
new UserPaymentOption {
})
{
Comment = null,
UserPmId = "",
Phone = ""
};
Assert.Pass();
}
public async Task <PayoutResponse> Payout(
string userTokenId,
string clientUniqueId,
string amount,
string currency,
UserPaymentOption userPaymentOption,
string comment = null,
DynamicDescriptor dynamicDescriptor = null,
MerchantDetails merchantDetails = null,
UrlDetails urlDetails = null,
DeviceDetails deviceDetails = null,
CardData cardData = null,
string userId = null,
string rebillingType = null,
string authenticationTypeOnly = null,
SubMerchant subMerchant = null,
Addendums addendums = null)
{
var request = new PayoutRequest(
merchantInfo,
sessionToken,
userTokenId,
clientUniqueId,
amount,
currency,
userPaymentOption)
{
Comment = comment,
DynamicDescriptor = dynamicDescriptor,
MerchantDetails = merchantDetails,
UrlDetails = urlDetails,
DeviceDetails = deviceDetails,
CardData = cardData,
UserId = userId,
RebillingType = rebillingType,
AuthenticationTypeOnly = authenticationTypeOnly,
SubMerchant = subMerchant,
Addendums = addendums
};
return(await safechargeRequestExecutor.Payout(request));
}
public string TryMakePayout()
{
ValidatePayout();
string paymentAddress = PaymentAccountDetails.GetPaymentProcessorUserAccount(user, paymentProcessor);
var request = new TransactionRequest(user.Name, paymentAddress, amountToPayout);
Transaction transaction = TransactionFactory.CreateTransaction(request, paymentProcessor);
var response = transaction.Commit();
if (!response.IsSuccess)
{
if (request != null && response != null)
{
PayoutManager.logPayout("Commission Balance Payout unsuccessful", request, response, paymentProcessor);
}
throw new MsgException(response.Note);
}
PayoutRequest req = new PayoutRequest();
req.Amount = amountToPayout;
req.IsPaid = true;
req.RequestDate = DateTime.Now;
req.Username = user.Name;
req.IsRequest = false;
req.BalanceType = BalanceType.CommissionBalance;
req.PaymentAddress = paymentAddress;
req.PaymentProcessor = paymentProcessor;
req.Save();
user.SubtractFromCommissionBalance(amountToPayout, "Payout");
user.SaveBalances();
History.AddCashout(user.Name, amountToPayout);
PayoutManager.logPayout("Commission Balance Payout successful", request, response, paymentProcessor);
PaymentProof.Add(user, req);
return(U3501.AUTOMATICCASHOUTSUCC + ": " + response.Note);
}
public static void AddPayoutRequest(ref ApplicationDbContext context, decimal money, string ownerId, bool paid)
{
RecipientType recipient = context.RecipientTypes.First(r => r.ID == 1);
ApplicationUser user = context.Users.First(u => u.Id == ownerId);
RecipientSettings recipientSettings = new RecipientSettings
{
Owner = user,
Receiver = ownerId,
RecipientType = recipient
};
user.DefaultRecipientSettings = recipientSettings;
PayoutRequest payoutRequest = new PayoutRequest
{
Money = money,
RecipientSettings = recipientSettings,
Paid = false
};
user.RequestedMoney += money;
}
/// <summary>
/// FROM AP
/// </summary>
/// <param name="request"></param>
/// <param name="gateway"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static bool MakePayout(PayoutRequest request, PaymentAccountDetails gateway, ref Transaction transaction)
{
transaction.Commit();
if (transaction.Response.IsSuccess)
{
request.IsPaid = true;
request.IsRequest = false;
request.Save();
Member User = new Member(request.Username);
//Add payment proof
PaymentProof.Add(User, request);
//Add statistics
var stats = new Statistics(StatisticsType.Cashflow);
stats.AddToData2(request.Amount);
stats.Save();
//Add history
History.AddCashout(request.Username, request.Amount);
if (gateway is PayPalAccountDetails)
{
// Log because payment may have response status SuccessWithWarning
// More on this: https://developer.paypal.com/webapps/developer/docs/classic/api/NVPAPIOverview/
logPayout("Payout successful", request, transaction.Response, request.PaymentProcessor);
}
return(true);
}
else
{
logPayout("Payout unsuccessful", request, transaction.Response, request.PaymentProcessor);
return(false);
}
}
private async Task ShouldRequestPayout()
{
var payoutRequest = new PayoutRequest
{
Destination = new PaymentRequestBankAccountDestination
{
AccountType = AccountType.Cash,
AccountNumber = "13654567455",
BankCode = "bank_code",
BranchCode = "6443",
Bban = "3704 0044 0532 0130 00",
Iban = "HU93116000060000000012345676",
SwiftBic = "37040044",
Country = CountryCode.HU,
AccountHolder = new AccountHolder {
FirstName = "First Name", LastName = "Last Name",
},
Bank = new BankDetails {
Name = "Bank Name", Address = new Address(), Branch = "branch"
}
}
};
var payoutResponse = new PayoutResponse();
_apiClient.Setup(apiClient =>
apiClient.Post <PayoutResponse>(PaymentsPath, _authorization, payoutRequest,
CancellationToken.None, null))
.ReturnsAsync(() => payoutResponse);
IPaymentsClient paymentsClient = new PaymentsClient(_apiClient.Object, _configuration.Object);
var response = await paymentsClient.RequestPayout(payoutRequest, null, CancellationToken.None);
response.ShouldNotBeNull();
response.ShouldBeSameAs(payoutResponse);
}
/// <summary>
/// FROM AP
/// </summary>
/// <param name="request"></param>
public static void RejectRequest(PayoutRequest request)
{
Member User = new Member(request.Username);
try
{
PaymentProcessor processor = PaymentAccountDetails.GetFromStringType(request.PaymentProcessor);
PaymentProportionsManager.UndoMemberPaidOut(request.Amount, processor, User);
}
catch
{
//processor = custom processor
}
request.IsPaid = true;
request.PaymentProcessor = "REJECTED";
request.Save();
User.MoneyCashout -= request.Amount;
User.AddToMainBalance(request.Amount, "Payout rejected");
User.Save();
History.AddCashoutRejection(User.Name, request.Amount.ToString());
}
private async Task ShouldRequestPayout()
{
var phone = new Phone {
CountryCode = "44", Number = "020 222333"
};
var billingAddress = new Address
{
AddressLine1 = "CheckoutSdk.com",
AddressLine2 = "90 Tottenham Court Road",
City = "London",
State = "London",
Zip = "W1T 4TJ",
Country = CountryCode.GB
};
var requestCardDestination = new PaymentRequestCardDestination
{
Name = TestCardSource.Visa.Name,
Number = TestCardSource.Visa.Number,
FirstName = "Mr. Test",
LastName = "Integration",
ExpiryYear = TestCardSource.Visa.ExpiryYear,
ExpiryMonth = TestCardSource.Visa.ExpiryMonth,
BillingAddress = billingAddress,
Phone = phone
};
var payoutRequest = new PayoutRequest
{
Destination = requestCardDestination,
FundTransferType = FundTransferType.AA,
Capture = false,
Reference = Guid.NewGuid().ToString(),
Amount = 5,
Currency = Currency.USD,
};
var paymentResponse = await PreviousApi.PaymentsClient().RequestPayout(payoutRequest);
paymentResponse.ShouldNotBeNull();
paymentResponse.Id.ShouldNotBeNullOrEmpty();
paymentResponse.Reference.ShouldNotBeNullOrEmpty();
paymentResponse.Status.ShouldBe(PaymentStatus.Pending);
paymentResponse.ThreeDs.ShouldBeNull();
//Customer
paymentResponse.Customer.ShouldNotBeNull();
paymentResponse.Customer.Id.ShouldNotBeNull();
paymentResponse.Customer.Name.ShouldBeNull();
//Links
paymentResponse.GetSelfLink().ShouldNotBeNull();
paymentResponse.HasLink("actions").ShouldBeFalse();
paymentResponse.HasLink("capture").ShouldBeFalse();
paymentResponse.HasLink("void").ShouldBeFalse();
var payment = await Retriable(async() =>
await PreviousApi.PaymentsClient().GetPaymentDetails(paymentResponse.Id));
payment.ShouldNotBeNull();
// Destination
payment.Destination.ShouldNotBeNull();
payment.Destination.ShouldBeAssignableTo(typeof(PaymentResponseCardDestination));
var paymentResponseCardDestination = (PaymentResponseCardDestination)payment.Destination;
paymentResponseCardDestination.Bin.ShouldNotBeNull();
//paymentResponseCardDestination.CardCategory.ShouldBe(CardCategory.Consumer);
//paymentResponseCardDestination.CardType.ShouldBe(CardType.Credit);
paymentResponseCardDestination.ExpiryMonth.ShouldBe(6);
paymentResponseCardDestination.ExpiryYear.ShouldBe(2025);
paymentResponseCardDestination.Last4.ShouldNotBeNullOrEmpty();
paymentResponseCardDestination.Fingerprint.ShouldNotBeNullOrEmpty();
paymentResponseCardDestination.Name.ShouldNotBeNullOrEmpty();
//paymentResponseCardDestination.Issuer.ShouldNotBeNullOrEmpty();
//paymentResponseCardDestination.IssuerCountry.ShouldBe(CountryCode.US);
//paymentResponseCardDestination.ProductId.ShouldNotBeNullOrEmpty();
//paymentResponseCardDestination.ProductType.ShouldNotBeNullOrEmpty();
paymentResponseCardDestination.Type().ShouldBe(PaymentDestinationType.Card);
}
private string TryMakeInstantPayout(Money fee)
{
// payoutRequest --> change property to false (it isn't request)
PayoutRequest req = new PayoutRequest();
req.Amount = AmountToPayout - fee;
req.IsPaid = true;
req.RequestDate = DateTime.Now;
req.Username = User.Name;
req.IsRequest = false;
req.BalanceType = BalanceType.MainBalance;
//Check if daily limit is not reached
if (AppSettings.Payments.GlobalCashoutsToday + AmountToPayout - fee > AppSettings.Payments.GlobalCashoutLimitPerDay)
{
throw new MsgException(L1.TOOMANYCASHOUTS + " " + AppSettings.Payments.GlobalCashoutLimitPerDay.ToString());
}
//User payment address
string paymentAddress = PaymentAccountDetails.GetPaymentProcessorUserAccount(User, TargetPaymentProcessor);
if (String.IsNullOrEmpty(paymentAddress))
{
throw new MsgException(U5004.YOUMUST);
}
request = new TransactionRequest(User.Name, paymentAddress, AmountToPayout - fee);
Transaction transaction = TransactionFactory.CreateTransaction(request, TargetPaymentProcessor);
response = transaction.Commit();
req.PaymentAddress = paymentAddress;
req.PaymentProcessor = TargetPaymentProcessor;
if (!response.IsSuccess)
{
if (request != null && response != null)
{
PayoutManager.logPayout("Payout unsuccessful", request, response, req.PaymentProcessor);
}
throw new MsgException(response.Note);
}
req.Save();
History.AddCashout(User.Name, AmountToPayout);
User.SubtractFromMainBalance(AmountToPayout, "Payout");
User.MoneyCashout += AmountToPayout - fee;
User.IsPhoneVerifiedBeforeCashout = false;
User.CashoutsProceed++;
User.Save();
//Update payout proportions
PaymentProportionsManager.MemberPaidOut(AmountToPayout - fee, PaymentAccountDetails.GetFromStringType(TargetPaymentProcessor), User, IsCustomPayoutProcessor);
//Add to daily cashout
AppSettings.Payments.GlobalCashoutsToday += AmountToPayout - fee;
AppSettings.Payments.Save();
//Add outcome to stats (Data2);
var stats = new Statistics(StatisticsType.Cashflow);
stats.AddToData2(AmountToPayout);
stats.Save();
//Add paymentproof
PaymentProof.Add(User.Id, AmountToPayout, PaymentType.Instant, PaymentAccountDetails.GetFromStringType(TargetPaymentProcessor));
// Log because payment may have response status SuccessWithWarning
// More on this: https://developer.paypal.com/webapps/developer/docs/classic/api/NVPAPIOverview/
logPayout("Payout successful", request, response, req.PaymentProcessor);
return(U3501.AUTOMATICCASHOUTSUCC + ": " + response.Note);
}
private string TryMakeManualPayout(Money fee)
{
//Manual, add to payoutrequests
PayoutRequest req = new PayoutRequest();
//Calculate fees for CustomPP
Money Fees = fee;
if (IsCustomPayoutProcessor)
{
CustomPayoutProcessor CPP = new CustomPayoutProcessor(CustomPayoutProcessorId);
Fees = Fees + CPP.MoneyFee;
Fees = Fees + (AmountToPayout * (CPP.PercentageFee * new Money(0.01)));
if (string.IsNullOrWhiteSpace(TargetAccount))
{
throw new MsgException(U4200.ACCOUNTFIELDNOTBLANK);
}
}
req.Amount = AmountToPayout - Fees;
req.IsPaid = false;
req.RequestDate = DateTime.Now;
req.Username = User.Name;
req.IsRequest = true;
req.BalanceType = BalanceType.MainBalance;
if (IsCustomPayoutProcessor)
{
//CustomPP
CustomPayoutProcessor CPP = new CustomPayoutProcessor(CustomPayoutProcessorId);
req.PaymentAddress = TargetAccount;
req.PaymentProcessor = CPP.Name;
//MPesa check
if (CPP.Name.ToLower() == "mpesa" && (TargetAccount.Length != 10 || !TargetAccount.StartsWith("07")))
{
throw new MsgException("Check your phone number format. The number should be 07******** (10 length)");
}
}
else
{
string paymentAddress = PaymentAccountDetails.GetPaymentProcessorUserAccount(User, TargetPaymentProcessor);
if (String.IsNullOrEmpty(paymentAddress))
{
throw new MsgException(U5004.YOUMUST);
}
if (TargetPaymentProcessor == "Payeer" && paymentAddress.Contains("@"))
{
throw new MsgException(U6006.VALIDPAYEER);
}
req.PaymentAddress = paymentAddress;
req.PaymentProcessor = TargetPaymentProcessor;
}
req.Save();
User.SubtractFromMainBalance(AmountToPayout, "Payout");
User.MoneyCashout += (AmountToPayout - Fees);
User.IsPhoneVerifiedBeforeCashout = false;
User.CashoutsProceed++;
User.Save();
//Update payout proportions
if (!IsCustomPayoutProcessor)
{
PaymentProportionsManager.MemberPaidOut(AmountToPayout - Fees, PaymentAccountDetails.GetFromStringType(TargetPaymentProcessor), User, IsCustomPayoutProcessor);
}
if (IsAutomaticButAvoveTheLimit)
{
return(U3501.CASHOUTSUCC + ": " + U3500.CASHOUT_APPROVE.Replace("%n%", TheLimit.ToString()));
}
else
{
return(U3501.CASHOUTSUCC + ": " + U3500.CASHOUT_MESSAGE.Replace("%n1%", (AmountToPayout - Fees).ToString()).Replace("%n2%", Fees.ToString()));
}
}
protected void WithdrawHistoryGridView_RowEditing(object sender, GridViewEditEventArgs e)
{
int id = (int)WithdrawHistoryGridView.DataKeys[e.NewEditIndex].Value;
EditedPayoutRequest = new PayoutRequest(id);
}
private async Task ShouldMakeCardPayoutPayments()
{
PayoutRequest request = new PayoutRequest
{
Source = new PayoutRequestCurrencyAccountSource {
Id = "ca_qcc7x4nxxk6efeogm7yczdnsxu"
},
Destination =
new PaymentRequestCardDestination
{
Number = "5219565036325411",
ExpiryMonth = 12,
ExpiryYear = 2024,
AccountHolder = new AccountHolder
{
Type = AccountHolderType.Individual,
FirstName = "Jhon",
LastName = "Smith",
DateOfBirth = "1939-05-05",
CountryOfBirth = CountryCode.FR,
BillingAddress =
new Address
{
AddressLine1 = "Checkout",
AddressLine2 = "Shepherdless Walk",
City = "London",
Zip = "N17BQ",
Country = CountryCode.GB
},
Phone = new Phone {
CountryCode = "44", Number = "09876512412"
},
Identification = new AccountHolderIdentification
{
Type = AccountHolderIdentificationType.Passport,
Number = "E2341",
IssuingCountry = CountryCode.FR,
DateOfExpiry = "2024-05-05"
},
Email = "*****@*****.**"
}
},
Amount = 10,
Currency = Currency.EUR,
Reference = "Pay-out to Card - Money Transfer",
BillingDescriptor = new PayoutBillingDescriptor {
Reference = "Pay-out to Card - Money Transfer"
},
Sender = new PaymentIndividualSender
{
FirstName = "Hayley",
LastName = "Jones",
Address = new Address
{
AddressLine1 = "Checkout",
AddressLine2 = "Shepherdless Walk",
City = "London",
Zip = "N17BQ",
Country = CountryCode.GB
},
Reference = "1234567ABCDEFG",
ReferenceType = "other",
DateOfBirth = "1939-05-05",
SourceOfFunds = SourceOfFunds.Credit,
},
Instruction = new PaymentInstruction
{
Purpose = "pension", FundsTransferType = "C07", Mvv = "0123456789"
},
ProcessingChannelId = "pc_q727c4x6vtwujbiys3bb7wjpaa"
};
PayoutResponse response = await DefaultApi.PaymentsClient().RequestPayout(request);
response.ShouldNotBeNull();
response.Id.ShouldNotBeNull();
response.Status.ShouldNotBeNull();
response.Instruction.ShouldNotBeNull();
response.Instruction.ValueDate.ShouldNotBeNull();
}
public async Task <RefundResponse> PayoutAsync(PayoutRequest request)
{
return(await RequestAsync <PayoutRequest, RefundResponse>(request));
}
public static void CRON()
{
using (var bridge = ParserPool.Acquire(Database.Client))
{
//0. RevenueShareAdsWatched yesterday
string RevenueShareAdsWatchedCommand = @"
UPDATE Users
SET RevenueShareAdsWatchedYesterday = (
CASE WHEN Users.RSAAdsViewed = '-1'
THEN -1
ELSE len(Users.RSAAdsViewed) - len(replace(Users.RSAAdsViewed, '#', ''))
END
) + 1
";
bridge.Instance.ExecuteRawCommandNonQuery(RevenueShareAdsWatchedCommand);
}
using (var bridge = ParserPool.Acquire(Database.Client))
{
//1. Credit new Referral Reward
CreditForNewReferrals();
//2. Delete watched ads & TrafficGrid and other
string resetDailyStatsCommand = "UPDATE Users SET " + Member.Columns.ViewedAds + " = '-1', "
+ Member.Columns.TrafficGridHitsToday + " = 0, PointsToday = 0, PointsCreditedForVideoToday = 0, PointsCreditedForSearchToday = 0, CPACompletedToday = 0, CompletedDailyCPAOffersToday = '-1', CompletedOffersFromOfferwallsToday = 0, MatrixBonusMoneyCyclesToday = 0, CompletedOffersMoreThan100pFromOfferwallsToday = 0, FbLikesToday = 0";
if (AppSettings.RevShare.DistributionTime != DistributionTimePolicy.EveryWeek ||
AppSettings.ServerTime.DayOfWeek == AppSettings.RevShare.DayOfWeekDistribution)
{
resetDailyStatsCommand += ", RSAAdsViewed = '-1'";
}
bridge.Instance.ExecuteRawCommandNonQuery(resetDailyStatsCommand);
}
//3. Recalculate Statistics
RecalculateStatistics(Member.Columns.StatsEarned, true);
RecalculateStatistics(Member.Columns.StatsClicks, false);
RecalculateStatistics(Member.Columns.UserClicksStats, false);
RecalculateStatistics("RawDirectReferralsClicks", false);
RecalculateStatistics("RawRentedReferralsClicks", false);
RecalculateStatistics("StatsDirectReferralsEarned", true);
RecalculateStatistics("StatsPointsEarned", false);
RecalculateStatistics("StatsDirectReferralsPointsEarned", false);
RecalculateStatistics("StatsDRAdPacksEarned", true);
RecalculateStatistics("StatsCashLinksEarned", true);
RecalculateStatistics("StatsDRCashLinksEarned", true);
using (var bridge = ParserPool.Acquire(Database.Client))
{
//4. Mark inactive ones
string Command = string.Format(@"UPDATE Users SET {0} = {2}, AccountStatus = 'Expired'
WHERE Username <> 'admin'
AND {0} = {3}
AND (
(
(LastLoginDate IS NOT NULL
AND DATEADD (day, {1}, LastLoginDate) < GETDATE())
OR
(LastLoginDate IS NULL
AND DATEADD (day, {1}, RegisterDate) < GETDATE())
)
AND (
(VacationModeEnds IS NULL)
OR
(DATEADD (day, {1}, VacationModeEnds) < GETDATE())
)
)", "AccountStatusInt", AppSettings.Misc.DaysToInactivity, (int)MemberStatus.Expired, (int)MemberStatus.Active);
bridge.Instance.ExecuteRawCommandNonQuery(Command);
//5. Upgrade expiration
var upgradeExpiredMembersQuery = "SELECT * FROM Users WHERE UpgradeExpires IS NOT NULL AND UpgradeExpires < GETDATE()";
var upgradeExpiredMembers = TableHelper.GetListFromRawQuery <Member>(upgradeExpiredMembersQuery);
foreach (Member user in upgradeExpiredMembers)
{
DateTime membershipExpires = (DateTime)user.MembershipExpires;
var dateWhenReferralsWillBeResolved = membershipExpires.AddDays(AppSettings.Referrals.ResolveReferralsAfterSpecifiedDays);
if (dateWhenReferralsWillBeResolved <= DateTime.Now)
{
user.ResolveReferralsLimitDate = null;
user.Downgrade();
}
else
{
user.ResolveReferralsLimitDate = dateWhenReferralsWillBeResolved;
user.Downgrade(false);
}
History.AddUpgradeExpiration(user.Name, user.MembershipName);
}
var usersWhoCouldHaveTooManyReferralsQuery = string.Format("SELECT * FROM {0} WHERE {1} IS NOT NULL AND {1} <= GETDATE()",
Member.TableName, Member.Columns.ResolveReferralsLimitDate, AppSettings.Referrals.ResolveReferralsAfterSpecifiedDays);
var usersWhoCouldHaveTooManyReferrals = TableHelper.GetListFromRawQuery <Member>(usersWhoCouldHaveTooManyReferralsQuery);
foreach (var user in usersWhoCouldHaveTooManyReferrals)
{
user.ResolveReferralsLimitDate = null;
user.SaveMembership();
user.ResolveReferralLimits(user.Membership);
}
DateTime DateNow = DateTime.Now;
//6 Vacation mode expiration
string VacationModeExpiredCommand = "UPDATE Users SET LastActivityTime = GETDATE(), AccountStatusInt = " + (int)MemberStatus.Active + ", AccountStatus = 'Active' WHERE VacationModeEnds IS NOT NULL AND VacationModeEnds < GETDATE() AND AccountStatusInt = " + (int)MemberStatus.VacationMode;
bridge.Instance.ExecuteRawCommandNonQuery(VacationModeExpiredCommand);
//7. RemovalReferrals
Member.DeleteReferralsCRON();
//8. Inactivity fee:
if (AppSettings.VacationAndInactivity.InactivityChargePerDay > Money.Zero)
{
try
{
string InactivityUpdateCommand = string.Format("UPDATE Users SET Balance1 = Balance1 - {0}", AppSettings.VacationAndInactivity.InactivityChargePerDay.ToClearString());
string InactivitySelectCommand = "SELECT * FROM Users";
string InactivityCondition = string.Format(" WHERE (LastActivityTime IS NOT NULL AND LastActivityTime < '{0}') AND AccountStatusInt = {1}",
DateNow.AddDays(-AppSettings.VacationAndInactivity.DaysToInactivityCharge).ToDBString(), (int)MemberStatus.Active);
BalanceLogManager.GlobalMemberAdjustHelper(bridge.Instance, InactivitySelectCommand, InactivityUpdateCommand, InactivityCondition, "Inactivity fee", AppSettings.VacationAndInactivity.InactivityChargePerDay, BalanceLogType.Other);
}
catch (Exception ex)
{
ErrorLogger.Log(ex);
}
}
if (DateNow.Day == 1)
{
bridge.Instance.ExecuteRawCommandNonQuery("UPDATE Users SET PtcAutoSurfClicksThisMonth = 0;");
}
DowngradeMembersLevels();
//Automatically reject all payout requests from banned members
//We are doing it to properly calculate 'CheckMaxValueOfPendingRequestsPerDay' for payment processors
var PayoutRequestsToReject = TableHelper.GetListFromRawQuery <PayoutRequest>(PayoutRequest.GetPayoutRequestsSQLQuery(true));
foreach (var request in PayoutRequestsToReject)
{
PayoutManager.RejectRequest(request);
}
}
//9. Commissions Income Statistics
//WEEKLY
if (AppSettings.ServerTime.DayOfWeek == DayOfWeek.Sunday)
{
TableHelper.ExecuteRawCommandNonQuery("UPDATE Users SET StatsCommissionsLastWeekIncome = StatsCommissionsCurrentWeekIncome, StatsCommissionsCurrentWeekIncome = 0");
}
//MONTHLY
if (AppSettings.ServerTime.Day == DateTime.DaysInMonth(AppSettings.ServerTime.Year, AppSettings.ServerTime.Month))
{
TableHelper.ExecuteRawCommandNonQuery("UPDATE Users SET StatsCommissionsLastMonthIncome = StatsCommissionsCurrentMonthIncome, StatsCommissionsCurrentMonthIncome = 0");
}
}
