internal Transaction(TransactionKind kind, double amount, Account account, Account secondAccount = null)
{
if (kind == TransactionKind.None ||
!Enum.IsDefined(typeof(TransactionKind), kind))
{
throw new InvalidEnumArgumentException(nameof(kind), (int)kind, typeof(TransactionKind));
}
if (kind == TransactionKind.Transfer)
{
if (secondAccount == null)
{
throw new ArgumentNullException(nameof(secondAccount));
}
}
else if (secondAccount != null)
{
throw new ArgumentOutOfRangeException(nameof(secondAccount));
}
Date = DateTime.Now;
Kind = kind;
Amount = amount;
Account = account ?? throw new ArgumentNullException(nameof(account));
SecondAccount = secondAccount;
}
protected Refund(Guid id, TransactionKind kind, decimal debited, Wallet debitedWallet, User author)
: base(id, kind, author)
{
DebitedWallet = debitedWallet;
DebitedWalletId = debitedWallet.Id;
Debited = debited;
}
public void valid(string code, TransactionKind expected)
{
var kind = new RequestCode(code);
Assert.Equal(expected, kind.Value);
Assert.Equal(expected.ToString(), kind.ToString());
}
protected Transaction(Guid id, TransactionKind kind, User author)
{
Id = id;
Kind = kind;
Author = author;
AuthorId = author.Id;
Status = TransactionStatus.Waiting;
}
public RequestCode(TransactionKind kind)
{
if (kind == TransactionKind.None)
{
throw new ArgumentException($"{nameof(TransactionKind)} must not be {kind}");
}
Value = kind;
}
public RequestCode(string value)
{
FieldTypes.AssertA100(value);
if (!Enum.IsDefined(typeof(TransactionKind), value))
{
throw new ArgumentException($"Unknown value '{value}'");
}
Value = (TransactionKind)Enum.Parse(typeof(TransactionKind), value);
}
private void ParseTransactionChildren(XElement xElement, TransactionKind transactionKind)
{
var childElements = xElement.Elements(XmlParsersConfig.ElementTransactionKind);
foreach (var childElement in childElements)
{
var childKind = ParseTransactionKind(childElement);
transactionKind.AddChild(childKind);
ParseTransactionChildren(childElement, childKind);
}
}
protected Payin(Guid id, TransactionKind kind, Wallet creditedWallet, Order order)
: base(id, kind, creditedWallet.User)
{
Order = order;
OrderId = order.Id;
Fees = order.FeesPrice;
Debited = order.TotalPrice;
CreditedWallet = creditedWallet;
CreditedWalletId = creditedWallet.Id;
Reference = "SHEAFT";
DomainEvents = new List <DomainEvent>();
Refunds = new List <PayinRefund>();
}
private List <TransactionKind> GetTransactionDefinitions(ProcessKind process)
{
var t1 = new TransactionKind("T1", "Rental contracting", process.Id, actorRenter.Id, actorRentalContracter.Id);
var t2 = new TransactionKind("T2", "Rental payment", process.Id, actorRentalContracter.Id, actorRenter.Id);
var t3 = new TransactionKind("T3", "Car pick up", process.Id, actorDriver.Id, actorCarIssuer.Id);
var t4 = new TransactionKind("T4", "Car drop off", process.Id, actorCarIssuer.Id, actorDriver.Id);
var t5 = new TransactionKind("T5", "Penalty payment", process.Id, actorCarIssuer.Id, actorDriver.Id);
t1.AddChild(t2);
t3.AddChild(t4);
t3.AddChild(t5);
process.AddTransactionLink(t1, t2, TransactionCompletion.Requested, TransactionCompletion.Promised, TransactionLinkType.Response);
process.AddTransactionLink(t2, t1, TransactionCompletion.Promised, TransactionCompletion.Promised, TransactionLinkType.Waiting);
process.AddTransactionLink(t2, t1, TransactionCompletion.Accepted, TransactionCompletion.Executed, TransactionLinkType.Waiting);
process.AddTransactionLink(t3, t4, TransactionCompletion.Promised, TransactionCompletion.Requested, TransactionLinkType.Response);
process.AddTransactionLink(t4, t3, TransactionCompletion.Promised, TransactionCompletion.Executed, TransactionLinkType.Waiting);
var linkT4T5Reject = new TransactionLink()
{
SourceTransactionKindId = t4.Id,
DestinationTransactionKindId = t5.Id,
SourceCompletion = TransactionCompletion.Rejected,
DestinationCompletion = TransactionCompletion.Requested,
SourceCardinality = TransactionLinkCardinality.ZeroToOne,
Type = TransactionLinkType.Response
};
process.AddTransactionLink(linkT4T5Reject);
var linkT5T4Ac = new TransactionLink()
{
SourceTransactionKindId = t5.Id,
DestinationTransactionKindId = t4.Id,
SourceCompletion = TransactionCompletion.Accepted,
DestinationCompletion = TransactionCompletion.Accepted,
DestinationCardinality = TransactionLinkCardinality.ZeroToOne,
Type = TransactionLinkType.Waiting
};
process.AddTransactionLink(linkT5T4Ac);
return(new List <TransactionKind> {
t1, t3
});
}
private static XElement CreateTransactionKindElement(TransactionKind kind)
{
var kindElement = new XElement(XmlParsersConfig.ElementTransactionKind);
kindElement.Add(new XAttribute(XmlParsersConfig.AttributeId, kind.Id));
kindElement.Add(new XAttribute(XmlParsersConfig.AttributeIdentificator, kind.Identificator));
kindElement.Add(new XAttribute(XmlParsersConfig.AttributeFirstName, kind.Name));
kindElement.Add(new XAttribute(XmlParsersConfig.AttributeOptimisticTimeEstimate, kind.OptimisticTimeEstimate));
kindElement.Add(new XAttribute(XmlParsersConfig.AttributeNormalTimeEstimate, kind.NormalTimeEstimate));
kindElement.Add(new XAttribute(XmlParsersConfig.AttributePesimisticTimeEstimate, kind.PesimisticTimeEstimate));
kindElement.Add(new XAttribute(XmlParsersConfig.AttributeProcessKindId, kind.ProcessKindId));
kindElement.Add(new XAttribute(XmlParsersConfig.AttributeInitiatorRoleId, kind.InitiatorKindId));
kindElement.Add(new XAttribute(XmlParsersConfig.AttributeExecutorRoleId, kind.ExecutorKindId));
return(kindElement);
}
/// <summary>
/// Convenience function for running tests. Creates an object and automatically adds it to the queue for deleting after tests finish.
/// </summary>
public async Task <Transaction> Create(long orderId, TransactionKind kind = TransactionKind.Capture, bool skipAddToCreatedList = false)
{
var obj = await Service.CreateAsync(orderId, new Transaction()
{
Amount = Amount,
Currency = Currency,
Gateway = Gateway,
Status = Status,
Test = true,
Kind = kind
});
if (!skipAddToCreatedList)
{
Created.Add(obj);
}
return(obj);
}
private TransactionKind ParseTransactionKind(XElement xElement)
{
var transaction = new TransactionKind()
{
Id = int.Parse(xElement.Attribute(XmlParsersConfig.AttributeId).Value),
Identificator = xElement.Attribute(XmlParsersConfig.AttributeIdentificator).Value,
Name = xElement.Attribute(XmlParsersConfig.AttributeName).Value,
ProcessKindId = int.Parse(xElement.Attribute(XmlParsersConfig.AttributeProcessKindId).Value),
InitiatorKindId = xElement.Attribute(XmlParsersConfig.AttributeInitiatorRoleId).Value.ToNullableInt(),
ExecutorKindId = xElement.Attribute(XmlParsersConfig.AttributeExecutorRoleId).Value.ToNullableInt(),
ParentId = xElement.Attribute(XmlParsersConfig.AttributeParentid).Value.ToNullableInt()
};
var optimisticTime = double.Parse(xElement.Attribute(XmlParsersConfig.AttributeOptimisticTimeEstimate).Value);
var normalTime = double.Parse(xElement.Attribute(XmlParsersConfig.AttributeNormalTimeEstimate).Value);
var pesimisticTime = double.Parse(xElement.Attribute(XmlParsersConfig.AttributePesimisticTimeEstimate).Value);
transaction.SetTimeEstimate(optimisticTime, normalTime, pesimisticTime);
return(transaction);
}
protected Refund(Guid id, TransactionKind kind, Transfer transaction)
: this(id, kind, transaction.Credited, transaction.CreditedWallet, transaction.Author)
{
}
public override object ConvertTo(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, System.Type destinationType)
{
if ((value == null))
{
return(null);
}
TransactionKind valueCasted = ((TransactionKind)(value));
if ((valueCasted == TransactionKind.TokenExchange))
{
return("tokenExchange");
}
if ((valueCasted == TransactionKind.Other))
{
return("other");
}
if ((valueCasted == TransactionKind.TaxChargePayment))
{
return("taxChargePayment");
}
if ((valueCasted == TransactionKind.TokenCancellation))
{
return("tokenCancellation");
}
if ((valueCasted == TransactionKind.TokenSalePayment))
{
return("tokenSalePayment");
}
if ((valueCasted == TransactionKind.ServiceChargePayment))
{
return("serviceChargePayment");
}
if ((valueCasted == TransactionKind.AccountPayment))
{
return("accountPayment");
}
if ((valueCasted == TransactionKind.TokenGrant))
{
return("tokenGrant");
}
if ((valueCasted == TransactionKind.DiversePayment))
{
return("diversePayment");
}
if ((valueCasted == TransactionKind.TokenFreeIssue))
{
return("tokenFreeIssue");
}
if ((valueCasted == TransactionKind.MeterConfigurationToken))
{
return("meterConfigurationToken");
}
if ((valueCasted == TransactionKind.AuxiliaryChargePayment))
{
return("auxiliaryChargePayment");
}
if ((valueCasted == TransactionKind.TransactionReversal))
{
return("transactionReversal");
}
throw new ArgumentOutOfRangeException("value");
}
