1636 lines
62 KiB
C#
1636 lines
62 KiB
C#
using FluentFTP.Helpers;
|
|
using Microsoft.EntityFrameworkCore.Storage;
|
|
using NPOI.SS.Formula.Functions;
|
|
using Org.BouncyCastle.Ocsp;
|
|
using Qdp.Pricing.Base.Utilities;
|
|
using YLErp.BLL.Calculation;
|
|
using YLErp.Configuration.Enums;
|
|
using YLErp.Helpers;
|
|
using YLErp.Model.Enum;
|
|
using YLErp.Modules.CalculationModule;
|
|
using YLErp.Modules.SystemModule;
|
|
using YLErp.Modules.TagModule;
|
|
using static iTextSharp.text.pdf.AcroFields;
|
|
|
|
namespace YLErp.Modules.TradeModule.OrderModule
|
|
{
|
|
/// <summary>
|
|
/// 衍生品交易录入服务
|
|
/// </summary>
|
|
public class OtcTradeSaveService : YLBaseService
|
|
{
|
|
public OtcTradeSaveService(OptUserInfo userInfo) : base(userInfo)
|
|
{
|
|
|
|
}
|
|
|
|
public OtcTradeSaveService(YLBaseService baseService) : base(baseService)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存来自API或导入的交易
|
|
/// </summary>
|
|
public trade SaveOptionTradeFromApiOrImport(OtcOptionTradeFullEx tdReq, TradeSourceEnum dataSource, IDbContextTransaction trans = null)
|
|
{
|
|
if (tdReq is null)
|
|
{
|
|
throw new ArgumentNullException(nameof(tdReq));
|
|
}
|
|
|
|
if (dataSource != TradeSourceEnum.WebApiV2 && dataSource != TradeSourceEnum.导入交易)
|
|
{
|
|
throw new NotSupportedException("不支持:" + dataSource.ToString());
|
|
}
|
|
|
|
if (tdReq._Update)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(tdReq.TradeNumber))
|
|
{
|
|
throw new ServiceException("交易编号 必须填写");
|
|
}
|
|
|
|
var td = DbContext.trade.Where(n => n.TradeNumber == tdReq.TradeNumber)
|
|
.Select(n => new
|
|
{
|
|
n.id,
|
|
n.TradeType,
|
|
n.IsGroup,
|
|
n.TradeDate,
|
|
n.ClientId,
|
|
n.SpotPrice,
|
|
n.TradePrice,
|
|
n.ParentTradeId,
|
|
n.StructureType,
|
|
n.TradeStatus
|
|
}).FirstOrDefault();
|
|
|
|
if (td == null)
|
|
{
|
|
throw new ServiceException("未找到对应的交易数据:" + tdReq.TradeNumber);
|
|
}
|
|
|
|
//国君需求,如果有更多update需求,更改tdReq._Update处理
|
|
if (td.TradeStatus != ConsTrade.新增待确认)
|
|
{
|
|
throw new ServiceException("交易状态必须是'新增待确认'状态才允许修改");
|
|
}
|
|
|
|
tdReq.id = td.id;
|
|
|
|
//扩展支持组合交易主交易的修改
|
|
if (td.IsGroup == 1 && td.TradeType == "结构化交易")
|
|
{
|
|
tdReq.IsGroup = 1;
|
|
tdReq.TradeType = "结构化交易";
|
|
tdReq.ClientId = td.ClientId;
|
|
tdReq.TradeDate = td.TradeDate;
|
|
|
|
if (!tdReq.SpotPrice.HasValue)
|
|
{
|
|
tdReq.SpotPrice = td.SpotPrice;
|
|
}
|
|
|
|
tdReq.TradePrice = td.TradePrice;
|
|
|
|
CheckApiOrImportSave(tdReq, dataSource);
|
|
return new TradeSaveService(this).SaveGroupTrade(tdReq, null);
|
|
}
|
|
else if (td.IsGroup == 2 && td.ParentTradeId > 0)
|
|
{
|
|
tdReq.IsGroup = 2;
|
|
tdReq.ParentTradeId = td.ParentTradeId;
|
|
tdReq.StructureType = td.StructureType;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tdReq.id = 0;
|
|
}
|
|
|
|
var saveExt = CheckApiOrImportSave(tdReq, dataSource);
|
|
|
|
var dbtrade = TradeConverter.ConvertOptionTrade(tdReq);
|
|
|
|
dbtrade.SaveExt = saveExt;
|
|
|
|
return new TradeSaveService(this).SaveTrade(dbtrade, dataSource, trans);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存来自API或导入的结构化组合交易
|
|
/// </summary>
|
|
public trade SaveStructureOptionTradeFromApiOrImport(StructureOrderRequest request, TradeSourceEnum dataSource, IDbContextTransaction trans = null)
|
|
{
|
|
if (request is null)
|
|
{
|
|
throw new ArgumentNullException(nameof(request));
|
|
}
|
|
|
|
if (dataSource != TradeSourceEnum.WebApiV2 && dataSource != TradeSourceEnum.导入交易)
|
|
{
|
|
throw new NotSupportedException("不支持:" + dataSource.ToString());
|
|
}
|
|
|
|
switch (request.StructureType)
|
|
{
|
|
case "牛市价差":
|
|
case "熊市价差":
|
|
case "亚式熊市价差":
|
|
case "跨式组合":
|
|
case "宽跨式组合":
|
|
case "复制标的资产":
|
|
case "蝶式组合":
|
|
case "飞鹰式组合":
|
|
case "比例价差":
|
|
case "日历价差":
|
|
case "箱式价差":
|
|
case "风险逆转":
|
|
case "三领口组合":
|
|
case "结构化交易":
|
|
break;
|
|
default:
|
|
if (string.IsNullOrWhiteSpace(request.StructureType))
|
|
{
|
|
throw new ServiceException("结构化类型 必须填写");
|
|
}
|
|
throw new ServiceException("结构化类型 不可辨识:" + request.StructureType);
|
|
}
|
|
|
|
if (request.Trades == null || request.Trades.Count() < 2)
|
|
{
|
|
throw new ServiceException("结构化交易组合必须有两条腿及以上");
|
|
}
|
|
|
|
var dbtrades = request.Trades.Select(td =>
|
|
{
|
|
td.id = 0;
|
|
td.StructureType = request.StructureType;
|
|
var saveExt = CheckApiOrImportSave(td, dataSource);
|
|
var trad = TradeConverter.ConvertOptionTrade(td);
|
|
trad.SaveExt = saveExt;
|
|
return trad;
|
|
}).ToArray();
|
|
|
|
var struTrade = dbtrades[0].Clone();
|
|
struTrade.TradeType = "结构化交易";
|
|
struTrade.SubTrades = dbtrades;
|
|
|
|
return new TradeSaveService(OptUser).SaveTrade(struTrade, dataSource, trans);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存来自API或导入的组合交易
|
|
/// </summary>
|
|
public trade SaveGroupOptionTradeFromApiOrImport(StructureOrderRequest request, TradeSourceEnum dataSource, IDbContextTransaction trans = null)
|
|
{
|
|
if (request is null)
|
|
{
|
|
throw new ArgumentNullException(nameof(request));
|
|
}
|
|
|
|
if (dataSource != TradeSourceEnum.WebApiV2 && dataSource != TradeSourceEnum.导入交易)
|
|
{
|
|
throw new NotSupportedException("不支持:" + dataSource.ToString());
|
|
}
|
|
|
|
if (request.Trades == null || request.Trades.Count() <= 2)
|
|
{
|
|
throw new ServiceException("组合交易必须有两条腿及以上");
|
|
}
|
|
|
|
var dbtrades = request.Trades.Select(td =>
|
|
{
|
|
td.id = 0;
|
|
if (td.IsGroup == 1)
|
|
{
|
|
td.StructureType = td.TradeType;
|
|
td.TradeType = "结构化交易";
|
|
}
|
|
var saveExt = CheckApiOrImportSave(td, dataSource);
|
|
var trad = TradeConverter.ConvertOptionTrade(td);
|
|
trad.SaveExt = saveExt;
|
|
return trad;
|
|
}).ToArray();
|
|
|
|
var struTrade = dbtrades.FirstOrDefault(x => x.IsGroup == 1);
|
|
if (struTrade == null)
|
|
{
|
|
throw new Exception("未找到组合主交易，组合子交易必须和主交易配对出现");
|
|
}
|
|
struTrade.SubTrades = dbtrades.Where(x => x.IsGroup != 1);
|
|
|
|
return new TradeSaveService(OptUser).SaveTrade(struTrade, dataSource, trans);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存组合报价的交易
|
|
/// </summary>
|
|
public List<trade> SaveOptionTradesFromPricing(IEnumerable<OtcOptionTradeFull> trades)
|
|
{
|
|
var tdGroups = trades.GroupBy(n => n.CalcId.Split('-')[0]).ToArray();
|
|
var dbTrades = new List<trade>();
|
|
var saveChecker = new OtcOptionSaveChecker(this);
|
|
var tags = (trades != null && trades.Any()) ? trades.First().Tags : null;
|
|
try
|
|
{
|
|
foreach (var tdGroup in tdGroups)
|
|
{
|
|
var tdList = tdGroup.Select(td =>
|
|
{
|
|
saveChecker.CheckBasic(td).CheckAnnualizeFactorForEditSave(td);
|
|
saveChecker.CheckPrincipalRate(td).CheckParticipationRate(td);
|
|
saveChecker.CheckExoticFields(td);
|
|
return TradeConverter.ConvertOptionTrade(td);
|
|
}).ToArray();
|
|
|
|
var tdConv = tdList.Where(O => O.TradeType != "现金流交易").FirstOrDefault() ?? tdList[0];
|
|
if (tdList.Length > 1)
|
|
{
|
|
tdConv = tdConv.Clone();
|
|
tdConv.TradeType = "结构化交易";
|
|
tdConv.SubTrades = tdList;
|
|
}
|
|
|
|
if (PS.Config.Is浙期 && IsCodesExistsCommoditySpot(new string[] { tdConv.UnderlyingCode }))
|
|
{
|
|
tdConv.MetaDic["ActualExerciseDate"] = tdConv.ExerciseDate.Value.ToString("yyyy-MM-dd"); //没有录入
|
|
}
|
|
|
|
var dbTrade = new TradeSaveService(this).SaveTrade(tdConv, TradeSourceEnum.系统交易);
|
|
using (var tagService = new TagService(OptUser))
|
|
{
|
|
tagService.SetTradeTagForTradeEdit(new TagModule.Dto.SetTradeTagForTradeEditRequest
|
|
{
|
|
TradeId = dbTrade.id,
|
|
Tags = tags
|
|
});
|
|
if ("结构化交易".Equals(dbTrade.TradeType))
|
|
{
|
|
if (dbTrade.SubTrades != null && dbTrade.SubTrades.Any())
|
|
{
|
|
dbTrade.SubTrades.ToList().ForEach(p =>
|
|
{
|
|
if (p.id > 0)
|
|
{
|
|
tagService.SetTradeTagForTradeEdit(new TagModule.Dto.SetTradeTagForTradeEditRequest
|
|
{
|
|
TradeId = p.id,
|
|
Tags = tags
|
|
});
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
}
|
|
var variety = UnderlyingDataProvider.GetVariety(dbTrade.UnderlyingCode);
|
|
if (variety != null)
|
|
{
|
|
dbTrade.QuoteUnit = variety.QuoteUnit;
|
|
dbTrade.QuoteUnitSingle = variety.QuoteUnitSingle;
|
|
}
|
|
dbTrades.Add(dbTrade);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
if (dbTrades.Count > 0)
|
|
{
|
|
var ids = dbTrades.Select(n => n.id.ToString()).ToArray();
|
|
var sql = "UPDATE trade SET ValidState='InValid', TradeNumber='XX', ClientId=0, ChangeMsg='因组合报价录入交易部分失败所以无效' WHERE id in ({0}) OR ParentTradeId in ({0});";
|
|
sql = string.Format(sql, string.Join(",", ids));
|
|
var changes = DbContext.Database.ExecuteSqlRaw(sql);
|
|
}
|
|
throw;
|
|
}
|
|
|
|
return dbTrades;
|
|
}
|
|
|
|
public trade SaveOptionForwardTradeFromApi(OtcTradeForward req, TradeSourceEnum dataSource)
|
|
{
|
|
req.TradeType = "远期";
|
|
var otcOptionTradeFullEx = new OtcOptionTradeFullEx { ClientName = req.ClientName };
|
|
new OtcOptionSaveChecker(this).CheckAssetBook(req).CheckTrader(req).CheckClient(otcOptionTradeFullEx);
|
|
req.ClientId = otcOptionTradeFullEx.ClientId;
|
|
var um = DataCacheProvider.GetUnderlyingDataSource().GetData(req.UnderlyingCode);
|
|
if (um == null)
|
|
{
|
|
throw new ServiceException("系统中不存在，传入的标的1代码");
|
|
}
|
|
else if (!string.IsNullOrEmpty(req.BasisUnderlyingCode))
|
|
{
|
|
if (DataCacheProvider.GetUnderlyingDataSource().GetData(req.BasisUnderlyingCode) == null)
|
|
{
|
|
throw new ServiceException("系统中不存在，传入的标的2代码");
|
|
}
|
|
|
|
}
|
|
if (req.IsSupplyForwardValue == 0)
|
|
{
|
|
req.MetaDic["IsSupplyForwardValue"] = "0";
|
|
}
|
|
else if (req.IsSupplyForwardValue == -1)
|
|
{
|
|
req.MetaDic["IsSupplyForwardValue"] = "-1";
|
|
}
|
|
else if (req.IsSupplyForwardValue == 1)
|
|
{
|
|
req.MetaDic["IsSupplyForwardValue"] = "1";
|
|
}
|
|
else
|
|
{
|
|
throw new ServiceException("是否补偿远期价值，传入值错误，只能为0,1，-1;");
|
|
}
|
|
|
|
if (req.PriceModel == 0)
|
|
{
|
|
if ((PS.Config.ErpElement.ForwardTradePriceModel == ForwardTradePriceModel.STANDARD || PS.Config.ErpElement.ForwardTradePriceModel == ForwardTradePriceModel.HOOK_PRICE))
|
|
{
|
|
if (PS.Config.ErpElement.ForwardTradePriceModel == ForwardTradePriceModel.STANDARD)
|
|
{
|
|
var spList = new List<string>
|
|
{
|
|
req.SpotPrice.OtcFormatUmPrice()
|
|
};
|
|
if (!string.IsNullOrEmpty(req.BasisUnderlyingCode))
|
|
{
|
|
|
|
if (req.SpotPrice2 == null)
|
|
{
|
|
throw new ServiceException("填写标的2代码，则必须填写标的2期初价格");
|
|
}
|
|
else
|
|
{
|
|
spList.Add((req.SpotPrice2 ?? 0).OtcFormatUmPrice());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw new ServiceException("请填写标的2代码");
|
|
}
|
|
|
|
req.SpotPrice = (double)((decimal)req.SpotPrice - (decimal)(req.SpotPrice2 ?? 0));
|
|
req.MetaDic["期初信息"] = spList.ToJson();
|
|
}
|
|
new ForwardModule.ForwardTradeImportService(UserInfo).GetSpotPrice(req);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var spList = new List<string>
|
|
{
|
|
req.SpotPrice.OtcFormatUmPrice()
|
|
};
|
|
req.MetaDic["期初信息"] = spList.ToJson();
|
|
}
|
|
new ForwardModule.ForwardTradeImportService(UserInfo).GetCountRatio(req);
|
|
new ForwardModule.ForwardTradeImportService(UserInfo).GetNotional_TradeAmount_Lots(req, um);
|
|
new ForwardModule.ForwardTradeImportService(UserInfo).GetForwardValue(req);
|
|
new ForwardModule.ForwardTradeImportService(UserInfo).GetOpenCommission_TradePrice(req, null, req.OpenCommission, req.TradePrice);
|
|
var td = TradeConverter.ConvertForward(req);
|
|
|
|
td = new TradeSaveService(this).SaveTrade(td, dataSource);
|
|
var variety = UnderlyingDataProvider.GetVariety(td.UnderlyingCode);
|
|
if (variety != null)
|
|
{
|
|
td.QuoteUnit = variety.QuoteUnit;
|
|
td.QuoteUnitSingle = variety.QuoteUnitSingle;
|
|
}
|
|
return td;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存分组交易
|
|
/// </summary>
|
|
public trade SaveGroupTradeFromPricing(trade trade, IEnumerable<OtcOptionTradeFull> subTrades)
|
|
{
|
|
var saveChecker = new OtcOptionSaveChecker(this);
|
|
|
|
subTrades.ToList().ForEach(x =>
|
|
{
|
|
saveChecker.CheckBasic(x).CheckAnnualizeFactorForEditSave(x);
|
|
saveChecker.CheckPrincipalRate(x).CheckParticipationRate(x);
|
|
saveChecker.CheckExoticFields(x);
|
|
});
|
|
|
|
trade.TradeType = "结构化交易";
|
|
trade.IsGroup = 1;
|
|
trade.SubTrades = subTrades.Select(x => TradeConverter.ConvertOptionTrade(x)).ToArray();
|
|
trade.UnderlyingCode = trade.SubTrades.FirstOrDefault(x => !string.IsNullOrEmpty(x.UnderlyingCode)).UnderlyingCode;
|
|
var dbTrade = new TradeSaveService(this).SaveTrade(trade, TradeSourceEnum.系统交易);
|
|
using (var tagService = new TagService(OptUser))
|
|
{
|
|
tagService.SetTradeTagForTradeEdit(new TagModule.Dto.SetTradeTagForTradeEditRequest
|
|
{
|
|
TradeId = dbTrade.id,
|
|
Tags = trade.Tags
|
|
});
|
|
}
|
|
return dbTrade;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保存交易编辑的交易
|
|
/// </summary>
|
|
public trade SaveOptionTradesFromTradeEdit(OtcOptionTradeFull td)
|
|
{
|
|
var saveChecker = new OtcOptionSaveChecker(this);
|
|
|
|
saveChecker.CheckBasic(td).CheckAnnualizeFactorForEditSave(td);
|
|
saveChecker.CheckPrincipalRate(td).CheckParticipationRate(td);
|
|
saveChecker.CheckExoticFields(td);
|
|
|
|
var tdConv = TradeConverter.ConvertOptionTrade(td);
|
|
|
|
var dbTrade = new TradeSaveService(this).SaveTrade(tdConv, TradeSourceEnum.系统交易);
|
|
var variety = UnderlyingDataProvider.GetVariety(dbTrade.UnderlyingCode);
|
|
if (variety != null)
|
|
{
|
|
dbTrade.QuoteUnit = variety.QuoteUnit;
|
|
dbTrade.QuoteUnitSingle = variety.QuoteUnitSingle;
|
|
}
|
|
using (var tagService = new TagService(OptUser))
|
|
{
|
|
tagService.SetTradeTagForTradeEdit(new TagModule.Dto.SetTradeTagForTradeEditRequest
|
|
{
|
|
TradeId = dbTrade.id,
|
|
Tags = td.Tags
|
|
});
|
|
}
|
|
return dbTrade;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 判断标的是否为现货
|
|
/// </summary>
|
|
/// <param name="codes"></param>
|
|
/// <returns></returns>
|
|
public bool IsCodesExistsCommoditySpot(string[] codes)
|
|
{
|
|
return UndelyingHelper.IsCodesExistsCommoditySpot(codes, (um) =>
|
|
{
|
|
return um.UnderlyingInstrumentType == "CommoditySpot" ? true : false;
|
|
});
|
|
|
|
}
|
|
|
|
//检查导入和API数据
|
|
private TradeSaveExt CheckApiOrImportSave(OtcOptionTradeFullEx td, TradeSourceEnum dataSource)
|
|
{
|
|
if (dataSource != TradeSourceEnum.WebApiV2 && dataSource != TradeSourceEnum.导入交易)
|
|
{
|
|
throw new NotSupportedException("不支持:" + dataSource.ToString());
|
|
}
|
|
|
|
var saveChecker = new OtcOptionSaveChecker(this).CheckBasic(td);
|
|
|
|
//簿记、交易员、交易对手
|
|
saveChecker.CheckAssetBook(td).CheckTrader(td).CheckClient(td);
|
|
|
|
//年化系数
|
|
saveChecker.CheckAnnualizeFactorForApiOrImport(td);
|
|
|
|
//保底收益率、参与率
|
|
saveChecker.CheckPrincipalRate(td).CheckParticipationRate(td);
|
|
|
|
TradingPremiumFlag premiumFlag;
|
|
var notionalFlag = TradingNotionalFlag.None;
|
|
|
|
// 权利金单价/期权费率/权利金总额
|
|
// 20200622: 权利金总额/单价/费率、名义本金/份额导入时可能存在为负值的情况
|
|
// 20210425: 国海凤凰雪球期权资金记录方向问题，需要权利金可以为负
|
|
if (dataSource == TradeSourceEnum.导入交易)
|
|
{
|
|
if ((td.HasFlag & OtcOptionTradeFullHasFlag.TradeSinglePrice) > 0)
|
|
{
|
|
premiumFlag = TradingPremiumFlag.TradeSinglePrice;
|
|
td.TradeSinglePrice = td.TradeSinglePrice.Value;
|
|
}
|
|
else if ((td.HasFlag & OtcOptionTradeFullHasFlag.TradePrice) > 0)
|
|
{
|
|
premiumFlag = TradingPremiumFlag.TradePrice;
|
|
td.TradePrice = td.TradePrice.Value;
|
|
}
|
|
else if ((td.HasFlag & OtcOptionTradeFullHasFlag.PremiumRate) > 0)
|
|
{
|
|
premiumFlag = TradingPremiumFlag.PremiumRate;
|
|
td.PremiumRate = td.PremiumRate.Value;
|
|
}
|
|
else
|
|
{
|
|
//暂时不支持小于0
|
|
td.TradeSinglePrice = td.PremiumRate = td.TradePrice = 0;
|
|
premiumFlag = TradingPremiumFlag.AllZero;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (td.TradeSinglePrice.HasValue)
|
|
{
|
|
premiumFlag = TradingPremiumFlag.TradeSinglePrice;
|
|
}
|
|
else if (td.PremiumRate.HasValue)
|
|
{
|
|
premiumFlag = TradingPremiumFlag.PremiumRate;
|
|
}
|
|
else
|
|
{
|
|
//TradePrice在20200803被修改后一直有值，已经不具备优先使用的条件
|
|
premiumFlag = TradingPremiumFlag.TradePrice;
|
|
}
|
|
}
|
|
|
|
// 有效名义本金/名义本金/交易份额/交易数量
|
|
|
|
if (notionalFlag == TradingNotionalFlag.None)
|
|
{
|
|
if (Math.Abs(td.Notional) > 0)
|
|
{
|
|
notionalFlag = TradingNotionalFlag.Notional;
|
|
td.Notional = Math.Abs(td.Notional);
|
|
}
|
|
else if (Math.Abs(td.TradeAmount) > 0)
|
|
{
|
|
notionalFlag = TradingNotionalFlag.TradeAmount;
|
|
td.TradeAmount = Math.Abs(td.TradeAmount);
|
|
}
|
|
else if (td.TradeType == "累计期权")
|
|
{
|
|
throw new ServiceException("有效交易份额/有效交易数量 两个字段中必须有一个值大于0");
|
|
}
|
|
else if (Math.Abs(td.StockEqvNotional) > 0)
|
|
{
|
|
notionalFlag = TradingNotionalFlag.StockEqvNotional;
|
|
td.StockEqvNotional = Math.Abs(td.StockEqvNotional);
|
|
}
|
|
else if (Math.Abs(td.StockEqvNotionalReal) > 0)
|
|
{
|
|
notionalFlag = TradingNotionalFlag.StockEqvNotionalReal;
|
|
td.StockEqvNotionalReal = Math.Abs(td.StockEqvNotionalReal);
|
|
}
|
|
else
|
|
{
|
|
//交易数量
|
|
throw new ServiceException("有效交易份额/有效交易数量/有效名义本金/名义本金 四个字段中必须有一个值大于0");
|
|
}
|
|
}
|
|
|
|
if (!(td.TradeType == "结构化交易" && td.IsGroup == 1))
|
|
{
|
|
td.IsUsePremiumRate = premiumFlag == TradingPremiumFlag.PremiumRate
|
|
|| premiumFlag == TradingPremiumFlag.TradePrice && (notionalFlag == TradingNotionalFlag.StockEqvNotionalReal || notionalFlag == TradingNotionalFlag.StockEqvNotional);
|
|
}
|
|
|
|
// 组合标的(使用最大名义本金)
|
|
if (saveChecker.CheckSyntheticUnderlying(td, td.SyntheticPrices, out var maxSpotPrice) && maxSpotPrice > 0)
|
|
{
|
|
//暂时不再支持最大名义本金方式导入处理
|
|
//var spotPrice = Math.Abs(td.SpotPrice.Value);
|
|
//var spotPriceRate = spotPrice / maxSpotPrice;
|
|
//switch (notionalFlag)
|
|
//{
|
|
// case TradingNotionalFlag.StockEqvNotionalReal:
|
|
// td.StockEqvNotionalMax = TradeHelper.GetStockEqvNotional(td.StockEqvNotionalReal, td.ParticipationRate, td.AnnualizeFactor);
|
|
// td.StockEqvNotionalReal *= spotPriceRate;
|
|
// break;
|
|
// case TradingNotionalFlag.StockEqvNotional:
|
|
// td.StockEqvNotionalMax = td.StockEqvNotional;
|
|
// td.StockEqvNotional *= spotPriceRate;
|
|
// break;
|
|
// case TradingNotionalFlag.Notional:
|
|
// td.StockEqvNotionalMax = td.Notional * maxSpotPrice;
|
|
// break;
|
|
// case TradingNotionalFlag.TradeAmount:
|
|
// //组合标的没有数量和份额的乘积因子
|
|
// td.StockEqvNotionalMax = td.TradeAmount * maxSpotPrice;
|
|
// break;
|
|
// default:
|
|
// throw new SystemException("[NotionalFlag]系统程序错误");
|
|
//}
|
|
}
|
|
|
|
if (td.Comments?.Length > 100)
|
|
{
|
|
throw new ServiceException("交易备注 最多100个字");
|
|
}
|
|
|
|
// 奇异期权检查
|
|
saveChecker.CheckExoticFields(td);
|
|
|
|
return new TradeSaveExt
|
|
{
|
|
PremiumFlag = premiumFlag,
|
|
NotionalFlag = notionalFlag
|
|
};
|
|
}
|
|
}
|
|
|
|
class OtcOptionSaveChecker : YLBaseService
|
|
{
|
|
public OtcOptionSaveChecker(YLBaseService baseService) : base(baseService)
|
|
{
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 检查基础信息(结构类型/标的代码/初始预付金)
|
|
/// </summary>
|
|
public OtcOptionSaveChecker CheckBasic(OtcTradeBase td)
|
|
{
|
|
if (!string.IsNullOrEmpty(td.TradeNumber))
|
|
{
|
|
var exclueStr = new List<string> { "+","/","?","%","#","&","=" };
|
|
exclueStr.ForEach(x =>
|
|
{
|
|
if (td.TradeNumber.Contains(x))
|
|
{
|
|
throw new ServiceException("交易编号不合法，不能包含以下字符："+ exclueStr.Join(","));
|
|
}
|
|
});
|
|
}
|
|
// 结构类型
|
|
if (string.IsNullOrWhiteSpace(td.TradeType))
|
|
{
|
|
throw new ServiceException("结构类型 必须填写");
|
|
}
|
|
if (td.TradeType == "现金流交易" || td.TradeType == "结构化交易" && td.IsGroup == 1)
|
|
{
|
|
return this;
|
|
}
|
|
// 标的代码
|
|
if (string.IsNullOrWhiteSpace(td.UnderlyingCode))
|
|
{
|
|
throw new ServiceException("标的代码 必须填写");
|
|
}
|
|
|
|
var um = DataCacheProvider.GetUnderlyingDataSource().GetData(td.UnderlyingCode);
|
|
|
|
// 标的代码
|
|
if (um == null)
|
|
{
|
|
throw new ServiceException("标的代码 必须在系统中存在:" + td.UnderlyingCode);
|
|
}
|
|
if (um.UnderlyingInstrumentType == "Stock")
|
|
{
|
|
var limitStatus = new UnderlyingModule.StockBlackWhiteService(UserInfo).GetStockBlackWhiteList(Configuration.Enums.LimitRangeEnum.Option, out var Codes);
|
|
if (Codes != null)
|
|
{
|
|
if (limitStatus == Codes.Contains(um.UnderlyingCode))
|
|
{
|
|
if (limitStatus)
|
|
{
|
|
throw new ServiceException("标的代码 填写错误,存在于黑名单中,请求值:" + td.UnderlyingCode);
|
|
}
|
|
else
|
|
{
|
|
throw new ServiceException("标的代码 填写错误,不存在于白名单中,请求值:" + td.UnderlyingCode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 簿记账户
|
|
/// </summary>
|
|
public OtcOptionSaveChecker CheckAssetBook(OtcTradeBase td)
|
|
{
|
|
if (td.AssetId > 0)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(td.AssetBookName))
|
|
{
|
|
throw new ServiceException("簿记账户 必须填写");
|
|
}
|
|
var assetUnit = DbContext.assetunit.Where(au => au.Name == td.AssetBookName).Select(n => new { n.id }).FirstOrDefault();
|
|
if (assetUnit == null)
|
|
{
|
|
throw new ServiceException("簿记账户不存在:" + td.AssetBookName);
|
|
}
|
|
td.AssetId = assetUnit.id;
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 交易员赋值及验证逻辑
|
|
/// </summary>
|
|
public OtcOptionSaveChecker CheckTrader(OtcTradeBase td)
|
|
{
|
|
if (td.TraderId > 0)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(td.TraderName))
|
|
{
|
|
throw new ServiceException("交易员名称 必须填写");
|
|
}
|
|
|
|
using (var sysdb = DbContextFactory.GetErpBaseContext())
|
|
{
|
|
var systemUser = sysdb.SystemUsers.Where(su => su.LoginName == td.TraderName)
|
|
.Select(n => new { n.Id, n.Name }).FirstOrDefault()
|
|
?? sysdb.SystemUsers.Where(su => su.Name == td.TraderName)
|
|
.Select(n => new { n.Id, n.Name }).FirstOrDefault();
|
|
if (systemUser == null)
|
|
{
|
|
throw new ServiceException("交易员不存在:" + td.TraderName);
|
|
}
|
|
else
|
|
{
|
|
td.TraderId = systemUser.Id;
|
|
td.TraderName = systemUser.Name;
|
|
}
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 交易对手方
|
|
/// </summary>
|
|
public OtcOptionSaveChecker CheckClient(OtcOptionTradeFullEx td)
|
|
{
|
|
if (td.ClientId > 0)
|
|
{
|
|
return this;
|
|
}
|
|
|
|
var clientQuery = DbContextFactory.GetClientDbContext(OptUser).client.AsQueryable();
|
|
|
|
if (!string.IsNullOrWhiteSpace(td.ClientNumber))
|
|
{
|
|
clientQuery = clientQuery.Where(c => c.Number == td.ClientNumber);
|
|
}
|
|
else if (!string.IsNullOrWhiteSpace(td.ClientName))
|
|
{
|
|
clientQuery = clientQuery.Where(c => c.Name == td.ClientName);
|
|
}
|
|
else
|
|
{
|
|
throw new ServiceException("交易对手方名称或编号 必须填写");
|
|
}
|
|
|
|
var client = clientQuery.Select(n => new { n.id }).FirstOrDefault();
|
|
|
|
if (client == null)
|
|
{
|
|
throw new ServiceException($"交易对手方不存在,客户名称:[{td.ClientName}],交易对手方编号:[{td.ClientNumber}]");
|
|
}
|
|
|
|
td.ClientId = client.id;
|
|
|
|
if (!td.MetaDic.ContainsKey("主协议编号"))
|
|
{
|
|
var mainProtocal = ClientDataModelV1.getMainProtocols(td.ClientId).FirstOrDefault();
|
|
if (mainProtocal != null)
|
|
{
|
|
td.MetaDic.Add("主协议编号", mainProtocal.Value);
|
|
}
|
|
}
|
|
|
|
if (!td.MetaDic.ContainsKey("补充协议编号") && td.MetaDic.ContainsKey("主协议编号"))
|
|
{
|
|
var sideProtocal = ClientDataModelV1.getSideProtocols(td.MetaDic["主协议编号"]).FirstOrDefault();
|
|
if (sideProtocal != null)
|
|
{
|
|
td.MetaDic.Add("补充协议编号", sideProtocal);
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 年化系数(API或导入的时候使用的是trade的字段所以雪球和凤凰需要转换为自己的字段)
|
|
/// </summary>
|
|
public OtcOptionSaveChecker CheckAnnualizeFactorForApiOrImport(OtcOptionTradeFull td)
|
|
{
|
|
//非期权年化
|
|
if (!td.IsAnnualized)
|
|
{
|
|
td.AnnualizeFactor = 1;
|
|
if (td.TradeType == "雪球期权" || td.TradeType == "凤凰期权")
|
|
{
|
|
td.IsAnnualized2 = false;
|
|
td.AnnualizeFactor2 = 1;
|
|
}
|
|
td.MetaDic[nameof(td.AnnualizeFactor)] = null;
|
|
td.MetaDic[nameof(td.AnnualizeFactor2)] = null;
|
|
return this;
|
|
}
|
|
|
|
//期权年化
|
|
if (!td.MetaDic.TryGetValue(nameof(td.AnnualizeFactor), out var str) || string.IsNullOrWhiteSpace(str))
|
|
{
|
|
if (td.AnnualizeFactor > 0)
|
|
{
|
|
var daysInYear = CalculatorHelper.GetTradeDayCount().ToDayCountImpl().DaysInYear();
|
|
var ttmdays = td.AnnualizeFactor.Value * daysInYear;
|
|
td.MetaDic[nameof(td.AnnualizeFactor)] = $"{ttmdays}/{daysInYear}";
|
|
}
|
|
else
|
|
{
|
|
var un = UnderlyingDataProvider.GetUnderlying(td.UnderlyingCode);
|
|
var ttmdays = TradeCalcHelper.CalculateTTMDays(td.TradeDate.Value, td.SettlementDate ?? td.ExerciseDate.Value, un?.UnderlyingTypeId ?? 0, false);
|
|
var daysInYear = CalculatorHelper.GetTradeDayCount().ToDayCountImpl().DaysInYear();
|
|
td.AnnualizeFactor = ttmdays / daysInYear;
|
|
td.MetaDic[nameof(td.AnnualizeFactor)] = $"{ttmdays}/{daysInYear}";
|
|
}
|
|
}
|
|
|
|
//雪球和凤凰使用自己的年化处理方式
|
|
if (td.TradeType == "雪球期权" || td.TradeType == "凤凰期权")
|
|
{
|
|
td.IsAnnualized2 = true;
|
|
td.AnnualizeFactor2 = td.AnnualizeFactor;
|
|
td.MetaDic[nameof(td.AnnualizeFactor2)] = td.MetaDic[nameof(td.AnnualizeFactor)];
|
|
|
|
td.IsAnnualized = false;
|
|
td.AnnualizeFactor = 1;
|
|
td.MetaDic[nameof(td.AnnualizeFactor)] = null;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 检查年化系数(组合报价或编辑保存时使用)
|
|
/// </summary>
|
|
public OtcOptionSaveChecker CheckAnnualizeFactorForEditSave(OtcOptionTradeFull td)
|
|
{
|
|
var IsAnnualized2 = td.TradeType == "雪球期权" || td.TradeType == "凤凰期权";
|
|
|
|
if (IsAnnualized2)
|
|
{
|
|
td.IsAnnualized = false;
|
|
td.AnnualizeFactor = 1;
|
|
td.MetaDic[nameof(td.AnnualizeFactor)] = null;
|
|
|
|
if (!td.IsAnnualized2)
|
|
{
|
|
td.AnnualizeFactor2 = 1;
|
|
td.MetaDic[nameof(td.AnnualizeFactor2)] = null;
|
|
return this;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
td.IsAnnualized2 = false;
|
|
td.AnnualizeFactor2 = 1;
|
|
td.MetaDic[nameof(td.AnnualizeFactor2)] = null;
|
|
|
|
if (!td.IsAnnualized)
|
|
{
|
|
td.AnnualizeFactor = 1;
|
|
td.MetaDic[nameof(td.AnnualizeFactor)] = null;
|
|
return this;
|
|
}
|
|
}
|
|
|
|
var AnnualizeFactorField = IsAnnualized2 ? nameof(td.AnnualizeFactor2) : nameof(td.AnnualizeFactor);
|
|
|
|
if (!td.MetaDic.TryGetValue(AnnualizeFactorField, out var str) || string.IsNullOrWhiteSpace(str))
|
|
{
|
|
throw new ServiceException("年化系数 必须填写");
|
|
}
|
|
|
|
var index = str.IndexOf('/');
|
|
|
|
if (index < 0)
|
|
{
|
|
throw new ServiceException("年化系数 填写错误,格式必须为:天数/年天数,填写值为:" + str);
|
|
}
|
|
|
|
if (!double.TryParse(str.Substring(0, index).Trim(), out var ttmDays))
|
|
{
|
|
throw new ServiceException("年化系数 填写错误,天数解析失败,填写值为:" + str);
|
|
}
|
|
|
|
if (ttmDays < 0)
|
|
{
|
|
throw new ServiceException("年化系数 填写错误,格式必须为:天数/年天数,天数必须大于等于0,填写值为:" + str);
|
|
}
|
|
|
|
if (!double.TryParse(str.Substring(index + 1).Trim(), out var daysOfYear))
|
|
{
|
|
throw new ServiceException("年化系数 填写错误,格式必须为:天数/年天数,年天数解析失败,填写值为:" + str);
|
|
}
|
|
|
|
if (daysOfYear < 1)
|
|
{
|
|
throw new ServiceException("年化系数 填写错误,格式必须为:天数/年天数,年天数必须大于0,填写值为:" + str);
|
|
}
|
|
|
|
if (IsAnnualized2)
|
|
{
|
|
td.AnnualizeFactor2 = ttmDays / daysOfYear;
|
|
}
|
|
else
|
|
{
|
|
td.AnnualizeFactor = ttmDays / daysOfYear;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 保底收益率
|
|
/// </summary>
|
|
public OtcOptionSaveChecker CheckPrincipalRate(OtcTradeBase td)
|
|
{
|
|
if (!td.PrincipalRate.HasValue)
|
|
{
|
|
td.PrincipalRate = 0;
|
|
}
|
|
else if (td.PrincipalRate.Value < 0)
|
|
{
|
|
throw new ServiceException("保底收益率 填写错误,必须大于等于0,请求值:" + td.PrincipalRate.Value);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 参与率
|
|
/// </summary>
|
|
public OtcOptionSaveChecker CheckParticipationRate(OtcTradeBase td)
|
|
{
|
|
if (!td.ParticipationRate.HasValue)
|
|
{
|
|
td.ParticipationRate = 1;
|
|
}
|
|
else if (td.ParticipationRate.Value < 0)
|
|
{
|
|
throw new ServiceException("参与率 填写错误,必须大于等于0,请求值:" + td.ParticipationRate.Value);
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
//组合标的
|
|
public bool CheckSyntheticUnderlying(OtcTradeBase td, IEnumerable<UnderlyingPriceModel> syntheticPrices, out double maxSpotPrice)
|
|
{
|
|
maxSpotPrice = 0;
|
|
|
|
var synthetic = DataCacheProvider.GetUnderlyingDataSource().GetSyntheticUnderlying(td.UnderlyingCode);
|
|
|
|
if (synthetic == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (syntheticPrices == null)
|
|
{
|
|
throw new ServiceException("[组合标的]必须填写每个组成标的的期初价格");
|
|
}
|
|
|
|
var model = synthetic.GetSyntheticPriceModel();
|
|
var codeSet = model.SuList.Select(n => n.UnderlyingCode).ToHashSet(StringComparer.OrdinalIgnoreCase);
|
|
|
|
foreach (var item in syntheticPrices)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(item.UnderlyingCode))
|
|
{
|
|
continue;
|
|
}
|
|
if (!codeSet.Remove(item.UnderlyingCode))
|
|
{
|
|
throw new ServiceException($"[组合标的]填写错误,组合标的中不存在此标的:{item.UnderlyingCode}");
|
|
}
|
|
model.SuList.First(n => n.UnderlyingCode.Equals(item.UnderlyingCode, StringComparison.OrdinalIgnoreCase)).Price = item.Price;
|
|
}
|
|
|
|
if (codeSet.Any())
|
|
{
|
|
throw new ServiceException("[组合标的]标的价格未填写完整,缺少:" + string.Join(",", codeSet));
|
|
}
|
|
|
|
//组合标的有独特的名义本金处理方式
|
|
|
|
maxSpotPrice = model.SuList.Max(n => Math.Abs(n.Coefficient * n.Price));
|
|
if (maxSpotPrice < 1e-6)
|
|
{
|
|
throw new ServiceException("[组合标的]标的价格 填写错误");
|
|
}
|
|
|
|
td.SpotPrice = model.Price = model.SuList.Sum(n => n.Coefficient * n.Price) + model.Constant;
|
|
|
|
td.MetaDic["组合标的"] = JsonHelper.ToJson(model);
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 奇异期权字段检查
|
|
/// </summary>
|
|
public OtcOptionSaveChecker CheckExoticFields(OtcOptionTradeFull td)
|
|
{
|
|
switch (td.TradeType)
|
|
{
|
|
case "香草期权":
|
|
case "自定义交易":
|
|
case "结构化产品":
|
|
case "合成价差期权": break;
|
|
case "障碍期权":
|
|
CheckBarrierTrade(td); break;
|
|
case "Risky期权":
|
|
CheckRiskyTrade(td); break;
|
|
case "二元期权":
|
|
CheckBinaryTrade(td); break;
|
|
case "亚式期权":
|
|
CheckAisanTrade(td); break;
|
|
case "双鲨期权":
|
|
CheckDoubleSharkTrade(td); break;
|
|
case "区间累积期权":
|
|
CheckRangeAccTrade(td); break;
|
|
case "凤凰期权":
|
|
CheckAutoCallTrade(td); break;
|
|
case "雪球期权":
|
|
CheckSnowballTrade(td); break;
|
|
case "气囊结构":
|
|
CheckAirbagTrade(td); break;
|
|
case "收益增强结构":
|
|
CheckUnderlyigEnhanceTrade(td); break;
|
|
case "结构化交易":
|
|
case "现金流交易": break;
|
|
case "累计期权":
|
|
CheckAccumulatorTrade(td); break;
|
|
case "彩虹期权":
|
|
case "价差期权":
|
|
throw new ServiceException("暂不支持");
|
|
default:
|
|
throw new ServiceException("不可辨识的结构类型:" + td.TradeType);
|
|
}
|
|
return this;
|
|
}
|
|
|
|
//障碍期权
|
|
private void CheckBarrierTrade(OtcOptionTradeFull td)
|
|
{
|
|
//---------------------------------------------
|
|
// 障碍类型
|
|
//---------------------------------------------
|
|
|
|
if (string.IsNullOrWhiteSpace(td.BarrierType))
|
|
{
|
|
throw new ServiceException("[障碍期权]障碍类型 必须填写");
|
|
}
|
|
|
|
switch (td.BarrierType)
|
|
{
|
|
default:
|
|
throw new ServiceException("[障碍期权]障碍类型 不支持:" + td.BarrierType);
|
|
case "上升敲入":
|
|
case "上升敲出":
|
|
case "下降敲入":
|
|
case "下降敲出":
|
|
case "双障碍敲入":
|
|
case "双障碍敲出":
|
|
break;
|
|
}
|
|
|
|
//障碍价格BarrierLow 高障碍价格BarrierHigh
|
|
|
|
if (td.BarrierType.Contains("双障碍"))
|
|
{
|
|
if (!td.BarrierHigh.HasValue)
|
|
{
|
|
throw new ServiceException($"[障碍期权][障碍类型为{td.BarrierType}时]高障碍价格 必须填写");
|
|
}
|
|
|
|
if (td.BarrierHigh < td.BarrierLow)
|
|
{
|
|
throw new ServiceException("[障碍期权]高障碍价格 必须大于障碍价格");
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// 观察方式
|
|
//---------------------------------------------
|
|
if (string.IsNullOrWhiteSpace(td.MonitorType))
|
|
{
|
|
td.MonitorType = "离散";
|
|
}
|
|
else if (td.MonitorType != "离散" && td.MonitorType != "连续")
|
|
{
|
|
throw new ServiceException("[障碍期权]观察方式 填写错误,当前支持的类型为：离散、连续,请求值为:" + td.MonitorType);
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// 补偿支付方式
|
|
//---------------------------------------------
|
|
if (string.IsNullOrWhiteSpace(td.RebateType))
|
|
{
|
|
td.RebateType = "AtHit";
|
|
}
|
|
else if (td.RebateType != "AtHit" && td.RebateType != "AtEnd")
|
|
{
|
|
throw new ServiceException("[障碍期权]补偿支付方式 填写错误,当前支持的类型为：AtHit、AtEnd,请求值为:" + td.RebateType);
|
|
}
|
|
|
|
//补偿金额(根据权利金数据格式进行处理)
|
|
if (td.IsUsePremiumRate == true)
|
|
{
|
|
td.Rebate = 0;
|
|
}
|
|
else
|
|
{
|
|
td.RebateRate = 0;
|
|
}
|
|
|
|
//高障碍补偿金额(根据权利金数据格式进行处理)
|
|
if (td.IsUsePremiumRate == true)
|
|
{
|
|
td.RebateHigh = 0;
|
|
}
|
|
else
|
|
{
|
|
td.RebateHighRate = 0;
|
|
}
|
|
|
|
//补偿金额是否年化选否的时候,清空DayCount
|
|
if (!td.RebateAnnualizedAtKO)
|
|
{
|
|
td.RebateDayCount = "";
|
|
}
|
|
|
|
//障碍偏移
|
|
if (!td.BarrierShift.HasValue)
|
|
{
|
|
td.BarrierShift = 0;
|
|
}
|
|
}
|
|
|
|
//二元期权
|
|
private void CheckBinaryTrade(OtcOptionTradeFull td)
|
|
{
|
|
//---------------------------------------------
|
|
// 二元类型
|
|
//---------------------------------------------
|
|
|
|
if (string.IsNullOrWhiteSpace(td.PayoffType))
|
|
{
|
|
throw new ServiceException("[二元期权]二元类型 必须填写");
|
|
}
|
|
|
|
switch (td.PayoffType)
|
|
{
|
|
default:
|
|
throw new ServiceException("[二元期权]二元类型 不支持:" + td.PayoffType);
|
|
case "CashOrNothing":
|
|
case "AssetOrNothing":
|
|
if (td.ExerciseMode != "European")
|
|
{
|
|
throw new ServiceException("[二元期权]二元类型 填写错误,所选行权方式不支持:" + td.PayoffType);
|
|
}
|
|
break;
|
|
case "UpOneTouch":
|
|
case "DownOneTouch":
|
|
case "UpNoTouch":
|
|
case "DownNoTouch":
|
|
case "DoubleOneTouch":
|
|
case "DoubleNoTouch":
|
|
if (td.ExerciseMode != "American")
|
|
{
|
|
throw new ServiceException("[二元期权]二元类型 填写错误,所选行权方式不支持:" + td.PayoffType);
|
|
}
|
|
break;
|
|
}
|
|
|
|
//补偿金额,高障碍补偿金额(根据权利金数据格式进行处理)
|
|
if (td.IsUsePremiumRate == true)
|
|
{
|
|
td.CashOrNothingAmount = 0;
|
|
td.CashOrNothingAmountHigh = 0;
|
|
}
|
|
else
|
|
{
|
|
td.CashOrNothingAmountRate = 0;
|
|
td.CashOrNothingAmountHighRate = 0;
|
|
}
|
|
|
|
//补偿金额是否年化选否的时候,清空DayCount
|
|
if (!td.RebateAnnualizedAtKO)
|
|
{
|
|
td.RebateDayCount = "";
|
|
}
|
|
|
|
if (td.ExerciseMode == "American")
|
|
{
|
|
if (td.PayoffType.Contains("Double"))
|
|
{
|
|
if (!td.BarrierHigh.HasValue)
|
|
{
|
|
throw new ServiceException($"[二元期权][美式行权,二元类型为{td.PayoffType}时]高障碍价格 必须填写");
|
|
}
|
|
|
|
//高障碍价格BarrierHigh
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// 观察方式
|
|
//---------------------------------------------
|
|
if (string.IsNullOrWhiteSpace(td.MonitorType))
|
|
{
|
|
td.MonitorType = "离散";
|
|
}
|
|
else if (td.MonitorType != "离散" && td.MonitorType != "连续")
|
|
{
|
|
throw new ServiceException("[二元期权]观察方式 填写错误,当前支持的类型为：离散、连续,请求值为:" + td.MonitorType);
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// 补偿支付方式
|
|
//---------------------------------------------
|
|
if (string.IsNullOrWhiteSpace(td.RebateType))
|
|
{
|
|
td.RebateType = "AtHit";
|
|
}
|
|
else if (td.RebateType != "AtHit" && td.RebateType != "AtEnd")
|
|
{
|
|
throw new ServiceException("[二元期权]补偿支付方式 填写错误,当前支持的类型为：AtHit、AtEnd,请求值为:" + td.RebateType);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
td.MonitorType = "";
|
|
td.RebateType = "";
|
|
}
|
|
}
|
|
|
|
//亚式期权
|
|
private void CheckAisanTrade(OtcOptionTradeFull td)
|
|
{
|
|
if (!td.AveragingPeriodStartDate.HasValue)
|
|
{
|
|
td.AveragingPeriodStartDate = td.TradeDate.Value;
|
|
}
|
|
else if (td.AveragingPeriodStartDate.Value < td.TradeDate.Value || td.AveragingPeriodStartDate >= td.ExerciseDate.Value)
|
|
{
|
|
throw new ServiceException("[亚式期权]均价起算日 必须在交易开始日和到期日之间");
|
|
}
|
|
|
|
switch (td.PayoffType)
|
|
{
|
|
default:
|
|
if (!string.IsNullOrWhiteSpace(td.PayoffType))
|
|
{
|
|
throw new ServiceException("[亚式期权]均价计算方式 不支持:" + td.PayoffType);
|
|
}
|
|
td.PayoffType = td.StrikeType == "Segmented" ? "EnhancedArithmeticAverage" : "ArithmeticAverage";
|
|
break;
|
|
case "ArithmeticAverage":
|
|
case "GeometricAverage":
|
|
case "DiscreteArithmeticAverage":
|
|
case "EnhancedArithmeticAverage":
|
|
break;
|
|
}
|
|
|
|
switch (td.StrikeType)
|
|
{
|
|
default:
|
|
if (!string.IsNullOrWhiteSpace(td.StrikeType))
|
|
{
|
|
throw new ServiceException("[亚式期权]行权价类型 不支持:" + td.StrikeType);
|
|
}
|
|
td.StrikeType = "Fixed";
|
|
break;
|
|
case "Fixed":
|
|
break;
|
|
case "Segmented":
|
|
if (td.PayoffType != "EnhancedArithmeticAverage")
|
|
{
|
|
throw new ServiceException("[亚式期权]行权价类型为'分段式'时,均价计算类型只支持'增强算术平均'");
|
|
}
|
|
break;
|
|
case "Floating":
|
|
td.Strike = null;
|
|
break;
|
|
}
|
|
|
|
if (!td.StrikeGearingFactor.HasValue)
|
|
{
|
|
td.StrikeGearingFactor = 1;
|
|
}
|
|
else if (td.StrikeGearingFactor < 0)
|
|
{
|
|
throw new ServiceException("[亚式期权]杠杆率 必须大于等于0");
|
|
}
|
|
}
|
|
|
|
//双鲨期权
|
|
private void CheckDoubleSharkTrade(OtcOptionTradeFull td)
|
|
{
|
|
//BarrierLow 障碍价格,BarrierHigh 高障碍价格
|
|
|
|
if (!td.BarrierHigh.HasValue)
|
|
{
|
|
throw new ServiceException("[双鲨期权]高障碍价格 必须填写");
|
|
}
|
|
|
|
if (td.BarrierHigh <= td.BarrierLow)
|
|
{
|
|
throw new ServiceException("[双鲨期权]高障碍价格 必须大于障碍价格");
|
|
}
|
|
|
|
//补偿金额+高障碍补偿金额(根据权利金数据格式进行处理)
|
|
if (td.IsUsePremiumRate == true)
|
|
{
|
|
td.Rebate = 0;
|
|
td.RebateHigh = 0;
|
|
}
|
|
else
|
|
{
|
|
td.RebateRate = 0;
|
|
td.RebateHighRate = 0;
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// 观察方式
|
|
//---------------------------------------------
|
|
if (string.IsNullOrWhiteSpace(td.MonitorType))
|
|
{
|
|
td.MonitorType = "离散";
|
|
}
|
|
else if (td.MonitorType != "离散" && td.MonitorType != "连续")
|
|
{
|
|
throw new ServiceException("[双鲨期权]观察方式 填写错误,当前支持的类型为：离散、连续,请求值为:" + td.MonitorType);
|
|
}
|
|
|
|
//---------------------------------------------
|
|
// 补偿支付方式
|
|
//---------------------------------------------
|
|
if (string.IsNullOrWhiteSpace(td.RebateType))
|
|
{
|
|
td.RebateType = "AtHit";
|
|
}
|
|
else if (td.RebateType != "AtHit" && td.RebateType != "AtEnd")
|
|
{
|
|
throw new ServiceException("[双鲨期权]补偿支付方式 填写错误,当前支持的类型为：AtHit、AtEnd,请求值为:" + td.RebateType);
|
|
}
|
|
}
|
|
|
|
//区间累积期权
|
|
private void CheckRangeAccTrade(OtcOptionTradeFull td)
|
|
{
|
|
//区间下限 LowerRange,区间上限 UpperRange
|
|
|
|
if (td.UpperRange < td.LowerRange)
|
|
{
|
|
throw new ServiceException("[区间累积期权]区间下限 必须小于 区间上限");
|
|
}
|
|
|
|
if (td.BonusRate < 0)
|
|
{
|
|
throw new ServiceException("[区间累积期权]区间收益 必须大于等于0");
|
|
}
|
|
}
|
|
|
|
//凤凰期权
|
|
private void CheckAutoCallTrade(OtcOptionTradeFull td)
|
|
{
|
|
//敲出障碍价格 KOBarrier,敲入障碍价格:KIBarrier,派息障碍价格 CouponBarrier
|
|
//敲入期权行权价2 SpreadStrike,敲入期权行权价1 SpreadStrike1
|
|
|
|
if (td.Coupon < 0)
|
|
{
|
|
throw new ServiceException("[凤凰期权]票息/敲出补偿 必须大于等于0");
|
|
}
|
|
}
|
|
|
|
//雪球期权
|
|
private void CheckSnowballTrade(OtcOptionTradeFull td)
|
|
{
|
|
if (td.KORebate < 0)
|
|
{
|
|
throw new ServiceException("[雪球期权]票息/敲出补偿 必须大于等于0");
|
|
}
|
|
|
|
if (td.Coupon < 0)
|
|
{
|
|
throw new ServiceException("[雪球期权]未敲出补偿 必须大于等于0");
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(td.KOObservationDates) && !td.KOObservationDates.All(n => n == ';') && !td.KOObservationDates.Contains(td.ExerciseDate.Value.ToString("yyyy-MM-dd")))
|
|
{
|
|
//throw new ServiceException($"[雪球期权]敲出观察频率 必须包含到期日({td.ExerciseDate.Value:yyyy-MM-dd})");
|
|
throw new ServiceException($"[雪球期权]到期日和最后一个敲出观察日不一致，请修改敲出观察日列表");
|
|
}
|
|
}
|
|
|
|
//气囊结构
|
|
private void CheckAirbagTrade(OtcOptionTradeFull td)
|
|
{
|
|
//敲入参与率
|
|
if (td.KIParticipationRate < 0)
|
|
{
|
|
throw new ServiceException("[气囊结构]敲入参与率 必须大于等于0");
|
|
}
|
|
|
|
//障碍价格 BarrierLow,收益封顶价格 HighStrike
|
|
}
|
|
|
|
//收益增强结构
|
|
private void CheckUnderlyigEnhanceTrade(OtcOptionTradeFull td)
|
|
{
|
|
if (td.AnnualizedEnhanceRate < 0)
|
|
{
|
|
throw new ServiceException("[收益增强结构]年化增强收益 必须大于等于0");
|
|
}
|
|
}
|
|
|
|
//累计期权
|
|
private void CheckAccumulatorTrade(OtcOptionTradeFull td)
|
|
{
|
|
|
|
switch (td.PayoffType)
|
|
{
|
|
default:
|
|
if (!string.IsNullOrWhiteSpace(td.PayoffType))
|
|
{
|
|
throw new ServiceException("[累计期权]上端收益类型 不支持:" + td.PayoffType);
|
|
}
|
|
td.PayoffType = "浮动";
|
|
break;
|
|
case "固定":
|
|
case "浮动": break;
|
|
}
|
|
|
|
switch (td.SettlementMode)
|
|
{
|
|
default:
|
|
if (!string.IsNullOrWhiteSpace(td.SettlementMode))
|
|
{
|
|
throw new ServiceException("[累计期权]结算方式 不支持:" + td.SettlementMode);
|
|
}
|
|
td.SettlementMode = "现金当日";
|
|
break;
|
|
case "现金当日":
|
|
case "现金期末":
|
|
case "实物交割":
|
|
case "现金实物合并结算":
|
|
break;
|
|
case "现金结算(当日)":
|
|
td.SettlementMode = "现金当日"; break;
|
|
case "现金结算(期末)":
|
|
td.SettlementMode = "现金期末"; break;
|
|
}
|
|
|
|
if (string.IsNullOrWhiteSpace(td.CouponDayCount))
|
|
{
|
|
td.CouponDayCount = "Act365";
|
|
}
|
|
else
|
|
{
|
|
var daycounts = Enum.GetNames(typeof(Qdp.Pricing.Base.Enums.DayCount));
|
|
if (!daycounts.Any(n => n.Equals(td.CouponDayCount, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
throw new ServiceException("[累计期权]票息日历规则 不支持:" + td.CouponDayCount);
|
|
}
|
|
}
|
|
if (td.AccumulatorStructureType== AccumulatorStructureTypeEnum.Segmented)
|
|
{
|
|
switch (td.SettlementMode2)
|
|
{
|
|
default:
|
|
if (!string.IsNullOrWhiteSpace(td.SettlementMode2))
|
|
{
|
|
throw new ServiceException("[累计期权]结算方式 不支持:" + td.SettlementMode2);
|
|
}
|
|
td.SettlementMode2 = "现金当日";
|
|
break;
|
|
case "现金当日":
|
|
case "现金期末":
|
|
case "实物交割": break;
|
|
case "现金实物合并结算":
|
|
break;
|
|
case "现金结算(当日)":
|
|
td.SettlementMode2 = "现金当日"; break;
|
|
}
|
|
|
|
switch (td.SettlementMode3)
|
|
{
|
|
default:
|
|
if (!string.IsNullOrWhiteSpace(td.SettlementMode3))
|
|
{
|
|
throw new ServiceException("[累计期权]结算方式 不支持:" + td.SettlementMode3);
|
|
}
|
|
td.SettlementMode3 = "现金当日";
|
|
break;
|
|
case "现金当日":
|
|
case "现金期末":
|
|
case "实物交割": break;
|
|
case "现金实物合并结算":
|
|
break;
|
|
case "现金结算(当日)":
|
|
td.SettlementMode3 = "现金当日"; break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//Risky期权
|
|
private void CheckRiskyTrade(OtcOptionTradeFull td)
|
|
{
|
|
if (td.Strike1 == null)
|
|
{
|
|
throw new ServiceException("[Risky期权]执行价格1 必须填写");
|
|
}
|
|
if (td.Strike2 == null)
|
|
{
|
|
throw new ServiceException("[Risky期权]执行价格2 必须填写");
|
|
}
|
|
if (td.Strike3 == null)
|
|
{
|
|
throw new ServiceException("[Risky期权]执行价格3 必须填写");
|
|
}
|
|
if (td.ParticipationRate1 == null)
|
|
{
|
|
throw new ServiceException("[Risky期权]参与率1 必须填写");
|
|
}
|
|
if (td.ParticipationRate2 == null)
|
|
{
|
|
throw new ServiceException("[Risky期权]参与率2 必须填写");
|
|
}
|
|
if (td.ParticipationRate3 == null)
|
|
{
|
|
throw new ServiceException("[Risky期权]参与率3 必须填写");
|
|
}
|
|
if (td.Strike1 > td.Strike2)
|
|
{
|
|
throw new ServiceException("[Risky期权]执行价格1 必须小于等于执行价格2");
|
|
}
|
|
if (td.Strike2 > td.Strike3)
|
|
{
|
|
throw new ServiceException("[Risky期权]执行价格2 必须小于等于执行价格3");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 为了解决导入时某些可用null类型判断的属性被人为设定成必然不为null，比如TradePrice
|
|
/// </summary>
|
|
enum OtcOptionTradeFullHasFlag
|
|
{
|
|
None = 0,
|
|
|
|
PremiumRate = 1 << 0,
|
|
|
|
TradeSinglePrice = 1 << 1,
|
|
|
|
TradePrice = 1 << 2
|
|
}
|
|
|
|
/// <summary>
|
|
/// 场外期权全量(API和导入用到)
|
|
/// </summary>
|
|
public class OtcOptionTradeFullEx : OtcOptionTradeFull
|
|
{
|
|
/// <summary>
|
|
/// 是否更新已有数据
|
|
/// </summary>
|
|
public bool _Update { get; set; }
|
|
|
|
/// <summary>
|
|
/// 了结信息
|
|
/// </summary>
|
|
public TradeCloseRequestModel CloseRequest { get; set; }
|
|
|
|
/// <summary>
|
|
/// 组合标的价格列表
|
|
/// </summary>
|
|
public IEnumerable<UnderlyingPriceModel> SyntheticPrices { get; set; }
|
|
|
|
/// <summary>
|
|
/// HasFlag
|
|
/// </summary>
|
|
internal OtcOptionTradeFullHasFlag HasFlag { get; set; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// 组合交易下单请求
|
|
/// </summary>
|
|
public class StructureOrderRequest
|
|
{
|
|
public string StructureType { get; set; }
|
|
|
|
public IEnumerable<OtcOptionTradeFullEx> Trades { get; set; }
|
|
}
|
|
}
|
|
|
|
//if (td.IsUsePremiumRate == true)
|
|
//{
|
|
// td.StockEqvNotionalMax = TradeHelper.GetStockEqvNotionalReal(td.StockEqvNotional, td.ParticipationRate, td.AnnualizeFactor);
|
|
//}
|
|
//else
|
|
//{
|
|
// td.StockEqvNotionalReal = spotPrice * td.Notional;
|
|
// td.StockEqvNotional = TradeHelper.GetStockEqvNotional(td.StockEqvNotionalReal, td.ParticipationRate, td.AnnualizeFactor);
|
|
//} |