public async Task <JsonResult> Save(SettlementModel settlement)
{
var settlementToSend = new SettlementCatalog
{
ID = settlement.ID.Value,
CASUSMO = settlement.CASUSMO,
CASISR86 = settlement.CASISR86,
CalDirecPerc = settlement.CalDirecPerc,
Indem90 = settlement.Indem90,
Indem20 = settlement.Indem20,
PrimaAntig = settlement.PrimaAntig,
ValidityDate = settlement.Validity,
//Common
Active = true,
company = SessionModel.CompanyID,
InstanceID = SessionModel.InstanceID,
CreationDate = DateTime.Now,
StatusID = 1,
user = SessionModel.IdentityID,
Timestamp = DateTime.Now,
};
//Just update
await client.UpdateAsync(new List <SettlementCatalog>() { settlementToSend }, SessionModel.CompanyID);
return(Json(settlement.ID));
}
/// <summary>
/// 得到会员发票信息
/// </summary>
/// <returns></returns>
protected virtual void SetInvoices(SettlementModel model)
{
var query = new QueryInfo();
query.Query <InvoiceEntity>().Select(it => new object[] { it, it.Title, it.Type, it.GeneralType, it.Content });
model.Invoices = this.GetEntitiesByIdentity <InvoiceEntity>(query);
}
/// <summary>
/// 得到会员地址信息
/// </summary>
/// <returns></returns>
protected virtual void SetAddresses(SettlementModel model)
{
var query = new QueryInfo();
query.Query <AddressEntity>();
model.Addresses = this.GetEntitiesByIdentity <AddressEntity>(query);
}
public void ModelFactory_ConvertFrom_SettlementModel_ModelIsNull_ModelConverted()
{
ModelFactory factory = new ModelFactory();
SettlementModel model = null;
SettlementResponse response = factory.ConvertFrom(model);
response.ShouldBeNull();
}
/// <summary>
/// 结算
/// </summary>
/// <returns></returns>
public async Task <bool> Settlement(SettlementModel settlement)
{
var client = await _clientCreater.CreateClient();
var guid = Guid.Parse(settlement.SettlementID);
var settlementGrain = client.GetGrain <ISettlementGrain>(guid);
return(await settlementGrain.Settlement(settlement));
}
public async Task <SettlementModel> GetSettlement(Guid estateId,
Guid?merchantId,
Guid settlementId,
CancellationToken cancellationToken)
{
SettlementModel model = await this.RepositoryForReports.GetSettlement(estateId, merchantId, settlementId, cancellationToken);
return(model);
}
/// <summary>
/// 得到会员优惠券信息
/// </summary>
/// <returns></returns>
protected virtual void SetCoupons(SettlementModel model)
{
var query = new QueryInfo();
query.Query <CouponEntity>()
.Where(it => it.EndDate >= DateTime.Now.Date && !it.IsUsed)
.Select(it => new object[] { it.Id, it.Name, it.Amount });
model.Coupons = this.GetEntitiesByIdentity <CouponEntity>(query);
}
public async Task <IActionResult> GetSettlement([FromRoute] Guid estateId,
[FromQuery] Guid?merchantId,
[FromRoute] Guid settlementId,
CancellationToken cancellationToken)
{
SettlementModel model = await this.ReportingManager.GetSettlement(estateId, merchantId, settlementId, cancellationToken);
return(this.Ok(this.ModelFactory.ConvertFrom(model)));
}
private void GetTotalProfits()
{
SettlementModel report = new SettlementModel();
report.ShowTotalProfits();
profitsTotalBindingSource.DataSource = report;
profitsTotalBindingSource.DataSource = report.reportSetlementPTotal;
this.ReportViewerSettlement.RefreshReport();
}
private void GetTotalVault()
{
SettlementModel report = new SettlementModel();
report.ShowTotalVault();
vaultTotalBindingSource.DataSource = report;
vaultTotalBindingSource.DataSource = report.reportSetlementVTotal;
this.ReportViewerSettlement.RefreshReport();
}
private void GetReport()
{
SettlementModel report = new SettlementModel();
report.ShowReport();
settlementSummaryBindingSource.DataSource = report;
settlementSummaryBindingSource.DataSource = report.reportSetlementVault;
this.ReportViewerSettlement.RefreshReport();
}
/// <summary>
/// 请求
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
protected virtual ActionResult Settlement(SettlementDto dto)
{
dto.IsGenerate = false;
var model = new SettlementModel();
SetAddresses(model);
SetCoupons(model);
SetInvoices(model);
model.SettlementDto = Ioc.Resolve <IOrderApplicationService>().Create(dto);
SetPartners(model);
return(View("Settlement", model));
}
public ActionResult AuditSettlement(SettlementModel model)
{
try
{
model.AuditUser = CurrentUser.Id;
return(Json(new JsonMessage(service.AuditSettlement(model))));
}
catch (Exception e)
{
return(Json(new JsonMessage(false, e.Message)));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RobinHoodBrokerModel"/> class.
/// </summary>
/// <param name="accounttype">The accounttype.</param>
/// <param name="latencymodel">The latencymodel.</param>
/// <param name="slippagemodel">The slippagemodel.</param>
public RobinHoodBrokerModel(
AccountType accounttype,
LatencyModel latencymodel,
SlippageModel slippagemodel)
: base(accounttype, new RobinhoodFeeModel(), new ImmediateFillBehaviour(), latencymodel, new GenericMarginCallModel(),
new EquityMarginModel(0m, 0m), new ImmediateSettlementModel(), slippagemodel,
new FloatingMarketSpreadModel())
{
//Set delayed settlement model
_delayedSettlementModel = new DelayedSettlementModel(3, TimeSpan.FromHours(4));
//Set compatible currencies
CompatibleBaseCurrencies = new[] { CurrencyType.USD };
}
/// <summary>
/// Gets the settlement.
/// </summary>
/// <param name="estateId">The estate identifier.</param>
/// <param name="merchantId">The merchant identifier.</param>
/// <param name="settlementId">The settlement identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <SettlementModel> GetSettlement(Guid estateId,
Guid?merchantId,
Guid settlementId,
CancellationToken cancellationToken)
{
EstateReportingGenericContext context = await this.DbContextFactory.GetContext(estateId, cancellationToken);
IQueryable <SettlementView> query = context.SettlementsView.Where(t => t.EstateId == estateId && t.SettlementId == settlementId).AsQueryable();
if (merchantId.HasValue)
{
query = query.Where(t => t.MerchantId == merchantId);
}
var result = query.AsEnumerable().GroupBy(t => new {
t.SettlementId,
t.SettlementDate,
t.IsCompleted
}).SingleOrDefault();
if (result == null)
{
return(null);
}
SettlementModel model = new SettlementModel {
SettlementDate = result.Key.SettlementDate,
SettlementId = result.Key.SettlementId,
NumberOfFeesSettled = result.Count(),
ValueOfFeesSettled = result.Sum(x => x.CalculatedValue),
IsCompleted = result.Key.IsCompleted
};
result.ToList().ForEach(f => model.SettlementFees.Add(new SettlementFeeModel {
SettlementDate = f.SettlementDate,
SettlementId = f.SettlementId,
CalculatedValue = f.CalculatedValue,
MerchantId = f.MerchantId,
MerchantName = f.MerchantName,
FeeDescription = f.FeeDescription,
IsSettled = f.IsSettled,
TransactionId = f.TransactionId,
OperatorIdentifier = f.OperatorIdentifier
}));
return(model);
}
/// <summary>
/// 下单
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public virtual ActionResult Order(SettlementDto dto)
{
dto.IsGenerate = true;
Ioc.Resolve <IOrderApplicationService>().Create(dto);
if (dto.IsSaveSuccess)
{
return(RedirectToAction("Sucessful"));
}
var model = new SettlementModel {
SettlementDto = dto
};
SetAddresses(model);
SetCoupons(model);
SetPartners(model);
return(View("Settlement", model));
}
/// <summary>
/// 得到会员发票信息
/// </summary>
/// <returns></returns>
protected virtual void SetPartners(SettlementModel model)
{
if (model.SettlementDto == null || model.SettlementDto.Products == null)
{
return;
}
var accountIds =
model.SettlementDto.Products.Where(
it => it.Product != null && it.Product.Goods != null && it.Product.Goods.Account != null)
.Select(it => it.Product.Goods.Account.Id)
.ToArray();
var query = new QueryInfo();
query.Query <PartnerEntity>().Where(it => accountIds.Contains(it.Account.Id)).Select(it => new object[] { it.Account.Id, it.Name });
model.Partners = this.GetEntities <PartnerEntity>(query);
model.Partners.Add(new PartnerEntity {
Id = 0
});
}
public async Task ReportingManager_GetSettlement_DataReturned()
{
Mock <IEstateReportingRepository> repository = new Mock <IEstateReportingRepository>();
Mock <IEstateReportingRepositoryForReports> repositoryForReports = new Mock <IEstateReportingRepositoryForReports>();
repositoryForReports.Setup(r => r.GetSettlement(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(TestData.SettlementModel);
ReportingManager manager = new ReportingManager(repository.Object, repositoryForReports.Object);
SettlementModel model = await manager.GetSettlement(TestData.EstateId, TestData.MerchantId, TestData.SettlementId, CancellationToken.None);
model.ShouldNotBeNull();
model.ShouldSatisfyAllConditions(p => p.SettlementDate.ShouldBe(TestData.SettlementModel.SettlementDate),
p => p.IsCompleted.ShouldBe(TestData.SettlementModel.IsCompleted),
p => p.NumberOfFeesSettled.ShouldBe(TestData.SettlementModel.NumberOfFeesSettled),
p => p.SettlementId.ShouldBe(TestData.SettlementModel.SettlementId),
p => p.ValueOfFeesSettled.ShouldBe(TestData.SettlementModel.ValueOfFeesSettled));
}
public SettlementResponse ConvertFrom(SettlementModel model)
{
if (model == null)
{
return(null);
}
SettlementResponse response = new SettlementResponse
{
SettlementDate = model.SettlementDate,
IsCompleted = model.IsCompleted,
NumberOfFeesSettled = model.NumberOfFeesSettled,
SettlementId = model.SettlementId,
ValueOfFeesSettled = model.ValueOfFeesSettled,
};
model.SettlementFees.ForEach(f => response.SettlementFees.Add(this.ConvertFrom(f)));
return(response);
}
/// <summary>
/// Create brokerage model for internal usage
/// </summary>
/// <param name="accounttype"></param>
/// <param name="feemodel"></param>
/// <param name="fillmodel"></param>
/// <param name="latencymodel"></param>
/// <param name="margincallmodel"></param>
/// <param name="marginmodel"></param>
/// <param name="settlementmodel"></param>
/// <param name="slippagemodel"></param>
/// <param name="spreadmodel"></param>
protected GenericBrokerModel(
AccountType accounttype,
FeeModel feemodel,
FillModel fillmodel,
LatencyModel latencymodel,
MarginCallModel margincallmodel,
MarginModel marginmodel,
SettlementModel settlementmodel,
SlippageModel slippagemodel,
SpreadModel spreadmodel)
{
//Set given values
AccountType = accounttype;
FeeModel = feemodel;
FillModel = fillmodel;
LatencyModel = latencymodel;
MarginCallModel = margincallmodel;
SettlementModel = settlementmodel;
SlippageModel = slippagemodel;
MarginModel = marginmodel;
SpreadModel = spreadmodel;
}
public ActionResult SubmitSettlement(SettlementModel model)
{
model.UpdateUser = CurrentUser.Id;
return(Json(new JsonMessage(service.SaveSettlement(model, true))));
}
private void ListarMiembros()
{
SettlementModel members = new SettlementModel();
DataGridMembers.DataSource = members.ShowMembers();
}
private void ListarLiquidacion()
{
SettlementModel liquidation = new SettlementModel();
DataGridSettlement.DataSource = liquidation.ShowSettlement();
}
