public async Task <IActionResult> SetPermission([FromBody] PermissionsDto newPermission)
{
int environmentOwnerId = await _repo.GetEnvironmentOwnerId(newPermission.EnvironmentId);
//TODO Umbauen?
AuthorizationResult authorization = await _authService.AuthorizeAsync(User, null,
new[]
{
new ChangePermissionRequirement(newPermission.EnvironmentId, environmentOwnerId, newPermission.UserId,
PermissionFlags.IsOwner | PermissionFlags.ManageUsers)
});
if (!authorization.Succeeded)
{
return(Unauthorized());
}
Permission currentPermission = await _repo.GetUserPermission(newPermission.EnvironmentId, newPermission.UserId);
_mapper.Map(newPermission, currentPermission);
currentPermission.Serial = SerialGenerator.Generate();
_permissionsCache.Update(currentPermission.UserId, currentPermission.Environment.Id, currentPermission);
if (await _repo.SaveAll())
{
return(NoContent());
}
throw new Exception($"Error saving permissions user:{newPermission.UserId} env:{newPermission.EnvironmentId}");
}
public static bool Prefix(LG_ComputerTerminal terminal, TerminalUplinkPuzzle __instance)
{
__instance.m_rounds = new Il2CppSystem.Collections.Generic.List <TerminalUplinkPuzzleRound>();
__instance.TerminalUplinkIP = SerialGenerator.GetIpAddress();
__instance.m_roundIndex = 0;
__instance.m_lastRoundIndexToUpdateGui = -1;
__instance.m_position = terminal.transform.position;
int num = RandomUtil.TerminalRound.GetRound();
for (int i = 0; i < num; i++)
{
int num2 = 6;
TerminalUplinkPuzzleRound terminalUplinkPuzzleRound = new TerminalUplinkPuzzleRound();
terminalUplinkPuzzleRound.CorrectIndex = Builder.SessionSeedRandom.Range(0, num2, "NO_TAG");
terminalUplinkPuzzleRound.Prefixes = new string[num2];
terminalUplinkPuzzleRound.Codes = new string[num2];
for (int j = 0; j < num2; j++)
{
terminalUplinkPuzzleRound.Codes[j] = RandomUtil.GetPassword(5);
terminalUplinkPuzzleRound.Prefixes[j] = SerialGenerator.GetCodeWordPrefix();
}
__instance.m_rounds.Add(terminalUplinkPuzzleRound);
}
Log.Debug($"Terminal {terminal.PublicName} has {__instance.m_rounds.Count} rounds");
return(false);
}
public async Task <bool> JoinEnvironment(int userId, int environmentId)
{
var permission = new Permission()
{
UserId = userId,
EnvironmentId = environmentId,
Serial = SerialGenerator.Generate()
};
await _context.Permissions.AddAsync(permission);
Invitation invitation = await _context.Invitations.FirstOrDefaultAsync(i =>
i.EnvironmentId == environmentId &&
i.InviteeId == userId);
invitation.AnsweredOn = DateTime.Now;
return(await _context.SaveChangesAsync() > 0);
}
public void Generate_StateUnderTest_ExpectedBehavior()
{
// Arrange
var Movie = new Movie();
Movie.Number = 1;
Movie.ReleaseDate = System.DateTime.Now;
// Act
var result = SerialGenerator.Generate(
Movie);
System.Console.WriteLine(result);
// Assert
Assert.AreEqual(result[1], "ACME#01-" + System.String.Format("{0:MMyy}", System.DateTime.Now) + "-R");
Assert.AreEqual(result[0], "ACME#01-" + System.String.Format("{0:MMyy}", System.DateTime.Now) + "-W");
}
public async Task <User> CreateFirstEnvironment(User newUser)
{
var environment = new BeepEnvironment()
{
Name = $"Zu Hause von {newUser.DisplayName}", User = newUser, DefaultEnvironment = true
};
var permissions = new Permission()
{
IsOwner = true, User = newUser, Environment = environment, Serial = SerialGenerator.Generate()
};
await _context.AddAsync(environment);
await _context.AddAsync(permissions);
await _context.SaveChangesAsync();
return(newUser);
}
public async Task <BeepEnvironment> AddEnvironment(int userId)
{
User owner = await _context.Users.FirstOrDefaultAsync(u => u.Id == userId);
var newEnv = new BeepEnvironment()
{
Name = "Neue Umgebung", User = owner
};
var permission = new Permission()
{
IsOwner = true, Environment = newEnv, User = owner, Serial = SerialGenerator.Generate()
};
await _context.Permissions.AddAsync(permission);
await _context.Environments.AddAsync(newEnv);
return(await _context.SaveChangesAsync() > 0 ? newEnv : null);
}
protected void JoinEnvironment(string userName, string environmentName, Permission withPermission)
{
withPermission ??= new Permission();
User user = DbContext.Users.FirstOrDefault(u => u.UserName == userName);
BeepEnvironment env = DbContext.Environments.FirstOrDefault(e => e.Name == environmentName);
if (user == null || env == null)
{
return;
}
withPermission.User = user;
withPermission.Environment = env;
withPermission.Serial = SerialGenerator.Generate();
DbContext.Permissions.Add(withPermission);
DbContext.SaveChanges();
}
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return(NotFound());
}
var serial = SerialGenerator.Generate(movie);
ViewData["Serial-W"] = serial[0];
ViewData["Serial-R"] = serial[1];
return(View(movie));
}
public async Task <Invitation> InviteMemberByMail(string email, int envitonmentId)
{
bool isNewUser = false;
User invitee = await _context.Users.FirstOrDefaultAsync(u => u.Email == email);
if (invitee == null)
{
isNewUser = true;
invitee = new User()
{
UserName = email,
DisplayName = email,
LockoutEnabled = true
};
IdentityResult result = await _userMgr.CreateAsync(invitee, SerialGenerator.Generate());
IdentityResult roleResult = await _userMgr.AddToRoleAsync(invitee, RoleNames.Dummy);
if (!result.Succeeded || !roleResult.Succeeded)
{
return(null);
}
}
var invitation = new Invitation()
{
Invitee = invitee,
EnvironmentId = envitonmentId,
IssuedAt = DateTime.Now,
Serial = isNewUser ? SerialGenerator.Generate() : string.Empty
};
await _context.AddAsync(invitation);
return(await _context.SaveChangesAsync() > 0 ? invitation : null);
}
/// <summary>
/// Erstellt einen User mit Member Rolle
/// </summary>
/// <param name="displayName"></param>
protected void SeedUser(string displayName)
{
var newUser = new User()
{
UserName = displayName.ToLower().Replace(" ", ""),
DisplayName = displayName,
Email = $"{displayName.ToLower().Replace(" ", "")}@abc.ch"
};
var newEnvironment = new BeepEnvironment()
{
Name = $"Zu Hause von {displayName}",
DefaultEnvironment = true,
User = newUser
};
UsrManager.CreateAsync(newUser, "P@ssw0rd").Wait();
string confirmationToken = UsrManager.GenerateEmailConfirmationTokenAsync(newUser).Result;
IdentityResult result = UsrManager.ConfirmEmailAsync(newUser, confirmationToken).Result;
if (!result.Succeeded)
{
OutputWriter.WriteLine(string.Join("\n", result.Errors));
}
UsrManager.AddToRoleAsync(newUser, RoleNames.Member).Wait();
DbContext.Environments.Add(newEnvironment);
DbContext.Permissions.Add(new Permission()
{
IsOwner = true,
User = newUser,
Environment = newEnvironment,
Serial = SerialGenerator.Generate()
});
DbContext.SaveChanges();
}
/// <summary>
/// 对订单进行发货
/// 当所有商品已发货时，设置订单为已发货
/// </summary>
/// <param name="orderId">订单Id</param>
/// <param name="operatorId">发货人Id</param>
/// <param name="logisticsId">物流Id</param>
/// <param name="invoiceNo">快递单编号</param>
/// <param name="remark">备注</param>
/// <param name="deliveryCounts">订单商品Id到发货数量的索引</param>
public virtual void DeliveryGoods(
Guid orderId, Guid?operatorId,
Guid logisticsId, string invoiceNo,
string remark, IDictionary <Guid, long> deliveryCounts)
{
var unitOfWork = Application.Ioc.Resolve <IUnitOfWork>();
using (unitOfWork.Scope()) {
// 开始事务
unitOfWork.Context.BeginTransaction();
// 获取订单
var orderManager = Application.Ioc.Resolve <SellerOrderManager>();
var order = orderManager.Get(orderId);
if (order == null)
{
throw new BadRequestException(new T("Order not exist"));
}
// 获取物流
var containsRealProduct = order.ContainsRealProduct();
var logisticsManager = Application.Ioc.Resolve <LogisticsManager>();
var logistics = containsRealProduct ? logisticsManager.Get(logisticsId) : null;
if (!containsRealProduct)
{
// 虚拟商品不需要物流和快递单编号
}
else if (logistics == null)
{
throw new BadRequestException(new T("Selected logistics does not exist"));
}
else if (string.IsNullOrEmpty(invoiceNo))
{
throw new BadRequestException(new T("Please provide logistics serial (invoice no)"));
}
// 检查发货数量
if (deliveryCounts.Sum(c => c.Value) <= 0)
{
throw new BadRequestException(new T("No products to be delivery"));
}
var unshippedMapping = GetUnshippedProductMapping(order);
foreach (var count in deliveryCounts)
{
if (!unshippedMapping.ContainsKey(count.Key))
{
throw new BadRequestException(new T("Can't delivery product that not exists in order"));
}
else if (count.Value < 0)
{
throw new BadRequestException(new T("Invalid delivery count"));
}
else if (count.Value > unshippedMapping[count.Key])
{
throw new BadRequestException(new T("Delivery count can't be larger than unshipped count"));
}
}
// 添加发货单
var userManager = Application.Ioc.Resolve <UserManager>();
var delivery = new OrderDelivery()
{
Order = order,
Logistics = logistics,
LogisticsSerial = invoiceNo,
Operator = operatorId.HasValue ? userManager.Get(operatorId.Value) : null,
Remark = remark
};
delivery.Serial = SerialGenerator.GenerateFor(delivery);
Save(ref delivery);
foreach (var count in deliveryCounts.Where(p => p.Value > 0))
{
var orderProduct = order.OrderProducts.First(p => p.Id == count.Key);
var orderDeliveryToOrderProduct = new OrderDeliveryToOrderProduct()
{
OrderDelivery = delivery,
OrderProduct = orderProduct,
Count = count.Value
};
orderProduct.Deliveries.Add(orderDeliveryToOrderProduct);
}
var orderRepository = Application.Ioc.Resolve <IRepository <SellerOrder, Guid> >();
orderRepository.Save(ref order, null);
// 当所有商品已发货时，设置订单为已发货
if (deliveryCounts.Sum(c => c.Value) == unshippedMapping.Sum(c => c.Value))
{
var canProcessAllGoodsShipped = order.Check(c => c.CanProcessAllGoodsShipped);
if (!canProcessAllGoodsShipped.First)
{
throw new BadRequestException(canProcessAllGoodsShipped.Second);
}
orderManager.ProcessAllGoodsShipped(orderId);
}
// 结束事务
unitOfWork.Context.FinishTransaction();
}
}
/// <summary>
/// 按卖家分别创建订单
/// </summary>
protected virtual void CreateOrdersBySellers()
{
var orderManager = Application.Ioc.Resolve <SellerOrderManager>();
var userManager = Application.Ioc.Resolve <UserManager>();
var productManager = Application.Ioc.Resolve <ProductManager>();
var buyerOrderManager = Application.Ioc.Resolve <BuyerOrderManager>();
var transactionManager = Application.Ioc.Resolve <PaymentTransactionManager>();
var products = new Dictionary <Guid, Product>();
var groupedProductParameters = Parameters.OrderProductParametersList.Select(p => new {
productParameters = p,
product = products.GetOrCreate(p.ProductId, () => productManager.Get(p.ProductId))
}).GroupBy(p => p.product.Seller?.Id).ToList(); // { 卖家: [ (参数, 商品) ] }
var now = DateTime.UtcNow;
foreach (var group in groupedProductParameters)
{
// 计算订单的价格
// 支付手续费需要单独提取出来
var orderPrice = orderManager.CalculateOrderPrice(
Parameters.CloneWith(group.Select(o => o.productParameters).ToList()));
var paymentFee = orderPrice.Parts.FirstOrDefault(p => p.Type == "PaymentFee");
orderPrice.Parts.Remove(paymentFee);
// 生成卖家订单
var sellerOrder = new SellerOrder()
{
Buyer = Parameters.UserId == null ? null : userManager.Get(Parameters.UserId.Value),
Owner = (group.Key == null) ? null : userManager.Get(group.Key.Value),
State = OrderState.WaitingBuyerPay,
OrderParameters = Parameters.OrderParameters,
TotalCost = orderPrice.Parts.Sum(),
Currency = orderPrice.Currency,
TotalCostCalcResult = orderPrice,
OriginalTotalCostCalcResult = orderPrice,
StateTimes = new OrderStateTimes()
{
{ OrderState.WaitingBuyerPay, now }
}
};
// 添加关联的订单商品
// 这里会重新计算单价，但应该和之前的计算结果一样
foreach (var obj in group)
{
var unitPrice = orderManager.CalculateOrderProductUnitPrice(
Parameters.UserId, obj.productParameters);
var orderCount = obj.productParameters.MatchParameters.GetOrderCount();
var properties = obj.productParameters.MatchParameters.GetProperties();
var orderProduct = new OrderProduct()
{
Id = GuidUtils.SequentialGuid(now),
Order = sellerOrder,
Product = obj.product,
MatchParameters = obj.productParameters.MatchParameters,
Count = orderCount,
UnitPrice = unitPrice.Parts.Sum(),
Currency = unitPrice.Currency,
UnitPriceCalcResult = unitPrice,
OriginalUnitPriceCalcResult = unitPrice,
CreateTime = now,
UpdateTime = now
};
// 添加关联的属性
foreach (var productToPropertyValue in obj.product
.FindPropertyValuesFromPropertyParameters(properties))
{
orderProduct.PropertyValues.Add(new OrderProductToPropertyValue()
{
Id = GuidUtils.SequentialGuid(now),
OrderProduct = orderProduct,
Category = obj.product.Category,
Property = productToPropertyValue.Property,
PropertyValue = productToPropertyValue.PropertyValue,
PropertyValueName = productToPropertyValue.PropertyValueName
});
}
sellerOrder.OrderProducts.Add(orderProduct);
}
// 添加关联的订单留言
var comment = Parameters.OrderParameters.GetOrderComment();
if (!string.IsNullOrEmpty(comment))
{
sellerOrder.OrderComments.Add(new OrderComment()
{
Id = GuidUtils.SequentialGuid(now),
Order = sellerOrder,
Owner = sellerOrder.Buyer,
Side = OrderCommentSide.BuyerComment,
Contents = comment,
CreateTime = now,
UpdateTime = now
});
}
// 生成订单编号
sellerOrder.Serial = SerialGenerator.GenerateFor(sellerOrder);
// 保存卖家订单
orderManager.Save(ref sellerOrder);
Result.CreatedSellerOrders.Add(sellerOrder);
// 生成买家订单
var buyerOrder = new BuyerOrder()
{
Owner = sellerOrder.Buyer,
SellerOrder = sellerOrder,
BuyerSessionId = (sellerOrder.Buyer != null) ? null : (Guid?)Parameters.SessionId
};
// 保存买家订单
buyerOrderManager.Save(ref buyerOrder);
Result.CreatedBuyerOrders.Add(buyerOrder);
// 创建订单交易
// 因为目前只能使用后台的支付接口，所以收款人应该是null
var paymentApiId = Parameters.OrderParameters.GetPaymentApiId();
var transaction = transactionManager.CreateTransaction(
OrderTransactionHandler.ConstType,
paymentApiId,
sellerOrder.TotalCost,
paymentFee?.Delta ?? 0,
sellerOrder.Currency,
sellerOrder.Buyer?.Id,
null,
sellerOrder.Id,
sellerOrder.Serial);
Result.CreatedTransactions.Add(transaction);
}
}
/// <summary>
/// 按卖家分别创建订单
/// </summary>
protected virtual void CreateOrdersBySellers()
{
var orderManager = Application.Ioc.Resolve <OrderManager>();
var userRepository = RepositoryResolver.Resolve <User>(Context);
var productRepository = RepositoryResolver.Resolve <Product>(Context);
var orderRepository = RepositoryResolver.Resolve <Database.Order>(Context);
var transactionRepository = RepositoryResolver
.ResolveRepository <PaymentTransactionRepository>(Context);
var products = new Dictionary <long, Product>();
var groupedProductParameters = Parameters.OrderProductParametersList.Select(p => new {
productParameters = p,
product = products.GetOrCreate(p.ProductId, () => productRepository.GetById(p.ProductId))
}).GroupBy(p => (p.product.Seller == null) ? null : (long?)p.product.Seller.Id).ToList();
var now = DateTime.UtcNow;
foreach (var group in groupedProductParameters)
{
// 计算订单的价格
// 支付手续费需要单独提取出来
var orderPrice = orderManager.CalculateOrderPrice(
Parameters.CloneWith(group.Select(o => o.productParameters).ToList()));
var paymentFee = orderPrice.Parts.FirstOrDefault(p => p.Type == "PaymentFee");
orderPrice.Parts.Remove(paymentFee);
// 生成订单
var order = new Database.Order()
{
Buyer = userRepository.GetById(Parameters.UserId),
BuyerSessionId = Parameters.SessionId,
Seller = (group.Key == null) ? null : userRepository.GetById(group.Key),
State = OrderState.WaitingBuyerPay,
OrderParameters = Parameters.OrderParameters,
TotalCost = orderPrice.Parts.Sum(),
Currency = orderPrice.Currency,
TotalCostCalcResult = orderPrice,
OriginalTotalCostCalcResult = orderPrice,
CreateTime = now,
LastUpdated = now,
StateTimes = new OrderStateTimes()
{
{ OrderState.WaitingBuyerPay, now }
}
};
// 添加关联的订单商品
// 这里会重新计算单价，但应该和之前的计算结果一样
foreach (var obj in group)
{
var unitPrice = orderManager.CalculateOrderProductUnitPrice(
Parameters.UserId, obj.productParameters);
var orderCount = obj.productParameters.MatchParameters.GetOrderCount();
var properties = obj.productParameters.MatchParameters.GetProperties();
var orderProduct = new OrderProduct()
{
Order = order,
Product = obj.product,
MatchParameters = obj.productParameters.MatchParameters,
Count = orderCount,
UnitPrice = unitPrice.Parts.Sum(),
Currency = unitPrice.Currency,
UnitPriceCalcResult = unitPrice,
OriginalUnitPriceCalcResult = unitPrice,
CreateTime = now,
LastUpdated = now
};
// 添加关联的属性
foreach (var productToPropertyValue in obj.product
.FindPropertyValuesFromPropertyParameters(properties))
{
orderProduct.PropertyValues.Add(new Database.OrderProductToPropertyValue()
{
OrderProduct = orderProduct,
Category = obj.product.Category,
Property = productToPropertyValue.Property,
PropertyValue = productToPropertyValue.PropertyValue,
PropertyValueName = productToPropertyValue.PropertyValueName
});
}
order.OrderProducts.Add(orderProduct);
}
// 添加关联的订单留言
var comment = Parameters.OrderParameters.GetOrderComment();
if (!string.IsNullOrEmpty(comment))
{
order.OrderComments.Add(new Database.OrderComment()
{
Order = order,
Creator = order.Buyer,
Side = OrderCommentSide.BuyerComment,
Content = comment,
CreateTime = now
});
}
// 生成订单编号
order.Serial = SerialGenerator.GenerateFor(order);
// 保存订单
orderRepository.Save(ref order);
Result.CreatedOrders.Add(order);
// 创建订单交易
// 因为目前只能使用后台的支付接口，所以收款人应该是null
var paymentApiId = Parameters.OrderParameters.GetPaymentApiId();
var transaction = transactionRepository.CreateTransaction(
OrderTransactionHandler.ConstType, paymentApiId, order.TotalCost,
(paymentFee == null) ? 0 : paymentFee.Delta, order.Currency,
(order.Buyer == null) ? null : (long?)order.Buyer.Id, null, order.Id, order.Serial);
Result.CreatedTransactions.Add(transaction);
}
}
/// <summary>
/// 创建交易
/// </summary>
/// <param name="transactionType">交易类型</param>
/// <param name="paymentApiId">支付接口Id</param>
/// <param name="amount">交易金额</param>
/// <param name="paymentFee">手续费</param>
/// <param name="currencyType">货币类型</param>
/// <param name="payerId">付款人Id</param>
/// <param name="payeeId">收款人Id</param>
/// <param name="releatedId">关联对象Id</param>
/// <param name="description">描述</param>
/// <param name="extraData">附加数据</param>
/// <param name="releatedTransactions">关联的交易列表</param>
/// <returns></returns>
public virtual PaymentTransaction CreateTransaction(
string transactionType, Guid paymentApiId,
decimal amount, decimal paymentFee, string currencyType, Guid?payerId, Guid?payeeId,
Guid?releatedId, string description, object extraData = null,
IList <PaymentTransaction> releatedTransactions = null)
{
using (UnitOfWork.Scope()) {
// 开启事务
UnitOfWork.Context.BeginTransaction();
// 检查参数
if (amount <= 0)
{
throw new BadRequestException("Transaction amount must large than zero");
}
else if (string.IsNullOrEmpty(description))
{
throw new BadRequestException("Transaction description is required");
}
// 检查接口是否可以使用
var apiManager = Application.Ioc.Resolve <PaymentApiManager>();
var api = apiManager.Get(paymentApiId);
if (api == null)
{
throw new BadRequestException(new T("Payment api not exist"));
}
else if (!api.SupportTransactionTypes.Contains(transactionType))
{
throw new BadRequestException(new T("Selected payment api not support this transaction"));
}
else if (api.Deleted)
{
throw new BadRequestException(new T("Selected payment api is deleted"));
}
// 保存交易到数据库
var userManager = Application.Ioc.Resolve <UserManager>();
var transaction = new PaymentTransaction()
{
Type = transactionType,
Api = api,
Amount = amount,
PaymentFee = paymentFee,
CurrencyType = currencyType,
Payer = (payerId == null) ? null : userManager.Get(payerId.Value),
Payee = (payeeId == null) ? null : userManager.Get(payeeId.Value),
ReleatedId = releatedId,
Description = description,
State = PaymentTransactionState.Initial,
ExtraData = extraData.ConvertOrDefault <PaymentTransactionExtraData>()
};
if (releatedTransactions != null)
{
transaction.ReleatedTransactions.AddRange(releatedTransactions);
}
transaction.Serial = SerialGenerator.GenerateFor(transaction);
Save(ref transaction);
// 调用创建交易后的处理
var handlers = transaction.GetHandlers();
handlers.ForEach(h => h.OnCreated(transaction));
// 记录结果到数据库
AddDetailRecord(transaction.Id, null, new T("Transaction Created"));
// 结束事务
UnitOfWork.Context.FinishTransaction();
return(transaction);
}
}
/// <summary>
/// 创建交易
/// </summary>
/// <param name="transactionType">交易类型</param>
/// <param name="paymentApiId">支付接口Id</param>
/// <param name="amount">交易金额</param>
/// <param name="paymentFee">手续费</param>
/// <param name="currencyType">货币类型</param>
/// <param name="payerId">付款人Id</param>
/// <param name="payeeId">收款人Id</param>
/// <param name="releatedId">关联对象Id</param>
/// <param name="description">描述</param>
/// <param name="extraData">附加数据</param>
/// <param name="releatedTransactions">关联的交易列表</param>
/// <returns></returns>
public virtual PaymentTransaction CreateTransaction(
string transactionType, long paymentApiId,
decimal amount, decimal paymentFee, string currencyType, long?payerId, long?payeeId,
long?releatedId, string description, object extraData = null,
IList <PaymentTransaction> releatedTransactions = null)
{
// 检查参数
if (amount <= 0)
{
throw new BadRequestException("Transaction amount must large than zero");
}
else if (string.IsNullOrEmpty(description))
{
throw new BadRequestException("Transaction description is required");
}
// 检查接口是否可以使用
var api = Context.Get <PaymentApi>(a => a.Id == paymentApiId);
if (api == null)
{
throw new BadRequestException(new T("Payment api not exist"));
}
else if (!api.SupportTransactionTypes.Contains(transactionType))
{
throw new BadRequestException(new T("Selected payment api not support this transaction"));
}
else if (api.Deleted)
{
throw new BadRequestException(new T("Selected payment api is deleted"));
}
// 保存交易到数据库
var transaction = new PaymentTransaction()
{
Type = transactionType,
Api = api,
Amount = amount,
PaymentFee = paymentFee,
CurrencyType = currencyType,
Payer = Context.Get <User>(u => u.Id == payerId),
Payee = Context.Get <User>(u => u.Id == payeeId),
ReleatedId = releatedId,
Description = description,
State = PaymentTransactionState.Initial,
ExtraData = extraData.ConvertOrDefault <PaymentTransactionExtraData>(),
CreateTime = DateTime.UtcNow,
LastUpdated = DateTime.UtcNow
};
if (releatedTransactions != null)
{
transaction.ReleatedTransactions.AddRange(releatedTransactions);
}
transaction.Serial = SerialGenerator.GenerateFor(transaction);
Save(ref transaction);
// 调用创建交易后的处理
var handlers = transaction.GetHandlers();
handlers.ForEach(h => h.OnCreated(Context, transaction));
// 记录结果到数据库
AddDetailRecord(transaction.Id, null, new T("Transaction Created"));
return(transaction);
}
