1392 lines
63 KiB
C#
1392 lines
63 KiB
C#
using BaseOUDAL;
|
|
using Confluent.Kafka;
|
|
using DocumentFormat.OpenXml.Wordprocessing;
|
|
using Microsoft.Office.Interop.Excel;
|
|
using CsvHelper;
|
|
using Newtonsoft.Json;
|
|
using Qdp.Foundation.Utilities;
|
|
using YLErp.Abstract;
|
|
using YLErp.BLL;
|
|
using YLErp.BLL.Eod;
|
|
using YLErp.Commons;
|
|
using YLErp.DBModels;
|
|
using YLErp.DBModels.Enums;
|
|
using YLErp.Enums;
|
|
using YLErp.Helpers;
|
|
using YLErp.Model;
|
|
using YLErp.Model.HengTaiModel;
|
|
using YLErp.Models;
|
|
using YLErp.Modules.AppModule;
|
|
using YLErp.Modules.ClientModule;
|
|
using YLErp.Modules.ExchangeTradeModule;
|
|
using YLErp.Modules.TradeModule;
|
|
using static YLErp.ConsGlobal;
|
|
|
|
namespace YLErp.Modules.SwapModule
|
|
{
|
|
public class SwapConsumerService : YLBaseService
|
|
{
|
|
|
|
static readonly IYcLogger logger = LogFactory.GetLogger<SwapConsumerService>();
|
|
|
|
private IKafkaProduce kafkaProduceHelper;
|
|
private string reqMarginInsert = string.Empty;
|
|
public SwapConsumerService(OptUserInfo optUser) : base(optUser)
|
|
{
|
|
reqMarginInsert = Environment.GetEnvironmentVariable("KafkaConfig_ReqMarginInsertTopic");
|
|
}
|
|
public void SetKafKaProduce(IKafkaProduce kafkaProduce)
|
|
{
|
|
kafkaProduceHelper = kafkaProduce;
|
|
}
|
|
/// <summary>
|
|
/// 4.8.1. 消费收益互换回执交易接口
|
|
/// </summary>
|
|
/// <param name="_kafkaConsumer"></param>
|
|
public void ConsumerTradeResp(KafkaConsumerHelper _kafkaConsumer)
|
|
{
|
|
_kafkaConsumer.Subscribe(msg =>
|
|
{
|
|
if (!string.IsNullOrEmpty(msg))
|
|
{
|
|
var result = JsonHelper.Deserialize<RequestBaseWithHead<SwapTradeReq>>(msg);
|
|
var pushLogService = new PushLogService(UserInfo);
|
|
var serialNo = result.HEADER.SERIAL_NO;
|
|
var extNo = result.HEADER.EXT_NO;
|
|
var pushLog = pushLogService.GetLogBySerialNo(serialNo, (int)SwapPushDataEnum.收益互换交易回执);
|
|
var resultState = SwapPushDataStateEnum.接收处理成功;
|
|
if (pushLog != null && pushLog.data_state == (int)resultState)
|
|
{
|
|
return;
|
|
}
|
|
string dealResult = "";
|
|
if (result.RECORD == null)
|
|
{
|
|
resultState = SwapPushDataStateEnum.接收处理失败;
|
|
dealResult = "收益互换信息不能为空";
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrEmpty(extNo) && result.RECORD.BASEINFO != null)
|
|
{
|
|
extNo = result.RECORD.BASEINFO.EXT_NO;
|
|
}
|
|
try
|
|
{
|
|
var trade = DbContext.trade.FirstOrDefault(x => x.TradeNumber == extNo);
|
|
if (trade != null)
|
|
{
|
|
var HTStatus = TryFormatInt(result.RECORD.BASEINFO.ORDSTATUS);
|
|
trade.HTStatus = HTStatus;
|
|
DbContext.SaveChanges();
|
|
if (HTStatus != 7)
|
|
{
|
|
return;
|
|
}
|
|
DealUpdateConsumerTrade(result.RECORD, trade);
|
|
}
|
|
else
|
|
{
|
|
throw new Exception($"交易{extNo}不存在");
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
resultState = SwapPushDataStateEnum.接收处理失败;
|
|
dealResult = e.Message;
|
|
LogFactory.GetLogger("SwapConsumerService").Error("消费收益互换回执交易接口", e);
|
|
}
|
|
}
|
|
pushLogService.SaveConsumerLog(serialNo, extNo, SwapPushDataEnum.收益互换交易回执, resultState, msg, dealResult);
|
|
}
|
|
});
|
|
}
|
|
/// <summary>
|
|
/// 4.8.2. 消费互换资产交易回执接口
|
|
/// </summary>
|
|
/// <param name="_kafkaConsumer"></param>
|
|
public void ConsumerTradePosiResp(KafkaConsumerHelper _kafkaConsumer)
|
|
{
|
|
_kafkaConsumer.Subscribe(msg =>
|
|
{
|
|
if (!string.IsNullOrEmpty(msg))
|
|
{
|
|
var result = JsonHelper.Deserialize<RequestBaseWithHead<SwapPosiReq>>(msg);
|
|
var pushLogService = new PushLogService(UserInfo);
|
|
var serialNo = result.HEADER.SERIAL_NO;
|
|
var extNo = result.HEADER.EXT_NO;
|
|
var pushLog = pushLogService.GetLogBySerialNo(serialNo, (int)SwapPushDataEnum.互换资产交易回执);
|
|
var resultState = SwapPushDataStateEnum.接收处理成功;
|
|
string dealResult = "";
|
|
if (pushLog != null && pushLog.data_state == (int)resultState)
|
|
{
|
|
return;
|
|
}
|
|
if (result.RECORD == null || result.RECORD.BASEINFO == null)
|
|
{
|
|
resultState = SwapPushDataStateEnum.接收处理失败;
|
|
dealResult = "找不到合约编号";
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
var account = result.RECORD.BASEINFO.SECU_INT;
|
|
var HTAccounts = DbContext.exchange_account.Where(x => !string.IsNullOrEmpty(x.AccountCode)).Select(s => s.AccountCode).Distinct().ToList();
|
|
if (HTAccounts.Contains(account))
|
|
{
|
|
PrepareExchangeTradeData(result.RECORD,"衡泰同步");
|
|
return;
|
|
}
|
|
if (OtcAppConfigHelper.HTUpdate != 1)
|
|
{
|
|
return;
|
|
}
|
|
var tradeNumber = result.RECORD.BASEINFO.TRD_RELATED_NO;
|
|
var HTStatus = TryFormatInt(result.RECORD.BASEINFO.ORDSTATUS);
|
|
var trade = CheckTradeExist(tradeNumber);
|
|
// 衡泰状态不是成交确认或者 当前交易有平仓，不给修改，如日内平仓，或者dma部分平仓
|
|
if (HTStatus != 7)
|
|
{
|
|
return;
|
|
}
|
|
if (pushLog == null && !CheckPositionNumber(extNo))
|
|
{
|
|
if (long.TryParse(extNo, out long dataId))//平仓
|
|
{
|
|
pushLog = pushLogService.GetLogByDataId(dataId);
|
|
if (pushLog != null)//我方平仓，不做操作
|
|
{
|
|
extNo = pushLog.data_number;
|
|
}
|
|
}
|
|
else //衡泰平仓
|
|
{
|
|
var posiGrossPrice = TryFormatDecimal(result.RECORD.TRADEINFO.ORDPRICE) / 100;
|
|
var orderDate = TryFormatDate(result.RECORD.BASEINFO.ORDDATE).Date;
|
|
dealResult = DealUnwindPosiEvent(posiGrossPrice, trade, orderDate);
|
|
}
|
|
}
|
|
else if (trade.UnWindDate == null)
|
|
{
|
|
PreparePosiData(result.RECORD, trade, extNo);
|
|
}
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
resultState = SwapPushDataStateEnum.接收处理失败;
|
|
dealResult = e.Message;
|
|
LogFactory.GetLogger("SwapConsumerService").Error("消费互换资产交易回执接口", e);
|
|
}
|
|
}
|
|
new PushLogService(UserInfo).SaveConsumerLog(serialNo, extNo, SwapPushDataEnum.互换资产交易回执, resultState, msg, dealResult);
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 对冲交易回执接口
|
|
/// </summary>
|
|
/// <param name="_kafkaConsumer"></param>
|
|
public void ConsumerExchangeTradeResp(KafkaConsumerHelper _kafkaConsumer,string tradeSource)
|
|
{
|
|
_kafkaConsumer.Subscribe(msg =>
|
|
{
|
|
var hedgingSource = OtcAppConfigHelper.HedgingSource == 2 || OtcAppConfigHelper.HedgingSource == 0;
|
|
if (hedgingSource)
|
|
{
|
|
return;
|
|
}
|
|
if (!string.IsNullOrEmpty(msg))
|
|
{
|
|
var result = JsonHelper.Deserialize<SwapAsset>(msg);
|
|
if (result == null)
|
|
{
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
var account = result.SECU_INT;
|
|
var HTAccounts = DbContext.exchange_account.Where(x => !string.IsNullOrEmpty(x.AccountCode)).Select(s => s.AccountCode).Distinct().ToList();
|
|
if (HTAccounts.Contains(account))
|
|
{
|
|
PrepareExchangeTradeData(result, tradeSource);
|
|
return;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
LogFactory.GetLogger("SwapConsumerService").Error("对冲交易回执接口", e);
|
|
}
|
|
|
|
}
|
|
});
|
|
}
|
|
/// <summary>
|
|
/// Trs对冲交易接口
|
|
/// </summary>
|
|
/// <param name="_kafkaConsumer"></param>
|
|
public void ConsumerTrsExchangeTradeResp(KafkaConsumerHelper _kafkaConsumer, string tradeSource)
|
|
{
|
|
_kafkaConsumer.Subscribe(msg =>
|
|
{
|
|
var hedgingSource = OtcAppConfigHelper.HedgingSource==1|| OtcAppConfigHelper.HedgingSource==0;
|
|
if (hedgingSource)
|
|
{
|
|
return;
|
|
}
|
|
if (!string.IsNullOrEmpty(msg))
|
|
{
|
|
var result = JsonHelper.Deserialize<SwapAsset>(msg);
|
|
if (result == null)
|
|
{
|
|
return;
|
|
}
|
|
try
|
|
{
|
|
var account = result.SECU_INT;
|
|
var HTAccounts = DbContext.exchange_account.Where(x => !string.IsNullOrEmpty(x.AccountCode)).Select(s => s.AccountCode).Distinct().ToList();
|
|
if (HTAccounts.Contains(account))
|
|
{
|
|
PrepareExchangeTradeData(result, tradeSource);
|
|
Task.Run(() =>
|
|
{
|
|
RealtimePnlCalc.RealtimeSwapPosition(new OptUserInfo(0, "互换实时持仓服务", OptUserFrom.Service));
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
LogFactory.GetLogger("SwapConsumerService").Error("TRS对冲交易回执接口", e);
|
|
}
|
|
|
|
}
|
|
});
|
|
}
|
|
/// <summary>
|
|
/// 4.8.3. 消费预付金交易回执接口
|
|
/// </summary>
|
|
/// <param name="_kafkaConsumer"></param>
|
|
public void ConsumerTradeMarginResp(KafkaConsumerHelper _kafkaConsumer)
|
|
{
|
|
_kafkaConsumer.Subscribe(msg =>
|
|
{
|
|
if (!string.IsNullOrEmpty(msg))
|
|
{
|
|
var result = JsonHelper.Deserialize<RequestBaseWithHead<SwapMarginReq>>(msg);
|
|
var pushLogService = new PushLogService(UserInfo);
|
|
var serialNo = result.HEADER.SERIAL_NO;
|
|
var extNo = result.HEADER.EXT_NO;
|
|
var pushLog = pushLogService.GetLogBySerialNo(serialNo, (int)SwapPushDataEnum.预付金交易回执);
|
|
var resultState = SwapPushDataStateEnum.接收处理成功;
|
|
if (pushLog != null && pushLog.data_state == (int)resultState)
|
|
{
|
|
return;
|
|
}
|
|
string dealResult = "";
|
|
if (result.RECORD == null || result.RECORD.RESERVE == null)
|
|
{
|
|
resultState = SwapPushDataStateEnum.接收处理失败;
|
|
dealResult = "找不到合约编号";
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
if (OtcAppConfigHelper.HTUpdate != 1)
|
|
{
|
|
return;
|
|
}
|
|
//处理回执
|
|
var trade = CheckTradeExist(result.RECORD.RESERVE.CONTRACT_CODE);
|
|
var HTStatus = TryFormatInt(result.RECORD.BASEINFO.ORDSTATUS);
|
|
// 衡泰状态不是成交确认或者 当前交易有平仓，不给修改，如日内平仓，或者dma部分平仓
|
|
if (HTStatus != 7)
|
|
{
|
|
return;
|
|
}
|
|
if (pushLog == null && !CheckPositionNumber(extNo))//可能平仓
|
|
{
|
|
if (long.TryParse(extNo, out long dataId))//平仓
|
|
{
|
|
pushLog = pushLogService.GetLogByDataId(dataId);
|
|
if (pushLog != null)// 我方平仓
|
|
{
|
|
extNo = pushLog.data_number;
|
|
}
|
|
}
|
|
else //衡泰平仓
|
|
{
|
|
PrepareUnwindMarginData(result.RECORD, trade);
|
|
}
|
|
|
|
}
|
|
else if (trade.UnWindDate == null)
|
|
{
|
|
PrepareMarginData(result.RECORD, trade, extNo);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
resultState = SwapPushDataStateEnum.接收处理失败;
|
|
dealResult = e.Message;
|
|
LogFactory.GetLogger("SwapConsumerService").Error("消费预付金交易回执接口", e);
|
|
}
|
|
}
|
|
new PushLogService(UserInfo).SaveConsumerLog(serialNo, extNo, SwapPushDataEnum.预付金交易回执, resultState, msg, dealResult);
|
|
}
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// 4.8.4. 消费合约终止交易回执接口
|
|
/// </summary>
|
|
/// <param name="_kafkaConsumer"></param>
|
|
public void ConsumerTradeUnwindResp(KafkaConsumerHelper _kafkaConsumer)
|
|
{
|
|
_kafkaConsumer.Subscribe(msg =>
|
|
{
|
|
if (!string.IsNullOrEmpty(msg))
|
|
{
|
|
var result = JsonHelper.Deserialize<RequestBase<SwapUnwindReq>>(msg);
|
|
var pushLogService = new PushLogService(UserInfo);
|
|
var serialNo = result.SERIAL_NO;
|
|
var pushLog = pushLogService.GetLogBySerialNo(serialNo, (int)SwapPushDataEnum.合约终止交易回执);
|
|
var resultState = SwapPushDataStateEnum.接收处理成功;
|
|
if (pushLog != null && pushLog.data_state == (int)resultState)
|
|
{
|
|
return;
|
|
}
|
|
string dealResult = "";
|
|
string extNo = result.EXT_NO;
|
|
try
|
|
{
|
|
//处理回执
|
|
if (result.RECORD.ACCTSWAP_TERMINATE==null)
|
|
{
|
|
return;
|
|
}
|
|
extNo = result.RECORD.ACCTSWAP_TERMINATE.CONTRACT_CODE;
|
|
var trade = CheckTradeExist(extNo);
|
|
var HTStatus = TryFormatInt(result.RECORD.ACCTSWAP_TERMINATE.ORDSTATUS);
|
|
if (HTStatus!=7)
|
|
{
|
|
return;
|
|
}
|
|
PrepareUnwindData(result.RECORD, trade);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
resultState = SwapPushDataStateEnum.接收处理失败;
|
|
dealResult = e.Message;
|
|
LogFactory.GetLogger("SwapConsumerService").Error("消费合约终止交易回执接口", e);
|
|
}
|
|
pushLogService.SaveConsumerLog(serialNo, result.EXT_NO, SwapPushDataEnum.合约终止交易回执, resultState, msg, dealResult);
|
|
}
|
|
});
|
|
}
|
|
/// <summary>
|
|
/// 4.8.6. 消费收益互换资金流水数据回执接口
|
|
/// </summary>
|
|
/// <param name="_kafkaConsumer"></param>
|
|
public void ConsumerTradeCashResp(KafkaConsumerHelper _kafkaConsumer)
|
|
{
|
|
_kafkaConsumer.Subscribe(msg =>
|
|
{
|
|
if (!string.IsNullOrEmpty(msg))
|
|
{
|
|
var result = JsonHelper.Deserialize<RequestBaseWithHead<SwapCashReq>>(msg);
|
|
var pushLogService = new PushLogService(UserInfo);
|
|
var serialNo = result.HEADER.SERIAL_NO;
|
|
var pushLog = pushLogService.GetLogBySerialNo(serialNo, (int)SwapPushDataEnum.收益互换资金流水数据回执);
|
|
var resultState = SwapPushDataStateEnum.接收处理成功;
|
|
if (pushLog != null && pushLog.data_state == (int)resultState)
|
|
{
|
|
return;
|
|
}
|
|
string dealResult = "";
|
|
List<int> clientIds = new List<int>();
|
|
try
|
|
{
|
|
var extNos = result.RECORD.ACCTSWAP_CASH_LIST.Where(x => !string.IsNullOrEmpty(x.EXT_NO)).Select(s => s.EXT_NO).ToList();
|
|
var trades = CheckTradeExistByList(extNos);
|
|
//处理回执
|
|
|
|
clientIds = PrepareTradeCashData(result.RECORD, trades);
|
|
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
resultState = SwapPushDataStateEnum.接收处理失败;
|
|
dealResult = e.Message;
|
|
LogFactory.GetLogger("SwapConsumerService").Error("消费收益互换资金流水数据回执接口", e);
|
|
}
|
|
pushLogService.SaveConsumerLog(serialNo, "", SwapPushDataEnum.收益互换资金流水数据回执, resultState, msg, dealResult);
|
|
//if (clientIds.Count>0)
|
|
//{
|
|
// PushClientCash(clientIds, onRspAccountCapitalTopicTopic);
|
|
//}
|
|
}
|
|
});
|
|
}
|
|
|
|
public bool CheckPositionNumber(string extNo)
|
|
{
|
|
return DbContext.swap_position.Any(x => x.PosiNumber == extNo);
|
|
}
|
|
/// <summary>
|
|
/// 收盘 收益互换回执查衡泰库返回
|
|
/// </summary>
|
|
/// <param name="_kafkaConsumer"></param>
|
|
public void ConsumerIRSDb(KafkaConsumerHelper _kafkaConsumer)
|
|
{
|
|
_kafkaConsumer.Subscribe(msg =>
|
|
{
|
|
if (!string.IsNullOrEmpty(msg))
|
|
{
|
|
var result = JsonHelper.Deserialize<IRDbRespBase>(msg);
|
|
var respMappers = GetHTDbRespMapperData<ReqQryIRSDbResp>(result);
|
|
}
|
|
});
|
|
}
|
|
/// <summary>
|
|
/// 客户资金推送
|
|
/// </summary>
|
|
/// <param name="_kafkaConsumer"></param>
|
|
public void ConsumerCashNotice(KafkaConsumerHelper _kafkaConsumer)
|
|
{
|
|
_kafkaConsumer.Subscribe(msg =>
|
|
{
|
|
if (!string.IsNullOrEmpty(msg))
|
|
{
|
|
var result = JsonHelper.Deserialize<CashNoticeReq>(msg);
|
|
if (result!=null)
|
|
{
|
|
PushCashToHT(result.cashId, null);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
/// <summary>
|
|
/// 对返回数据库数据进行映射
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="iRDbResp"></param>
|
|
/// <returns></returns>
|
|
private List<T> GetHTDbRespMapperData<T>(IRDbRespBase iRDbResp) where T : new()
|
|
{
|
|
List<T> values = new List<T>();
|
|
string[] fields = iRDbResp.Header.Split(',');
|
|
var records = iRDbResp.Records;
|
|
for (int j = 0; j < records.Count; j++)
|
|
{
|
|
string[] recordFields = records[j].Split(',');
|
|
T iRSDb = Activator.CreateInstance<T>();
|
|
for (int i = 0; i < fields.Length; i++)
|
|
{
|
|
string fieldName = fields[i];
|
|
string fieldValue = recordFields[i];
|
|
typeof(T).GetProperty(fieldName)?.SetValue(iRSDb, fieldValue);
|
|
values.Add(iRSDb);
|
|
}
|
|
}
|
|
return values;
|
|
}
|
|
#region 交易回执相关私有方法
|
|
/// <summary>
|
|
/// 修改交易
|
|
/// </summary>
|
|
/// <param name="swapTradeReq"></param>
|
|
private void DealUpdateConsumerTrade(SwapTradeReq swapTradeReq, trade trade)
|
|
{
|
|
var HTStatus = trade.HTStatus;
|
|
if (OtcAppConfigHelper.HTUpdate != 1)
|
|
{
|
|
return;
|
|
}
|
|
//0新建、-4交易执行中、-3风险预审中、7成交确认、9交易撤单、1审批中、5审批通过、4审批拒绝、10交易终止
|
|
if (HTStatus == 9)
|
|
{
|
|
new SwapTradeService(UserInfo).deleteTrade(trade.id, false);
|
|
return;
|
|
}
|
|
// 衡泰状态不是成交确认或者 当前交易有平仓，不给修改，如日内平仓，或者dma部分平仓
|
|
if (trade.UnWindDate!=null)
|
|
{
|
|
throw new Exception($"交易{trade.TradeNumber}已经产生平仓信息，不支持再修改");
|
|
}
|
|
ValidateTrade(swapTradeReq, trade);
|
|
trade.trade_extend = DbContext.trade_extend.FirstOrDefault(x => x.TradeId == trade.id);
|
|
PrepareTradeData(swapTradeReq, trade, false);
|
|
if (trade.TradeStatus == ConsTrade.确认成交)
|
|
{
|
|
AfterUpdateDeal(trade, (int)SwapEventTypeEnum.修改交易, "接口修改交易");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 互换交易数据准备
|
|
/// </summary>
|
|
/// <param name="swapTradeReq"></param>
|
|
/// <param name="trade"></param>
|
|
private void PrepareTradeData(SwapTradeReq swapTradeReq, trade trade, bool isAdd)
|
|
{
|
|
var tradeDirection = swapTradeReq.BASEINFO.TRDTYPE == "151" ? (int)SwapDirectionEnum.收取 : (int)SwapDirectionEnum.支付;
|
|
var positions = DbContext.swap_position.Where(x => x.SwapTradeId == trade.id && x.IsInitial && !x.Invalid).ToList();
|
|
positions.ForEach(x =>
|
|
{
|
|
x.PosiStartDate = trade.StartDate.Value;
|
|
x.PosiMatuirityDate = trade.ExerciseDate.Value;
|
|
});
|
|
var interestList = positions.Where(x => ConsTrade.InterestModels.Contains(x.InterestMode)).ToList();
|
|
var posiList = positions.Where(x => x.InterestDirection == 0).ToList();
|
|
interestList.ForEach(x =>
|
|
{
|
|
x.PosiStartDate = trade.StartDate.Value;
|
|
x.PosiMatuirityDate = trade.ExerciseDate.Value;
|
|
});
|
|
var floatRateInterest = positions.FirstOrDefault(x => !string.IsNullOrEmpty(x.FloatRateUnderlyingCode));
|
|
swap_position interest;
|
|
if (interestList.Any())
|
|
{
|
|
interest = interestList[0];
|
|
}
|
|
else
|
|
{
|
|
throw new Exception($"交易{trade.TradeNumber}找不到固定端信息");
|
|
}
|
|
var rate = swapTradeReq.ACCTSWAP.REGULAR_INFO.SPREAD;
|
|
|
|
if (!string.IsNullOrEmpty(swapTradeReq.ACCTSWAP.REGULAR_INFO.RATE))
|
|
{
|
|
var rated= TryFormatDecimal(rate);
|
|
if (rated!=0)
|
|
{
|
|
rate = swapTradeReq.ACCTSWAP.REGULAR_INFO.RATE;
|
|
}
|
|
}
|
|
interest.InterestRateDefault = TryFormatDecimal(rate);
|
|
interest.InterestDirection = tradeDirection;
|
|
if (!string.IsNullOrEmpty(swapTradeReq.ACCTSWAP.IR_I_CODE))
|
|
{
|
|
interest.FloatRateUnderlyingCode = swapTradeReq.ACCTSWAP.IR_I_CODE;
|
|
interest.IsAnnualized = true;
|
|
}
|
|
else
|
|
{
|
|
interest.IsAnnualized = interest.InterestRateDefault != 0;
|
|
}
|
|
interest.InterestType = swapTradeReq.ACCTSWAP.FLOAT_METHOD == "0" ? (int)InterestTypeEnum.单利 : (int)InterestTypeEnum.复利;
|
|
if (trade.trade_extend != null)
|
|
{
|
|
var calcMode = GetInterestRule(swapTradeReq.ACCTSWAP.FIXED_INTEREST_RULE);
|
|
TradeExtendJson tradeExtendJson = trade.trade_extend.ExtendObj;
|
|
tradeExtendJson.InterestCalcMode = calcMode;
|
|
trade.trade_extend.ExtendJson = JsonHelper.Serialize(tradeExtendJson);
|
|
if (isAdd)
|
|
{
|
|
DbContext.trade_extend.Add(trade.trade_extend);
|
|
}
|
|
}
|
|
|
|
var rateDate = TryFormatDate(swapTradeReq.ACCTSWAP.REGULAR_INFO.INTEREST_END_DAY);
|
|
|
|
IntervalModel intervalModel = new IntervalModel()
|
|
{
|
|
Date = rateDate,
|
|
Rate = interest.InterestRateDefault,
|
|
Settlement = 0
|
|
};
|
|
List<IntervalModel> intervalModels = new List<IntervalModel>
|
|
{
|
|
intervalModel
|
|
};
|
|
interest.InterestSwapInterval = JsonHelper.Serialize(intervalModels);
|
|
|
|
if (interest.id == 0)
|
|
{
|
|
DbContext.swap_position.Add(interest);
|
|
}
|
|
DbContext.SaveChanges();
|
|
var observation = DbContext.trade_obervation.FirstOrDefault(x => x.PositionId == interest.id);
|
|
if (observation == null)
|
|
{
|
|
observation = new TradeObervation()
|
|
{
|
|
PositionId = interest.id,
|
|
IsDeductPrincipal = true,
|
|
ObservationAlignEnd = true,
|
|
ObservationNum = 1,
|
|
ObservationUnit = "D",
|
|
ObservationHolidayType = "Following",
|
|
ObservationStart = trade.TradeDate
|
|
};
|
|
}
|
|
observation.ObservationInterval = interest.InterestSwapInterval;
|
|
if (observation.id == 0)
|
|
{
|
|
DbContext.trade_obervation.Add(observation);
|
|
}
|
|
DbContext.SaveChanges();
|
|
}
|
|
/// <summary>
|
|
/// 校验交易信息
|
|
/// </summary>
|
|
/// <param name="swapTradeReq"></param>
|
|
/// <param name="td"></param>
|
|
/// <exception cref="ServiceException"></exception>
|
|
private Client ValidateTrade(SwapTradeReq swapTradeReq, trade td)
|
|
{
|
|
//CheckTradeStatus(td);
|
|
if (string.IsNullOrEmpty(swapTradeReq.BASEINFO.PARTY_NAME))
|
|
{
|
|
throw new ServiceException($"参数PARTY_NAME为空");
|
|
}
|
|
Client client = null;
|
|
string partyNo = string.Empty;
|
|
client = DataCacheProvider.GetClientDataSource().AsQueryable().FirstOrDefault(x => x.Name == swapTradeReq.BASEINFO.PARTY_NAME);
|
|
partyNo = swapTradeReq.BASEINFO.PARTY_NAME;
|
|
if (client == null)
|
|
{
|
|
throw new ServiceException($"交易对手方{partyNo}信息不存在");
|
|
}
|
|
td.ClientId = client.id;
|
|
td.ClientName = client.Name;
|
|
td.ClientNumber = client.Number;
|
|
var orddDate = TryFormatDate(swapTradeReq.BASEINFO.ORDDATE);
|
|
var endDate = TryFormatDate(swapTradeReq.ACCTSWAP.END_DAY);
|
|
var stockNotional = TryFormatDouble(swapTradeReq.ACCTSWAP.PRINCIPAL);
|
|
td.TradeDate = orddDate.Date;
|
|
td.ExerciseDate = endDate.Date;
|
|
td.OriginalStockEqvNotional = stockNotional;
|
|
td.StockEqvNotional = td.OriginalStockEqvNotional.Value;
|
|
return client;
|
|
}
|
|
/// <summary>
|
|
/// 创建交易
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private trade CreateTrade(SwapTradeReq swapTradeReq)
|
|
{
|
|
TradeExtendJson tradeExtendJson = new TradeExtendJson()
|
|
{
|
|
FlowBookMode = (int)FlowBookModeEnum.重置,
|
|
FloatingPnlAnnualized = false,
|
|
NeedOpenFee = false,
|
|
OpenFeeType = 0,
|
|
Direction = 2,
|
|
};
|
|
var r = new trade()
|
|
{
|
|
TradeType = "收益互换",
|
|
BuySell = "卖出",
|
|
UnderlyingInstrumentType = "Stock",
|
|
StartDate = valuedateBLL.ValueDate,
|
|
TradeDate = valuedateBLL.ValueDate,
|
|
TraderId = UserId,
|
|
TraderName = UserName,
|
|
MarginTemplateName = "系统默认",
|
|
OpponentRole = "乙方",
|
|
OriginalStockEqvNotional = 0,
|
|
StructureType = "普通债券类收益互换",
|
|
InitialMargin = 0,
|
|
TradeStatus = "确认成交"
|
|
};
|
|
r.ExerciseDate = r.TradeDate.Value.AddDays(7);
|
|
r.trade_extend = new trade_extend()
|
|
{
|
|
ExtendJson = JsonHelper.Serialize(tradeExtendJson)
|
|
};
|
|
//山证衡泰互换簿记
|
|
|
|
var client = DataCacheProvider.GetClientDataSource().AsQueryable().FirstOrDefault(x => x.Name == swapTradeReq.BASEINFO.PARTY_NAME);
|
|
if (client == null)
|
|
{
|
|
throw new ServiceException($"找不到名称为{swapTradeReq.BASEINFO.PARTY_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}的簿记账户未设置交易员");
|
|
}
|
|
r.AssetBookName = asset.Name;
|
|
r.AssetId = asset.id;
|
|
r.TraderId = asset.TraderIdsInt.FirstOrDefault();
|
|
r.TraderName = asset.TraderNamesList.FirstOrDefault();
|
|
r.TradeOldStatus = ConsTrade.新增待确认;
|
|
r.OptId = UserId;
|
|
r.OptName = UserName;
|
|
r.OptDate = OptDate;
|
|
r.CreateDate = OptDate;
|
|
r.ValidState = ConsGlobal.Valid;
|
|
r.TradeSource = "系统交易";
|
|
r.TradeNumber = swapTradeReq.BASEINFO.EXT_NO;
|
|
return r;
|
|
}
|
|
private trade CheckTradeExist(string extNo)
|
|
{
|
|
var trade = DbContext.trade.FirstOrDefault(x => x.TradeNumber == extNo);
|
|
if (trade == null)
|
|
{
|
|
Thread.Sleep(5000);
|
|
trade = DbContext.trade.FirstOrDefault(x => x.TradeNumber == extNo);
|
|
if (trade == null)
|
|
{
|
|
throw new ServiceException($"不存在交易编号为{extNo}的交易，无法修改");
|
|
}
|
|
}
|
|
return trade;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 批量校验交易是否存在
|
|
/// </summary>
|
|
/// <param name="extNos"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ServiceException"></exception>
|
|
private List<trade> CheckTradeExistByList(List<string> extNos)
|
|
{
|
|
List<trade> tradeList = new List<trade>();
|
|
var trades = DbContext.trade.Where(x => extNos.Contains(x.TradeNumber)).AsNoTracking();
|
|
foreach (var extNo in extNos)
|
|
{
|
|
var trade = trades.FirstOrDefault();
|
|
//if (trade==null)
|
|
//{
|
|
// throw new ServiceException($"交易编号为{extNo}的交易不存在");
|
|
//}
|
|
if (trade != null)
|
|
{
|
|
tradeList.Add(trade);
|
|
}
|
|
}
|
|
return tradeList;
|
|
}
|
|
/// <summary>
|
|
/// 校验交易状态
|
|
/// </summary>
|
|
/// <param name="trade"></param>
|
|
/// <exception cref="ServiceException"></exception>
|
|
private void CheckTradeStatus(trade trade)
|
|
{
|
|
if (trade.UnWindDate.HasValue)
|
|
{
|
|
throw new ServiceException($"交易已经产生平仓或收益结算，无法修改");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 保存交易后需要做的处理
|
|
/// </summary>
|
|
/// <param name="td"></param>
|
|
/// <param name="eventType"></param>
|
|
/// <param name="msg"></param>
|
|
private void AfterUpdateDeal(trade td, int eventType, string msg)
|
|
{
|
|
SwapTradeService swapTradeService = new SwapTradeService(this);
|
|
swapTradeService.ClearSwapPositions(td);
|
|
DbContext.SaveChanges();
|
|
swapTradeService.InitialPosition(td, true);
|
|
swapTradeService.AddPositionEvent(td,"衡泰同步");
|
|
DbContext.SaveChanges();
|
|
//new SwapEodPositionService(this).InitSaveEodSwapPosition(td);
|
|
var swapEventService = new SwapEventService(this);
|
|
swapEventService.AddSwapEventDate(td.TradeDate.Value, td.id, eventType, "", 0, true, msg + "确认");
|
|
swapEventService.AddSwapEventDate(td.TradeDate.Value, td.id, (int)SwapEventTypeEnum.确认交易, "", 0, true, msg + "确认");
|
|
}
|
|
|
|
private void DeleteSwapEvent(int tradeId)
|
|
{
|
|
new SwapEventService(this).DeleteEvent(tradeId);
|
|
}
|
|
/// <summary>
|
|
/// 添加交易元数据
|
|
/// </summary>
|
|
private void AddTradeMeta(bool saveChanges, int tradeId, string metaKey, string metaValue)
|
|
{
|
|
DbContext.TradeMeta.Add(new TradeMeta
|
|
{
|
|
TradeId = tradeId,
|
|
MetaKey = metaKey,
|
|
MetaValue = metaValue,
|
|
CreateTime = DateTime.Now
|
|
});
|
|
if (saveChanges)
|
|
{
|
|
DbContext.SaveChanges();
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region 互换资产回执相关私有方法
|
|
private void PreparePosiData(SwapPosiReq swapPosiReq, trade td, string extNo)
|
|
{
|
|
var underlying = CheckUnderlying(swapPosiReq.TRADEINFO.I_CODE, swapPosiReq.TRADEINFO.MARKET);
|
|
var positions = DbContext.swap_position.Where(x => x.SwapTradeId == td.id && x.PosiDirection > 0 && !x.Invalid).ToList();
|
|
var position = positions.Where(x => x.PosiNumber == extNo && x.IsInitial).FirstOrDefault();
|
|
var realPosition = positions.Where(x => x.PosiNumber == extNo && !x.IsInitial).FirstOrDefault();
|
|
if (position == null)
|
|
{
|
|
throw new Exception($"交易{td.TradeNumber}找不到持仓信息");
|
|
}
|
|
decimal price = Convert.ToDecimal(underlying.Price ?? 100);
|
|
bool init = swapPosiReq.TRADEINFO.OCFLAG == "0";
|
|
if (swapPosiReq.TRADEINFO.OCFLAG == "0")
|
|
{
|
|
position.UnderlyingCode= underlying.UnderlyingCode;
|
|
position.UnderlyingInstrumentType = underlying.UnderlyingInstrumentType;
|
|
position.PositionType = swapPosiReq.BASEINFO.TRDTYPE == "10" ? (int)PositionTypeFlag.Long : (int)PositionTypeFlag.Short;
|
|
position.PosiQuantity = TryFormatDecimal(swapPosiReq.TRADEINFO.PARVALUE);
|
|
position.PosiGrossPrice = TryFormatDecimal(swapPosiReq.TRADEINFO.ORDPRICE) / price;
|
|
int tradeSide = position.PositionType == (int)EnumDirection.Long ? 1 : -1;
|
|
position.PosiNetPrice = position.PosiQuantity == 0 ? position.PosiGrossPrice : position.PosiGrossPrice + position.PosiTradingFee * tradeSide / position.PosiQuantity;
|
|
td.OriginalNotional = Convert.ToDouble(position.PosiQuantity);
|
|
td.Notional = td.OriginalNotional ?? 0;
|
|
td.UnderlyingCode = underlying.UnderlyingCode;
|
|
td.UnderlyingAssetName = underlying.UnderlyingInstrumentTypeCn;
|
|
td.UnderlyingName = underlying.UnderlyingName;
|
|
td.SpotPrice = Convert.ToDouble(position.PosiNetPrice);
|
|
td.TradePrice = Convert.ToDouble(position.PosiTradingFee);
|
|
td.UnderlyingInstrumentType = underlying.UnderlyingInstrumentType;
|
|
position.PosiNotionalValue = position.PosiQuantity * position.ContractSize;
|
|
if (realPosition!=null)
|
|
{
|
|
realPosition.UnderlyingCode = underlying.UnderlyingCode;
|
|
realPosition.UnderlyingInstrumentType= underlying.UnderlyingInstrumentType;
|
|
realPosition.PositionType = position.PositionType;
|
|
realPosition.PosiQuantity= position.PosiQuantity;
|
|
realPosition.PosiGrossPrice = position.PosiGrossPrice;
|
|
realPosition.PosiNetPrice = position.PosiNetPrice;
|
|
realPosition.PosiNotionalValue = position.PosiNotionalValue;
|
|
}
|
|
|
|
var flowEvent = DbContext.swap_flow_event.FirstOrDefault(x => x.PositionId == position.id &&x.EventType==(int)SwapFlowEventTypeEnum.开仓 && x.DataState == (int)SwapFlowDateStateEnum.完成);
|
|
if (flowEvent!=null)
|
|
{
|
|
flowEvent.PositionQty = position.PosiQuantity;
|
|
flowEvent.UnderlyingCode = position.UnderlyingCode;
|
|
flowEvent.UnderlyingInstrumentType= position.UnderlyingInstrumentType;
|
|
flowEvent.PositionType= position.PositionType;
|
|
flowEvent.Quantity= position.PosiQuantity;
|
|
flowEvent.TradingAmount= position.PosiNotionalValue;
|
|
}
|
|
DbContext.SaveChanges();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 修改衡泰平仓明细价格
|
|
/// </summary>
|
|
/// <param name="price"></param>
|
|
/// <param name="td"></param>
|
|
/// <param name="valueDate"></param>
|
|
private string DealUnwindPosiEvent(decimal price,trade td,DateTime valueDate)
|
|
{
|
|
var posi = DbContext.swap_position.Where(x=>!x.Invalid&&x.IsInitial&&x.PosiDirection>0).FirstOrDefault();
|
|
if (posi==null)
|
|
{
|
|
throw new Exception("找不到资产端信息");
|
|
}
|
|
var flowEvent = GetSwapFlowEvent(posi.id,valueDate);
|
|
if (flowEvent==null)
|
|
{
|
|
throw new Exception("找不到资产端平仓事件明细信息");
|
|
}
|
|
flowEvent.TradingAmountAvg = price;
|
|
int tradeSide = posi.PositionType == (int)EnumDirection.Long ? 1 : -1;
|
|
flowEvent.TradingAmountFeeAvg = flowEvent.Quantity == 0 ? flowEvent.TradingAmountAvg : flowEvent.TradingAmountAvg + flowEvent.TradingFeePending * tradeSide / flowEvent.Quantity;
|
|
flowEvent.TradingAmountNetFeeAvg = flowEvent.Quantity == 0 ? flowEvent.TradingAmountNetAvg : flowEvent.TradingAmountNetAvg + flowEvent.TradingFeePending * tradeSide / flowEvent.Quantity;
|
|
DbContext.SaveChanges();
|
|
return "";
|
|
}
|
|
/// <summary>
|
|
/// 获取平仓明细
|
|
/// </summary>
|
|
/// <param name="posiId"></param>
|
|
/// <param name="valueDate"></param>
|
|
/// <param name="attempts"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="Exception"></exception>
|
|
private swap_flow_event GetSwapFlowEvent(long posiId,DateTime valueDate,int attempts=0)
|
|
{
|
|
var flowEvent = DbContext.swap_flow_event.FirstOrDefault(x=>x.PositionId== posiId&&x.EventDate==valueDate&&x.EventReason== "接口合约终止交易"&&x.DataState==(int)SwapFlowDateStateEnum.完成);
|
|
if (flowEvent==null)
|
|
{
|
|
attempts++;
|
|
if (attempts>10)
|
|
{
|
|
return null;
|
|
}
|
|
Thread.Sleep(1000* attempts);
|
|
return GetSwapFlowEvent(posiId, valueDate, attempts);
|
|
}
|
|
else
|
|
{
|
|
return flowEvent;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// 接入对冲标的
|
|
/// </summary>
|
|
/// <param name="swapPosiReq"></param>
|
|
private void PrepareExchangeTradeData(SwapPosiReq swapPosiReq,string tradeSource)
|
|
{
|
|
var underlying = CheckUnderlying(swapPosiReq.TRADEINFO.I_CODE, swapPosiReq.TRADEINFO.MARKET);
|
|
var orddDate = TryFormatDate(swapPosiReq.BASEINFO.ORDDATE);
|
|
var longType = swapPosiReq.BASEINFO.TRDTYPE == "10" ? "多头" : "空头";
|
|
var openType = swapPosiReq.TRADEINFO.OCFLAG == "0" ? "开仓" : "平仓";
|
|
|
|
if (string.IsNullOrEmpty(swapPosiReq.BASEINFO.TRD_RELATED_NO) || !double.TryParse(swapPosiReq.TRADEINFO.PARVALUE, out _) || !double.TryParse(swapPosiReq.TRADEINFO.ORDPRICE, out _))
|
|
{
|
|
logger.Error("同步场内交易失败，数据格式不正确：" + JsonHelper.Serialize(swapPosiReq));
|
|
return;
|
|
}
|
|
|
|
ExchangeTradeSaveApiReq req = new ExchangeTradeSaveApiReq
|
|
{
|
|
ExchangeAccountCode = swapPosiReq.BASEINFO.SECU_INT,
|
|
BuySell = longType + openType,
|
|
Commission = 0,
|
|
IsHistory = orddDate.Date < valuedateBLL.ValueDate ? true : false,
|
|
Lots = double.Parse(swapPosiReq.TRADEINFO.PARVALUE) / underlying.ContractSize,
|
|
TradeDate = orddDate.Date,
|
|
TradeNumber = swapPosiReq.BASEINFO.TRD_RELATED_NO,
|
|
TradePrice = double.Parse(swapPosiReq.TRADEINFO.ORDPRICE) / (underlying.Price ?? 100),
|
|
TradeType = underlying.UnderlyingInstrumentTypeCn,
|
|
UnderlyingCode = underlying.UnderlyingCode
|
|
};
|
|
var service = new ExchangeTradeSyncApiService(UserInfo);
|
|
service.Save(req, tradeSource);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 接入对冲标的
|
|
/// </summary>
|
|
/// <param name="swapPosiReq"></param>
|
|
private void PrepareExchangeTradeData(SwapAsset swapPosiReq,string tradeSource)
|
|
{
|
|
var underlying = CheckUnderlying(swapPosiReq.I_CODE, swapPosiReq.MARKET);
|
|
var orddDate = TryFormatDate(swapPosiReq.ORD_DATE);
|
|
var longType = swapPosiReq.TRD_TYPE == "10" ? "多头" : "空头";
|
|
var openType = swapPosiReq.OC_FLAG == "0" ? "开仓" : "平仓";
|
|
|
|
if (string.IsNullOrEmpty(swapPosiReq.EXT_NO) || !double.TryParse(swapPosiReq.PAR_VALUE, out _) || !double.TryParse(swapPosiReq.ORD_PRICE, out _))
|
|
{
|
|
logger.Error("同步场内交易失败，数据格式不正确：" + JsonHelper.Serialize(swapPosiReq));
|
|
return;
|
|
}
|
|
|
|
ExchangeTradeSaveApiReq req = new ExchangeTradeSaveApiReq
|
|
{
|
|
ExchangeAccountCode = swapPosiReq.SECU_INT,
|
|
BuySell = longType + openType,
|
|
Commission = 0,
|
|
IsHistory = orddDate.Date < valuedateBLL.ValueDate ? true : false,
|
|
Lots = double.Parse(swapPosiReq.PAR_VALUE) / underlying.ContractSize,
|
|
TradeDate = orddDate.Date,
|
|
TradeNumber = swapPosiReq.EXT_NO,
|
|
TradePrice = double.Parse(swapPosiReq.ORD_PRICE) / (underlying.Price ?? 100),
|
|
TradeType = underlying.UnderlyingInstrumentTypeCn,
|
|
UnderlyingCode = underlying.UnderlyingCode
|
|
};
|
|
var service = new ExchangeTradeSyncApiService(UserInfo);
|
|
service.Save(req, tradeSource);
|
|
}
|
|
|
|
#endregion
|
|
#region 预付金交易回执相关私有方法
|
|
private void PrepareMarginData(SwapMarginReq swapMarginReq, trade td, string extNo)
|
|
{
|
|
var positions = DbContext.swap_position.Where(x => x.SwapTradeId == td.id && x.PosiNumber == extNo).ToList();
|
|
var position = positions.FirstOrDefault(x => x.IsInitial);
|
|
var realPosition = positions.FirstOrDefault(x => !x.IsInitial);
|
|
if (position == null)
|
|
{
|
|
throw new Exception($"找不到持仓编码{extNo}的信息");
|
|
}
|
|
var marginDirection = swapMarginReq.BASEINFO.TRDTYPE == "128" ? (int)SwapDirectionEnum.收取 : (int)SwapDirectionEnum.支付;
|
|
position.InterestDirection = marginDirection;
|
|
position.InterestPrincipalFix = TryFormatDecimal(swapMarginReq.TRADEINFO.PARVALUE);
|
|
position.InterestRateDefault = TryFormatDecimal(swapMarginReq.RESERVE.RATE);
|
|
position.IsAnnualized = position.InterestRateDefault != 0;
|
|
position.Currency = swapMarginReq.RESERVE.CURRENCY;
|
|
IntervalModel intervalModel = new IntervalModel()
|
|
{
|
|
Date = td.ExerciseDate.Value,
|
|
Rate = position.InterestRateDefault,
|
|
Settlement = 0
|
|
};
|
|
List<IntervalModel> intervalModels = new List<IntervalModel>
|
|
{
|
|
intervalModel
|
|
};
|
|
var marginDateStr = swapMarginReq.BASEINFO.ORDDATE;
|
|
if (!string.IsNullOrEmpty(swapMarginReq.BASEINFO.SETDATE))
|
|
{
|
|
marginDateStr = swapMarginReq.BASEINFO.SETDATE;
|
|
}
|
|
var marginDate = TryFormatDate(marginDateStr);
|
|
position.HappenDate=marginDate;
|
|
position.InterestSwapInterval = JsonHelper.Serialize(intervalModels);
|
|
var observation = DbContext.trade_obervation.FirstOrDefault(x => x.PositionId == position.id);
|
|
if (observation == null)
|
|
{
|
|
observation = new TradeObervation()
|
|
{
|
|
PositionId = position.id,
|
|
IsDeductPrincipal = true,
|
|
ObservationAlignEnd = true,
|
|
ObservationNum = 1,
|
|
ObservationUnit = "D",
|
|
ObservationHolidayType = "Following",
|
|
ObservationStart = td.TradeDate
|
|
};
|
|
}
|
|
observation.ObservationInterval = position.InterestSwapInterval;
|
|
|
|
if (observation.id == 0)
|
|
{
|
|
DbContext.trade_obervation.Add(observation);
|
|
}
|
|
if (realPosition!=null)
|
|
{
|
|
realPosition.InterestDirection = position.InterestDirection;
|
|
realPosition.InterestPrincipalFix = position.InterestPrincipalFix;
|
|
realPosition.InterestRateDefault = position.InterestRateDefault;
|
|
realPosition.InterestSwapInterval = position.InterestSwapInterval;
|
|
realPosition.HappenDate = position.HappenDate;
|
|
realPosition.IsAnnualized = position.IsAnnualized;
|
|
realPosition.Currency = realPosition.Currency;
|
|
}
|
|
var flowEvent = DbContext.swap_flow_event.FirstOrDefault(x => x.PositionId == position.id && x.EventType == (int)SwapFlowEventTypeEnum.开仓&&x.DataState==(int)SwapFlowDateStateEnum.完成);
|
|
if (flowEvent != null)
|
|
{
|
|
flowEvent.InterestDirection = position.InterestDirection;
|
|
flowEvent.InterestPrincipal = position.InterestPrincipalFix;
|
|
flowEvent.InterestRate = position.InterestRateDefault;
|
|
flowEvent.InterestSwapInterval = position.InterestSwapInterval;
|
|
}
|
|
DbContext.SaveChanges();
|
|
// AfterUpdateDeal(td, (int)SwapEventTypeEnum.修改交易, $"接口预付金{msg}交易", true);
|
|
AddMarginCash(position, td);
|
|
}
|
|
private void PrepareUnwindMarginData(SwapMarginReq swapMarginReq, trade td)
|
|
{
|
|
var posi = DbContext.swap_position.Where(x => !x.Invalid && x.IsInitial && ConsTrade.InterestMarginModels.Contains(x.InterestMode)).FirstOrDefault();
|
|
if (posi == null)
|
|
{
|
|
throw new Exception($"{td.TradeNumber}找不到持仓信息");
|
|
}
|
|
var marginDate = TryFormatDate(swapMarginReq.BASEINFO.ORDDATE);
|
|
var flowEvent = GetSwapFlowEvent(posi.id, marginDate);
|
|
if (flowEvent == null)
|
|
{
|
|
throw new Exception($"{posi.PosiNumber}找不到平仓事件");
|
|
}
|
|
var swapEvent = DbContext.swap_event.Where(x=>x.id==flowEvent.EventId).FirstOrDefault();
|
|
if (swapEvent==null|| string.IsNullOrEmpty(swapEvent.EventData))
|
|
{
|
|
throw new Exception($"{td.TradeNumber}找不到平仓事件");
|
|
}
|
|
swapEvent.unwindData = JsonConvert.DeserializeObject<UnwindData>(swapEvent.EventData);
|
|
decimal unwindMarginMoney = 0;
|
|
unwindMarginMoney = TryFormatDecimal(swapMarginReq.TRADEINFO.PARVALUE);
|
|
var interestAmount = TryFormatDecimal(swapMarginReq.TRADEINFO.INTEREST_AMOUNT);
|
|
var currentMarginMoney = posi.InterestPrincipalFix;
|
|
var origamount = currentMarginMoney * swapEvent.unwindData.ClosePercent;
|
|
var difMarginMoney = currentMarginMoney- (unwindMarginMoney> origamount? unwindMarginMoney: origamount);
|
|
posi.InterestPrincipalFix = difMarginMoney;
|
|
flowEvent.InterestPrincipal = unwindMarginMoney;
|
|
flowEvent.TdInterestAmount = interestAmount;
|
|
flowEvent.InterestAmount = interestAmount;
|
|
flowEvent.InterestClosePnL = interestAmount;
|
|
DbContext.SaveChanges();
|
|
UpdateUnwindMarginCash(posi, td, -unwindMarginMoney, marginDate, ClientCashInCashOut.系统操作_应付预付金);
|
|
new SwapTradeBaseService(this).AddClientCashInCashOut(td, Convert.ToDouble(-interestAmount), ClientCashInCashOut.系统操作_预付金返息, marginDate);
|
|
}
|
|
/// <summary>
|
|
/// 添加预付金资金记录
|
|
/// </summary>
|
|
/// <param name="marginPosition"></param>
|
|
/// <param name="td"></param>
|
|
private void AddMarginCash(swap_position marginPosition, trade td)
|
|
{
|
|
var cashService = new ClientCashInCashOutService(this);
|
|
var marginAmount = marginPosition.InterestPrincipalFix * (marginPosition.InterestDirection == 1 ? -1 : 1);
|
|
cashService.SaveSwapTradeClientCash(td, Convert.ToDouble(marginAmount), marginPosition.HappenDate.HasValue ? marginPosition.HappenDate.Value : td.TradeDate.Value, marginPosition.id, ClientCashInCashOut.系统操作_应付预付金);
|
|
}
|
|
/// <summary>
|
|
/// 修改预付金返息记录
|
|
/// </summary>
|
|
/// <param name="marginPosition"></param>
|
|
/// <param name="td"></param>
|
|
/// <param name="marginAmount"></param>
|
|
/// <param name="marginDate"></param>
|
|
private void UpdateUnwindMarginCash(swap_position marginPosition, trade td, decimal marginAmount, DateTime marginDate,string actionName)
|
|
{
|
|
var cashService = new ClientCashInCashOutService(this);
|
|
cashService.SaveSwapTradeClientCash(td, Convert.ToDouble(marginAmount), marginDate, marginPosition.id, actionName);
|
|
}
|
|
#endregion
|
|
#region 合约终止回执相关私有方法
|
|
private void PrepareUnwindData(SwapUnwindReq swapUnwindReq, trade td)
|
|
{
|
|
var eventIdStr = swapUnwindReq.ACCTSWAP_TERMINATE.EXT_NO;
|
|
bool allClose = swapUnwindReq.ACCTSWAP_TERMINATE.TERMINATE_TYPE == "1";
|
|
var closeQty = TryFormatDecimal(swapUnwindReq.ACCTSWAP_TERMINATE.TERMINATE_COUNT);
|
|
var unwindDate = TryFormatDate(swapUnwindReq.ACCTSWAP_TERMINATE.TERMINATE_DAY).Date;
|
|
var payDate = TryFormatDate(swapUnwindReq.ACCTSWAP_TERMINATE.PAY_DAY).Date;
|
|
var markClosePnl = TryFormatDecimal(swapUnwindReq.ACCTSWAP_TERMINATE.ZCD_AMOUNT);
|
|
var interestAmount= TryFormatDecimal(swapUnwindReq.ACCTSWAP_TERMINATE.GDD_AMOUNT);
|
|
var tradeinfFee = TryFormatDecimal(swapUnwindReq.ACCTSWAP_TERMINATE.ASSET_FEE);
|
|
var fixFee = TryFormatDecimal(swapUnwindReq.ACCTSWAP_TERMINATE.FIX_FEE);
|
|
interestAmount -= fixFee;
|
|
markClosePnl += tradeinfFee;
|
|
swap_event swapEvent;
|
|
if (!long.TryParse(eventIdStr, out long eventId))//不识别，为衡泰新增的平仓信息
|
|
{
|
|
swapEvent = null;
|
|
}
|
|
else
|
|
{
|
|
swapEvent = DbContext.swap_event.FirstOrDefault(x => x.id == eventId);
|
|
}
|
|
// 先不支持衡泰修改平仓信息
|
|
if (swapEvent == null&& OtcAppConfigHelper.HTUpdate == 1&&td.TradeStatus!= ConsTrade.已平仓)
|
|
{
|
|
new SwapDealService(this).AutoSwapUnwindFromConsumer(td, unwindDate, payDate, markClosePnl, tradeinfFee, interestAmount, fixFee, closeQty, allClose);
|
|
}
|
|
}
|
|
#endregion
|
|
#region 互换资金流水回执相关私有方法
|
|
private List<int> PrepareTradeCashData(SwapCashReq swapCashReq, List<trade> trades)
|
|
{
|
|
var tradenumbers = trades.Select(s => s.TradeNumber).ToList();
|
|
List<int> clientIds = new List<int>();
|
|
foreach (var cashItem in swapCashReq.ACCTSWAP_CASH_LIST)
|
|
{
|
|
var money = cashItem.CASH_AMOUNT;
|
|
var backCard = cashItem.BANK_ACC_CODE;
|
|
var bankCardInfo = new ClientBankCardService(UserInfo).GetBankCardByBankCode(backCard);
|
|
if (bankCardInfo == null)
|
|
{
|
|
throw new ServiceException("根据银行卡信息找不到对应客户");
|
|
}
|
|
var trade = trades.FirstOrDefault(x => x.TradeNumber == cashItem.EXT_NO);
|
|
var client = DataCacheProvider.GetClientDataSource().GetData(bankCardInfo.ClientId ?? 0);
|
|
var cash = new ClientCashInCashOut();
|
|
cash.ClientId = bankCardInfo.ClientId;
|
|
cash.ClientName = client?.Name;
|
|
cash.ClientNumber = client?.Number;
|
|
cash.Direction = money > 0 ? "入金" : "出金";
|
|
cash.Money = Math.Abs(money);
|
|
cash.TradeId = trade?.id;
|
|
cash.TradeNumber = trade?.TradeNumber;
|
|
cash.HappenDate = TryFormatDate(cashItem.SETDATE_REAL).Date;
|
|
cash.OptDate = TryFormatDate(cashItem.SETDATE);
|
|
cash.CurrencyCode = "CNY";
|
|
cash.Number = UniqueTimeId.GetStr();
|
|
cash.State = "未确认";
|
|
cash.SetOpt(UserInfo);
|
|
cash.Comments = "互换资金流水回执";
|
|
cash.OpenBankCard = backCard;
|
|
cash.OpenBankId = bankCardInfo?.id;
|
|
DbContext.ClientCashInCashOut.Add(cash);
|
|
if (client?.SwapTradeType == 1)
|
|
{
|
|
clientIds.Add(cash.ClientId ?? 0);
|
|
}
|
|
}
|
|
DbContext.SaveChanges();
|
|
return clientIds.Distinct().ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 推送客户资金信息到客户端
|
|
/// </summary>
|
|
/// <param name="clientIds"></param>
|
|
/// <param name="onRspAccountCapitalTopicTopic"></param>
|
|
private void PushClientCash(List<int> clientIds, string onRspAccountCapitalTopicTopic)
|
|
{
|
|
try
|
|
{
|
|
var clientSettles = new RealTimeClientBanlanceService(new OptUserInfo(0, "实时客户资金服务", OptUserFrom.Service)).GetBanlances(clientIds, valuedateBLL.ValueDate);
|
|
foreach (var cb in clientSettles)
|
|
{
|
|
Result result = new Result();
|
|
try
|
|
{
|
|
var obj = new ClientBalanceForTrsResponse
|
|
{
|
|
TotalAmountTotal = cb.RoundedTotalAmountTotal,
|
|
AvailableAmount = Math.Round(cb.AvailableAmount, 2),
|
|
PositionPv = cb.RoundedPositionPv,
|
|
PositionPnl = cb.RoundedPositionPnl,
|
|
DaliyPnl = Math.Round(cb.DaliyPnl, 2),
|
|
ClientId = cb.ClientId,
|
|
ClientType = cb.ClientType,
|
|
Credit = cb.TotalCredit
|
|
};
|
|
result.success = true;
|
|
result.obj = obj;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
result.msg = ex.Message;
|
|
result.success = false;
|
|
}
|
|
kafkaProduceHelper.Produce(onRspAccountCapitalTopicTopic, JsonConvert.SerializeObject(result));
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region 出入金相关私有方法
|
|
public void PushCashToHT(int cashId, PushLog pushLog)
|
|
{
|
|
//var cash= DbContext.ClientCashInCashOut.FirstOrDefault(x=>x.id==cashId);
|
|
// if (cash==null)
|
|
// {
|
|
// return;
|
|
// }
|
|
// var req = new RequestBase<SwapMarginReq>();
|
|
// var pushService = new PushLogService(UserInfo);
|
|
// var enumType = cash.Direction=="出金"? SwapPushDataEnum.客户出金新增: SwapPushDataEnum.客户入金新增;
|
|
// if (pushLog==null)
|
|
// {
|
|
// pushLog = pushService.AddLog(cashId, enumType, cash.Number);
|
|
// }
|
|
// req.RECORD = PrepareTradeMarginReq(cash);
|
|
// if (req.RECORD == null)
|
|
// {
|
|
// return;
|
|
// }
|
|
// req.EXT_NO = cash.Number;
|
|
// req.SERIAL_NO = pushLog.id.ToString();
|
|
// req.ACTION = "2043";
|
|
// var data_req = JsonHelper.Serialize(req);
|
|
// pushService.UpdateLogReq(pushLog.id, data_req);
|
|
// kafkaProduceHelper.Produce(reqMarginInsert, data_req);
|
|
}
|
|
/// <summary>
|
|
/// 互换预付金请求数据组装
|
|
/// </summary>
|
|
/// <param name="model"></param>
|
|
/// <returns></returns>
|
|
private SwapMarginReq PrepareTradeMarginReq(ClientCashInCashOut model)
|
|
{
|
|
SwapMarginReq swapMarginReq = new SwapMarginReq();
|
|
var etradeAccount = DbContext.etrade_account.FirstOrDefault();
|
|
#region BASEINFO
|
|
swapMarginReq.BASEINFO.ORDDATE = model.HappenDate.Value.ToString("yyyy-MM-dd");
|
|
swapMarginReq.BASEINFO.SETDATE = swapMarginReq.BASEINFO.ORDDATE;
|
|
swapMarginReq.BASEINFO.PARTY_NAME = model.ClientName;
|
|
swapMarginReq.BASEINFO.ORDSTATUS = "1";
|
|
swapMarginReq.BASEINFO.TRDTYPE = model.Direction == "入金" ? "128" : "127";
|
|
swapMarginReq.BASEINFO.TRADER_ID = etradeAccount?.trader_account;
|
|
swapMarginReq.BASEINFO.SECU_INT = etradeAccount?.balance_account_trade;
|
|
#endregion
|
|
#region TRADEINFO
|
|
swapMarginReq.TRADEINFO.PARVALUE = model.Money.OtcFormatMoney(false, 4);
|
|
#endregion
|
|
return swapMarginReq;
|
|
}
|
|
#endregion
|
|
/// <summary>
|
|
/// 校验标的信息
|
|
/// </summary>
|
|
/// <param name="underlyingCode"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ServiceException"></exception>
|
|
private underlying_manager CheckUnderlying(string underlyingCode, string market)
|
|
{
|
|
var underlying = DbContext.underlying_manager.FirstOrDefault(x => x.UnderlyingCode.StartsWith(underlyingCode + ".") && x.MarketCode == market);
|
|
if (underlying == null)
|
|
{
|
|
throw new ServiceException($"标的代码{underlyingCode}不存在");
|
|
}
|
|
return underlying;
|
|
}
|
|
private DateTime TryFormatDate(string val)
|
|
{
|
|
if (!DateTime.TryParse(val, out DateTime formatDate))
|
|
{
|
|
throw new ServiceException($"参数{val}不是正确的日期格式");
|
|
}
|
|
return formatDate;
|
|
}
|
|
private double TryFormatDouble(string val)
|
|
{
|
|
if (!double.TryParse(val, out double doubleVal))
|
|
{
|
|
throw new ServiceException($"参数{val}不是数字");
|
|
}
|
|
return doubleVal;
|
|
}
|
|
private decimal TryFormatDecimal(string val)
|
|
{
|
|
if (!decimal.TryParse(val, out decimal decimalVal))
|
|
{
|
|
throw new ServiceException($"参数{val}不是数字");
|
|
}
|
|
return decimalVal;
|
|
}
|
|
private int TryFormatInt(string val)
|
|
{
|
|
if (!int.TryParse(val, out int intVal))
|
|
{
|
|
throw new ServiceException($"参数{val}不是数字");
|
|
}
|
|
return intVal;
|
|
}
|
|
private string GetInterestRule(string interestRule)
|
|
{
|
|
switch (interestRule)
|
|
{
|
|
case "1":
|
|
return "01";
|
|
case "2":
|
|
return "11";
|
|
default:
|
|
return "10";
|
|
}
|
|
}
|
|
|
|
private string GetTradeStatus(string orderStatus)
|
|
{
|
|
switch (orderStatus)
|
|
{
|
|
//0新建、-4交易执行中、-3风险预审中、7成交确认、9交易撤单、1审批中、5审批通过、4审批拒绝、10交易终止
|
|
case "0":
|
|
return ConsTrade.新增待确认;
|
|
case "1":
|
|
return ConsTrade.审批中;
|
|
case "4":
|
|
case "9"://撤单
|
|
return "";
|
|
case "10":
|
|
return ConsTrade.已平仓;
|
|
default:
|
|
return ConsTrade.确认成交;
|
|
}
|
|
}
|
|
}
|
|
}
|