private List <DataSeries> GetChartByDataset(string projectGuid, string paymentDay, Func <PaymentDetail, double> selector)
{
var project = m_dbAdapter.Project.GetProjectByGuid(projectGuid);
var datasets = m_dbAdapter.Dataset.GetDatasetByProjectId(project.ProjectId);
var subDatasets = datasets.Where(x => x.PaymentDate.HasValue && x.PaymentDate.Value.ToString("yyyyMMdd") == paymentDay).ToList();
CommUtils.AssertEquals(subDatasets.Count, 1, "加载Dataset (project=" + project.Name + ", paymentDay=" + paymentDay + ") 失败");
var dataset = subDatasets.Single();
var notes = m_dbAdapter.Dataset.GetNotes(project.ProjectId);
var cnabsNotes = new ProjectLogicModel(CurrentUserName, project).Notes;
var noteDict = Toolkit.GetNoteDictionary(project, notes, cnabsNotes);
var noteInfos = notes.ConvertAll(x => noteDict[x.NoteId]);
//Load dataset info
var dealSchedule = NancyUtils.GetDealSchedule(project.ProjectId);
var noteDatas = m_dbAdapter.Dataset.GetNoteDatas(dataset.DatasetId);
var datasetViewModel = Toolkit.GetDatasetViewModel(dataset, dealSchedule.PaymentDates, noteDict, noteDatas);
var dataSeriesList = new List <DataSeries>();
foreach (var noteData in datasetViewModel.NoteDatas)
{
var ds = new DataSeries();
ds.name = noteData.NoteInfo.Name;
ds.data = new List <Vector>();
ds.data.Add(new Vector(selector(noteData.PaymentDetail)));
dataSeriesList.Add(ds);
}
return(dataSeriesList);
}
public ActionResult Index(string projectGuid, string paymentDay)
{
var projectLogicModel = new ProjectLogicModel(CurrentUserName, projectGuid);
var project = projectLogicModel.Instance;
var datasetSchedule = projectLogicModel.DealSchedule.GetByPaymentDay(DateUtils.ParseDigitDate(paymentDay));
CommUtils.AssertNotNull(datasetSchedule.Dataset.Instance,
"Dataset数据加载失败，projectGuid=[" + projectGuid + "] paymentDay=[" + paymentDay + "]");
var dataset = datasetSchedule.Dataset.Instance;
var notes = m_dbAdapter.Dataset.GetNotes(project.ProjectId);
var cnabsNotes = projectLogicModel.Notes;
var noteDict = Toolkit.GetNoteDictionary(project, notes, cnabsNotes);
var dealSchedule = NancyUtils.GetDealSchedule(project.ProjectId);
var noteDatas = m_dbAdapter.Dataset.GetNoteDatas(dataset.DatasetId);
var datasetViewModel = Toolkit.GetDatasetViewModel(dataset, dealSchedule.PaymentDates, noteDict, noteDatas);
var datasetFolder = m_dbAdapter.Dataset.GetDatasetFolder(project, dataset.AsOfDate);
VariablesHelper helper = new VariablesHelper(datasetFolder);
var variables = helper.GetVariablesByDate(dataset.PaymentDate.Value);
var rateResetRecords = InterestRateUtils.RateResetRecords(variables);
//计算当期浮动利率
datasetViewModel.NoteDatas.ForEach(x => x.CurrentCouponRate = InterestRateUtils.CalculateCurrentCouponRate(x.NoteInfo.CouponString, rateResetRecords));
var viewModel = new CashflowDatasetViewModel();
viewModel.Dataset = datasetViewModel;
viewModel.ProjectGuid = projectGuid;
//添加今天之前所有已上传模型的支付日
var nowDate = DateTime.Today;
viewModel.ValidPaymentDays = datasetSchedule.SelectPaymentDates(
x => x.PaymentDate <= nowDate &&
x.Dataset != null && x.Dataset.Instance != null);
if (project.CnabsDealId.HasValue)
{
viewModel.AllPaymentDays = m_dbAdapter.Model.GetPaymentDates(project.CnabsDealId.Value);
}
else
{
if (projectLogicModel.DealSchedule.Instanse != null)
{
viewModel.AllPaymentDays = projectLogicModel.DealSchedule.Instanse.PaymentDates.ToList();
}
else
{
viewModel.AllPaymentDays = new List <DateTime>();
}
}
return(View(viewModel));
}
private void Run(double cdr, double cpr, AssetOverrideSetting assetOverrideSetting = null)
{
var folderInfo = CopyTemporaryModel();
m_staticAnalysisResult = NancyUtils.RunStaticResultByPath(cdr.ToString(), cpr.ToString(),
folderInfo.YmlFolder, folderInfo.DsFolder, assetOverrideSetting);
ParallelUtils.Start(() => Directory.Delete(folderInfo.YmlFolder, true));
}
public void Load(int projectId, DateTime asOfDate)
{
var project = m_dbAdapter.Project.GetProjectById(projectId);
var dealSchedule = NancyUtils.GetDealSchedule(projectId, asOfDate.ToString("yyyyMMdd"));
m_dealSchedule = dealSchedule;
var errorMsg = "Search payment date/as of date failed, projectGuid=[" + project.ProjectGuid + "] asOfDate=[" + asOfDate.ToString() + "]";
CommUtils.Assert(dealSchedule.DeterminationDates != null && dealSchedule.DeterminationDates.Length > 0, errorMsg);
CommUtils.Assert(dealSchedule.PaymentDates != null && dealSchedule.PaymentDates.Length > 0, errorMsg);
CommUtils.Assert(dealSchedule.DeterminationDates.Length == dealSchedule.PaymentDates.Length, errorMsg);
CommUtils.Assert(asOfDate < dealSchedule.LegalMaturity, errorMsg);
var asOfDateList = dealSchedule.DeterminationDates.ToList();
asOfDateList.Insert(0, dealSchedule.FirstCollectionPeriodStartDate);
asOfDateList.RemoveAt(asOfDateList.Count - 1);
var paymentDateList = dealSchedule.PaymentDates.ToList();
var projectLogicModel = new ProjectLogicModel(m_userName, project);
var findPaymentDates = projectLogicModel.DealSchedule.DurationPeriods
.Where(x => x.Dataset != null && x.Dataset.Instance != null &&
DateUtils.ParseDigitDate(x.Dataset.Instance.AsOfDate) == asOfDate)
.Select(x => x.Dataset.Instance.PaymentDate);
CommUtils.AssertEquals(findPaymentDates.Count(), 1, "查找PaymentDay失败，AsOfDate={0}", asOfDate);
m_paymentDay = findPaymentDates.Single().Value;
var index = paymentDateList.IndexOf(m_paymentDay);
CommUtils.Assert(index >= 0, errorMsg);
m_asOfDay = asOfDate;
if (index == 0)
{
m_previousPaymentDay = paymentDateList[0];
}
else
{
m_previousPaymentDay = paymentDateList[index - 1];
}
if (index == paymentDateList.Count - 1)
{
m_nextAsOfDay = null;
m_nextPaymentDay = null;
}
else
{
m_nextAsOfDay = asOfDateList[index + 1];
m_nextPaymentDay = paymentDateList[index + 1];
}
m_isInitialized = true;
}
public ActionResult GetAmortizationByAsset(string projectGuid, string paymentDate, int assetId)
{
return(ActionUtils.Json(() =>
{
var project = new ProjectLogicModel(CurrentUserName, projectGuid);
var dataset = project.DealSchedule.GetByPaymentDay(DateUtils.ParseDigitDate(paymentDate)).Dataset;
var asset = dataset.Assets.Single(x => x.AssetId == assetId);
if (asset.AmortizationType == AmortizationType.UserDefined)
{
var records = dataset.AmortizationSchedule.SelectByAsset(assetId);
var viewModel = new PrepayRecordListViewModel(dataset.DatasetSchedule, records);
viewModel.AsOfDateBegin = dataset.DatasetSchedule.AsOfDateBegin;
viewModel.AsOfDateEnd = dataset.DatasetSchedule.AsOfDateEnd;
return ActionUtils.Success(viewModel);
}
else if (IsEqualPmtOrEqualPrin(asset.AmortizationType))
{
if (IsEqualPmtOrEqualPrin(asset.SecurityData.PaymentMethod))
{
//当期的偿付类型是EqualPmt/EqualPrin
//返回值为系统根据EqualPmt/EqualPrin测算出的本金
var basicAnalyticsData = NancyUtils.GetBasicAnalyticsData(project.Instance.ProjectId, null, dataset.Instance.AsOfDate);
var assetCashflow = basicAnalyticsData.BasicAssetCashflow.BasicAssetCashflowItems.SelectByAsset(assetId);
var viewModel = new PrepayRecordListViewModel(dataset.DatasetSchedule, assetCashflow);
return ActionUtils.Success(viewModel);
}
else
{
//已经发生了提前偿付，后几期的偿付类型是EqualPmt/EqualPrin
//返回值为提前偿付+系统根据EqualPmt/EqualPrin测算出的本金
var records = dataset.AmortizationSchedule.SelectByAsset(assetId);
var viewModel = new PrepayRecordListViewModel(dataset.DatasetSchedule, records);
var nextDatasetBasicAnalyticsData = NancyUtils.GetBasicAnalyticsData(project.Instance.ProjectId, null, dataset.DatasetSchedule.Next.AsOfDateBegin);
var nextAssetCashflowItems = nextDatasetBasicAnalyticsData.BasicAssetCashflow.BasicAssetCashflowItems
.SelectByAsset(assetId).Where(x => x.PaymentDate > dataset.DatasetSchedule.PaymentDate);
viewModel.AddRange(nextAssetCashflowItems);
return ActionUtils.Success(viewModel);
}
}
else if (asset.AmortizationType == AmortizationType.SingleAmortization)
{
var records = dataset.AmortizationSchedule.SelectByAsset(assetId);
var sumPrepayMoney = records.Sum(x => x.ReductionAmount);
var viewModel = new PrepayRecordListViewModel(dataset.DatasetSchedule, records);
viewModel.Add(assetId, asset.SecurityData.PrincipalBalance - sumPrepayMoney, project.DealSchedule.LegalMaturity);
return ActionUtils.Success(viewModel);
}
return ActionUtils.Failure("无法识别的偿付类型，projectGuid=["
+ projectGuid + "] + paymentDate=[" + paymentDate + "] + assetId=[" + assetId + "]");
}));
}
public static NancyDealInfo GetNancyDealData(ABSDeal absDeal)
{
using (StreamReader sr = new StreamReader(absDeal.Location.Yml))
{
var dateFromYml = NancyUtils.ReadYmlExInfo(sr);
var info = NancyUtils.GetNancyDealDataByFile(sr.BaseStream);
info.UseCustomCashflow = dateFromYml.Item2;
return(new NancyDealInfo
{
Info = info,
FirstCollectionPeriodStartDate = dateFromYml.Item1,
UseCustomCashflow = dateFromYml.Item2,
});
}
}
private List <AssetDatasetViewModel> GetAssetCashflow(int projectId, DateTime[] paymentDates, List <DateTime> allPaymentDays)
{
var project = m_dbAdapter.Project.GetProjectById(projectId);
var nowDate = DateTime.Today;
List <AssetDatasetViewModel> viewModel = new List <AssetDatasetViewModel>();
foreach (var paymentDate in paymentDates)
{
var dataset = m_dbAdapter.Dataset.GetDataset(projectId, paymentDate);
if (dataset == null)
{
continue;
}
var basicAnalyticsData = NancyUtils.GetBasicAnalyticsData(projectId, null, dataset.AsOfDate);
AssetDatasetViewModel assetViewModel = new AssetDatasetViewModel();
assetViewModel.Assets = new List <AssetViewModel>();
var assetItems = basicAnalyticsData.BasicAssetCashflow.BasicAssetCashflowItems.Where(x => x.PaymentDate == paymentDate);
foreach (var assetItem in assetItems)
{
assetViewModel.Assets.Add(new AssetViewModel
{
AssetId = assetItem.AssetId,
Interest = (decimal)assetItem.Interest,
Principal = (decimal)assetItem.Principal,
Name = assetItem.AssetId.ToString()
});
}
assetViewModel.PaymentDay = paymentDate;
assetViewModel.ReCalculateSumAsset();
assetViewModel.Sequence = CommUtils.GetSequence(allPaymentDays, paymentDate);
viewModel.Add(assetViewModel);
if (paymentDate >= nowDate)
{
break;
}
}
return(viewModel);
}
public void LoadAssetCashflowInfo()
{
var basicAnalyticsData = NancyUtils.GetBasicAnalyticsData(m_project.Instance.ProjectId, null, m_instance.AsOfDate);
var assetItems = basicAnalyticsData.BasicAssetCashflow.BasicAssetCashflowItems.Where(x => x.PaymentDate == DatasetSchedule.PaymentDate);
foreach (var assetItem in assetItems)
{
var findAssets = Assets.Where(x => x.SecurityData.AssetId == assetItem.AssetId).ToList();
if (findAssets.Count > 1)
{
CommUtils.Assert(false, "找到了重复的AssetId[{0}]", assetItem.AssetId);
}
var findAsset = findAssets.SingleOrDefault();
findAsset.BasicAsset = assetItem;
}
}
public List <AmortizationRecord> LoadAmortizationRecords()
{
List <AmortizationRecord> amortizationRecords = null;
var asset = m_assetLogicModel;
if (asset.AmortizationType == AmortizationType.UserDefined)
{
var records = asset.Dataset.AmortizationSchedule.SelectByAsset(asset.AssetId);
amortizationRecords = records.Select(x => new AmortizationRecord {
AssetId = x.AssetId,
Date = x.ReductionDate,
Money = x.ReductionAmount,
}).ToList();
}
else if (asset.IsEqualPmtOrEqualPrin)
{
var basicAnalyticsData = NancyUtils.GetBasicAnalyticsData(ProjectLogicModel.Instance.ProjectId, null, asset.Dataset.Instance.AsOfDate);
var records = basicAnalyticsData.BasicAssetCashflow.BasicAssetCashflowItems.SelectByAsset(asset.AssetId);
amortizationRecords = records.Select(x => new AmortizationRecord {
AssetId = x.AssetId,
Date = x.PaymentDate,
Money = x.Principal
}).ToList();
}
else if (asset.AmortizationType == AmortizationType.SingleAmortization)
{
var records = asset.Dataset.AmortizationSchedule.SelectByAsset(asset.AssetId);
var sumPrepayMoney = records.Sum(x => x.ReductionAmount);
amortizationRecords = new List <AmortizationRecord> {
new AmortizationRecord {
AssetId = asset.AssetId,
Date = asset.SecurityData.LegalMaturityDate,
Money = asset.SecurityData.PrincipalBalance,
}
};
}
CommUtils.AssertNotNull(amortizationRecords, "不支持的 AmortizationType");
amortizationRecords = amortizationRecords.Where(x => MathUtils.MoneyNE(x.Money, 0))
.OrderBy(x => x.Date).ToList();
return(amortizationRecords);
}
private decimal GetFee(string feeName)
{
//var dsVariables = NancyUtils.GetOverridableVariables(m_project.ProjectId);
var logicModel = new ProjectLogicModel(m_userName, m_project.ProjectId);
var dataset = logicModel.DealSchedule.GetByPaymentDay(m_paymentDay).Dataset;
NancyStaticAnalysisResult results = NancyUtils.GetStaticAnalyticsResult(m_project.ProjectId,
null, dataset.Instance.AsOfDate, dataset.AssetOverrideSetting);
var cfTable = results.CashflowDt;
int columnIndex = -1;
for (int i = 0; i < cfTable.Columns.Count; ++i)
{
DateTime columnDate;
if (DateTime.TryParse(cfTable.Columns[i].ColumnName, out columnDate) &&
m_paymentDay == columnDate)
{
columnIndex = i;
break;
}
}
CommUtils.Assert(columnIndex >= 0, "找不到对应支付日[" + m_paymentDay.ToString() + "]的数据");
for (int i = 0; i < cfTable.Rows.Count; ++i)
{
var row = cfTable.Rows[i];
if (row.ItemArray[1].Equals(feeName))
{
return(decimal.Parse(row.ItemArray[columnIndex].ToString()));
}
}
throw new ApplicationException("Can't find [" + feeName + "].");
}
public static DataTable GetCashflowDt(DatasetScheduleLogicModel datasetSchedule,
AssetCashflowVariable assetCashflowVariable,
double sysPredictInterest, double sysPredictPrincipal,
out double currInterestCollection, out double currPrincipalCollection)
{
currInterestCollection = sysPredictInterest;
currPrincipalCollection = sysPredictPrincipal;
var assetOverrideSetting = new AssetOverrideSetting(assetCashflowVariable);
DataTable cashflowDt = new DataTable();
var project = datasetSchedule.ProjectLogicModel.Instance;
var dataset = datasetSchedule.Dataset.Instance;
var paymentDate = datasetSchedule.PaymentDate;
var hasOsa = false;
var osa = datasetSchedule.Dataset.DealModel.OverrideSingleAsset;
foreach (var asset in datasetSchedule.Dataset.Assets)
{
var overridePrincipal = osa.GetPrincipal(asset.AssetId);
var overrideInterest = osa.GetInterest(asset.AssetId);
if (overridePrincipal != null || overrideInterest != null)
{
hasOsa = true;
break;
}
}
//测算优先级：
//1、覆盖现金流测算
//2、单笔资产覆盖的方式测算
//3、系统测算
//未填写覆盖现金流值，或填写值和系统测算值一致，认为是不使用本息覆盖现金流测算
var hasOverrideCashflow = assetCashflowVariable != null &&
assetCashflowVariable.EnableOverride;
if (hasOverrideCashflow)
{
//使用覆盖现金流的方式测算
cashflowDt = NancyUtils.GetStaticAnalyticsResult(project.ProjectId, null, dataset.AsOfDate, assetOverrideSetting).CashflowDt;
currInterestCollection = assetOverrideSetting.Interest;
currPrincipalCollection = assetOverrideSetting.Principal;
}
else
{
if (hasOsa)
{
//未填写覆盖现金流参数，已填写单笔资产覆盖
//重新计算本息，使用覆盖现金流的方式测算
var dealModel = datasetSchedule.Dataset.DealModel;
var absDeal = new ABSDeal(dealModel.YmlFolder, dealModel.DsFolder);
var acfResult = absDeal.Result.AcfResult;
var acfDataset = acfResult.Dataset.SingleOrDefault(x => x.PaymentDay == paymentDate);
acfResult.MergeOsa(osa);
acfResult.ReCalcSum();
var sumPrincipal = double.Parse(acfDataset.Sum.Principal.ToString("n2"));
var sumInterest = double.Parse(acfDataset.Sum.Interest.ToString("n2"));
assetOverrideSetting.IsOverride = true;
assetOverrideSetting.Principal = sumPrincipal;
assetOverrideSetting.Interest = sumInterest;
assetOverrideSetting.PaymentDate = paymentDate;
cashflowDt = NancyUtils.GetStaticAnalyticsResult(project.ProjectId, null, dataset.AsOfDate, assetOverrideSetting).CashflowDt;
currInterestCollection = assetOverrideSetting.Interest;
currPrincipalCollection = assetOverrideSetting.Principal;
}
else
{
//未填写覆盖现金流参数，且未填写单笔资产覆盖
//使用非覆盖现金流的方式测算
cashflowDt = NancyUtils.GetStaticAnalyticsResult(project.ProjectId, null, dataset.AsOfDate).CashflowDt;
}
}
return(cashflowDt);
}
public Page <Project> GetProjects(long pageNum, long itemsPerPage, bool isLoadDealInfo, List <int> authorizedProjectIds)
{
if (authorizedProjectIds.Count == 0)
{
return(new Page <Project>
{
Items = new List <Project>()
});
}
var sqlCondition = "(" + string.Join(", ", authorizedProjectIds.ConvertAll(x => x.ToString())) + ")";
var page = m_db.Page <ABSMgrConn.TableProject>(pageNum, itemsPerPage,
"SELECT * FROM dbo.Project WHERE project_id IN "
+ sqlCondition + " AND record_status_id <> @0" + m_orderBy, (int)RecordStatus.Deleted);
var projects = new Page <Project>().Parse(page);
projects.Items = page.Items.ConvertAll(item => new Project(item));
if (isLoadDealInfo)
{
if (projects.Items.Any(x => x.CnabsDealId.HasValue))
{
var vwProjects = m_db.Fetch <ABSMgrConn.VwProject>(
"SELECT * FROM dbo.vw_project WHERE project_id IN (@authorizedProjectIds)" + m_orderBy, new { authorizedProjectIds });
var cnabsDealIds = projects.Items.Where(x => x.CnabsDealId.HasValue).Select(x => x.CnabsDealId);
var vwDeals = m_db.Fetch <ABSMgrConn.VwDeal>(
"SELECT * FROM dbo.vw_deal WHERE deal_id IN (@cnabsDealIds)", new { cnabsDealIds });
var vwPaymentDates = m_db.Fetch <ABSMgrConn.VwPaymentDates>(
"SELECT * FROM " + m_db.ChineseABSDB + "[dbo].[PaymentDates] WHERE deal_id IN (@cnabsDealIds) ORDER BY payment_date", new { cnabsDealIds });
var nowDate = DateTime.Today;
foreach (var project in projects.Items)
{
var vwProject = vwProjects.FirstOrDefault(x => x.project_id == project.ProjectId);
if (vwProject != null)
{
if (vwProject.deal_name_chinese != null || vwProject.issuer != null ||
vwProject.total_offering != null || vwProject.frequency != null)
{
project.ProjectDealInfo = new ProjectDealInfo();
project.ProjectDealInfo.FromTableObject(vwProject);
}
}
//Get deal type
if (project.CnabsDealId.HasValue)
{
var vwDeal = vwDeals.FirstOrDefault(x => x.deal_id == project.CnabsDealId.Value);
if (vwDeal != null)
{
project.DealType = vwDeal.type;
}
var vwPaymentDate = vwPaymentDates
.Where(x => x.deal_id == project.CnabsDealId.Value && x.payment_date.HasValue)
.FirstOrDefault(x => x.payment_date.Value >= nowDate);
if (vwPaymentDate != null)
{
project.NextPaymentDate = vwPaymentDate.payment_date.Value;
}
}
}
}
if (projects.Items.Any(x => !x.CnabsDealId.HasValue))
{
var rootFolder = WebConfigUtils.RootFolder;
foreach (var project in projects.Items)
{
if (project.CnabsDealId.HasValue || project.ModelId <= 0)
{
continue;
}
project.Model = GetModel(project.ModelId);
var modelFolder = Path.Combine(rootFolder, project.Model.ModelFolder);
var ymlFilePath = modelFolder + @"\Script.yml";
if (File.Exists(ymlFilePath))
{
using (StreamReader sr = new StreamReader(ymlFilePath))
{
var nancyDealData = NancyUtils.GetNancyDealDataByFile(sr.BaseStream);
if (nancyDealData != null)
{
project.DealType = nancyDealData.DealTypeString;
project.ProjectDealInfo = new ProjectDealInfo();
project.ProjectDealInfo.Originator = nancyDealData.Originator;
var paymentDates = nancyDealData.ScheduleData.PaymentSchedule.GetPaymentDates();
var nowDate = DateTime.Today;
if (paymentDates.Any(x => x >= nowDate))
{
project.NextPaymentDate = paymentDates.First(x => x >= nowDate);
}
else
{
project.NextPaymentDate = paymentDates.Last();
}
}
}
}
}
}
}
return(projects);
}
private Dictionary <string, string> SaveNoteData(int projectId)
{
var taskPeriod = m_dbAdapter.TaskPeriod.GetByShortCode(this.m_task.ShortCode);
var paymentDate = this.m_task.EndTime.Value;
if (taskPeriod != null)
{
paymentDate = taskPeriod.PaymentDate;
}
var projectLogicModel = new ProjectLogicModel(m_userName, projectId);
var project = projectLogicModel.Instance;
var dataset = m_dbAdapter.Dataset.GetDatasetByDurationPeriod(project.ProjectId, paymentDate);
var results = NancyUtils.GetStaticAnalyticsResult(projectId, null, dataset.AsOfDate);
var cfTable = results.CashflowDt;
Func <string, string> findValue = (key) => {
var rowIndex = cfTable.IndexOfRow(x => x[1].ToString() == key);
if (rowIndex >= 0)
{
return(cfTable.Rows[rowIndex][2].ToString());
}
else
{
return(string.Empty);
}
};
var dict = new Dictionary <string, string>();
dict["Expense.Received"] = findValue("Expense.Received");
dict["Tax.Received"] = findValue("Tax.Received");
var notes = m_dbAdapter.Dataset.GetNotes(project.ProjectId);
var currentDatasetColumnIndex = 2;
for (int i = 0; i < cfTable.Columns.Count; ++i)
{
DateTime temp;
if (DateTime.TryParse(cfTable.Columns[i].ColumnName, out temp) &&
dataset.PaymentDate.Value == temp)
{
currentDatasetColumnIndex = i;
break;
}
}
foreach (var n in notes)
{
var nd = m_dbAdapter.Dataset.GetNoteData((int)n.NoteId, dataset.DatasetId);
var prin = cfTable.AsEnumerable().FirstOrDefault(r => r[1].ToString().Contains(n.ShortName + ".Principal") && r[1].ToString().Contains("Received"))[currentDatasetColumnIndex].ToString();
nd.PrincipalPaid = (decimal)((prin == string.Empty || prin == "-") ? 0.0 : double.Parse(prin));
var interest = cfTable.AsEnumerable().FirstOrDefault(r => r[1].ToString().Contains(n.ShortName + ".Interest") && r[1].ToString().Contains("Received"))[currentDatasetColumnIndex].ToString();
nd.InterestPaid = (decimal)((interest == string.Empty || interest == "-") ? 0.0 : double.Parse(interest));
var end = cfTable.AsEnumerable().FirstOrDefault(r => r[1].ToString().Contains(n.ShortName + ".Beginning") && r[1].ToString().Contains("Outstanding"))[currentDatasetColumnIndex + 1].ToString();
nd.EndingBalance = (decimal)((end == string.Empty || end == "-") ? 0.0 : double.Parse(end));
m_dbAdapter.Dataset.UpdateNoteData(nd);
}
//var nr = m_dbAdapter.Dataset.GetNoteResultByProjectIdAndDatasetId(project.ProjectId, dataset.DatasetId);
//DataTable drResult = results.AssetCashflowDt;
//DataTable drCf = results.CashflowDt;
//nr.NoteResultTable = results.Tables[0];
//nr.NoteCashflowTable = CommUtils.ToJson(drCf);
//m_dbAdapter.Dataset.UpdateNoteResult(nr);
return(dict);
}
protected override object MakeObjectInstance()
{
var book = LoadExcelBook(m_excelFileName, m_excelStream);
List <CellKeyword> keywordList = new List <CellKeyword>();
var collateralInterestCollectionKey = new CellKeyword("收款信息", "收入回收款", "");
keywordList.Add(collateralInterestCollectionKey);
var collateralPrincipalCollectionKey = new CellKeyword("收款信息", "本金回收款", "");
keywordList.Add(collateralPrincipalCollectionKey);
var collateralLossAmountKey = new CellKeyword("违约及严重拖欠信息", "新增违约抵押贷款", "金额");
keywordList.Add(collateralLossAmountKey);
#region Word文档中表格里的字段抓取
var 正常贷款金额 = new CellKeyword("本收款期间资产池贷款状态特征", "正常", "贷款余额");
keywordList.Add(正常贷款金额);
var 正常贷款金额占比 = new CellKeyword("本收款期间资产池贷款状态特征", "正常", "占期末资产池抵押贷款余额百分比");
keywordList.Add(正常贷款金额占比);
var 拖欠31至60天以上贷款金额 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠31至60天", "贷款余额");
keywordList.Add(拖欠31至60天以上贷款金额);
var 拖欠31至60天以上贷款金额占比 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠31至60天", "占期末资产池抵押贷款余额百分比");
keywordList.Add(拖欠31至60天以上贷款金额占比);
var 拖欠61至90天以上贷款金额 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠61至90天", "贷款余额");
keywordList.Add(拖欠61至90天以上贷款金额);
var 拖欠61至90天以上贷款金额占比 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠61至90天", "占期末资产池抵押贷款余额百分比");
keywordList.Add(拖欠61至90天以上贷款金额占比);
var 拖欠91至120天以上贷款金额 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠91至120天", "贷款余额");
keywordList.Add(拖欠91至120天以上贷款金额);
var 拖欠91至120天以上贷款金额占比 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠91至120天", "占期末资产池抵押贷款余额百分比");
keywordList.Add(拖欠91至120天以上贷款金额占比);
var 拖欠121至150天以上贷款金额 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠121至150天", "贷款余额");
keywordList.Add(拖欠121至150天以上贷款金额);
var 拖欠121至150天以上贷款金额占比 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠121至150天", "占期末资产池抵押贷款余额百分比");
keywordList.Add(拖欠121至150天以上贷款金额占比);
var 拖欠151至180天以上贷款金额 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠151至180天", "贷款余额");
keywordList.Add(拖欠151至180天以上贷款金额);
var 拖欠151至180天以上贷款金额占比 = new CellKeyword("本收款期间资产池贷款状态特征", "拖欠151至180天", "占期末资产池抵押贷款余额百分比");
keywordList.Add(拖欠151至180天以上贷款金额占比);
var 违约抵押贷款_未被注销金额 = new CellKeyword("本收款期间资产池贷款状态特征", "违约抵押贷款（未被注销）", "贷款余额");
keywordList.Add(违约抵押贷款_未被注销金额);
var 违约抵押贷款_未被注销占比 = new CellKeyword("本收款期间资产池贷款状态特征", "违约抵押贷款（未被注销）", "占期末资产池抵押贷款余额百分比");
keywordList.Add(违约抵押贷款_未被注销占比);
var 贷款余额_汇总 = new CellKeyword("本收款期间资产池贷款状态特征", "汇总", "贷款余额");
keywordList.Add(贷款余额_汇总);
var 期初本金总余额 = new CellKeyword("资产池存续期总体信息", "入池总金额", "上次报告期");
keywordList.Add(期初本金总余额);
var 期末本金总余额 = new CellKeyword("资产池存续期总体信息", "入池总金额", "本次报告期");
keywordList.Add(期末本金总余额);
var 本期应收本金 = new CellKeyword("资产池存续期总体信息", "", "应收本金");
keywordList.Add(本期应收本金);
var 本期应收利息 = new CellKeyword("资产池存续期总体信息", "", "应收利息");
keywordList.Add(本期应收利息);
var 收入账_利息_正常回收_上次报告期 = new CellKeyword("收款信息", "计划内还款", new[] { "上一收款期", "利息" });
keywordList.Add(收入账_利息_正常回收_上次报告期);
var 收入账_利息_正常回收_本次报告期 = new CellKeyword("收款信息", "计划内还款", new[] { "本收款期", "利息" });
keywordList.Add(收入账_利息_正常回收_本次报告期);
var 收入账_利息_提前偿还_上次报告期 = new CellKeyword("收款信息", "提前还款", new[] { "上一收款期", "利息" });
keywordList.Add(收入账_利息_提前偿还_上次报告期);
var 收入账_利息_提前偿还_本次报告期 = new CellKeyword("收款信息", "提前还款", new[] { "本收款期", "利息" });
keywordList.Add(收入账_利息_提前偿还_本次报告期);
var 收入账_利息_拖欠回收_上次报告期 = new CellKeyword("收款信息", "拖欠回收", new[] { "上一收款期", "利息" });
keywordList.Add(收入账_利息_拖欠回收_上次报告期);
var 收入账_利息_拖欠回收_本次报告期 = new CellKeyword("收款信息", "拖欠回收", new[] { "本收款期", "利息" });
keywordList.Add(收入账_利息_拖欠回收_本次报告期);
var 收入账_利息_违约回收_上次报告期 = new CellKeyword("收款信息", "违约回收", new[] { "上一收款期", "利息" });
keywordList.Add(收入账_利息_违约回收_上次报告期);
var 收入账_利息_违约回收_本次报告期 = new CellKeyword("收款信息", "违约回收", new[] { "本收款期", "利息" });
keywordList.Add(收入账_利息_违约回收_本次报告期);
var 收入账_利息_合计_上次报告期 = new CellKeyword("收款信息", "合计", new[] { "上一收款期", "利息" });
keywordList.Add(收入账_利息_合计_上次报告期);
var 收入账_利息_合计_本次报告期 = new CellKeyword("收款信息", "合计", "利息");
keywordList.Add(收入账_利息_合计_本次报告期);
//var 收入账_其他收入_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(收入账_其他收入_上次报告期);
//var 收入账_其他收入_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(收入账_其他收入_本次报告期);
//var 收入账_上期转存_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(收入账_上期转存_上次报告期);
//var 收入账_上期转存_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(收入账_上期转存_本次报告期);
//var 收入账_合格投资_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(收入账_合格投资_上次报告期);
//var 收入账_合格投资_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(收入账_合格投资_本次报告期);
var 收入账_合计_上次报告期 = new CellKeyword("收款信息", "收入回收款", "上一收款期");
keywordList.Add(收入账_合计_上次报告期);
var 收入账_合计_本次报告期 = new CellKeyword("收款信息", "收入回收款", "");
keywordList.Add(收入账_合计_本次报告期);
var 本金账_本金_正常回收_上次报告期 = new CellKeyword("收款信息", "计划内还款", new[] { "上一收款期", "本金" });
keywordList.Add(本金账_本金_正常回收_上次报告期);
var 本金账_本金_正常回收_本次报告期 = new CellKeyword("收款信息", "计划内还款", new[] { "本收款期", "本金" });
keywordList.Add(本金账_本金_正常回收_本次报告期);
var 本金账_本金_提前偿还_上次报告期 = new CellKeyword("收款信息", "提前还款", new[] { "上一收款期", "本金" });
keywordList.Add(本金账_本金_提前偿还_上次报告期);
var 本金账_本金_提前偿还_本次报告期 = new CellKeyword("收款信息", "提前还款", new[] { "本收款期", "本金" });
keywordList.Add(本金账_本金_提前偿还_本次报告期);
var 本金账_本金_拖欠回收_上次报告期 = new CellKeyword("收款信息", "拖欠回收", new[] { "上一收款期", "本金" });
keywordList.Add(本金账_本金_拖欠回收_上次报告期);
var 本金账_本金_拖欠回收_本次报告期 = new CellKeyword("收款信息", "拖欠回收", new[] { "本收款期", "本金" });
keywordList.Add(本金账_本金_拖欠回收_本次报告期);
var 本金账_本金_违约回收_上次报告期 = new CellKeyword("收款信息", "违约回收", new[] { "上一收款期", "本金" });
keywordList.Add(本金账_本金_违约回收_上次报告期);
var 本金账_本金_违约回收_本次报告期 = new CellKeyword("收款信息", "违约回收", new[] { "本收款期", "本金" });
keywordList.Add(本金账_本金_违约回收_本次报告期);
var 本金账_本金_合计_上次报告期 = new CellKeyword("收款信息", "合计", new[] { "上一收款期", "本金" });
keywordList.Add(本金账_本金_合计_上次报告期);
var 本金账_本金_合计_本次报告期 = new CellKeyword("收款信息", "合计", new[] { "本收款期", "本金" });
keywordList.Add(本金账_本金_合计_本次报告期);
//var 本金账_其他收入_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(本金账_其他收入_上次报告期);
//var 本金账_其他收入_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(本金账_其他收入_本次报告期);
//var 本金账_上期转存_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(本金账_上期转存_上次报告期);
//var 本金账_上期转存_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(本金账_上期转存_本次报告期);
var 本金账_合计_上次报告期 = new CellKeyword("收款信息", "本金回收款", "上一收款期");
keywordList.Add(本金账_合计_上次报告期);
var 本金账_合计_本次报告期 = new CellKeyword("收款信息", "本金回收款", "本收款期");
keywordList.Add(本金账_合计_本次报告期);
//var 收入及本金合计_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(收入及本金合计_上次报告期);
//var 收入及本金合计_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(收入及本金合计_本次报告期);
//var 税收_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(税收_上次报告期);
//var 税收_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(税收_本次报告期);
//var 费用支出_服务总费用支出_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(费用支出_服务总费用支出_上次报告期);
//var 费用支出_服务总费用支出_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(费用支出_服务总费用支出_本次报告期);
//var 费用支出_其他费用支出_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(费用支出_其他费用支出_上次报告期);
//var 费用支出_其他费用支出_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(费用支出_其他费用支出_本次报告期);
//var 证券账户支出_证券利息总支出_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(证券账户支出_证券利息总支出_上次报告期);
//var 证券账户支出_证券利息总支出_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(证券账户支出_证券利息总支出_本次报告期);
//var 证券账户支出_证券本金总支出_上次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(证券账户支出_证券本金总支出_上次报告期);
//var 证券账户支出_证券本金总支出_本次报告期 = new CellKeyword("收款信息", "计划内还款", "利息");
//keywordList.Add(证券账户支出_证券本金总支出_本次报告期);
//var 信托核算日 = new CellKeyword("资产池存续期总体信息", "", "时间111");
//keywordList.Add(信托核算日);
#endregion
var cumlossKey = new CellKeyword("违约及严重拖欠信息", "累计违约时点违约抵押贷款金额", "上一收款期间期末");
keywordList.Add(cumlossKey);
var dictValues = GetCellValues(book, keywordList);
var idrObj = new DemoJianYuanReport();
idrObj.违约抵押贷款在本收款期间期末所处的处置状态 = new PatternTable();
GetPatternTable(book, idrObj.违约抵押贷款在本收款期间期末所处的处置状态,
"违约抵押贷款在本收款期间期末所处的处置状态及抵销权风险监控",
"占初始起算日资产池余额百分比", "汇总");
idrObj.入池资产笔数与金额特征 = new PatternTable();
GetPatternTable(book, idrObj.入池资产笔数与金额特征,
"资产池存续期总体信息",
"单笔贷款平均本金余额", new [] { "1、入池资产笔数与金额特征", "本次报告期" });
idrObj.入池资产的期限特征 = new PatternTable();
GetPatternTable(book, idrObj.入池资产的期限特征,
"资产池存续期总体信息",
"贷款最短到期期限", new [] { "2、入池资产的期限特征", "本次报告期" });
idrObj.入池资产利率特征 = new PatternTable();
GetPatternTable(book, idrObj.入池资产利率特征,
"资产池存续期总体信息",
"最低贷款利率(%)", new [] { "3、入池资产利率特征", "本次报告期" });
var logicModel = new ProjectLogicModel(m_userName, m_project.ProjectId);
var schedule = logicModel.DealSchedule.Instanse;
List <DateTime> paymentDates = schedule.PaymentDates.ToList();
var taskPeriod = m_dbAdapter.TaskPeriod.GetByShortCode(this.m_task.ShortCode);
var paymentDate = m_task.EndTime.Value;
if (taskPeriod != null)
{
paymentDate = taskPeriod.PaymentDate;
}
var datasets = m_dbAdapter.Dataset.GetDatasetByProjectId(m_project.ProjectId);
paymentDate = paymentDates.First(x => x >= paymentDate);
datasets = datasets.Where(x => x.PaymentDate.HasValue && x.PaymentDate.Value <= paymentDate).ToList();
var findDatasets = datasets.Where(x => x.PaymentDate.HasValue && x.PaymentDate.Value == paymentDate).ToList();
findDatasets.Sort((l, r) => l.AsOfDate.CompareTo(r.AsOfDate));
CommUtils.Assert(findDatasets.Count >= 1, "找不到偿付期为 [{0}] 的数据模型", DateUtils.DateToString(paymentDate));
var dataset = findDatasets[0];
var scheduledPaymentDates = paymentDates.Select(x => x).ToList();
var rootFolder = WebConfigUtils.RootFolder;
var project = m_dbAdapter.Project.GetProjectById(logicModel.Instance.ProjectId);
var modelFolder = Path.Combine(rootFolder, project.Model.ModelFolder);
var ymlFilePath = modelFolder + @"\Script.yml";
if (File.Exists(ymlFilePath))
{
using (StreamReader sr = new StreamReader(ymlFilePath))
{
var nancyDealData = NancyUtils.GetNancyDealDataByFile(sr.BaseStream);
if (nancyDealData != null)
{
scheduledPaymentDates = nancyDealData.ScheduleData.PaymentSchedule.GetScheduledPaymentDates().ToList();
}
}
}
var dealScheduleLogicModel = logicModel.DealSchedule.GetByPaymentDay(findDatasets[0].PaymentDate.Value);
var dbAdapter = new DBAdapter();
var datasetFolder = dbAdapter.Dataset.GetDatasetFolder(logicModel.Instance, dataset.AsOfDate);
Func <CellKeyword, double> parseDouble = (x) =>
{
double temp = 0;
CommUtils.Assert(double.TryParse(dictValues[x], out temp), "无法转换{0}-{1}-{2}为数值",
x.TitleName, x.RowName, x.ColumnName);
return(temp);
};
Func <CellKeyword, double> percentParseDouble = (x) =>
{
double temp = 0;
CommUtils.Assert(dictValues[x].Substring(dictValues[x].Length - 1) == "%", "无法转换{0}-{1}-{2}为数值",
x.TitleName, x.RowName, x.ColumnName);
var value = dictValues[x].Substring(0, dictValues[x].Length - 1);
CommUtils.Assert(double.TryParse(value, out temp), "无法转换{0}-{1}-{2}为数值",
x.TitleName, x.RowName, x.ColumnName);
return(temp / 100);
};
//FutureVariables.csv
//Cumloss
//违约及严重拖欠信息
// 累计违约时点违约抵押贷款金额（行） + 上一收款期间期末（列） 16154029.17
//var futureVariablesPath = Path.Combine(datasetFolder, "FutureVariables.csv");
//var futureVariablesCsv = new VariablesCsv();
//futureVariablesCsv.Load(futureVariablesPath);
//double cumloss = parseDouble(cumlossKey);
//futureVariablesCsv.UpdateCellValue("Cumloss", paymentDate, cumloss.ToString());
//futureVariablesCsv.Save();
//CurrentVariables.csv
//Collateral.InterestCollection
//Collateral.PrincipalCollection
//收款信息
// 本金回收款（行） + 下一列 123009207.33
// 收入回收款（行） + 下一列 26277809.43
//Collateral.Loss.Amount
//违约及严重拖欠信息
// 新增违约抵押贷款 （行） + 金额（列） 1834059.79
//var currentVariablesPath = Path.Combine(datasetFolder, "CurrentVariables.csv");
//var currentVariablesCsv = new VariablesCsv();
//currentVariablesCsv.Load(currentVariablesPath);
//double collateralInterestCollection = parseDouble(collateralInterestCollectionKey);
//currentVariablesCsv.UpdateCellValue("Collateral.InterestCollection", paymentDate, collateralInterestCollection.ToString());
//double collateralPrincipalCollection = parseDouble(collateralPrincipalCollectionKey);
//currentVariablesCsv.UpdateCellValue("Collateral.PrincipalCollection", paymentDate, collateralPrincipalCollection.ToString());
//double collateralLossAmount = parseDouble(collateralLossAmountKey);
//currentVariablesCsv.UpdateCellValue("Collateral.Loss.Amount", paymentDate, collateralLossAmount.ToString());
//currentVariablesCsv.Save();
var dict = SaveNoteData(m_project.ProjectId);
idrObj.ExpenseReceived = dict["Expense.Received"];
idrObj.TaxReceived = dict["Tax.Received"];
var maker = new IncomeDistributionReportMaker(m_userName);
idrObj.DistInfo = (IncomeDistributionReport)maker.GetObjInstance(m_task.ProjectId, paymentDate, m_task.EndTime.Value);
//从第N期开始模型数据时，getDealSchedule中不包含前几期的PaymentDate
if (m_project.CnabsDealId.HasValue)
{
paymentDates = m_dbAdapter.Model.GetPaymentDates(m_project.CnabsDealId.Value);
}
idrObj.CurrentYear = idrObj.DistInfo.T.Year;
idrObj.Sequence = idrObj.DistInfo.Sequence;
idrObj.SequenceInYear = paymentDates.Where(x => x.Year == idrObj.CurrentYear)
.Count(x => x <= idrObj.DistInfo.T);
Func <DateTime, DateTime> findScheduledPaymentDate = (date) =>
{
//倒序scheduledPaymentDates 然后再查找
scheduledPaymentDates = scheduledPaymentDates.OrderByDescending(x => x).ToList();
var lastIndex = paymentDates.Count - paymentDates.IndexOf(date) - 1;
CommUtils.Assert(scheduledPaymentDates.Count > lastIndex, "找不到scheduledPaymentDate，scheduledPaymentDates.Count <= lastIndex");
return(scheduledPaymentDates[lastIndex]);
};
idrObj.ScheduledPreviousT = findScheduledPaymentDate(idrObj.DistInfo.PreviousT);
idrObj.ScheduledT = findScheduledPaymentDate(idrObj.DistInfo.T);
idrObj.正常贷款金额 = (decimal)parseDouble(正常贷款金额);
idrObj.正常贷款金额占比 = (decimal)percentParseDouble(正常贷款金额占比);
idrObj.期初本金总余额 = (decimal)parseDouble(期初本金总余额);
idrObj.期末本金总余额 = (decimal)parseDouble(期末本金总余额);
idrObj.本期应收本金 = (decimal)parseDouble(本期应收本金);
idrObj.本期应收利息 = (decimal)parseDouble(本期应收利息);
idrObj.拖欠90天以上贷款金额 = (decimal)parseDouble(拖欠91至120天以上贷款金额)
+ (decimal)parseDouble(拖欠121至150天以上贷款金额)
+ (decimal)parseDouble(拖欠151至180天以上贷款金额)
+ (decimal)parseDouble(违约抵押贷款_未被注销金额);
idrObj.拖欠90天以上贷款金额占比 = idrObj.拖欠90天以上贷款金额 / (decimal)parseDouble(贷款余额_汇总);
idrObj.拖欠60天以上贷款金额 = idrObj.拖欠90天以上贷款金额 + (decimal)parseDouble(拖欠61至90天以上贷款金额);
idrObj.拖欠60天以上贷款金额占比 = idrObj.拖欠60天以上贷款金额 / (decimal)parseDouble(贷款余额_汇总);
//idrObj.拖欠90天以上贷款金额占比 + (decimal)percentParseDouble(拖欠61至90天以上贷款金额占比);
idrObj.拖欠30天以上贷款金额 = idrObj.拖欠60天以上贷款金额 + (decimal)parseDouble(拖欠31至60天以上贷款金额);
idrObj.拖欠30天以上贷款金额占比 = idrObj.拖欠30天以上贷款金额 / (decimal)parseDouble(贷款余额_汇总);
//idrObj.拖欠60天以上贷款金额占比 + (decimal)percentParseDouble(拖欠31至60天以上贷款金额占比);
idrObj.收入账_利息_正常回收_上次报告期 = (decimal)parseDouble(收入账_利息_正常回收_上次报告期);
idrObj.收入账_利息_提前偿还_上次报告期 = (decimal)parseDouble(收入账_利息_提前偿还_上次报告期);
idrObj.收入账_利息_拖欠回收_上次报告期 = (decimal)parseDouble(收入账_利息_拖欠回收_上次报告期);
idrObj.收入账_利息_违约回收_上次报告期 = (decimal)parseDouble(收入账_利息_违约回收_上次报告期);
idrObj.收入账_利息_合计_上次报告期 = (decimal)parseDouble(收入账_利息_合计_上次报告期);
idrObj.收入账_利息_正常回收_本次报告期 = (decimal)parseDouble(收入账_利息_正常回收_本次报告期);
idrObj.收入账_利息_提前偿还_本次报告期 = (decimal)parseDouble(收入账_利息_提前偿还_本次报告期);
idrObj.收入账_利息_拖欠回收_本次报告期 = (decimal)parseDouble(收入账_利息_拖欠回收_本次报告期);
idrObj.收入账_利息_违约回收_本次报告期 = (decimal)parseDouble(收入账_利息_违约回收_本次报告期);
idrObj.收入账_利息_合计_本次报告期 = (decimal)parseDouble(收入账_利息_合计_本次报告期);
//idrObj.收入账_其他收入_上次报告期 = (decimal)parseDouble(收入账_其他收入_上次报告期);
//idrObj.收入账_其他收入_本次报告期 = (decimal)parseDouble(收入账_其他收入_本次报告期);
//idrObj.收入账_上期转存_上次报告期 = (decimal)parseDouble(收入账_上期转存_上次报告期);
//idrObj.收入账_上期转存_本次报告期 = (decimal)parseDouble(收入账_上期转存_本次报告期);
//idrObj.收入账_合格投资_上次报告期 = (decimal)parseDouble(收入账_合格投资_上次报告期);
//idrObj.收入账_合格投资_本次报告期 = (decimal)parseDouble(收入账_合格投资_本次报告期);
idrObj.收入账_合计_上次报告期 = (decimal)parseDouble(收入账_合计_上次报告期);
idrObj.收入账_合计_本次报告期 = (decimal)parseDouble(收入账_合计_本次报告期);
idrObj.本金账_本金_正常回收_上次报告期 = (decimal)parseDouble(本金账_本金_正常回收_上次报告期);
idrObj.本金账_本金_正常回收_本次报告期 = (decimal)parseDouble(本金账_本金_正常回收_本次报告期);
idrObj.本金账_本金_提前偿还_上次报告期 = (decimal)parseDouble(本金账_本金_提前偿还_上次报告期);
idrObj.本金账_本金_提前偿还_本次报告期 = (decimal)parseDouble(本金账_本金_提前偿还_本次报告期);
idrObj.本金账_本金_拖欠回收_上次报告期 = (decimal)parseDouble(本金账_本金_拖欠回收_上次报告期);
idrObj.本金账_本金_拖欠回收_本次报告期 = (decimal)parseDouble(本金账_本金_拖欠回收_本次报告期);
idrObj.本金账_本金_违约回收_上次报告期 = (decimal)parseDouble(本金账_本金_违约回收_上次报告期);
idrObj.本金账_本金_违约回收_本次报告期 = (decimal)parseDouble(本金账_本金_违约回收_本次报告期);
idrObj.本金账_本金_合计_上次报告期 = (decimal)parseDouble(本金账_本金_合计_上次报告期);
idrObj.本金账_本金_合计_本次报告期 = (decimal)parseDouble(本金账_本金_合计_本次报告期);
//idrObj.本金账_其他收入_上次报告期 = (decimal)parseDouble(本金账_其他收入_上次报告期);
//idrObj.本金账_其他收入_本次报告期 = (decimal)parseDouble(本金账_其他收入_本次报告期);
//idrObj.本金账_上期转存_上次报告期 = (decimal)parseDouble(本金账_上期转存_上次报告期);
//idrObj.本金账_上期转存_本次报告期 = (decimal)parseDouble(本金账_上期转存_本次报告期);
idrObj.本金账_合计_上次报告期 = (decimal)parseDouble(本金账_合计_上次报告期);
idrObj.本金账_合计_本次报告期 = (decimal)parseDouble(本金账_合计_本次报告期);
idrObj.收入及本金合计_上次报告期 = idrObj.本金账_合计_上次报告期 + idrObj.收入账_合计_上次报告期;
idrObj.收入及本金合计_本次报告期 = idrObj.本金账_合计_本次报告期 + idrObj.收入账_合计_本次报告期;
//idrObj.税收_上次报告期 = (decimal)parseDouble(税收_上次报告期);
//idrObj.税收_本次报告期 = (decimal)parseDouble(税收_本次报告期);
//idrObj.费用支出_服务总费用支出_上次报告期 = (decimal)parseDouble(费用支出_服务总费用支出_上次报告期);
//idrObj.费用支出_服务总费用支出_本次报告期 = (decimal)parseDouble(费用支出_服务总费用支出_本次报告期);
//idrObj.费用支出_其他费用支出_上次报告期 = (decimal)parseDouble(费用支出_其他费用支出_上次报告期);
//idrObj.费用支出_其他费用支出_本次报告期 = (decimal)parseDouble(费用支出_其他费用支出_本次报告期);
//idrObj.证券账户支出_证券利息总支出_上次报告期 = (decimal)parseDouble(证券账户支出_证券利息总支出_上次报告期);
//idrObj.证券账户支出_证券利息总支出_本次报告期 = (decimal)parseDouble(证券账户支出_证券利息总支出_本次报告期);
//idrObj.证券账户支出_证券本金总支出_上次报告期 = (decimal)parseDouble(证券账户支出_证券本金总支出_上次报告期);
//idrObj.证券账户支出_证券本金总支出_本次报告期 = (decimal)parseDouble(证券账户支出_证券本金总支出_本次报告期);
//idrObj.信托核算日 = dictValues[信托核算日];
//查找收款期间截止日
{
var sheet = FindSheetByTitle(book, 2, 0, "资产池存续期总体信息");
var val = GetCellValue(sheet, 0, 0);
var index = val.LastIndexOf(idrObj.DistInfo.T.Year.ToString());
var strEndDate = val.Substring(index);
var indexBeginDate = val.IndexOf(idrObj.DistInfo.T.Year.ToString());
var indexBeginDateDay = val.IndexOf("日");
var strBeginDate = val.Substring(indexBeginDate, indexBeginDateDay - indexBeginDate + 1);
DateTime receiveMoneyBeginDate;
CommUtils.Assert(DateTime.TryParse(strBeginDate, out receiveMoneyBeginDate),
"解析收款期间开始日失败：" + val);
idrObj.ReceiveMoneyBeginDate = receiveMoneyBeginDate;
DateTime receiveMoneyEndDate;
CommUtils.Assert(DateTime.TryParse(strEndDate, out receiveMoneyEndDate),
"解析收款期间截止日失败：" + val);
idrObj.ReceiveMoneyEndDate = receiveMoneyEndDate;
}
return(idrObj);
}
private object GetAssetCashflowTableDetail(string projectGuid, DateTime paymentDate)
{
var dictDeterminationDates = new Dictionary <DateTime, DateTime>();
var allAssetDetail = new NancyBasicAssetCashflow();
var projectLogicModel = Platform.GetProject(projectGuid);
ABSDeal absDeal = null;
try
{
var datasetSchedule = projectLogicModel.DealSchedule.GetByPaymentDay(paymentDate);
paymentDate = datasetSchedule.PaymentDate;
CommUtils.AssertNotNull(datasetSchedule.Dataset.Instance, "第{0}期模型未生成", Toolkit.DateToString(paymentDate));
CommUtils.Assert(datasetSchedule.Dataset.HasDealModel, "找不到第{0}期模型", Toolkit.DateToString(paymentDate));
absDeal = new ABSDeal(datasetSchedule.Dataset.DealModel);
dictDeterminationDates = ABSDealUtils.GetDeterminationDatesByPaymentDates(absDeal);
//获取当期所有的资产明细
var asOfDate = datasetSchedule.Dataset.Instance.AsOfDate;
allAssetDetail = NancyUtils.GetUnaggregateAssetCashflowByPath(projectLogicModel.Instance.ProjectId, asOfDate);
}
catch (ApplicationException ae)
{
var errorResult = new
{
isError = true,
errorMessage = ae.Message,
stackTrace = ae.StackTrace,
};
return(errorResult);
}
var dictAllAssetDetail = allAssetDetail.BasicAssetCashflowItems.ToList().GroupBy(x => x.AssetId).ToDictionary(x => x.Key, y => y.ToList());
var dataSetResult = new Dictionary <int, List <AssetCashflowData> >();
var dictRowSpan = new Dictionary <int, List <int> >();
var osaDict = new Dictionary <DateTime, OverrideSingleAssetLogicModel>();
var osaPrincipalRecords = m_dbAdapter.OverrideSingleAssetPrincipal.GetByProject(projectLogicModel.Instance.ProjectId);
var osaPrincipalBalanceRecords = m_dbAdapter.OverrideSingleAssetPrincipalBalance.GetByProject(projectLogicModel.Instance.ProjectId);
var osaInterestRecords = m_dbAdapter.OverrideSingleAssetInterest.GetByProject(projectLogicModel.Instance.ProjectId);
//获取每笔资产的明细
dictAllAssetDetail.Keys.ToList().ForEach(x =>
{
var currAssetDetailList = dictAllAssetDetail[x];
dictRowSpan[x] = new List <int>();
var dictCurrAssetList = new Dictionary <DateTime, List <NancyBasicAssetCashflowItem> >();
var data = new List <AssetCashflowData>();
var prevDateTime = DateTime.Parse("1753-01-02");
foreach (var currPaymentDate in dictDeterminationDates.Keys)
{
var currCompareTime = dictDeterminationDates[currPaymentDate];
dictCurrAssetList[currCompareTime] = currAssetDetailList.Where(item => prevDateTime < item.PaymentDate && item.PaymentDate <= currCompareTime).ToList();
var currAssetList = dictCurrAssetList[currCompareTime];
var assetId = x;
OverrideSingleAssetLogicModel osa = null;
if (osaDict.ContainsKey(currPaymentDate))
{
osa = osaDict[currPaymentDate];
}
else
{
osa = new OverrideSingleAssetLogicModel(projectLogicModel, currPaymentDate,
osaPrincipalRecords, osaInterestRecords, osaPrincipalBalanceRecords);
osaDict[currPaymentDate] = osa;
}
var hasOsa = osa.HasOverrideRecords(assetId);
if (currAssetList.Count > 0)
{
dictRowSpan[x].Add(hasOsa ? 1 : (currAssetList.Count + 1));
var rowName = Toolkit.DateToString(currCompareTime);
for (int i = 0; i < currAssetList.Count; i++)
{
var ditail = currAssetList[i];
var currACFRow = new AssetCashflowData();
currACFRow.RowName = rowName;
currACFRow.AddValue("资产回款日", Toolkit.DateToString(ditail.PaymentDate));
currACFRow.AddValue("利息", ditail.Interest.ToString("n2"));
currACFRow.AddValue("本金", ditail.Principal.ToString("n2"));
currACFRow.AddValue("合计", (ditail.Interest + ditail.Principal).ToString("n2"));
currACFRow.AddValue("剩余本金", ditail.Performing.ToString("n2"));
currACFRow.AddValue("损失", ditail.Loss.ToString("n2"));
currACFRow.AddValue("违约", ditail.Defaulted.ToString("n2"));
if (!hasOsa)
{
data.Add(currACFRow);
}
}
var total = new AssetCashflowData();
total.RowName = rowName;
var interest = currAssetList.Sum(value => value.Interest);
var principal = currAssetList.Sum(value => value.Principal);
var performing = currAssetList.Last().Performing;
if (osa.GetInterest(assetId) != null)
{
interest = osa.GetInterest(assetId).Interest;
}
if (osa.GetPrincipal(assetId) != null)
{
principal = osa.GetPrincipal(assetId).Principal;
}
if (osa.GetPrincipalBalance(assetId) != null)
{
performing = osa.GetPrincipalBalance(assetId).PrincipalBalance;
}
total.AddValue("资产回款日", "总计");
total.AddValue("利息", interest.ToString("n2"));
total.AddValue("本金", principal.ToString("n2"));
total.AddValue("合计", (interest + principal).ToString("n2"));
total.AddValue("剩余本金", performing.ToString("n2"));
total.AddValue("损失", currAssetList.Sum(value => value.Loss).ToString("n2"));
total.AddValue("违约", currAssetList.Sum(value => value.Defaulted).ToString("n2"));
data.Add(total);
}
prevDateTime = currCompareTime;
}
dataSetResult[x] = (data);
});
//获取所有的资产的中文名
var dictAssetIdCNName = absDeal.Assets.GetAssetIdNameMap();
var detailTableHeader = new List <string>()
{
"归集日", "资产回款日", "利息", "本金", "合计", "剩余本金", "损失", "违约"
};
return(new
{
tableHeader = detailTableHeader,
assetIdCNName = dictAllAssetDetail.Keys.ToList().ConvertAll(x => new
{
tableKey = x,
tableValues = dictAssetIdCNName[x]
}),
dataSets = dataSetResult.Keys.ToList().ConvertAll(x => new
{
tableKey = x,
tableValues = dataSetResult[x],
rowSpanList = dictRowSpan[x]
}),
isError = false
});
}
private void CreateDataset(Project project, string asOfDate)
{
var projectId = project.ProjectId;
var datasets = m_dbAdapter.Dataset.GetDatasetByProjectId(projectId);
if (datasets.Any(x => x.AsOfDate == asOfDate))
{
throw new ApplicationException("产品[" + project.Name + "]中，dataset [" + asOfDate + "]已存在。");
}
//Find payment date
DateTime?paymentDate = null;
var dealSchedule = NancyUtils.GetDealSchedule(project.ProjectId);
if (dealSchedule == null || dealSchedule.PaymentDates == null || dealSchedule.PaymentDates.Length == 0)
{
//创建第一期Dataset时，没有模型数据，无法读取DealSchedule，此时PaymentDate从数据库中取得
if (project.CnabsDealId.HasValue)
{
var paymentDates = m_dbAdapter.Model.GetPaymentDates(project.CnabsDealId.Value);
var date = DateTime.ParseExact(asOfDate, "yyyyMMdd", CultureInfo.InvariantCulture);
if (paymentDates.All(x => x < date))
{
throw new ApplicationException("产品[" + project.Name + "]中，dataset [" + asOfDate + "]不在任何支付日之前。");
}
paymentDate = paymentDates.First(x => x >= date);
}
}
else
{
//创建第N期Dataset时，有模型数据，此时PaymentDate按照DealSchedule中AsOfDate对应Index查出
var curAsOfDate = DateUtils.ParseDigitDate(asOfDate);
if (curAsOfDate == dealSchedule.FirstCollectionPeriodStartDate)
{
paymentDate = dealSchedule.PaymentDates[0];
}
else
{
for (int i = 0; i < dealSchedule.DeterminationDates.Length - 1; ++i)
{
if (curAsOfDate == dealSchedule.DeterminationDates[i])
{
paymentDate = dealSchedule.PaymentDates[i + 1];
break;
}
}
}
}
CommUtils.AssertNotNull(paymentDate, "无法根据AsOfDate[" + asOfDate + "]查询到对应的支付日。");
var notes = m_dbAdapter.Dataset.GetNotes(projectId);
//Create dataset
var dataset = new Dataset();
dataset.ProjectId = projectId;
dataset.AsOfDate = asOfDate;
dataset.PaymentDate = paymentDate;
LogEditProduct(EditProductType.CreateProduct, projectId, "创建Dataset[" + projectId + "][" + asOfDate + "]", "");
dataset = m_dbAdapter.Dataset.NewDataset(dataset);
//Create note result
var noteResult = new NoteResults();
noteResult.ProjectId = projectId;
noteResult.DatasetId = dataset.DatasetId;
LogEditProduct(EditProductType.CreateProduct, projectId, "创建NoteResult[" + projectId + "][" + dataset.DatasetId + "]", "");
noteResult = m_dbAdapter.Dataset.NewNoteResult(noteResult);
//Create note data
foreach (var note in notes)
{
var noteData = new NoteData();
noteData.NoteId = note.NoteId;
noteData.DatasetId = dataset.DatasetId;
LogEditProduct(EditProductType.CreateProduct, projectId, "创建NoteData[" + note.NoteName + "][" + note.NoteId + "][" + dataset.DatasetId + "]", "");
noteData = m_dbAdapter.Dataset.NewNoteData(noteData);
}
}
public ActionResult GetPaymentPercentChart(string projectGuid)
{
return(ActionUtils.Json(() =>
{
var project = m_dbAdapter.Project.GetProjectByGuid(projectGuid);
CommUtils.Assert(project.CnabsDealId.HasValue, "CNABS deal id is null.");
DealService dealService = new DealService();
var dealData = dealService.GetDealData(project.CnabsDealId.Value);
CommUtils.Assert(dealData.ClosingDate.HasValue, "查找计息日失败");
var closingDate = dealData.ClosingDate;
//Load note info
var notes = m_dbAdapter.Dataset.GetNotes(project.ProjectId);
var cnabsNotes = new ProjectLogicModel(CurrentUserName, project).Notes;
var noteDict = Toolkit.GetNoteDictionary(project, notes, cnabsNotes);
var noteInfos = notes.ConvertAll(x => noteDict[x.NoteId]);
//Load dataset info
var datasetViewModels = new List <DatasetViewModel>();
var dealSchedule = NancyUtils.GetDealSchedule(project.ProjectId);
var datasets = m_dbAdapter.Dataset.GetDatasetByProjectId(project.ProjectId);
foreach (var dataset in datasets)
{
var noteDatas = m_dbAdapter.Dataset.GetNoteDatas(dataset.DatasetId);
var datasetViewModel = Toolkit.GetDatasetViewModel(dataset, dealSchedule.PaymentDates, noteDict, noteDatas);
datasetViewModels.Add(datasetViewModel);
}
datasetViewModels.Reverse();
var dataSeries = new DataSeries();
dataSeries.name = "汇总";
dataSeries.data = new List <Vector>();
dataSeries.data.Add(new Vector(closingDate.Value, 100f));
var sumNotional = noteInfos.Sum(x => x.Notional);
var endingBalance = sumNotional;
if (sumNotional.HasValue && sumNotional.Value != 0)
{
foreach (var datasetViewModel in datasetViewModels)
{
var detail = datasetViewModel.SumPaymentDetail;
endingBalance -= detail.PrincipalPaid;
dataSeries.data.Add(new Vector(datasetViewModel.PaymentDay.Value, (endingBalance.Value / sumNotional.Value) * 100));
}
}
var dataSeriesList = new List <DataSeries>();
dataSeriesList.Add(dataSeries);
Dictionary <string, List <Vector> > series = new Dictionary <string, List <Vector> >();
Dictionary <string, decimal> endingBalances = new Dictionary <string, decimal>();
foreach (var noteInfo in noteInfos)
{
var key = noteInfo.Name;
series[key] = new List <Vector>();
endingBalances[key] = noteInfo.Notional.Value;
series[key].Add(new Vector(closingDate.Value, 100d));
}
foreach (var datasetViewModel in datasetViewModels)
{
foreach (var noteData in datasetViewModel.NoteDatas)
{
var key = noteData.NoteInfo.Name;
endingBalances[key] -= noteData.PaymentDetail.PrincipalPaid.Value;
series[key].Add(new Vector(datasetViewModel.PaymentDay.Value, (100 * endingBalances[key] / noteData.NoteInfo.Notional.Value)));
}
}
foreach (var key in series.Keys)
{
var ds = new DataSeries();
ds.name = key;
ds.data = series[key];
dataSeriesList.Add(ds);
}
return ActionUtils.Success(dataSeriesList);
}));
}
public ActionResult PrepayAmortizationByAsset(string projectGuid, string paymentDate, int assetId,
string prepayDate, double money, string distributionType, string distributionDetail, string comment)
{
return(ActionUtils.Json(() =>
{
CommUtils.Assert(money >= 0, "提前偿付金额不能为负数");
var type = CommUtils.ParseEnum <PrepayDistrubutionType>(distributionType);
var project = new ProjectLogicModel(CurrentUserName, projectGuid);
var dataset = project.DealSchedule.GetByPaymentDay(DateUtils.ParseDigitDate(paymentDate)).Dataset;
var asset = dataset.Assets.Single(x => x.AssetId == assetId);
CommUtils.Assert(DateUtils.ParseDigitDate(prepayDate) >= dataset.DatasetSchedule.AsOfDateBegin &&
DateUtils.ParseDigitDate(prepayDate) <= dataset.DatasetSchedule.AsOfDateEnd,
"提前偿付日期必须在当期时间范围（" + dataset.DatasetSchedule.AsOfDateBegin.ToShortDateString()
+ "~" + dataset.DatasetSchedule.AsOfDateEnd.ToShortDateString() + "）内");
if (asset.AmortizationType == AmortizationType.UserDefined)
{
var amortization = dataset.AmortizationSchedule;
amortization.AddPrepayment(assetId, DateUtils.ParseDigitDate(prepayDate), money, type, distributionDetail);
amortization.Save();
var history = new AssetPrepaymentHistory();
history.ProjectId = project.Instance.ProjectId;
history.DatasetId = dataset.Instance.DatasetId;
history.AssetId = assetId;
history.PrepayAmount = money;
history.PrepayTime = DateUtils.ParseDigitDate(prepayDate);
history.DistributionType = distributionType;
history.DistributionDetail = distributionDetail;
history.Comment = comment;
history.TimeStamp = DateTime.Now;
history.TimeStampUserName = CurrentUserName;
m_dbAdapter.PaymentHistory.NewAssetPrepaymentHistory(history);
var viewModel = new PrepayRecordListViewModel(dataset.DatasetSchedule, amortization.SelectByAsset(assetId));
return ActionUtils.Success(viewModel);
}
CommUtils.Assert(type != PrepayDistrubutionType.Custom, "等额本金、等额本息、一次偿付类的资产不支持自定义偿付。");
//处理等额本金、等额本息、一次偿付类的提前偿付，需要下期模型存在
if (dataset.Next == null)
{
//下期模型不存在，自动生成下一期模型
CommUtils.AssertNotNull(dataset.DatasetSchedule.Next, "找不到下期模型封包日，提前偿付测算失败");
CreateDataset(project.Instance, dataset.DatasetSchedule.Next.AsOfDateBegin.ToString("yyyyMMdd"));
var assetModifier = new AssetModifier(CurrentUserName);
assetModifier.Load(project.Instance.ProjectId, dataset.DatasetSchedule.AsOfDateBegin);
assetModifier.GenerateNextDataset(project.Instance.ProjectId);
}
CommUtils.AssertNotNull(dataset.Next, "无法找到下期模型数据，提前偿付测算失败");
if (IsEqualPmtOrEqualPrin(asset.AmortizationType))
{
var curDatasetBasicAnalyticsData = NancyUtils.GetBasicAnalyticsData(project.Instance.ProjectId, null, dataset.DatasetSchedule.AsOfDateBegin);
double curDatasetPrincipal = 0;
if (IsEqualPmtOrEqualPrin(asset.SecurityData.PaymentMethod))
{
//当期未发生过提前偿付，当期偿付金额是Nancy测算金额
curDatasetPrincipal = curDatasetBasicAnalyticsData.BasicAssetCashflow.BasicAssetCashflowItems
.Single(x => x.AssetId == assetId && x.PaymentDate == dataset.DatasetSchedule.PaymentDate).Principal;
}
else
{
var nextDatasetAsset = dataset.Next.Assets.Single(x => x.AssetId == assetId);
CommUtils.Assert(IsEqualPmtOrEqualPrin(nextDatasetAsset.AmortizationType),
"第[" + dataset.Next.DatasetSchedule.PaymentDate.ToString("yyyyMMdd") + "]期偿付类型错误，提前偿付测算失败");
//当期发生过提前偿付，当期偿付金额是AmortizationSchedule中金额
var curAmortizationRecord = dataset.AmortizationSchedule.Single(x => x.ReductionDate == dataset.DatasetSchedule.PaymentDate);
//当期未发生本次提前偿付的偿付本金
curDatasetPrincipal = (double)curAmortizationRecord.ReductionAmount;
}
//保存AmortizationSchedule
var amortization = dataset.AmortizationSchedule;
amortization.Add(new AmortizationScheduleRecord {
AssetId = assetId,
ReductionAmount = money + curDatasetPrincipal,
ReductionDate = DateUtils.ParseDigitDate(prepayDate)
});
amortization.Save();
//更新PaymentMethod
dataset.CollateralCsv.UpdateCellValue(assetId, "PaymentMethod", "");
dataset.CollateralCsv.Save();
var sumFutureDatasetPrincipal = curDatasetBasicAnalyticsData.BasicAssetCashflow.BasicAssetCashflowItems
.Where(x => x.AssetId == assetId && x.PaymentDate > dataset.DatasetSchedule.PaymentDate)
.Sum(x => x.Principal);
var records = new List <AmortizationScheduleRecord>();
//当期的新的本金偿付值是 根据等额本金/等额本息计算出的本金值 加上提前偿付金额
records.Add(new AmortizationScheduleRecord
{
AssetId = assetId,
ReductionAmount = curDatasetPrincipal + money,
ReductionDate = dataset.DatasetSchedule.PaymentDate
});
//更新下期的本金期末余额（减去提前偿付金额），重新根据等额本金/等额本息计算本金
dataset.Next.CollateralCsv.UpdateCellValue(assetId, "PrincipalBalance", (sumFutureDatasetPrincipal - money).ToString());
dataset.Next.CollateralCsv.Save();
var nextDatasetBasicAnalyticsData = NancyUtils.GetBasicAnalyticsData(project.Instance.ProjectId, null, dataset.DatasetSchedule.Next.AsOfDateBegin);
var nextAssetCashflowItems = nextDatasetBasicAnalyticsData.BasicAssetCashflow.BasicAssetCashflowItems
.Where(x => x.AssetId == assetId && x.PaymentDate > dataset.DatasetSchedule.PaymentDate && x.Principal != 0)
.OrderBy(x => x.PaymentDate);
foreach (var item in nextAssetCashflowItems)
{
records.Add(new AmortizationScheduleRecord
{
AssetId = assetId,
ReductionAmount = item.Principal,
ReductionDate = item.PaymentDate
});
}
var viewModel = new PrepayRecordListViewModel(dataset.DatasetSchedule, records);
return ActionUtils.Success(viewModel);
}
else if (asset.AmortizationType == AmortizationType.SingleAmortization)
{
var nextDatasetAsset = dataset.Next.Assets.Single(x => x.AssetId == assetId);
CommUtils.AssertEquals(nextDatasetAsset.SecurityData.PaymentMethod, ZEnums.EPaymentMethod.UNDEFINEDENUM,
"无法识别的偿付类型，提前偿付测算失败。");
var nextAmortizationRecords = dataset.Next.AmortizationSchedule.SelectByAsset(assetId);
CommUtils.AssertEquals(nextAmortizationRecords.Count, 0,
"第[" + dataset.Next.DatasetSchedule.PaymentDate.ToString("yyyyMMdd") + "]期已发生提前偿付, 提前偿付测算失败");
var records = dataset.AmortizationSchedule.SelectByAsset(assetId);
var prepayRecord = new AmortizationScheduleRecord
{
AssetId = assetId,
ReductionAmount = money,
ReductionDate = DateUtils.ParseDigitDate(prepayDate)
};
records.Add(prepayRecord);
var sumPrepayAmount = records.Sum(x => x.ReductionAmount);
CommUtils.Assert(sumPrepayAmount <= asset.SecurityData.PrincipalBalance,
"提前偿付金额[" + sumPrepayAmount + "]大于剩余未偿付金额[" + asset.SecurityData.PrincipalBalance + "]");
records.Add(new AmortizationScheduleRecord()
{
AssetId = assetId,
ReductionAmount = asset.SecurityData.PrincipalBalance - sumPrepayAmount,
ReductionDate = asset.SecurityData.MaturityDate
});
dataset.AmortizationSchedule.AddPrepayment(assetId, DateUtils.ParseDigitDate(prepayDate), money, type, distributionDetail);
dataset.AmortizationSchedule.Save();
dataset.Next.CollateralCsv.UpdateCellValue(assetId, "PrincipalBalance",
(asset.SecurityData.PrincipalBalance - sumPrepayAmount).ToString());
dataset.Next.CollateralCsv.Save();
var viewModel = new PrepayRecordListViewModel(dataset.DatasetSchedule, records);
return ActionUtils.Success(viewModel);
}
return ActionUtils.Success("无法识别的偿付类型，projectGuid=["
+ projectGuid + "] + paymentDate=[" + paymentDate + "] + assetId=[" + assetId + "]");
}));
}
public void GenerateNextDataset(int projectId)
{
CommUtils.Assert(m_isInitialized, "AssetModifier hasn't been initialized!");
var project = m_dbAdapter.Project.GetProjectById(projectId);
var datasetFolder = m_dbAdapter.Dataset.GetDatasetFolder(project, m_asOfDay);
CommUtils.Assert(Directory.Exists(datasetFolder), "Load dataset [" + project.ProjectGuid + "][" + m_asOfDay + "] failed!");
if (!m_nextAsOfDay.HasValue)
{
return;
}
//Create folder for next dataset if not exists.
var nextDatasetFolder = m_dbAdapter.Dataset.GetDatasetFolder(project, m_nextAsOfDay.Value);
if (!Directory.Exists(nextDatasetFolder))
{
try
{
Directory.CreateDirectory(nextDatasetFolder);
}
catch (Exception e)
{
throw new ApplicationException("Create dataset [" + project.ProjectGuid + "][" + m_asOfDay + "] folder failed! Exception: " + e.Message);
}
}
//Copy and modify collertal.csv
var collateralPath = Path.Combine(datasetFolder, "collateral.csv");
var nextCollateralPath = Path.Combine(nextDatasetFolder, "collateral.csv");
FileUtils.Copy(collateralPath, nextCollateralPath);
var amortizationPath = Path.Combine(datasetFolder, "AmortizationSchedule.csv");
var nextAmortizationPath = Path.Combine(nextDatasetFolder, "AmortizationSchedule.csv");
FileUtils.Copy(amortizationPath, nextAmortizationPath, false);
var promisedCashflowPath = Path.Combine(datasetFolder, "PromisedCashflow.csv");
var nextPromisedCashflowPath = Path.Combine(nextDatasetFolder, "PromisedCashflow.csv");
FileUtils.Copy(promisedCashflowPath, nextPromisedCashflowPath, false);
var reinvestmentPath = Path.Combine(datasetFolder, "Reinvestment.csv");
var nextReinvestmentPath = Path.Combine(nextDatasetFolder, "Reinvestment.csv");
FileUtils.Copy(reinvestmentPath, nextReinvestmentPath, false);
var currentCombileVaiablesPath = Path.Combine(datasetFolder, "CombinedVariables.csv");
var nextCombileVaiablesPath = Path.Combine(nextDatasetFolder, "CombinedVariables.csv");
FileUtils.Copy(currentCombileVaiablesPath, nextCombileVaiablesPath, false);
var currentVariablesPath = Path.Combine(datasetFolder, "CurrentVariables.csv");
var nextCurrentVariablesPath = Path.Combine(nextDatasetFolder, "CurrentVariables.csv");
FileUtils.Copy(currentVariablesPath, nextCurrentVariablesPath, false);
var futureVariablesPath = Path.Combine(datasetFolder, "FutureVariables.csv");
var nextFutureVariablesPath = Path.Combine(nextDatasetFolder, "FutureVariables.csv");
FileUtils.Copy(futureVariablesPath, nextFutureVariablesPath, false);
var pastVariablesPath = Path.Combine(datasetFolder, "PastVariables.csv");
var nextPastVariablesPath = Path.Combine(nextDatasetFolder, "PastVariables.csv");
FileUtils.Copy(pastVariablesPath, nextPastVariablesPath, false);
BasicAnalyticsData basicAnalyticsData = NancyUtils.GetBasicAnalyticsData(projectId, null, m_asOfDay);
//AssetId, 剩余本金
var dictPrincipalBalance = new Dictionary <int, double>();
foreach (var assetCashFlow in basicAnalyticsData.BasicAssetCashflow.BasicAssetCashflowItems)
{
if (assetCashFlow.PaymentDate == m_paymentDay)
{
dictPrincipalBalance[assetCashFlow.AssetId] = assetCashFlow.Performing;
}
}
var collateralCsv = new CollateralCsv();
collateralCsv.Load(nextCollateralPath);
foreach (var record in collateralCsv)
{
var assetId = record.AssetId;
//更新封包日日期
collateralCsv.UpdateCellValue(assetId, "AsOfDate",
m_nextAsOfDay.Value.ToString("MM/dd/yyyy"));
//更新剩余本金
collateralCsv.UpdateCellValue(assetId, "PrincipalBalance",
dictPrincipalBalance.ContainsKey(assetId) ? dictPrincipalBalance[assetId].ToString() : "0");
if (collateralCsv.ContainsColumn("AccrueFromAsOfDate"))
{
collateralCsv.UpdateCellValue(assetId, "AccrueFromAsOfDate", "FALSE");
}
}
collateralCsv.Save(nextCollateralPath);
ProcessVaiables(m_dbAdapter.Dataset.GetYmlFolder(project), basicAnalyticsData);
if (m_previousPaymentDay != m_paymentDay && File.Exists(nextPromisedCashflowPath))
{
var p = new PromisedCashflowCsv(nextPromisedCashflowPath);
p.Load();
p.Records = p.Records.Where(o => o.PaymentDate > m_previousPaymentDay).ToList();
p.Save();
}
}
public ActionResult GetProjectInfoAndContacts(string projectGuid)
{
return(ActionUtils.Json(() =>
{
//权限检查
var authorizedIds = m_dbAdapter.Authority.GetAuthorizedProjectIds();
var project = m_dbAdapter.Project.GetProjectByGuid(projectGuid);
CommUtils.Assert(authorizedIds.Contains(project.ProjectId), "当前用户没有读取产品[{0}]的权限", project.Name);
var projectInfo = new ProjectInfo();
if (project.CnabsDealId.HasValue)
{
DealService ds = new DealService();
projectInfo = MonitorConvertion.ConvertProjectInfo(ds.GetDealData(project.CnabsDealId.Value), projectGuid);
}
else
{
var rootFolder = WebConfigUtils.RootFolder;
project.Model = m_dbAdapter.Project.GetModel(project.ModelId);
var modelFolder = Path.Combine(rootFolder, project.Model.ModelFolder);
var ymlFilePath = modelFolder + @"\Script.yml";
if (System.IO.File.Exists(ymlFilePath))
{
using (StreamReader sr = new StreamReader(ymlFilePath))
{
var nancyDealData = NancyUtils.GetNancyDealDataByFile(sr.BaseStream);
if (nancyDealData != null)
{
DateTime?date = null;
projectInfo = new ProjectInfo()
{
guid = project.ProjectGuid,
fullName = project.Name,
closingDate = nancyDealData.ScheduleData.ClosingDate,
legalMaturityDate = nancyDealData.ScheduleData.LegalMaturity,
firstPaymentDate = nancyDealData.ScheduleData.PaymentSchedule.Periods.Count > 0 ?
nancyDealData.ScheduleData.PaymentSchedule.Periods[0].PaymentDate : date,
paymentFrequency = Toolkit.PaymentFrequency(nancyDealData.ScheduleData.PaymentPerYear),
//TODO: 监管机构 产品类型
//regulator
//productType
};
}
}
}
}
var result = new
{
ProjectInfo = new
{
Guid = projectInfo.guid,
FullName = projectInfo.fullName,
ClosingDate = Toolkit.DateToString(projectInfo.closingDate),
LegalMaturityDate = Toolkit.DateToString(projectInfo.legalMaturityDate),
FirstPaymentDate = Toolkit.DateToString(projectInfo.firstPaymentDate),
PaymentFrequency = projectInfo.paymentFrequency,
Regulator = Toolkit.ToString(projectInfo.regulator),
ProductType = Toolkit.ToString(projectInfo.productType),
},
Contacts = m_dbAdapter.Contact.GetContactsByProjectId(project.ProjectId),
};
return ActionUtils.Success(result);
}));
}
private void Initialize(ProjectLogicModel project)
{
var objStr = "产品 [" + project.Instance.Name + "] ";
var projectId = project.Instance.ProjectId;
if (project.Instance.Model == null && project.Instance.ModelId > 0)
{
project.Instance.Model = m_dbAdapter.Project.GetModel(project.Instance.ModelId);
}
var modelFolder = WebConfigUtils.RootFolder + project.Instance.Model.ModelFolder + "\\";
CommUtils.Assert(Directory.Exists(modelFolder), "找不到模型路径[{0}]", modelFolder);
DealSchedule dealSchedule = null;
try
{
dealSchedule = NancyUtils.GetDealSchedule(projectId, ignoreException: false);
}
catch (Exception e)
{
CommUtils.Assert(false, "加载模型失败：[{0}]，模型路径：{1}"
+ Environment.NewLine + e.Message, modelFolder);
}
CommUtils.AssertNotNull(dealSchedule, "加载模型失败：{0}", modelFolder);
m_instanse = dealSchedule;
CommUtils.Assert(DateUtils.IsNormalDate(dealSchedule.FirstCollectionPeriodStartDate),
"模型中，FirstCollectionPeriodStartDate({0})不是有效的日期", dealSchedule.FirstCollectionPeriodStartDate.ToString());
CommUtils.Assert(DateUtils.IsNormalDate(dealSchedule.FirstCollectionPeriodEndDate),
"模型中，FirstCollectionPeriodEndDate({0})不是有效的日期", dealSchedule.FirstCollectionPeriodEndDate.ToString());
CommUtils.AssertNotNull(dealSchedule.PaymentDates, objStr + "中没有PaymentDatas数据");
CommUtils.AssertNotNull(dealSchedule.DeterminationDates, objStr + "中没有DeterminationDates数据");
CommUtils.AssertEquals(dealSchedule.PaymentDates.Length, dealSchedule.DeterminationDates.Length, objStr + "中DealSchedule数据加载失败");
_durationPeriods = new List <DatasetScheduleLogicModel>();
for (int i = 0; i < dealSchedule.PaymentDates.Length; i++)
{
var paymentDate = dealSchedule.PaymentDates[i];
var durationPeriod = new DatasetScheduleLogicModel(project);
durationPeriod.Sequence = m_project.GetAllPaymentDates(dealSchedule.PaymentDates).IndexOf(paymentDate) + 1;
durationPeriod.PaymentDate = paymentDate;
if (i == 0)
{
durationPeriod.AsOfDateBegin = dealSchedule.FirstCollectionPeriodStartDate;
}
else
{
durationPeriod.AsOfDateBegin = dealSchedule.DeterminationDates[i - 1];
}
durationPeriod.AsOfDateEnd = dealSchedule.DeterminationDates[i];
if (i != 0)
{
durationPeriod.Previous = _durationPeriods[i - 1];
durationPeriod.Previous.Next = durationPeriod;
}
_durationPeriods.Add(durationPeriod);
}
ClosingDate = dealSchedule.ClosingDate;
LegalMaturity = dealSchedule.LegalMaturity;
}
