1517 lines
78 KiB
C#
1517 lines
78 KiB
C#
using ClosedXML.Report.Utils;
|
|
using Confluent.Kafka;
|
|
using CsvHelper;
|
|
using Dapper;
|
|
using DocumentFormat.OpenXml.Drawing;
|
|
using MoreLinq;
|
|
using NPOI.SS.Formula.Functions;
|
|
using Qdp.ComputeServiceV2.Data.CommonModels.TradeInfos;
|
|
using Qdp.Pricing.Base.Enums;
|
|
using Qdp.Pricing.Base.Implementations;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Reflection;
|
|
using YLErp.BLL;
|
|
using YLErp.BLL.Calculation;
|
|
using YLErp.BLL.Eod;
|
|
using YLErp.DataBase;
|
|
using YLErp.DBModels;
|
|
using YLErp.DBModels.Enums;
|
|
using YLErp.Enums;
|
|
using YLErp.Helpers;
|
|
using YLErp.Model;
|
|
using YLErp.Model.Enum;
|
|
using YLErp.Models;
|
|
using YLErp.Modules.AppModule;
|
|
using YLErp.Modules.EodModule.QueryModule;
|
|
using YLErp.Modules.RiskModule;
|
|
using YLErp.Modules.TradeMsgOutputModule;
|
|
using YLErp.QdpModule;
|
|
using static alglib;
|
|
|
|
namespace YLErp.Modules.SwapModule
|
|
{
|
|
public class SwapTradeAutoService : YLBaseService
|
|
{
|
|
protected static IYcLogger Log = LogFactory.GetLogger(typeof(SwapTradeAutoService).FullName);
|
|
private static string LongShortStructType = "定义文件型债券收益互换";
|
|
public SwapTradeAutoService(OptUserInfo optUser) : base(optUser)
|
|
{
|
|
|
|
}
|
|
/// <summary>
|
|
/// 从db获取流水自动簿记
|
|
/// </summary>
|
|
public void GenerateSwapTradeFromDb(DateTime valueDate, bool reset)
|
|
{
|
|
using (var bondDb = new BondOmsDBContext())
|
|
{
|
|
var bondDbConn = bondDb.Database.GetDbConnection();
|
|
var clientDealSql = GetClientDealSql(valueDate);
|
|
var currentDeals = bondDbConn.Query<ClientDeal>(clientDealSql);
|
|
var swapFlows = DbContext.swap_flow.Where(x => x.OccurTime >= valueDate && x.OccurTime < valueDate.AddDays(1)).ToList();
|
|
var underlyingCodes = DbContext.underlying_manager.Where(x => x.LaunchState == "1");
|
|
foreach (var item in currentDeals)
|
|
{
|
|
var swapFlow = swapFlows.FirstOrDefault(x => x.trs_deal_id == item.id);
|
|
if (swapFlow != null && !reset)
|
|
{
|
|
continue;
|
|
}
|
|
else if (swapFlow == null)
|
|
{
|
|
swapFlow = new swap_flow();
|
|
}
|
|
var underlying = underlyingCodes.FirstOrDefault(x => x.UnderlyingCode == item.security_id);
|
|
swapFlow.ContractSize = underlying == null ? 1 : Convert.ToDecimal(underlying.ContractSize);
|
|
swapFlow.OccurTime = valueDate;
|
|
swapFlow.trs_deal_id = item.id;
|
|
swapFlow.BsType = item.side + 1;
|
|
swapFlow.UnderlyingCode = item.security_id;
|
|
swapFlow.TradingQty = (item.last_shares ?? 0) * 10000;
|
|
swapFlow.TradingFee = (item.commission ?? 0);
|
|
if (swapFlow.id == 0 || reset)
|
|
{
|
|
swapFlow.SwapTradeId = null;
|
|
swapFlow.SwapTradeNo = null;
|
|
swapFlow.DataState = (int)SwapFlowDateStateEnum.等待完成;
|
|
}
|
|
swapFlow.TradingAmountAvg = (item.deal_full_price ?? 0) * 0.01m;
|
|
swapFlow.TradingAmountFeeAvg = (item.deal_full_price_include_fee ?? 0) * 0.01m;
|
|
swapFlow.TradingAmount = swapFlow.TradingQty * swapFlow.ContractSize;
|
|
swapFlow.ClientId = Convert.ToInt32(item.client_id ?? 0);
|
|
swapFlow.ytm = (item.ytm ?? 0) * 0.01m;
|
|
swapFlow.TradingAmountNet = (item.deal_price ?? 0) * 0.01m;
|
|
swapFlow.TradingAmountNetFee = (item.deal_price_include_fee ?? 0) * 0.01m;
|
|
swapFlow.ClientName = item.client_name;
|
|
swapFlow.SetOpt(UserInfo);
|
|
swapFlow.OptTime = item.create_time.HasValue ? item.create_time.Value : DateTime.Now;
|
|
swapFlow.UnderlyingName = item.symbol;
|
|
swapFlow.DealType = item.deal_type;
|
|
swapFlow.SettleDate = valuedateBLL.GetNonHoliday(valueDate.AddDays(1)).Date;
|
|
if (swapFlow.id == 0)
|
|
{
|
|
DbContext.swap_flow.Add(swapFlow);
|
|
}
|
|
}
|
|
if (reset)
|
|
{
|
|
foreach (var flow in swapFlows)
|
|
{
|
|
flow.DataState = (int)SwapFlowDateStateEnum.等待完成;
|
|
}
|
|
}
|
|
DbContext.SaveChanges();
|
|
Task.Run(() =>
|
|
{
|
|
RealtimePnlCalc.RealtimeSwapPosition(new OptUserInfo(0, "互换实时持仓服务", OptUserFrom.Service));
|
|
});
|
|
}
|
|
}
|
|
|
|
private string GetClientDealSql(DateTime valueDate)
|
|
{
|
|
var tomorrowDate = valueDate.AddDays(1);
|
|
Type type = typeof(ClientDeal);
|
|
PropertyInfo[] properties = type.GetProperties();
|
|
string[] fieldNames = properties.Where(s => s.CustomAttributes.Count() == 0).Select(f => "cd." + f.Name).ToArray();
|
|
var selectStr = string.Join(",", fieldNames);
|
|
string sql = $"select cd.id,{selectStr},co.settl_type from client_deal cd inner join client_order co on co.id=cd.client_order_id where cd.create_time<'{tomorrowDate.ToString("yyyy-MM-dd")}' and cd.create_time>='{valueDate.ToString("yyyy-MM-dd")}'";
|
|
return sql;
|
|
}
|
|
public void ResetTradeByDate(DateTime valueDate, int? clientId, string underlyingCode, Action<decimal>? action, List<int> tradeIds)
|
|
{
|
|
|
|
var swapEvents = DbContext.swap_event.Where(x => x.EventReason.Contains("自动") && x.ValueDate == valueDate);
|
|
//bool resetSingle = false;
|
|
if (tradeIds == null || tradeIds.Count() == 0)
|
|
{
|
|
tradeIds = swapEvents.Select(s => s.SwapTradeId).ToList();
|
|
}
|
|
//else
|
|
//{
|
|
// resetSingle = true;
|
|
//}
|
|
var swaptrades = DbContext.trade.Where(x => tradeIds.Contains(x.id) && x.ValidState != ConsGlobal.InValid).ToList();
|
|
var swapflowMerges = DbContext.swap_flow_merge.Where(x => x.OccurTime == valueDate);
|
|
var swapflowDeals = DbContext.swap_flow_deal.Where(x => x.OccurDate == valueDate);
|
|
var swapFlows = DbContext.swap_flow.Where(x => x.OccurTime == valueDate);
|
|
if (clientId.HasValue)
|
|
{
|
|
swapFlows = swapFlows.Where(x => x.ClientId == clientId);
|
|
swapflowDeals = swapflowDeals.Where(x => x.ClientId == clientId);
|
|
swapflowMerges = swapflowMerges.Where(x => x.ClientId == clientId);
|
|
}
|
|
if (!string.IsNullOrEmpty(underlyingCode))
|
|
{
|
|
swapFlows = swapFlows.Where(x => x.UnderlyingCode == underlyingCode);
|
|
swapflowMerges = swapflowMerges.Where(x => x.UnderlyingCode == underlyingCode);
|
|
swapflowDeals = swapflowDeals.Where(x => x.UnderlyingCode == underlyingCode);
|
|
}
|
|
var trsDealIds = swapFlows.Where(x => x.trs_deal_id > 0).Select(s => s.trs_deal_id ?? 0).ToList();
|
|
var swaptradesCount = swaptrades.Count();
|
|
decimal backProcessedCount = 0;
|
|
if (swaptradesCount == 0)
|
|
{
|
|
backProcessedCount = 100;
|
|
}
|
|
foreach (var td in swaptrades)
|
|
{
|
|
var isAutoOpenTrade = td.IsAutoGenerate == true;
|
|
new SwapTradeService(UserInfo).TradeBack(td.id, valueDate, isAutoOpenTrade);
|
|
backProcessedCount++;
|
|
var processedPercent = backProcessedCount * 100 / swaptradesCount;
|
|
action?.Invoke(processedPercent);
|
|
}
|
|
swapFlows.ForEach(x => { x.DataState = (int)SwapFlowDateStateEnum.等待完成; });
|
|
new TradeRiskCheckLogService(UserInfo).DeleteLogs(trsDealIds);
|
|
DbContext.swap_flow_merge.RemoveRange(swapflowMerges);
|
|
DbContext.swap_flow_deal.RemoveRange(swapflowDeals);
|
|
DbContext.SaveChanges();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 校验是否能重置流水
|
|
/// </summary>
|
|
/// <param name="clientId"></param>
|
|
/// <param name="underlyingCode"></param>
|
|
/// <param name="valueDate"></param>
|
|
/// <returns></returns>
|
|
public bool CheckFlowAfter(int? clientId, string underlyingCode, DateTime valueDate) {
|
|
Expression<Func<swap_flow, bool>> expression =x=> x.OccurTime > valueDate && x.DataState == (int)SwapFlowDateStateEnum.完成;
|
|
if (clientId.HasValue)
|
|
{
|
|
expression = expression.And(x=>x.ClientId==clientId);
|
|
}
|
|
if (!string.IsNullOrEmpty(underlyingCode))
|
|
{
|
|
expression = expression.And(x => x.UnderlyingCode == underlyingCode);
|
|
}
|
|
return DbContext.swap_flow.Any(expression);
|
|
}
|
|
/// <summary>
|
|
/// 获取需要重置的交易
|
|
/// </summary>
|
|
/// <param name="clientId"></param>
|
|
/// <param name="underlyingCode"></param>
|
|
/// <param name="valueDate"></param>
|
|
/// <returns></returns>
|
|
public List<int> GetNeedResetTradeIds(int? clientId, string underlyingCode, DateTime valueDate)
|
|
{
|
|
var swapEvents = DbContext.swap_event.Where(x => x.EventReason.Contains("自动") && x.ValueDate == valueDate);
|
|
var tradeIds = swapEvents.Select(s => s.SwapTradeId).ToList();
|
|
Expression<Func<trade, bool>> expression = x => tradeIds.Contains(x.id) && x.ValidState != ConsGlobal.InValid;
|
|
if (clientId.HasValue)
|
|
{
|
|
expression = expression.And(x => x.ClientId == clientId);
|
|
}
|
|
if (!string.IsNullOrEmpty(underlyingCode))
|
|
{
|
|
expression = expression.And(x => x.UnderlyingCode == underlyingCode);
|
|
}
|
|
var resetTradeIds = DbContext.trade.Where(expression).Select(s=>s.id).ToList();
|
|
return resetTradeIds;
|
|
}
|
|
/// <summary>
|
|
/// 校验交易是否收盘
|
|
/// </summary>
|
|
/// <param name="valueDate"></param>
|
|
/// <param name="mergeList"></param>
|
|
/// <exception cref="ServiceException"></exception>
|
|
public void CheckTradEods(DateTime valueDate, List<swap_flow_merge> mergeList)
|
|
{
|
|
var preSettleDate = QdpCalendarHelper.GetNonHolidayDefore(valueDate.AddDays(-1));
|
|
new BaseTradeAfterEodOutputService().CheckEodStatus(preSettleDate);//上日收盘校验
|
|
var clientIds = mergeList.Select(s => s.ClientId).Distinct().ToList();
|
|
var swaptrades = DbContext.trade.Where(t => t.TradeType == "收益互换"
|
|
&& t.TradeDate <= valueDate
|
|
&& t.ValidState != ConsGlobal.InValid
|
|
&& clientIds.Contains(t.ClientId)
|
|
&& !ConsTrade.TradeCompleteStatus.Contains(t.TradeStatus)).ToList();
|
|
var tradeIds = swaptrades.Select(s => s.id).ToList();
|
|
var swapEodTrades = new SwapEodPositionService(UserInfo).GetEodSwaps(tradeIds, preSettleDate);
|
|
foreach (var swap in swaptrades)
|
|
{
|
|
var eodTrade = swapEodTrades.FirstOrDefault(x => x.SwapTradeId == swap.id);
|
|
if (eodTrade == null && swap.StartDate.Value < valueDate)
|
|
{
|
|
throw new ServiceException($"交易{swap.TradeNumber}在{preSettleDate:yyyy-MM-dd}日未收盘");
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 检查当日是否流水合成簿记
|
|
/// </summary>
|
|
/// <param name="valueDate"></param>
|
|
/// <exception cref="ServiceException"></exception>
|
|
public void CheckBookByDate(DateTime valueDate)
|
|
{
|
|
if (DbContext.swap_flow.Any(x => x.OccurTime == valueDate && x.DataState == (int)SwapFlowDateStateEnum.完成))
|
|
{
|
|
throw new ServiceException($"{valueDate:yyyy-MM-dd}日已经处理过流水合成簿记，请重置再重新合成簿记！");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 修改风控日志记录
|
|
/// </summary>
|
|
/// <param name="swapFlows"></param>
|
|
/// <param name="mergeList"></param>
|
|
public void UpdateRiskCheckLog(List<swap_flow> swapFlows, List<swap_flow_merge> mergeList)
|
|
{
|
|
var riskCheckLogService = new TradeRiskCheckLogService(UserInfo);
|
|
foreach (var item in mergeList)
|
|
{
|
|
var flows = swapFlows.Where(x => x.ClientId == item.ClientId && x.UnderlyingCode == item.UnderlyingCode && x.BsType == item.BsType && x.trs_deal_id > 0);
|
|
var trsDealIds = flows.Select(s => s.trs_deal_id ?? 0).ToList();
|
|
riskCheckLogService.UpdateLogTradeNumber(trsDealIds, item.SwapTradeNo);
|
|
}
|
|
}
|
|
public List<swap_flow> GetFlows(DateTime valueDate)
|
|
{
|
|
var swapFlows = DbContext.swap_flow.Where(x => x.OccurTime == valueDate && x.DataState == (int)SwapFlowDateStateEnum.等待完成 && x.ClientId > 0).ToList();
|
|
return swapFlows;
|
|
}
|
|
public List<swap_flow> GetFlows(List<long> ids)
|
|
{
|
|
var swapFlows = DbContext.swap_flow.Where(x => ids.Contains(x.id) && x.DataState == (int)SwapFlowDateStateEnum.等待完成 && x.ClientId > 0).ToList();
|
|
return swapFlows;
|
|
}
|
|
/// <summary>
|
|
/// 簿记前自动校验
|
|
/// </summary>
|
|
/// <param name="mergeList"></param>
|
|
public void BookingValidate(List<swap_flow_merge> mergeList)
|
|
{
|
|
foreach (var merge in mergeList)
|
|
{
|
|
var client = DataCacheProvider.GetClientDataSource().GetData(merge.ClientId ?? 0);
|
|
if (client == null)
|
|
{
|
|
throw new ServiceException($"找不到id为{merge.ClientId}的客户信息");
|
|
}
|
|
if (!client.DerivativesInvestmentVarieties.Contains((int)DerivativesInvestmentVarietiesEnum.场外互换 + ""))
|
|
{
|
|
throw new ServiceException($"客户:{client.Name}未设置交易种类“场外互换”，无法生成互换交易！");
|
|
}
|
|
merge.SwapTradeType = client.SwapTradeType ?? 0;
|
|
var etradeRule = new EtradingRuleService(UserInfo).GetEtradingRuleAccont(client.BoundSide, client.Number);
|
|
if (etradeRule == null || string.IsNullOrEmpty(etradeRule.AssetAccount_0))
|
|
{
|
|
throw new ServiceException($"{client.Name}未设置TRS对客簿记账户");
|
|
}
|
|
string clearingAgency = etradeRule.ClearingAgency_0;
|
|
var asset = DataCacheProvider.GetAssetUnitDataSource().AsQueryable(x => x.Name == etradeRule.AssetAccount_0).FirstOrDefault();//取对客簿记账户
|
|
if (asset == null)
|
|
{
|
|
throw new ServiceException($"找不到名为{etradeRule.AssetAccount_0}的簿记账户信息");
|
|
}
|
|
if (asset.TraderIdsInt.Count == 0)
|
|
{
|
|
throw new ServiceException($"{etradeRule.AssetAccount_0}的簿记账户未设置交易员");
|
|
}
|
|
var underlying = DbContext.underlying_manager.FirstOrDefault(x => x.UnderlyingCode == merge.UnderlyingCode);
|
|
if (underlying == null)
|
|
{
|
|
throw new ServiceException($"找不到标的代码为{merge.UnderlyingCode}的标的信息");
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 汇总流水
|
|
/// </summary>
|
|
/// <param name="valueDate"></param>
|
|
public List<swap_flow_merge> SummaryFlow(List<swap_flow> swapFlows, bool save = true)
|
|
{
|
|
var swapFlowGroup = swapFlows.GroupBy(g => new { g.ClientId, g.OccurTime, g.UnderlyingCode, g.BsType }).ToList();
|
|
List<swap_flow_merge> list = new List<swap_flow_merge>();
|
|
foreach (var gourpItem in swapFlowGroup)
|
|
{
|
|
var flowList = gourpItem.OrderBy(O => O.OptTime).ToList();
|
|
var swapflow = flowList.First();
|
|
swap_flow_merge swap_flow_summary = new swap_flow_merge()
|
|
{
|
|
OccurTime = swapflow.OccurTime.Value,
|
|
FundAccount = swapflow.FundAccount,
|
|
SwapTradeId = swapflow.SwapTradeId,
|
|
SwapTradeNo = swapflow.SwapTradeNo,
|
|
UnderlyingCode = swapflow.UnderlyingCode,
|
|
BsType = swapflow.BsType,
|
|
TradingQty = gourpItem.Sum(s => s.TradingQty),
|
|
TradingFeePending = gourpItem.Sum(s => s.TradingFee),
|
|
DataState = (int)SwapFlowDateStateEnum.等待完成,
|
|
ContractSize = swapflow.ContractSize,
|
|
ClientId = swapflow.ClientId,
|
|
};
|
|
int tradeSide = swap_flow_summary.BsType == (int)EnumDirection.Long ? 1 : -1;
|
|
swap_flow_summary.FirstFlowTime = swapflow.OptTime;
|
|
swap_flow_summary.SettleDate = gourpItem.Max(s => s.SettleDate);
|
|
swap_flow_summary.TradingAmount = swap_flow_summary.TradingQty * swap_flow_summary.ContractSize;
|
|
swap_flow_summary.TradingAmountAvg = swap_flow_summary.TradingQty == 0 ? 0 : gourpItem.Sum(s => s.TradingAmountAvg * s.TradingQty) / swap_flow_summary.TradingQty;
|
|
swap_flow_summary.TradingAmountFeeAvg = swap_flow_summary.TradingQty == 0 ? swap_flow_summary.TradingAmountAvg : swap_flow_summary.TradingAmountAvg + swap_flow_summary.TradingFeePending * tradeSide / swap_flow_summary.TradingQty;
|
|
swap_flow_summary.TradingAmountNetAvg = swap_flow_summary.TradingQty == 0 ? 0 : gourpItem.Sum(s => s.TradingAmountNet * s.TradingQty) / swap_flow_summary.TradingQty;
|
|
swap_flow_summary.TradingAmountNetFeeAvg = swap_flow_summary.TradingQty == 0 ? swap_flow_summary.TradingAmountNetAvg : swap_flow_summary.TradingAmountNetAvg + swap_flow_summary.TradingFeePending * tradeSide / swap_flow_summary.TradingQty;
|
|
swap_flow_summary.SetOpt(UserInfo);
|
|
if (save)
|
|
{
|
|
DbContext.swap_flow_merge.Add(swap_flow_summary);
|
|
}
|
|
list.Add(swap_flow_summary);
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 汇总流水
|
|
/// </summary>
|
|
/// <param name="valueDate"></param>
|
|
public List<swap_flow_merge> SummaryFlow(List<SwapFlowDeal> swapFlows)
|
|
{
|
|
var swapFlowGroup = swapFlows.GroupBy(g => new { g.ClientId, g.OccurDate, g.UnderlyingCode, g.BsType }).ToList();
|
|
List<swap_flow_merge> list = new List<swap_flow_merge>();
|
|
foreach (var gourpItem in swapFlowGroup)
|
|
{
|
|
var flowList = gourpItem.OrderBy(O => O.OptTime).ToList();
|
|
var swapflow = flowList.First();
|
|
swap_flow_merge swap_flow_summary = new swap_flow_merge()
|
|
{
|
|
OccurTime = swapflow.OccurDate,
|
|
SwapTradeId = swapflow.SwapTradeId,
|
|
SwapTradeNo = swapflow.SwapTradeNo,
|
|
UnderlyingCode = swapflow.UnderlyingCode,
|
|
BsType = swapflow.BsType,
|
|
TradingQty = gourpItem.Sum(s => s.TradingQty),
|
|
TradingFeePending = gourpItem.Sum(s => s.TradingFee),
|
|
DataState = (int)SwapFlowDateStateEnum.等待完成,
|
|
ContractSize = swapflow.ContractSize,
|
|
ClientId = swapflow.ClientId,
|
|
};
|
|
int tradeSide = swap_flow_summary.BsType == (int)EnumDirection.Long ? 1 : -1;
|
|
swap_flow_summary.FirstFlowTime = swapflow.OptTime;
|
|
swap_flow_summary.SettleDate = gourpItem.Max(s => s.SettleDate);
|
|
swap_flow_summary.TradingAmount = swap_flow_summary.TradingQty * swap_flow_summary.ContractSize;
|
|
swap_flow_summary.TradingAmountAvg = swap_flow_summary.TradingQty == 0 ? 0 : gourpItem.Sum(s => s.FullPrice * s.TradingQty) / swap_flow_summary.TradingQty;
|
|
swap_flow_summary.TradingAmountFeeAvg = swap_flow_summary.TradingQty == 0 ? swap_flow_summary.TradingAmountAvg : swap_flow_summary.TradingAmountAvg + swap_flow_summary.TradingFeePending * tradeSide / swap_flow_summary.TradingQty;
|
|
swap_flow_summary.TradingAmountNetAvg = swap_flow_summary.TradingQty == 0 ? 0 : gourpItem.Sum(s => s.NetPrice * s.TradingQty) / swap_flow_summary.TradingQty;
|
|
swap_flow_summary.TradingAmountNetFeeAvg = swap_flow_summary.TradingQty == 0 ? swap_flow_summary.TradingAmountNetAvg : swap_flow_summary.TradingAmountNetAvg + swap_flow_summary.TradingFeePending * tradeSide / swap_flow_summary.TradingQty;
|
|
swap_flow_summary.SetOpt(UserInfo);
|
|
DbContext.swap_flow_merge.Add(swap_flow_summary);
|
|
list.Add(swap_flow_summary);
|
|
}
|
|
return list;
|
|
}
|
|
/// <summary>
|
|
/// 重置法生成开平仓事件
|
|
/// </summary>
|
|
/// <param name="valueDate"></param>
|
|
public void MergeRestModeCompose(List<swap_flow_merge> mergeList, DateTime valueDate, Action<int>? action)
|
|
{
|
|
var flowquery = mergeList.GroupBy(g => g.ClientId);
|
|
var flowCount = flowquery.Count();
|
|
if (flowCount == 0)
|
|
{
|
|
return;
|
|
}
|
|
var swaptrades = DbContext.trade.Where(t => t.TradeType == "收益互换" && t.StructureType == "普通债券类收益互换"
|
|
&& t.TradeDate <= valueDate
|
|
&& t.ValidState != ConsGlobal.InValid
|
|
&& !ConsTrade.TradeCompleteStatus.Contains(t.TradeStatus)).ToList();
|
|
var swapTradeIds = swaptrades.Select(s => s.id);
|
|
var tradeExtends = DbContext.trade_extend.Where(x => swapTradeIds.Contains(x.TradeId));
|
|
var clientMarginTemplates = DbContext.client_marginrate.Where(x => x.Type == "品种" && x.ValueDate <= valueDate).OrderByDescending(o => o.ValueDate).ToList();
|
|
var restSwapTrades = new List<trade>();
|
|
foreach (var swaptrade in swaptrades)
|
|
{
|
|
swaptrade.trade_extend = tradeExtends.FirstOrDefault(x => x.TradeId == swaptrade.id);
|
|
if (swaptrade.trade_extend?.ExtendObj.FlowBookMode == (int)FlowBookModeEnum.重置)
|
|
{
|
|
restSwapTrades.Add(swaptrade);
|
|
}
|
|
}
|
|
var swapPositions = DbContext.swap_position.Where(x => swapTradeIds.Contains(x.SwapTradeId) && !x.IsInitial && x.PosiQuantity > 0 && !x.Invalid && x.PosiDirection == (int)SwapDirectionEnum.支付).ToList();
|
|
var matuirityDate = QdpCalendarHelper.GetNonHolidayDefore(valueDate.AddDays(14));
|
|
var floatRatePredicate = PredicateBuilder.Create<SwapFloatRate>(x => x.StartDate <= valueDate && x.EndDate >= matuirityDate);
|
|
var floatRateQuery = DbContext.swap_float_rate.Where(floatRatePredicate);
|
|
int dealCount = 0;
|
|
foreach (var groupItem in flowquery)
|
|
{
|
|
MergeRestModelItem(groupItem, restSwapTrades, swapPositions, floatRateQuery, clientMarginTemplates, ref dealCount, action);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 加权平均法生成开平仓事件
|
|
/// </summary>
|
|
/// <param name="mergeList"></param>
|
|
/// <param name="valueDate"></param>
|
|
public void MergeAvgModeCompose(List<swap_flow> swapFlows, DateTime valueDate, Action<int>? action)
|
|
{
|
|
var flowquery = swapFlows.GroupBy(g => g.ClientId);
|
|
var flowCount = flowquery.Count();
|
|
if (flowCount == 0)
|
|
{
|
|
return;
|
|
}
|
|
var swaptrades = DbContext.trade.Where(t => t.StructureType == "定义文件型债券收益互换"
|
|
&& t.TradeDate <= valueDate
|
|
&& t.ValidState != ConsGlobal.InValid
|
|
&& !ConsTrade.TradeCompleteStatus.Contains(t.TradeStatus)).ToList();
|
|
var swapTradeIds = swaptrades.Select(s => s.id);
|
|
var swapPositions = DbContext.swap_position.Where(x => swapTradeIds.Contains(x.SwapTradeId) && x.PosiDirection > 0 && !x.IsInitial && x.PosiQuantity > 0 && !x.Invalid).ToList();
|
|
var matuirityDate = QdpCalendarHelper.GetNonHolidayDefore(valueDate.AddDays(14));
|
|
var floatRatePredicate = PredicateBuilder.Create<SwapFloatRate>(x => x.StartDate <= valueDate && x.EndDate >= matuirityDate);
|
|
var floatRateQuery = DbContext.swap_float_rate.Where(floatRatePredicate);
|
|
int dealCount = 0;
|
|
foreach (var groupItem in flowquery)
|
|
{
|
|
MergeAvgModelItem(groupItem, swaptrades, swapPositions, floatRateQuery, ref dealCount, action);
|
|
}
|
|
}
|
|
public void UpdateSwapFlowState(List<swap_flow> swapFlows)
|
|
{
|
|
foreach (var item in swapFlows)
|
|
{
|
|
item.DataState = (int)SwapFlowDateStateEnum.完成;
|
|
}
|
|
DbContext.SaveChanges();
|
|
}
|
|
/// <summary>
|
|
/// 重置法按客户合成持仓
|
|
/// </summary>
|
|
/// <param name="groupItem"></param>
|
|
/// <param name="swaptrades"></param>
|
|
/// <param name="swapPositions"></param>
|
|
/// <param name="floatRateQuery"></param>
|
|
/// <param name="direction"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <exception cref="ServiceException"></exception>
|
|
private void MergeRestModelItem(IGrouping<int?, swap_flow_merge> groupItem,
|
|
List<trade> swaptrades,
|
|
List<swap_position> swapPositions,
|
|
IQueryable<SwapFloatRate> floatRateQuery,
|
|
List<client_marginrate> client_Marginrates, ref int dealCount, Action<int>? action)
|
|
{
|
|
var clientId = groupItem.Key;
|
|
var client = DataCacheProvider.GetClientDataSource().GetData(clientId ?? 0);
|
|
if (client == null)
|
|
{
|
|
throw new ServiceException($"找不到id为{clientId}的客户信息");
|
|
}
|
|
if (!client.DerivativesInvestmentVarieties.Contains((int)DerivativesInvestmentVarietiesEnum.场外互换 + ""))
|
|
{
|
|
throw new ServiceException($"客户:{client.Name}未设置交易种类“场外互换”，无法生成互换交易！");
|
|
}
|
|
var etradeRule = new EtradingRuleService(UserInfo).GetEtradingRuleAccont(client.BoundSide, client.Number);
|
|
if (etradeRule == null || string.IsNullOrEmpty(etradeRule.AssetAccount_0))
|
|
{
|
|
throw new ServiceException($"{client.Number}未设置TRS对客簿记账户");
|
|
}
|
|
string clearingAgency = etradeRule.ClearingAgency_0;
|
|
var asset = DataCacheProvider.GetAssetUnitDataSource().AsQueryable(x => x.Name == etradeRule.AssetAccount_0).FirstOrDefault();//取对客簿记账户
|
|
if (asset == null)
|
|
{
|
|
throw new ServiceException($"找不到名为{etradeRule.AssetAccount_0}的簿记账户信息");
|
|
}
|
|
if (asset.TraderIdsInt.Count == 0)
|
|
{
|
|
throw new ServiceException($"{etradeRule.AssetAccount_0}的簿记账户未设置交易员");
|
|
}
|
|
var clientMarginTemplate = client_Marginrates.FirstOrDefault(x => x.ClientId == clientId);
|
|
if (clientMarginTemplate == null)
|
|
{
|
|
clientMarginTemplate = client_Marginrates.FirstOrDefault(x => x.ClientId == 0);
|
|
}
|
|
var underlyingGroup = groupItem.GroupBy(g => g.UnderlyingCode);
|
|
var clientSwapTrades = swaptrades.Where(x => x.ClientId == clientId).ToList();
|
|
var clientSwapTradeIds = clientSwapTrades.Select(s => s.id);
|
|
var clientSwapPositions = swapPositions.Where(x => clientSwapTradeIds.Contains(x.SwapTradeId));//现有客户持仓
|
|
|
|
var underlyingCodes = underlyingGroup.Select(s => s.Key).ToList();
|
|
var underlyings = DataCacheProvider.GetUnderlyingDataSource().AsQueryable(x => underlyingCodes.Contains(x.UnderlyingCode));
|
|
foreach (var underlyingGroupItem in underlyingGroup)
|
|
{
|
|
var underlyingCode = underlyingGroupItem.Key;
|
|
var underlying = underlyings.FirstOrDefault(x => x.UnderlyingCode == underlyingCode);
|
|
if (underlying == null)
|
|
{
|
|
throw new ServiceException($"找不到标的代码为{underlyingCode}的标的信息");
|
|
}
|
|
var floatRate = new SwapFloatRateService(UserInfo).GetSwapFloatRate(floatRateQuery, clientId ?? 0, underlyingCode);
|
|
var clientSwapPositionList = clientSwapPositions.Where(x => x.UnderlyingCode == underlyingCode).ToList();//现有标的持仓
|
|
var hasPayPosition = clientSwapPositionList.Any();
|
|
var mergeList = underlyingGroupItem.OrderByDescending(o => o.TradingQty).ToList();
|
|
var flowMerge = mergeList.First();
|
|
var flowMerge2 = mergeList.Last();
|
|
dealCount = dealCount + mergeList.Count();
|
|
action?.Invoke(dealCount);
|
|
flowMerge.DataState = 100;
|
|
flowMerge2.DataState = 100;
|
|
bool cashNeedAfter = false;//资金是否需要延后
|
|
if (mergeList.Count == 2)
|
|
{
|
|
var unwindQty = (flowMerge.TradingQty * (flowMerge.BsType == 1 ? 1 : -1)) + (flowMerge2.TradingQty * (flowMerge2.BsType == 1 ? 1 : -1));
|
|
if (unwindQty == 0)
|
|
{
|
|
cashNeedAfter = true;
|
|
}
|
|
}
|
|
if (cashNeedAfter)
|
|
{
|
|
var flowEvents = DbContext.swap_flow_event.Where(x => x.EventDate == flowMerge.OccurTime && x.PayDate > x.UnwindDate && x.EventType == (int)SwapFlowEventTypeEnum.平仓 && x.DataState == (int)SwapFlowDateStateEnum.完成 && x.ClientId == flowMerge.ClientId && x.PayDirection > 0);
|
|
var tradeIds = flowEvents.Select(s=>s.SwapTradeId).Distinct();
|
|
var trades = DbContext.trade.Where(x=> tradeIds.Contains(x.id)&&x.ValidState!=ConsGlobal.InValid);
|
|
cashNeedAfter = !trades.Any();
|
|
}
|
|
if (!hasPayPosition)//没有持仓
|
|
{
|
|
DealNoPosition(mergeList, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency, cashNeedAfter);
|
|
}
|
|
else
|
|
{
|
|
DealHasPosition(mergeList, client, asset, underlying, floatRate, clientSwapPositionList, clientSwapTrades, clientMarginTemplate, clearingAgency, cashNeedAfter);
|
|
}
|
|
|
|
}
|
|
DbContext.SaveChanges();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 加权平均法按客户合成持仓
|
|
/// </summary>
|
|
/// <param name="groupItem"></param>
|
|
/// <param name="swaptrades"></param>
|
|
/// <param name="swapPositions"></param>
|
|
/// <param name="floatRateQuery"></param>
|
|
/// <param name="direction"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <exception cref="ServiceException"></exception>
|
|
private void MergeAvgModelItem(IGrouping<int?, swap_flow> groupItem,
|
|
List<trade> swaptrades,
|
|
List<swap_position> swapPositions,
|
|
IQueryable<SwapFloatRate> floatRateQuery, ref int dealCount, Action<int>? action)
|
|
{
|
|
var clientId = groupItem.Key;
|
|
var client = DataCacheProvider.GetClientDataSource().GetData(clientId ?? 0);
|
|
var etradeRule = new EtradingRuleService(UserInfo).GetEtradingRuleAccont(client.BoundSide, client.Number);
|
|
string clearingAgency = etradeRule.ClearingAgency_0;
|
|
var asset = DataCacheProvider.GetAssetUnitDataSource().AsQueryable(x => x.Name == etradeRule.AssetAccount_0).FirstOrDefault();//取对客簿记账户
|
|
var underlyingGroup = groupItem.GroupBy(g => g.UnderlyingCode);
|
|
var clientSwapTrades = swaptrades.Where(x => x.ClientId == clientId).ToList();
|
|
var clientSwapTradeIds = clientSwapTrades.Select(s => s.id);
|
|
var clientSwapPositions = swapPositions.Where(x => clientSwapTradeIds.Contains(x.SwapTradeId));//现有客户持仓
|
|
|
|
var underlyingCodes = underlyingGroup.Select(s => s.Key).ToList();
|
|
var underlyings = DataCacheProvider.GetUnderlyingDataSource().AsQueryable(x => underlyingCodes.Contains(x.UnderlyingCode));
|
|
foreach (var underlyingGroupItem in underlyingGroup)
|
|
{
|
|
var underlyingCode = underlyingGroupItem.Key;
|
|
var underlying = underlyings.FirstOrDefault(x => x.UnderlyingCode == underlyingCode);
|
|
if (underlying == null)
|
|
{
|
|
throw new ServiceException($"找不到标的代码为{underlyingCode}的标的信息");
|
|
}
|
|
var floatRate = new SwapFloatRateService(UserInfo).GetSwapFloatRate(floatRateQuery, clientId ?? 0, underlyingCode);
|
|
var clientSwapPositionList = clientSwapPositions.Where(x => x.UnderlyingCode == underlyingCode).ToList();//现有标的持仓
|
|
var hasPayPosition = clientSwapPositionList.Any();
|
|
var mergeList = underlyingGroupItem.OrderBy(o => o.OptTime).ToList();
|
|
dealCount = dealCount + mergeList.Count();
|
|
action?.Invoke(dealCount);
|
|
if (!hasPayPosition)//没有持仓
|
|
{
|
|
var bsType = mergeList.OrderBy(o => o.OptTime).First().BsType;
|
|
AvgDealNoPosition(mergeList, client, asset, underlying, floatRate, clearingAgency, bsType);
|
|
}
|
|
else
|
|
{
|
|
AvgDealHasPosition(mergeList, client, asset, underlying, floatRate, clientSwapPositionList, clientSwapTrades, clearingAgency);
|
|
}
|
|
|
|
}
|
|
DbContext.SaveChanges();
|
|
}
|
|
/// <summary>
|
|
/// 将上日没有持仓的流水自动簿记
|
|
/// </summary>
|
|
/// <param name="mergeList"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
private void DealNoPosition(List<swap_flow_merge> mergeList,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
client_marginrate clientMarginTemplate,
|
|
string clearingAgency,
|
|
bool cashNeedAfter)
|
|
{
|
|
var mergeOrderList = mergeList.OrderBy(o => o.FirstFlowTime);
|
|
swap_flow_merge flowMergeMax = mergeOrderList.First();//先开最早的一条
|
|
swap_flow_merge flowMergeMin = mergeOrderList.Last();
|
|
var swapTradeService = new SwapTradeService(UserInfo);
|
|
var trade = swapTradeService.NewSwapTrade(flowMergeMax, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency, cashNeedAfter: cashNeedAfter);
|
|
flowMergeMax.SwapTradeNo = trade.TradeNumber;
|
|
flowMergeMin.SwapTradeNo = trade.TradeNumber;
|
|
if (mergeList.Count == 2)//有两条流水
|
|
{
|
|
var qty = flowMergeMax.TradingQtyAbs - flowMergeMin.TradingQtyAbs;//平仓剩余数量
|
|
new SwapDealService(UserInfo).AuotoSwapUnwind(trade.id,
|
|
flowMergeMin.TradingAmountAvg,
|
|
flowMergeMin.TradingAmountFeeAvg,
|
|
flowMergeMin.TradingAmountNetFeeAvg ?? 0,
|
|
flowMergeMin.TradingAmountNetAvg ?? 0,
|
|
flowMergeMin.OccurTime,
|
|
flowMergeMax.TradingQtyAbs,
|
|
flowMergeMin.TradingQty,
|
|
flowMergeMin.TradingFeePending);
|
|
var amount = qty * flowMergeMax.ContractSize;//平仓剩余金额=（平仓流水的成交均价-平仓对象的期初价格不含费）*平仓流水的成交数量*合约乘数
|
|
if (qty != 0)//平仓有剩余，开仓
|
|
{
|
|
var qtyAbs = Math.Abs(qty);
|
|
var flowMergeClone = flowMergeMax.Clone();
|
|
if (qty < 0)
|
|
{
|
|
flowMergeClone = flowMergeMin.Clone();
|
|
}
|
|
flowMergeClone.TradingAmount = Math.Abs(amount);
|
|
flowMergeClone.TradingFeePending = flowMergeClone.TradingFeePending * qtyAbs / flowMergeClone.TradingQty;//剩余后付费用
|
|
flowMergeClone.TradingQty = qtyAbs;
|
|
if (qty > 0)//交易有剩余新开仓
|
|
{
|
|
var posi = DbContext.swap_position.FirstOrDefault(x => x.SwapTradeId == trade.id && x.PosiDirection > 0 && !x.IsInitial);
|
|
SetNewOpenData(flowMergeMin, flowMergeClone, posi);
|
|
}
|
|
var trade2 = swapTradeService.NewSwapTrade(flowMergeClone, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency);
|
|
flowMergeMax.SwapTradeNo = trade2.TradeNumber;
|
|
flowMergeMin.SwapTradeNo = trade2.TradeNumber;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 将上日没有持仓的流水自动簿记
|
|
/// </summary>
|
|
/// <param name="swapFlows"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
private trade AvgDealNoPosition(List<swap_flow> swapFlows,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
string clearingAgency,
|
|
int byType)
|
|
{
|
|
var negativeFlows = swapFlows.Where(x => x.BsType != byType).OrderBy(o => o.OptTime).ToList();
|
|
var sameFlows = swapFlows.Where(x => x.BsType == byType).OrderBy(o => o.OptTime).ToList();
|
|
if (negativeFlows.Count == 0)
|
|
{
|
|
return DealOneDirectionFlows(sameFlows, client, asset, underlying, floatRate, clearingAgency);
|
|
}
|
|
return DealTwoDirectionFlows(sameFlows, negativeFlows, client, asset, underlying, floatRate, clearingAgency);
|
|
}
|
|
/// <summary>
|
|
/// 当前无持仓，且只有一个方向的流水合成簿记
|
|
/// </summary>
|
|
/// <param name="sameFlows"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
/// <param name="clearingAgency"></param>
|
|
private trade DealOneDirectionFlows(List<swap_flow> sameFlows,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
string clearingAgency)
|
|
{
|
|
List<SwapFlowDeal> swapFlowDeals = new List<SwapFlowDeal>();
|
|
foreach (var flow in sameFlows)
|
|
{
|
|
SwapFlowDeal swapFlowDeal = GetSwapFlowDeal(flow, flow.TradingQty, (int)OpenCloseEnum.开仓, flow.TradingFee, null);
|
|
swapFlowDeals.Add(swapFlowDeal);
|
|
}
|
|
return NewSwapTrade(swapFlowDeals, client, asset, underlying, floatRate, clearingAgency);
|
|
}
|
|
/// <summary>
|
|
/// 当前无持仓，且有2个方向流水合成簿记
|
|
/// </summary>
|
|
/// <param name="sameFlows"></param>
|
|
/// <param name="negativeFlows"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
/// <param name="clearingAgency"></param>
|
|
private trade DealTwoDirectionFlows(List<swap_flow> sameFlows,
|
|
List<swap_flow> negativeFlows,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
string clearingAgency)
|
|
{
|
|
var swapTradeService = new SwapTradeService(UserInfo);
|
|
var sameQty = sameFlows.Sum(s => s.TradingQty);
|
|
var negaQty = negativeFlows.Sum(s => s.TradingQty);
|
|
//第一次开仓流水拆分明细
|
|
List<SwapFlowDeal> openFirstFlows = new List<SwapFlowDeal>();
|
|
//第一次平仓流水拆分明细
|
|
List<SwapFlowDeal> unwindFirstFlows = new List<SwapFlowDeal>();
|
|
//第二次开仓流水拆分明细，最多可能存在第二次开仓
|
|
List<SwapFlowDeal> openLastFlows = new List<SwapFlowDeal>();
|
|
List<swap_flow> negaFlowClones = DataHelper.DeepCopyObject(negativeFlows);
|
|
List<swap_flow> sameFlowClones = DataHelper.DeepCopyObject(sameFlows);
|
|
unwindFirstFlows = GetRemainderFlows(negaFlowClones, sameQty, null);
|
|
var unwindQty = unwindFirstFlows.Sum(s => s.TradingQty);
|
|
//日内轧差全开全平
|
|
//同向总数量>=反向总数量，同向新开仓，反向流水全部平仓，同向剩余新开仓
|
|
if (sameQty >= negaQty)
|
|
{
|
|
openFirstFlows = GetRemainderFlows(sameFlowClones, negaQty, null);
|
|
openFirstFlows.ForEach(x => { x.OpenFlag = (int)OpenCloseEnum.开仓; });
|
|
var openQty = openFirstFlows.Sum(s => s.TradingQty);
|
|
if (openQty < negaQty)
|
|
{
|
|
var sameFlow = sameFlowClones.First();
|
|
var unwindFirstQty = negaQty - openQty;
|
|
var unwindFee = sameFlow.TradingFee * unwindFirstQty / sameFlow.TradingQty;
|
|
SwapFlowDeal firstOpenFlowDeal = GetSwapFlowDeal(sameFlow, unwindFirstQty, (int)OpenCloseEnum.开仓, unwindFee, null);
|
|
openFirstFlows.Add(firstOpenFlowDeal);
|
|
sameFlow.TradingQty = sameFlow.TradingQty - unwindFirstQty;
|
|
sameFlow.TradingFee = sameFlow.TradingFee - unwindFee;
|
|
sameFlow.TradingAmount = sameFlow.TradingQty;
|
|
}
|
|
//反向流水全部平仓
|
|
foreach (var negaFlow in negaFlowClones)
|
|
{
|
|
SwapFlowDeal swapFlowDeal = GetSwapFlowDeal(negaFlow, negaFlow.TradingQty, (int)OpenCloseEnum.平仓, negaFlow.TradingFee, null);
|
|
unwindFirstFlows.Add(swapFlowDeal);
|
|
}
|
|
foreach (var sameFlow in sameFlowClones)
|
|
{
|
|
SwapFlowDeal swapFlowDeal = GetSwapFlowDeal(sameFlow, sameFlow.TradingQty, (int)OpenCloseEnum.开仓, sameFlow.TradingFee, null);
|
|
openLastFlows.Add(swapFlowDeal);
|
|
}
|
|
}
|
|
else //同向总数量 < 反向总数量，同向先开仓，反向流水部分平仓，反向剩余新开仓
|
|
{
|
|
if (unwindQty < sameQty)
|
|
{
|
|
var negaFlow = negaFlowClones.First();
|
|
var unwindFirstQty = sameQty - unwindQty;
|
|
var unwindFee = negaFlow.TradingFee * unwindFirstQty / negaFlow.TradingQty;
|
|
SwapFlowDeal swapFirstFlowDeal = GetSwapFlowDeal(negaFlow, unwindFirstQty, (int)OpenCloseEnum.平仓, unwindFee, null);
|
|
unwindFirstFlows.Add(swapFirstFlowDeal);
|
|
negaFlow.TradingQty = negaFlow.TradingQty - unwindFirstQty;
|
|
negaFlow.TradingFee = negaFlow.TradingFee - unwindFee;
|
|
negaFlow.TradingAmount = negaFlow.TradingQty;
|
|
}
|
|
foreach (var flow in sameFlowClones)
|
|
{
|
|
SwapFlowDeal swapFlowDeal = GetSwapFlowDeal(flow, flow.TradingQty, (int)OpenCloseEnum.开仓, flow.TradingFee, null);
|
|
openFirstFlows.Add(swapFlowDeal);
|
|
}
|
|
foreach (var minFlow in negaFlowClones)
|
|
{
|
|
SwapFlowDeal swapFlowDeal = GetSwapFlowDeal(minFlow, minFlow.TradingQty, (int)OpenCloseEnum.开仓, minFlow.TradingFee, null);
|
|
openLastFlows.Add(swapFlowDeal);
|
|
}
|
|
}
|
|
|
|
var trade = NewSwapTrade(openFirstFlows, client, asset, underlying, floatRate, clearingAgency);
|
|
unwindFirstFlows.ForEach(x => { x.SwapTradeId = trade.id; x.SwapTradeNo = trade.TradeNumber; });
|
|
DbContext.swap_flow_deal.AddRange(unwindFirstFlows);
|
|
var mergeUnwindFlows = SummaryFlow(unwindFirstFlows);
|
|
var unwindMergeFlow = mergeUnwindFlows.First();
|
|
// 平仓
|
|
new SwapDealService(UserInfo).AuotoSwapUnwind(trade.id,
|
|
unwindMergeFlow.TradingAmountAvg,
|
|
unwindMergeFlow.TradingAmountFeeAvg,
|
|
unwindMergeFlow.TradingAmountNetFeeAvg ?? 0,
|
|
unwindMergeFlow.TradingAmountNetAvg ?? 0,
|
|
unwindMergeFlow.OccurTime,
|
|
unwindMergeFlow.TradingQty,
|
|
unwindMergeFlow.TradingQty,
|
|
unwindMergeFlow.TradingFeePending);
|
|
if (openLastFlows.Count > 0)
|
|
{
|
|
return NewSwapTrade(openLastFlows, client, asset, underlying, floatRate, clearingAgency);
|
|
}
|
|
return trade;
|
|
}
|
|
/// <summary>
|
|
/// 流水拆分后新开仓
|
|
/// </summary>
|
|
/// <param name="openFlows"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
/// <param name="clearingAgency"></param>
|
|
/// <returns></returns>
|
|
private trade NewSwapTrade(List<SwapFlowDeal> openFlows,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
string clearingAgency)
|
|
{
|
|
var swapTradeService = new SwapTradeService(UserInfo);
|
|
var mergeFlows = SummaryFlow(openFlows);
|
|
swap_flow_merge flowMergeFirst = mergeFlows.First();
|
|
var trade = swapTradeService.NewSwapTrade(flowMergeFirst, client, asset, underlying, floatRate, null, clearingAgency, LongShortStructType);
|
|
flowMergeFirst.SwapTradeNo = trade.TradeNumber;
|
|
flowMergeFirst.SwapTradeId = trade.id;
|
|
openFlows.ForEach(x => { x.SwapTradeId = trade.id; x.SwapTradeNo = trade.TradeNumber; });
|
|
DbContext.swap_flow_deal.AddRange(openFlows);
|
|
DbContext.SaveChanges();
|
|
return trade;
|
|
}
|
|
/// <summary>
|
|
/// 获取剩余要开仓流水
|
|
/// </summary>
|
|
/// <param name="flows"></param>
|
|
/// <param name="unwindQty"></param>
|
|
private List<SwapFlowDeal> GetRemainderFlows(List<swap_flow> flows, decimal unwindQty, trade td)
|
|
{
|
|
decimal openQty = 0;
|
|
List<SwapFlowDeal> unwindFirstFlows = new List<SwapFlowDeal>();
|
|
for (int i = 0; i < flows.Count; i++)
|
|
{
|
|
var flow = flows[i];
|
|
openQty += flow.TradingQty;
|
|
if (openQty <= unwindQty)
|
|
{
|
|
SwapFlowDeal swapFlowDeal = GetSwapFlowDeal(flow, flow.TradingQty, (int)OpenCloseEnum.平仓, flow.TradingFee, td);
|
|
unwindFirstFlows.Add(swapFlowDeal);
|
|
flows.Remove(flow);
|
|
i--;
|
|
}
|
|
}
|
|
return unwindFirstFlows;
|
|
}
|
|
/// <summary>
|
|
/// 转换拆分流水
|
|
/// </summary>
|
|
/// <param name="swapFlow"></param>
|
|
/// <param name="qty"></param>
|
|
/// <param name="openFlag"></param>
|
|
/// <returns></returns>
|
|
private SwapFlowDeal GetSwapFlowDeal(swap_flow swapFlow, decimal qty, int openFlag, decimal fee, trade td)
|
|
{
|
|
SwapFlowDeal swapFlowDeal = new SwapFlowDeal();
|
|
swapFlowDeal.ContractSize = swapFlow.ContractSize;
|
|
swapFlowDeal.SetOpt(UserInfo);
|
|
swapFlowDeal.BsType = swapFlow.BsType;
|
|
swapFlowDeal.ClientId = swapFlow.ClientId ?? 0;
|
|
swapFlowDeal.ClientName = swapFlow.ClientName;
|
|
swapFlowDeal.FullPriceFee = swapFlow.TradingAmountFeeAvg;
|
|
swapFlowDeal.FullPrice = swapFlow.TradingAmountAvg;
|
|
swapFlowDeal.OccurDate = swapFlow.OccurTime ?? DateTime.Now.Date;
|
|
swapFlowDeal.HedgeDealType = swapFlow.DealType ?? 0;
|
|
swapFlowDeal.SettleDate = swapFlow.SettleDate;
|
|
swapFlowDeal.TrsDealId = swapFlow.trs_deal_id;
|
|
swapFlowDeal.FlowId = swapFlow.id;
|
|
swapFlowDeal.HedgeTime = swapFlow.OptTime;
|
|
swapFlowDeal.OpenFlag = openFlag;
|
|
swapFlowDeal.TradeingAmount = qty;
|
|
swapFlowDeal.TradingFee = fee;
|
|
swapFlowDeal.NetPrice = swapFlow.TradingAmountNet ?? 0;
|
|
swapFlowDeal.NetPriceFee = swapFlow.TradingAmountNetFee ?? 0;
|
|
swapFlowDeal.TradingQty = qty;
|
|
swapFlowDeal.UnderlyingCode = swapFlow.UnderlyingCode;
|
|
swapFlowDeal.UnderlyingName = swapFlow.UnderlyingName;
|
|
swapFlowDeal.Ytm = swapFlow.ytm;
|
|
if (td != null)
|
|
{
|
|
swapFlowDeal.SwapTradeId = td.id;
|
|
swapFlowDeal.SwapTradeNo = td.TradeNumber;
|
|
}
|
|
return swapFlowDeal;
|
|
}
|
|
/// <summary>
|
|
/// 将上日有持仓的流水自动簿记
|
|
/// </summary>
|
|
/// <param name="mergeList"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
/// <param name="clientSwapPositionList"></param>
|
|
/// <param name="clientSwapTrades"></param>
|
|
private void DealHasPosition(List<swap_flow_merge> mergeList,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
List<swap_position> clientSwapPositionList,
|
|
List<trade> clientSwapTrades,
|
|
client_marginrate clientMarginTemplate,
|
|
string clearingAgency,
|
|
bool cashNeedAfter)
|
|
{
|
|
if (mergeList.Count == 1)//只有一条流水情况
|
|
{
|
|
DealSingleFlow(mergeList, clientSwapPositionList, clientSwapTrades, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency);
|
|
}
|
|
else
|
|
{
|
|
DealDoubleFlow(mergeList, clientSwapPositionList, clientSwapTrades, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency, cashNeedAfter);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 将上日有持仓的流水自动簿记
|
|
/// </summary>
|
|
/// <param name="flowList"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
/// <param name="clientSwapPositionList"></param>
|
|
/// <param name="clientSwapTrades"></param>
|
|
private void AvgDealHasPosition(List<swap_flow> flowList,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
List<swap_position> clientSwapPositionList,
|
|
List<trade> clientSwapTrades,
|
|
string clearingAgency)
|
|
{
|
|
var firstFlow = flowList.First();
|
|
var negaFlowExist = flowList.Any(x => x.BsType != firstFlow.BsType);
|
|
if (!negaFlowExist)//只有同向流水情况
|
|
{
|
|
AvgDealSingleFlow(flowList, clientSwapPositionList, clientSwapTrades, client, asset, underlying, floatRate, clearingAgency);
|
|
}
|
|
else
|
|
{
|
|
AvgDealDoubleFlow(flowList, clientSwapPositionList, clientSwapTrades, client, asset, underlying, floatRate, clearingAgency);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 处理单条流水情况
|
|
/// </summary>
|
|
/// <param name="mergeList"></param>
|
|
/// <param name="clientSwapPositionList"></param>
|
|
/// <param name="clientSwapTrades"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
private void DealSingleFlow(List<swap_flow_merge> mergeList,
|
|
List<swap_position> clientSwapPositionList,
|
|
List<trade> clientSwapTrades,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
client_marginrate clientMarginTemplate,
|
|
string clearingAgency)
|
|
{
|
|
var swapTradeService = new SwapTradeService(UserInfo);
|
|
swap_flow_merge flowMergeMax = mergeList.First();
|
|
swap_flow_merge flowMergeMin = mergeList.Last();
|
|
var negativeDirectionPositions = clientSwapPositionList.Where(x => x.PositionType != flowMergeMax.BsType).ToList();//查找反方向交易
|
|
var sameDirectionPositions = clientSwapPositionList.Where(x => x.PositionType == flowMergeMax.BsType).ToList();//查找同方向交易
|
|
var tradeIds = clientSwapPositionList.Select(x => x.SwapTradeId).ToList();
|
|
var sameTradeIds = sameDirectionPositions.Select(x => x.SwapTradeId).ToList();
|
|
var sameTrades = clientSwapTrades.Where(x => sameTradeIds.Contains(x.id) && x.TradeDate == flowMergeMax.OccurTime).ToList();//只处理当前清算日期的交易
|
|
if (negativeDirectionPositions.Any())//存在反方向交易
|
|
{
|
|
List<int> unwindTradeIds = new List<int>();
|
|
var negativeTradeIds = negativeDirectionPositions.Select(x => x.SwapTradeId).ToList();
|
|
var negativeTrades = clientSwapTrades.Where(x => negativeTradeIds.Contains(x.id)).OrderBy(o => o.TradeDate).ToList();
|
|
var flowMergeClone = flowMergeMax.Clone();
|
|
flowMergeMax.SwapTradeNo = flowMergeClone.SwapTradeNo;
|
|
var dealResult = DealNegativeTrade(negativeTrades, flowMergeClone, negativeDirectionPositions, unwindTradeIds, true, false);
|
|
if (dealResult.Item3)// 处理完有开仓需求
|
|
{
|
|
flowMergeClone.TradingAmount = dealResult.Item1;
|
|
flowMergeClone.TradingQty = dealResult.Item2;
|
|
if (flowMergeClone.BsType != flowMergeMax.BsType)//交易有剩余新开仓
|
|
{
|
|
SetNewOpenData(flowMergeMax, flowMergeClone, dealResult.Item4);
|
|
}
|
|
var trade = swapTradeService.NewSwapTrade(flowMergeClone, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency);
|
|
flowMergeMax.SwapTradeNo = trade.TradeNumber;
|
|
}
|
|
}
|
|
else //只存在同向交易
|
|
{
|
|
var trade = swapTradeService.NewSwapTrade(flowMergeMax, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency);
|
|
flowMergeMax.SwapTradeNo = trade.TradeNumber;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 交易平完有剩余重置法新开仓算价格等数据
|
|
/// </summary>
|
|
/// <param name="origin"></param>
|
|
/// <param name="flowMergeClone"></param>
|
|
/// <param name="position"></param>
|
|
private void SetNewOpenData(swap_flow_merge origin, swap_flow_merge flowMergeClone, swap_position position)
|
|
{
|
|
if (position == null)
|
|
{
|
|
return;
|
|
}
|
|
var ratio = flowMergeClone.BsType == 1 ? 1 : -1;
|
|
var oriRatio = flowMergeClone.BsType == 1 ? -1 : 1;
|
|
flowMergeClone.TradingFeePending = flowMergeClone.TradingQty / origin.TradingQty * origin.TradingFeePending;
|
|
flowMergeClone.TradingAmountAvg = origin.TradingAmountAvg + oriRatio * origin.TradingFeePending * 2 / origin.TradingQty;
|
|
flowMergeClone.TradingAmountNetAvg = origin.TradingAmountNetAvg + oriRatio * origin.TradingFeePending * 2 / origin.TradingQty;
|
|
|
|
flowMergeClone.TradingAmountFeeAvg = flowMergeClone.TradingAmountAvg + ratio * flowMergeClone.TradingFeePending / flowMergeClone.TradingQty;
|
|
flowMergeClone.TradingAmountNetFeeAvg = flowMergeClone.TradingAmountNetAvg + ratio * flowMergeClone.TradingFeePending / flowMergeClone.TradingQty;
|
|
}
|
|
/// <summary>
|
|
/// 加权平均处理单条流水情况
|
|
/// </summary>
|
|
/// <param name="flowList"></param>
|
|
/// <param name="clientSwapPositionList"></param>
|
|
/// <param name="clientSwapTrades"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
private void AvgDealSingleFlow(List<swap_flow> flowList,
|
|
List<swap_position> clientSwapPositionList,
|
|
List<trade> clientSwapTrades,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
string clearingAgency)
|
|
{
|
|
swap_flow flowMergeMax = flowList.First();
|
|
var negaSwapPositions = clientSwapPositionList.Where(x => x.PositionType != flowMergeMax.BsType).ToList();
|
|
List<swap_flow> flowClones = DataHelper.DeepCopyObject(flowList);
|
|
if (negaSwapPositions.Count > 0)//流水与持仓反向
|
|
{
|
|
AvgDealUnwind(flowClones, clientSwapTrades, negaSwapPositions, client, asset, underlying, floatRate, clearingAgency,true);
|
|
}
|
|
else //只存在同向交易,同向流水合并新开仓
|
|
{
|
|
DealOneDirectionFlows(flowClones, client, asset, underlying, floatRate, clearingAgency);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 处理多条流水情况
|
|
/// </summary>
|
|
/// <param name="mergeList"></param>
|
|
/// <param name="clientSwapPositionList"></param>
|
|
/// <param name="clientSwapTrades"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
public void DealDoubleFlow(List<swap_flow_merge> mergeList,
|
|
List<swap_position> clientSwapPositionList,
|
|
List<trade> clientSwapTrades,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
client_marginrate clientMarginTemplate,
|
|
string clearingAgency,
|
|
bool cashNeedAfter)
|
|
{
|
|
var swapTradeService = new SwapTradeService(UserInfo);
|
|
mergeList = mergeList.OrderBy(o => o.FirstFlowTime).ToList();
|
|
var flowMergeFirst = mergeList.First();
|
|
var flowMergeLast = mergeList.Last();
|
|
|
|
var flowMergeFirstClone = flowMergeFirst.Clone();
|
|
var flowMergeLastClone = flowMergeLast.Clone();
|
|
var sameDirectionPositions = clientSwapPositionList.Where(x => x.PositionType == flowMergeFirstClone.BsType).ToList();
|
|
var negDirectionPositions = clientSwapPositionList.Where(x => x.PositionType == flowMergeLastClone.BsType).ToList();
|
|
|
|
var sameTradeIds = sameDirectionPositions.Select(x => x.SwapTradeId).ToList();
|
|
var sameTrades = clientSwapTrades.Where(x => sameTradeIds.Contains(x.id)).ToList();//取出与第一条流水方向相同的交易
|
|
|
|
|
|
var negTradeIds = negDirectionPositions.Select(x => x.SwapTradeId).ToList();
|
|
var negTrades = clientSwapTrades.Where(x => negTradeIds.Contains(x.id)).ToList();//取出与第一条流水方向相反的交易
|
|
|
|
//先处理第一条流水的反向持仓
|
|
var firstTrade = DealDoubleFlowDetial(negTrades, negDirectionPositions, flowMergeFirstClone, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency, true, cashNeedAfter);
|
|
flowMergeFirst.SwapTradeNo = flowMergeFirstClone.SwapTradeNo;
|
|
|
|
//再处理第二条流水的反向持仓
|
|
var lastTrade = DealDoubleFlowDetial(sameTrades, sameDirectionPositions, flowMergeLastClone, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency, false,false);
|
|
flowMergeLast.SwapTradeNo = flowMergeLastClone.SwapTradeNo;
|
|
if (flowMergeFirstClone.BsType != flowMergeLastClone.BsType && firstTrade != null)
|
|
{
|
|
var trades = new List<trade> { firstTrade };
|
|
var positions = DbContext.swap_position.Where(x => x.SwapTradeId == firstTrade.id && x.PosiDirection > 0 && !x.IsInitial && !x.Invalid).ToList();
|
|
DealDoubleFlowDetial(trades, positions, flowMergeLastClone, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency, true,false);
|
|
flowMergeLast.SwapTradeNo = flowMergeLastClone.SwapTradeNo;
|
|
}
|
|
else if (lastTrade==null)
|
|
{
|
|
swapTradeService.NewSwapTrade(flowMergeLastClone, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 加权平均处理当前有持仓，切两个方向多条流水情况
|
|
/// </summary>
|
|
/// <param name="flowList"></param>
|
|
/// <param name="clientSwapPositionList"></param>
|
|
/// <param name="clientSwapTrades"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
public void AvgDealDoubleFlow(List<swap_flow> flowList,
|
|
List<swap_position> clientSwapPositionList,
|
|
List<trade> clientSwapTrades,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
string clearingAgency)
|
|
{
|
|
var swapTradeService = new SwapTradeService(UserInfo);
|
|
var firstPosi = clientSwapPositionList.First();
|
|
var swapPositions = clientSwapPositionList.Where(x => x.PositionType == firstPosi.PositionType).ToList();
|
|
var posiQty = swapPositions.Sum(s => s.PosiQuantity);
|
|
var flowSames = flowList.Where(x => x.BsType == firstPosi.PositionType).ToList();
|
|
var flowNegs = flowList.Where(x => x.BsType != firstPosi.PositionType).ToList();
|
|
var negaBsType= flowNegs.First().BsType;
|
|
|
|
var sameQty = posiQty + flowSames.Sum(s => s.TradingQty);
|
|
var flowSameClones = DataHelper.DeepCopyObject(flowSames);
|
|
var flowNegClones = DataHelper.DeepCopyObject(flowNegs);
|
|
//先平反向
|
|
AvgDealUnwind(flowNegClones, clientSwapTrades, swapPositions, client, asset, underlying, floatRate, clearingAgency,false);
|
|
var newFlowList = new List<swap_flow>();
|
|
var openBystype = firstPosi.PositionType;
|
|
if (flowNegClones.Count > 0)
|
|
{
|
|
newFlowList.AddRange(flowNegClones);
|
|
openBystype = negaBsType;
|
|
}
|
|
newFlowList.AddRange(flowSameClones);
|
|
//有历史持仓按反方向先开仓
|
|
AvgDealNoPosition(newFlowList, client, asset, underlying, floatRate, clearingAgency, openBystype);
|
|
}
|
|
/// <summary>
|
|
/// 有持仓流水
|
|
/// </summary>
|
|
/// <param name="swapFlows"></param>
|
|
/// <param name="trades"></param>
|
|
/// <param name="swapPositions"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
/// <param name="clearingAgency"></param>
|
|
private void AvgDealUnwind(List<swap_flow> swapFlows,
|
|
List<trade> trades,
|
|
List<swap_position> swapPositions,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
string clearingAgency,
|
|
bool needAdd)
|
|
{
|
|
var swapTradeService = new SwapTradeService(UserInfo);
|
|
foreach (var posi in swapPositions)
|
|
{
|
|
if (swapFlows.Count == 0)
|
|
{
|
|
break;
|
|
}
|
|
var td = trades.FirstOrDefault(p => p.id == posi.SwapTradeId);
|
|
if (td != null)
|
|
{
|
|
var posiQty = posi.PosiQuantity;
|
|
var flowQty = swapFlows.Sum(s => s.TradingQty);
|
|
var unwindSwapFlowDeals = GetRemainderFlows(swapFlows, posiQty, td);
|
|
var unwindQty = unwindSwapFlowDeals.Sum(x => x.TradingQty);
|
|
if (unwindQty < posiQty && swapFlows.Count > 0)
|
|
{
|
|
var unwindSwapFlow = swapFlows.First();
|
|
var flowUnindQty = posiQty - unwindQty;
|
|
var unwindFee = unwindSwapFlow.TradingQty == 0 ? 0 : unwindSwapFlow.TradingFee * flowUnindQty / unwindSwapFlow.TradingQty;
|
|
unwindSwapFlow.TradingQty = unwindSwapFlow.TradingQty - flowUnindQty;
|
|
unwindSwapFlow.TradingFee = unwindSwapFlow.TradingFee - unwindFee;
|
|
unwindSwapFlow.TradingAmount = unwindSwapFlow.TradingQty;
|
|
var unwindFlowDeal = GetSwapFlowDeal(unwindSwapFlow, flowUnindQty, (int)OpenCloseEnum.平仓, unwindFee, td);
|
|
unwindSwapFlowDeals.Add(unwindFlowDeal);
|
|
}
|
|
DbContext.swap_flow_deal.AddRange(unwindSwapFlowDeals);
|
|
var unwindMergeFlow = SummaryFlow(unwindSwapFlowDeals).First();
|
|
// 平仓
|
|
new SwapDealService(UserInfo).AuotoSwapUnwind(td.id,
|
|
unwindMergeFlow.TradingAmountAvg,
|
|
unwindMergeFlow.TradingAmountFeeAvg,
|
|
|
|
unwindMergeFlow.TradingAmountNetFeeAvg ?? 0,
|
|
unwindMergeFlow.TradingAmountNetAvg ?? 0,
|
|
unwindMergeFlow.OccurTime,
|
|
unwindMergeFlow.TradingQty,
|
|
posiQty,
|
|
unwindMergeFlow.TradingFeePending);
|
|
}
|
|
}
|
|
if (swapFlows.Count > 0 && needAdd)
|
|
{
|
|
var bsType = swapFlows.First().BsType;
|
|
AvgDealNoPosition(swapFlows, client, asset, underlying, floatRate, clearingAgency, bsType);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 2条流水处理明细
|
|
/// </summary>
|
|
/// <param name="maxTrades"></param>
|
|
/// <param name="minTrades"></param>
|
|
/// <param name="clientSwapPositionList"></param>
|
|
/// <param name="flowMergeMax"></param>
|
|
/// <param name="flowMergeMin"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
private trade DealDoubleFlowDetial(List<trade> negTrades,
|
|
List<swap_position> negDirectionPositions,
|
|
swap_flow_merge flowMergeSameClone,
|
|
Client client,
|
|
AssetUnit asset,
|
|
underlying_manager underlying,
|
|
SwapFloatRate floatRate,
|
|
client_marginrate clientMarginTemplate,
|
|
string clearingAgency,
|
|
bool needOpen,
|
|
bool cashNeedAfter
|
|
)
|
|
{
|
|
var swapTradeService = new SwapTradeService(UserInfo);
|
|
var flowMergeMax = flowMergeSameClone.Clone();
|
|
List<int> unwindTradeIds = new List<int>();
|
|
var dealResult = DealNegativeTrade(negTrades, flowMergeSameClone, negDirectionPositions, unwindTradeIds, needOpen, cashNeedAfter);
|
|
if (dealResult.Item3)// 处理完有开仓需求
|
|
{
|
|
flowMergeSameClone.TradingAmount = dealResult.Item1;
|
|
flowMergeSameClone.TradingQty = dealResult.Item2;
|
|
if (flowMergeSameClone.BsType != flowMergeMax.BsType)//交易有剩余新开仓
|
|
{
|
|
SetNewOpenData(flowMergeMax, flowMergeSameClone, dealResult.Item4);
|
|
}
|
|
return swapTradeService.NewSwapTrade(flowMergeSameClone, client, asset, underlying, floatRate, clientMarginTemplate, clearingAgency);
|
|
}
|
|
return null;
|
|
|
|
}
|
|
/// <summary>
|
|
/// 处理反方向流水簿记
|
|
/// </summary>
|
|
/// <param name="negativeTrades"></param>
|
|
/// <param name="flowMerge"></param>
|
|
/// <param name="floatPositions"></param>
|
|
/// <param name="matuirityDate"></param>
|
|
/// <param name="client"></param>
|
|
/// <param name="asset"></param>
|
|
/// <param name="underlying"></param>
|
|
/// <param name="floatRate"></param>
|
|
private (decimal, decimal, bool, swap_position) DealNegativeTrade(
|
|
List<trade> negativeTrades,
|
|
swap_flow_merge flowMerge,
|
|
List<swap_position> floatPositions,
|
|
List<int> unwindTradeIds,
|
|
bool needOpen,
|
|
bool cashNeedAfter
|
|
)
|
|
{
|
|
if (negativeTrades.Count == 0)
|
|
{
|
|
return (flowMerge.TradingAmount, flowMerge.TradingQty, needOpen, null);
|
|
}
|
|
var swapTradeService = new SwapTradeService(UserInfo);
|
|
List<trade> cloneNegativeTrades = new List<trade>(negativeTrades);
|
|
var first = true;
|
|
foreach (trade td in negativeTrades)
|
|
{
|
|
if (first&& cashNeedAfter)
|
|
{
|
|
cashNeedAfter = true;
|
|
}
|
|
else
|
|
{
|
|
cashNeedAfter = false;
|
|
}
|
|
var floatPosition = floatPositions.FirstOrDefault(x => x.SwapTradeId == td.id);
|
|
if (floatPosition == null)
|
|
{
|
|
cloneNegativeTrades.Remove(td);
|
|
if (cloneNegativeTrades.Count > 0)
|
|
{
|
|
return DealNegativeTrade(cloneNegativeTrades, flowMerge, floatPositions, unwindTradeIds, needOpen,false);//继续平下一个簿记
|
|
}
|
|
else //交易平完，流水有剩余
|
|
{
|
|
//新开
|
|
return (flowMerge.TradingAmount, flowMerge.TradingQty, needOpen, null);
|
|
}
|
|
}
|
|
//新开
|
|
var oldAmount = floatPosition.PosiNetPrice * floatPosition.PosiQuantity;
|
|
var newAmount = flowMerge.TradingAmountFeeAvg * flowMerge.TradingQty;
|
|
var newQty = floatPosition.PosiQuantity - flowMerge.TradingQtyAbs;
|
|
var newQtyAbs = Math.Abs(newQty);
|
|
flowMerge.SwapTradeNo = td.TradeNumber;
|
|
// 全平
|
|
new SwapDealService(UserInfo).AuotoSwapUnwind(td.id,
|
|
flowMerge.TradingAmountAvg,
|
|
flowMerge.TradingAmountFeeAvg,
|
|
flowMerge.TradingAmountNetFeeAvg ?? 0,
|
|
flowMerge.TradingAmountNetAvg ?? 0,
|
|
flowMerge.OccurTime,
|
|
floatPosition.PosiQuantity,
|
|
flowMerge.TradingQty,
|
|
flowMerge.TradingFeePending);
|
|
unwindTradeIds.Add(td.id);
|
|
flowMerge.TradingAmount = newQtyAbs * flowMerge.ContractSize;
|
|
if (newQty > 0)
|
|
{
|
|
flowMerge.TradingFeePending = floatPosition.PosiTradingFeePending * newQtyAbs / floatPosition.PosiQuantity;
|
|
}
|
|
else
|
|
{
|
|
flowMerge.TradingFeePending = flowMerge.TradingFeePending * newQtyAbs / flowMerge.TradingQty;
|
|
}
|
|
flowMerge.TradingQty = newQtyAbs;
|
|
if (newQty < 0)//交易不够平，继续平
|
|
{
|
|
cloneNegativeTrades.Remove(td);
|
|
if (cloneNegativeTrades.Count > 0)
|
|
{
|
|
return DealNegativeTrade(cloneNegativeTrades, flowMerge, floatPositions, unwindTradeIds, needOpen, false);//继续平下一个簿记
|
|
}
|
|
else //交易平完，流水有剩余
|
|
{
|
|
//新开
|
|
return (flowMerge.TradingAmount, flowMerge.TradingQty, needOpen, null);
|
|
}
|
|
|
|
}
|
|
else if (newQty > 0) //交易平完交易有剩余
|
|
{
|
|
flowMerge.BsType = flowMerge.BsType == 1 ? 2 : 1;
|
|
return (flowMerge.TradingAmount, flowMerge.TradingQty, true, floatPosition);
|
|
}
|
|
else //完全平仓
|
|
{
|
|
return (0, 0, false, null);
|
|
}
|
|
|
|
}
|
|
return (0, 0, false, null);
|
|
}
|
|
/// <summary>
|
|
/// 定时任务合成持仓
|
|
/// </summary>
|
|
/// <param name="flowList"></param>
|
|
/// <param name="swapPositions"></param>
|
|
/// <param name="clientPosition"></param>
|
|
/// <param name="multiplier"></param>
|
|
/// <param name="positionType"></param>
|
|
|
|
public void MergeSwapPositionAvg(List<swap_flow> flowList, List<swap_position> swapPositions, ClientPosition clientPosition, decimal multiplier, int positionType)
|
|
{
|
|
var hasPayPosition = swapPositions != null && swapPositions.Count > 0;
|
|
var posiQty = swapPositions == null ? 0 : swapPositions.Sum(x => x.PosiQuantity);
|
|
var flowSames = flowList.Where(x => x.BsType == positionType).OrderBy(o => o.OptTime).ToList();
|
|
var flowNegatives = flowList.Where(x => x.BsType != positionType).OrderBy(o => o.OptTime).ToList();
|
|
var sameQty = flowSames.Sum(s => s.TradingQty);
|
|
var negaQty = flowNegatives.Sum(s => s.TradingQty);
|
|
|
|
if (sameQty + posiQty < negaQty)
|
|
{
|
|
var negaPosiType = flowNegatives.First().BsType;
|
|
clientPosition.side = negaPosiType - 1;
|
|
}
|
|
var posiType = clientPosition.id == 0 ? 0 : clientPosition.side;
|
|
List<swap_flow> maxFlowClones = new List<swap_flow>(flowSames);
|
|
var mergeFlow = new swap_flow_merge();
|
|
if (hasPayPosition)//有日终持仓
|
|
{
|
|
var posiFlows = ConvertToSwapFlow(swapPositions, (int)clientPosition.client_id);
|
|
maxFlowClones.AddRange(posiFlows);
|
|
maxFlowClones = maxFlowClones.OrderBy(o => o.id).ToList();
|
|
sameQty = maxFlowClones.Sum(s => s.TradingQty);
|
|
}
|
|
var maxQty = sameQty;
|
|
var minQty = negaQty;
|
|
if (clientPosition.side + 1 != positionType)
|
|
{
|
|
maxQty = negaQty;
|
|
minQty = sameQty;
|
|
maxFlowClones = new List<swap_flow>(flowNegatives);
|
|
}
|
|
maxFlowClones.ForEach(x => { x.OccurTime = DateTime.Now.Date; });
|
|
var unwindDeals = GetRemainderFlows(maxFlowClones, minQty, null);
|
|
var unwindQty = unwindDeals.Sum(s => s.TradingQty);
|
|
if (minQty != 0 && unwindQty < maxQty)
|
|
{
|
|
var firstFlow = maxFlowClones.First();
|
|
var unwindFlowQty = minQty - unwindQty;
|
|
var unwindFee = firstFlow.TradingFee * unwindFlowQty / firstFlow.TradingQty;
|
|
firstFlow.TradingQty = firstFlow.TradingQty - unwindFlowQty;
|
|
firstFlow.TradingFee = firstFlow.TradingFee - unwindFee;
|
|
firstFlow.TradingAmount = firstFlow.TradingQty;
|
|
}
|
|
var mergeList = SummaryFlow(maxFlowClones, false);
|
|
mergeFlow = mergeList.Count>0? mergeList.First():new swap_flow_merge();
|
|
clientPosition.commission = mergeFlow.TradingFee;
|
|
clientPosition.position_qty = mergeFlow.TradingQty / 10000;
|
|
clientPosition.position_notional_principal = mergeFlow.TradingQty;
|
|
clientPosition.deal_full_price_avg = mergeFlow.TradingAmountAvg * multiplier;
|
|
clientPosition.deal_price_avg = mergeFlow.TradingAmountNetAvg * multiplier;
|
|
}
|
|
/// <summary>
|
|
/// 将持仓转换为流水
|
|
/// </summary>
|
|
/// <param name="positions"></param>
|
|
/// <param name="clientId"></param>
|
|
/// <returns></returns>
|
|
private List<swap_flow> ConvertToSwapFlow(List<swap_position> positions, int clientId)
|
|
{
|
|
List<swap_flow> flows = new List<swap_flow>();
|
|
foreach (var item in positions)
|
|
{
|
|
swap_flow flow = new swap_flow();
|
|
flow.TradingAmount = item.PosiNotionalValue;
|
|
flow.TradingAmountAvg = item.PosiGrossPrice;
|
|
flow.TradingAmountFeeAvg = item.PosiNetPrice;
|
|
flow.TradingAmountNet = item.PosiNetNoFeePrice;
|
|
flow.TradingAmountNetFee = item.PosiNetFeePrice;
|
|
flow.TradingFee = item.PosiTradingFeePending;
|
|
flow.TradingQty = item.PosiQuantity;
|
|
flow.UnderlyingCode = item.UnderlyingCode;
|
|
flow.OccurTime = DateTime.Now.Date;
|
|
flow.ContractSize = item.ContractSize;
|
|
flow.ClientId = clientId;
|
|
flow.BsType = item.PositionType;
|
|
flow.SettleDate = item.PosiStartDate;
|
|
flows.Add(flow);
|
|
}
|
|
return flows;
|
|
}
|
|
}
|
|
}
|