public async Task <string> ExecutePayment(string token, string paymentId, string payerId)
{
var urlToSent = $"https://api.sandbox.paypal.com/v1/payments/payment/{paymentId}/execute";
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
PayerId payId = new PayerId
{
payer_id = payerId
};
//Serializer the Payer object to the stream.
DataContractJsonSerializer serializePayerId = new DataContractJsonSerializer(typeof(PayerId));
//Create a stream to serialize the object to.
MemoryStream ms = new MemoryStream();
serializePayerId.WriteObject(ms, payId);
byte[] json = ms.ToArray();
ms.Close();
string bodyToSend = Encoding.UTF8.GetString(json, 0, json.Length);
HttpContent _body = new StringContent(bodyToSend, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync(urlToSent, _body);
//Response
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync();
return(responseBody);
}
private MeetingGroupPayment(PaymentTerm term, PayerId payerId)
{
this.Id = new MeetingGroupPaymentId(Guid.NewGuid());
_term = term;
_payerId = payerId;
_date = SystemClock.Now;
}
internal MeetingGroupPayment(PaymentTerm term, PayerId payerId)
{
this.Id = new MeetingGroupPaymentId(Guid.NewGuid());
_term = term;
_payerId = payerId;
_date = DateTime.UtcNow;
}
public void RegisterPayment_TermsAreNotOverlapping_IsSuccessful()
{
var meetingGroupId = new MeetingGroupId(Guid.NewGuid());
var paymentScheduleForMeetingGroup = MeetingGroupPaymentRegister.CreatePaymentScheduleForMeetingGroup(meetingGroupId);
var payerId = new PayerId(Guid.NewGuid());
var paymentTerm = new PaymentTerm(
new DateTime(2019, 1, 1),
new DateTime(2019, 1, 31));
paymentScheduleForMeetingGroup.RegisterPayment(
paymentTerm, payerId);
var nextPaymentTerm = new PaymentTerm(
new DateTime(2019, 2, 1),
new DateTime(2019, 2, 28));
paymentScheduleForMeetingGroup.RegisterPayment(
nextPaymentTerm, payerId);
var domainEvents = AssertPublishedDomainEvents <PaymentRegisteredDomainEvent>(paymentScheduleForMeetingGroup);
Assert.That(domainEvents.Count, Is.EqualTo(2));
Assert.That(domainEvents[1].DateTo, Is.EqualTo(nextPaymentTerm.EndDate));
}
public static SubscriptionPayment Buy(
PayerId payerId,
SubscriptionPeriod period,
string countryCode,
MoneyValue priceOffer,
PriceList priceList)
{
var priceInPriceList = priceList.GetPrice(countryCode, period, PriceListItemCategory.New);
CheckRule(new PriceOfferMustMatchPriceInPriceListRule(priceOffer, priceInPriceList));
var subscriptionPayment = new SubscriptionPayment();
var subscriptionPaymentCreated = new SubscriptionPaymentCreatedDomainEvent(
Guid.NewGuid(),
payerId.Value,
period.Code,
countryCode,
SubscriptionPaymentStatus.WaitingForPayment.Code,
priceOffer.Value,
priceOffer.Currency);
subscriptionPayment.Apply(subscriptionPaymentCreated);
subscriptionPayment.AddDomainEvent(subscriptionPaymentCreated);
return(subscriptionPayment);
}
internal CreateMeetingPaymentCommand(Guid id, PayerId payerId, MeetingId meetingId, decimal value, string currency) : base(id)
{
PayerId = payerId;
MeetingId = meetingId;
Value = value;
Currency = currency;
}
private MeetingPayment(PayerId payerId, MeetingId meetingId, MoneyValue fee)
{
PayerId = payerId;
MeetingId = meetingId;
_createDate = DateTime.UtcNow;
_fee = fee;
}
private void When(MeetingFeeCreatedDomainEvent meetingFeeCreated)
{
this.Id = meetingFeeCreated.MeetingFeeId;
_payerId = new PayerId(meetingFeeCreated.PayerId);
_meetingId = new MeetingId(meetingFeeCreated.MeetingId);
_fee = MoneyValue.Of(meetingFeeCreated.FeeValue, meetingFeeCreated.FeeCurrency);
_status = MeetingFeeStatus.Of(meetingFeeCreated.Status);
}
/// <summary>
/// Returns true if PaymentProduct840CustomerAccount instances are equal
/// </summary>
/// <param name="other">Instance of PaymentProduct840CustomerAccount to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(PaymentProduct840CustomerAccount other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
AccountId == other.AccountId ||
AccountId != null &&
AccountId.Equals(other.AccountId)
) &&
(
BillingAgreementId == other.BillingAgreementId ||
BillingAgreementId != null &&
BillingAgreementId.Equals(other.BillingAgreementId)
) &&
(
CompanyName == other.CompanyName ||
CompanyName != null &&
CompanyName.Equals(other.CompanyName)
) &&
(
CountryCode == other.CountryCode ||
CountryCode != null &&
CountryCode.Equals(other.CountryCode)
) &&
(
CustomerAccountStatus == other.CustomerAccountStatus ||
CustomerAccountStatus != null &&
CustomerAccountStatus.Equals(other.CustomerAccountStatus)
) &&
(
CustomerAddressStatus == other.CustomerAddressStatus ||
CustomerAddressStatus != null &&
CustomerAddressStatus.Equals(other.CustomerAddressStatus)
) &&
(
FirstName == other.FirstName ||
FirstName != null &&
FirstName.Equals(other.FirstName)
) &&
(
PayerId == other.PayerId ||
PayerId != null &&
PayerId.Equals(other.PayerId)
) &&
(
Surname == other.Surname ||
Surname != null &&
Surname.Equals(other.Surname)
));
}
private void When(SubscriptionPaymentCreatedDomainEvent @event)
{
this.Id = @event.SubscriptionPaymentId;
_payerId = new PayerId(@event.PayerId);
_subscriptionPeriod = SubscriptionPeriod.Of(@event.SubscriptionPeriodCode);
_countryCode = @event.CountryCode;
_subscriptionPaymentStatus = SubscriptionPaymentStatus.Of(@event.Status);
_value = MoneyValue.Of(@event.Value, @event.Currency);
}
public void RegisterPayment(PaymentTerm term, PayerId payerId)
{
var meetingGroupPayment = new MeetingGroupPayment(term, payerId);
this.CheckRule(new MeetingGroupPaymentsCannotOverlapRule(_payments, meetingGroupPayment));
_payments.Add(meetingGroupPayment);
this.AddDomainEvent(new PaymentRegisteredDomainEvent(this.Id, term.EndDate));
}
private MeetingPayment(PayerId payerId, MeetingId meetingId, MoneyValue fee)
{
this.CheckRule(new MeetingPaymentFeeMustBeGreaterThanZeroRule(fee));
PayerId = payerId;
MeetingId = meetingId;
_createDate = SystemClock.Now;
_fee = fee;
this.AddDomainEvent(new MeetingPaymentCreatedDomainEvent(this.PayerId, this.MeetingId, _fee));
}
public void MeetingPayment_WhenFeeIsNotGreaterThanZero_CannotBeCreated()
{
var payerId = new PayerId(Guid.NewGuid());
var meetingId = new MeetingId(Guid.NewGuid());
var fee = new MoneyValue(0, "EUR");
AssertBrokenRule <MeetingPaymentFeeMustBeGreaterThanZeroRule>(() =>
{
MeetingPayment.CreatePaymentForMeeting(payerId, meetingId, fee);
});
}
public SubscriptionRenewalPaymentSnapshot(
SubscriptionRenewalPaymentId id,
PayerId payerId,
SubscriptionPeriod subscriptionPeriod,
string countryCode)
{
PayerId = payerId;
SubscriptionPeriod = subscriptionPeriod;
CountryCode = countryCode;
Id = id;
}
protected SubscriptionPaymentTestData CreateSubscriptionPaymentTestData()
{
var payerId = new PayerId(Guid.NewGuid());
var subscriptionId = new SubscriptionId(Guid.NewGuid());
var priceList = CreatePriceList();
var subscriptionPaymentTestData = new SubscriptionPaymentTestData(
priceList,
payerId,
subscriptionId);
return(subscriptionPaymentTestData);
}
public void MeetingPayment_WhenFeeIsGreaterThanZero_IsCreated()
{
var payerId = new PayerId(Guid.NewGuid());
var meetingId = new MeetingId(Guid.NewGuid());
var fee = new MoneyValue(100, "EUR");
var meetingPayment = MeetingPayment.CreatePaymentForMeeting(payerId, meetingId, fee);
var meetingCreated = GetPublishedDomainEvent <MeetingPaymentCreatedDomainEvent>(meetingPayment);
Assert.That(meetingCreated.PayerId, Is.EqualTo(payerId));
Assert.That(meetingCreated.MeetingId, Is.EqualTo(meetingId));
Assert.That(meetingCreated.Fee, Is.EqualTo(fee));
}
public void MarkPaymentAsPayed_WhenIsPayedAlready_CannotBePayedTwice()
{
var payerId = new PayerId(Guid.NewGuid());
var meetingId = new MeetingId(Guid.NewGuid());
var fee = new MoneyValue(100, "EUR");
var meetingPayment = MeetingPayment.CreatePaymentForMeeting(payerId, meetingId, fee);
meetingPayment.MarkIsPayed();
AssertBrokenRule <MeetingPaymentCannotBePayedTwiceRule>(() =>
{
meetingPayment.MarkIsPayed();
});
}
public PayerDocumentFilter ToDocumentFilter()
{
var filter = new PayerDocumentFilter {
Year = Period.Year,
Interval = Period.Interval,
Region = Region,
Recipient = Recipient
};
if (PayerId != null && PayerId.Length > 0)
{
filter.SearchText = PayerId.Implode();
}
return(filter);
}
public async Task CreateMeetingPayment_Test()
{
PayerId payerId = new PayerId(Guid.NewGuid());
MeetingId meetingId = new MeetingId(Guid.NewGuid());
decimal value = 100;
string currency = "EUR";
await PaymentsModule.ExecuteCommandAsync(new CreateMeetingPaymentCommand(Guid.NewGuid(),
payerId, meetingId, value, currency));
var payment = await PaymentsModule.ExecuteQueryAsync(new GetMeetingPaymentQuery(meetingId.Value, payerId.Value));
Assert.That(payment.PayerId, Is.EqualTo(payerId.Value));
Assert.That(payment.MeetingId, Is.EqualTo(meetingId.Value));
Assert.That(payment.FeeValue, Is.EqualTo(value));
Assert.That(payment.FeeCurrency, Is.EqualTo(currency));
}
public Dictionary <string, string> Parts()
{
var result = new Dictionary <string, string> {
{ "BillingCode", PayerId.ToString() }
};
if (ServiceId != 0)
{
result.Add("ClientCode", ServiceId.ToString());
}
if (!String.IsNullOrEmpty(ActiveTab))
{
result.Add("Tab", ActiveTab);
}
return(result);
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (AccountId != null)
{
hashCode = hashCode * 59 + AccountId.GetHashCode();
}
if (BillingAgreementId != null)
{
hashCode = hashCode * 59 + BillingAgreementId.GetHashCode();
}
if (CompanyName != null)
{
hashCode = hashCode * 59 + CompanyName.GetHashCode();
}
if (CountryCode != null)
{
hashCode = hashCode * 59 + CountryCode.GetHashCode();
}
if (CustomerAccountStatus != null)
{
hashCode = hashCode * 59 + CustomerAccountStatus.GetHashCode();
}
if (CustomerAddressStatus != null)
{
hashCode = hashCode * 59 + CustomerAddressStatus.GetHashCode();
}
if (FirstName != null)
{
hashCode = hashCode * 59 + FirstName.GetHashCode();
}
if (PayerId != null)
{
hashCode = hashCode * 59 + PayerId.GetHashCode();
}
if (Surname != null)
{
hashCode = hashCode * 59 + Surname.GetHashCode();
}
return(hashCode);
}
}
public void RegisterPayment_OnlyOnePayment_IsSuccessful()
{
var meetingGroupId = new MeetingGroupId(Guid.NewGuid());
var paymentScheduleForMeetingGroup = MeetingGroupPaymentRegister.CreatePaymentScheduleForMeetingGroup(meetingGroupId);
var payerId = new PayerId(Guid.NewGuid());
var paymentTerm = new PaymentTerm(
new DateTime(2019, 1, 1),
new DateTime(2019, 1, 31));
paymentScheduleForMeetingGroup.RegisterPayment(
paymentTerm, payerId);
var paymentRegistered = AssertPublishedDomainEvent <PaymentRegisteredDomainEvent>(paymentScheduleForMeetingGroup);
Assert.That(paymentRegistered.MeetingGroupPaymentRegisterId, Is.EqualTo(paymentScheduleForMeetingGroup.Id));
Assert.That(paymentRegistered.DateTo, Is.EqualTo(paymentTerm.EndDate));
}
public void MarkPaymentAsPayed_WhenIsNotPayed_IsPayed()
{
var payerId = new PayerId(Guid.NewGuid());
var meetingId = new MeetingId(Guid.NewGuid());
var fee = new MoneyValue(100, "EUR");
var paymentDate = DateTime.UtcNow;
SystemClock.Set(paymentDate);
var meetingPayment = MeetingPayment.CreatePaymentForMeeting(payerId, meetingId, fee);
meetingPayment.MarkIsPayed();
var meetingPayed = GetPublishedDomainEvent <MeetingPayedDomainEvent>(meetingPayment);
Assert.That(meetingPayed.MeetingId, Is.EqualTo(meetingId));
Assert.That(meetingPayed.PayerId, Is.EqualTo(payerId));
Assert.That(meetingPayed.PaymentDate, Is.EqualTo(paymentDate));
}
public static MeetingFee Create(
PayerId payerId,
MeetingId meetingId,
MoneyValue fee)
{
var meetingFee = new MeetingFee();
var meetingFeeCreated = new MeetingFeeCreatedDomainEvent(
Guid.NewGuid(),
payerId.Value,
meetingId.Value,
fee.Value,
fee.Currency,
MeetingFeeStatus.WaitingForPayment.Code);
meetingFee.Apply(meetingFeeCreated);
meetingFee.AddDomainEvent(meetingFeeCreated);
return(meetingFee);
}
public void RegisterPayment_TermsAreOverlapping_BreaksPaymentTermsCannotOverlapRule()
{
var meetingGroupId = new MeetingGroupId(Guid.NewGuid());
var paymentScheduleForMeetingGroup = MeetingGroupPaymentRegister.CreatePaymentScheduleForMeetingGroup(meetingGroupId);
var payerId = new PayerId(Guid.NewGuid());
var paymentTerm = new PaymentTerm(
new DateTime(2019, 1, 1),
new DateTime(2019, 1, 31));
paymentScheduleForMeetingGroup.RegisterPayment(
paymentTerm, payerId);
var nextPaymentTerm = new PaymentTerm(
new DateTime(2019, 1, 31),
new DateTime(2019, 2, 28));
AssertBrokenRule <MeetingGroupPaymentsCannotOverlapRule>(() =>
{
paymentScheduleForMeetingGroup.RegisterPayment(
nextPaymentTerm, payerId);
});
}
public void RegisterPayment(PaymentTerm term, PayerId payerId)
{
_payments.Add(new MeetingGroupPayment(term, payerId));
this.AddDomainEvent(new PaymentRegisteredDomainEvent(this.Id, term.EndDate));
}
public SubscriptionPaymentTestData(PriceList priceList, PayerId payerId, SubscriptionId subscriptionId)
{
PriceList = priceList;
PayerId = payerId;
SubscriptionId = subscriptionId;
}
public async Task <MeetingPayment> GetByIdAsync(PayerId payerId, MeetingId meetingId)
{
return(await _paymentsContext.MeetingPayments.FirstOrDefaultAsync(x =>
x.PayerId == payerId && x.MeetingId == meetingId));
}
public override string ToString()
{
return(PayerId.ToString());
}
public static MeetingPayment CreatePaymentForMeeting(PayerId payerId, MeetingId meetingId, MoneyValue fee)
{
return(new MeetingPayment(payerId, meetingId, fee));
}
