public static li_claims NewPrincipalChild(this li_claims parent, DateTime createTime, decimal childPrincipal)
{
var child = parent.MakeChild(createTime);
child.principal = childPrincipal;
return(child);
}
public static li_claims NewPrincipalAndStatusChild(this li_claims parent, DateTime createTime, Agp2pEnums.ClaimStatusEnum newStatus, decimal childPrincipal)
{
var child = parent.NewPrincipalChild(createTime, childPrincipal);
child.status = (byte)newStatus;
return(child);
}
public static li_claims NewStatusChild(this li_claims parent, DateTime createTime, Agp2pEnums.ClaimStatusEnum newStatus)
{
var child = parent.MakeChild(createTime);
child.status = (byte)newStatus;
return(child);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="claim"></param>
/// <param name="task"></param>
/// <param name="callback">三个参数的回调：债权生效前天数，债权生效天数，债权失效后天数</param>
/// <returns></returns>
public static T GetProfitingSectionDays <T>(this li_claims claim, li_repayment_tasks task, Func <int, int, int, T> callback)
{
int claimBeforeProfitingDays, claimProfitingDays;
var taskStartProfitingTime = task.GetStartProfitingTime();
if (claim.status == (int)Agp2pEnums.ClaimStatusEnum.NeedTransfer)
{
var parent = claim.Parent;
// 提现债权（返回提现成功后的实际收益天数）
claimBeforeProfitingDays = parent.createTime <= taskStartProfitingTime
? 0
: (int)(parent.createTime.Date - taskStartProfitingTime.Date).TotalDays;
claimProfitingDays = (int)(claim.createTime.Date - parent.createTime.Date).TotalDays;
}
else
{
// 普通债权
claimBeforeProfitingDays = claim.createTime <= taskStartProfitingTime
? 0
: (int)(claim.createTime.Date - taskStartProfitingTime.Date).TotalDays;
claimProfitingDays = (int)(task.should_repay_time.Date - new[] { claim.createTime, taskStartProfitingTime }.Max().Date).TotalDays;
}
var claimInvalidDays = task.GetTotalProfitingDays() - claimBeforeProfitingDays - claimProfitingDays;
Debug.Assert(0 <= claimInvalidDays);
return(callback(claimBeforeProfitingDays, claimProfitingDays, claimInvalidDays));
}
public void GenerateClaimFromOldData()
{
// 补充旧的债权
var context = new Agp2pDataContext();
// 定期项目：每笔投资产生一个债权，已完成的项目的债权状态为已完成，其余为不可转让
var ptrs =
context.li_project_transactions.Where(
ptr => ptr.type == (int)Agp2pEnums.ProjectTransactionTypeEnum.Invest)
.ToList();
int count = 0;
ptrs.ForEach(ptr =>
{
if (ptr.li_claims_invested.Any())
{
return;
}
var claimFromInvestment = new li_claims
{
principal = ptr.principal,
projectId = ptr.project,
profitingProjectId = ptr.project,
createFromInvestment = ptr.id,
createTime = ptr.create_time,
userId = ptr.investor,
status = (byte)Agp2pEnums.ClaimStatusEnum.Nontransferable,
number = Utils.HiResNowString,
};
context.li_claims.InsertOnSubmit(claimFromInvestment);
count += 1;
if (ptr.li_projects.IsNewbieProject1())
{
var task = ptr.li_projects.li_repayment_tasks.Single(ta => ta.only_repay_to == ptr.investor);
if (task.status != (int)Agp2pEnums.RepaymentStatusEnum.Unpaid)
{
var claim = claimFromInvestment.NewStatusChild(task.repay_at.Value,
Agp2pEnums.ClaimStatusEnum.Completed);
context.li_claims.InsertOnSubmit(claim);
count += 1;
}
}
else
{
if (ptr.li_projects.complete_time.HasValue)
{
var claim = claimFromInvestment.NewStatusChild(ptr.li_projects.complete_time.Value,
Agp2pEnums.ClaimStatusEnum.Completed);
context.li_claims.InsertOnSubmit(claim);
count += 1;
}
}
});
//context.SubmitChanges();
Debug.WriteLine("创建债权：" + count);
}
public static li_claims GetHistoryClaimByOwner(this li_claims claim, int userId)
{
if (claim.userId == userId)
{
return(claim);
}
else
{
return(claim.Parent?.GetHistoryClaimByOwner(userId));
}
}
public static li_claims TransferedChild(this li_claims parent, DateTime createTime,
Agp2pEnums.ClaimStatusEnum newStatus, decimal childPrincipal, li_project_transactions byPtr)
{
var child = parent.NewPrincipalAndStatusChild(createTime, newStatus, childPrincipal);
child.number = Utils.HiResNowString;
child.profitingProjectId = byPtr.project;
child.userId = byPtr.investor;
child.li_project_transactions_invest = byPtr;
return(child);
}
public static li_claims GetFirstHistoryClaimByOwner(this li_claims claim, int userId)
{
var hisClaim = claim.GetHistoryClaimByOwner(userId);
var olderClaim = hisClaim.Parent?.GetHistoryClaimByOwner(userId);
if (olderClaim != null)
{
return(hisClaim != olderClaim?olderClaim.GetFirstHistoryClaimByOwner(userId) : olderClaim);
}
return(hisClaim);
}
public static bool IsChildOf(this li_claims childClaim, li_claims parentClaim)
{
if (parentClaim.createTime <= childClaim.createTime)
{
if (childClaim.Parent != null)
{
return(childClaim.Parent == parentClaim || childClaim.Parent.IsChildOf(parentClaim));
}
}
return(false);
}
public static bool IsLeafClaim(this li_claims claim, DateTime?moment = null)
{
if (moment == null)
{
return(!claim.Children.Any());
}
var historyClaimByTime = claim.GetHistoryClaimByTime(moment.Value);
if (historyClaimByTime == null)
{
return(false);
}
return(!historyClaimByTime.Children.Any(c => c.createTime <= moment.Value));
}
public static li_claims GetSourceClaim(this li_claims claim)
{
if (claim.Parent == null)
{
return(claim);
}
else if (claim.Parent.userId != claim.userId)
{
return(claim);
}
else
{
return(claim.Parent.GetSourceClaim());
}
}
public static li_claims GetHistoryClaimByTime(this li_claims childClaim, DateTime time)
{
if (childClaim.createTime <= time)
{
return(childClaim);
}
else if (childClaim.Parent != null && childClaim.Parent.userId == childClaim.userId)
{
return(childClaim.Parent.GetHistoryClaimByTime(time));
}
else
{
return(null);
}
}
public static li_claims MakeChild(this li_claims parent, DateTime createTime)
{
return(new li_claims
{
Parent = parent,
createFromInvestment = parent.createFromInvestment,
createTime = createTime,
userId = parent.userId,
principal = parent.principal,
projectId = parent.projectId,
profitingProjectId = parent.profitingProjectId,
number = parent.number,
status = parent.status,
agent = parent.agent,
});
}
public static IEnumerable <li_claims> QueryLeafClaimsAtMoment(this li_claims rootClaim, DateTime?moment = null)
{
var realMoment = moment ?? DateTime.Now;
var childClaimsAtMoment = rootClaim.Children.Where(c => c.createTime <= realMoment).ToList();
if (childClaimsAtMoment.Any())
{
return(childClaimsAtMoment.SelectMany(c => c.QueryLeafClaimsAtMoment(realMoment)));
}
else if (rootClaim.createTime <= realMoment)
{
return(Enumerable.Repeat(rootClaim, 1));
}
return(Enumerable.Empty <li_claims>());
}
public void TestQueryLeafClaimsAtMoment()
{
var baseTime = DateTime.Today;
using (var ts = new TransactionScope())
{
var rootClaim = new li_claims {
createTime = baseTime
};
var c2 = rootClaim.MakeChild(baseTime.AddDays(1));
var c2c1 = c2.MakeChild(c2.createTime.AddDays(-1));
var c3 = rootClaim.MakeChild(baseTime.AddDays(2));
var c3c4 = c3.MakeChild(c3.createTime.AddDays(1));
var c3c3 = c3.MakeChild(c3.createTime);
var c3c4c5 = c3c4.MakeChild(c3c4.createTime.AddDays(1));
var d1 = rootClaim.QueryLeafClaimsAtMoment(baseTime).ToList();
Assert.AreEqual(1, d1.Count);
CollectionAssert.Contains(d1, rootClaim);
var d2 = rootClaim.QueryLeafClaimsAtMoment(baseTime.AddDays(1)).ToList();
Assert.AreEqual(1, d2.Count);
CollectionAssert.Contains(d2, c2c1);
var d3 = rootClaim.QueryLeafClaimsAtMoment(baseTime.AddDays(2)).ToList();
Assert.AreEqual(2, d3.Count);
CollectionAssert.Contains(d3, c2c1);
CollectionAssert.Contains(d3, c3c3);
var d4 = rootClaim.QueryLeafClaimsAtMoment(baseTime.AddDays(3)).ToList();
Assert.AreEqual(3, d4.Count);
CollectionAssert.Contains(d4, c2c1);
CollectionAssert.Contains(d4, c3c4);
CollectionAssert.Contains(d4, c3c3);
var d5 = rootClaim.QueryLeafClaimsAtMoment(baseTime.AddDays(4)).ToList();
Assert.AreEqual(3, d5.Count);
CollectionAssert.Contains(d5, c2c1);
CollectionAssert.Contains(d5, c3c4c5);
CollectionAssert.Contains(d5, c3c3);
ts.Dispose();
}
}
public static bool IsProfiting(this li_claims claim, DateTime?moment = null)
{
// 必须是叶子债权才能收益
if (!claim.IsLeafClaim(moment))
{
return(false);
}
if (claim.li_projects_profiting.IsHuoqiProject())
{
if (claim.status < (int)Agp2pEnums.ClaimStatusEnum.NeedTransfer)
{
// 如果是昨日之前创建的 不可转让/可转让 债权，则会产生收益（提现后不再产生收益）
var checkPoint = moment.GetValueOrDefault(DateTime.Now).Date.AddDays(-1);
return(claim.createTime < checkPoint ||
claim.li_project_transactions_invest.type == (int)Agp2pEnums.ProjectTransactionTypeEnum.AutoInvest); // 自动续投的话会产生收益
}
return(false);
}
return(claim.status < (int)Agp2pEnums.ClaimStatusEnum.NeedTransfer);
}
public void GenerateClaimFromNoData()
{
// 修复没有创建的债权
var context = new Agp2pDataContext();
//检查已完成的项目是否创建了债权
var ptrs =
context.li_project_transactions.Where(
ptr => ptr.type == (int)Agp2pEnums.ProjectTransactionTypeEnum.RepayToInvestor && ptr.project == 486)
.ToList();
int count = 0;
ptrs.ForEach(ptr =>
{
if (ptr.li_claims_invested.Any())
{
return;
}
var claimFromInvestment = new li_claims
{
principal = ptr.principal,
projectId = ptr.project,
profitingProjectId = ptr.project,
createFromInvestment = context.li_claims.Single(l => l.id == ptr.gainFromClaim).createFromInvestment,
createTime = (DateTime)ptr.li_projects.complete_time,
userId = ptr.investor,
status = (byte)Agp2pEnums.ClaimStatusEnum.Completed,
number = context.li_claims.Single(l => l.id == ptr.gainFromClaim).number,
parentClaimId = ptr.gainFromClaim
};
context.li_claims.InsertOnSubmit(claimFromInvestment);
count += 1;
});
context.SubmitChanges();
Debug.WriteLine("创建债权：" + count);
}
/// <summary>
/// 重写虚方法,此方法将在Init事件前执行
/// </summary>
protected override void ShowPage()
{
Init += Project_Init; //加入IInit事件
project_id = DTRequest.GetQueryInt("project_id");
page = Math.Max(1, DTRequest.GetQueryInt("page"));
buyClaimId = DTRequest.GetQueryInt("buyClaimId");
if (project_id <= 0)
{
return;
}
projectModel = context.li_projects.FirstOrDefault(p => p.id == project_id);
if (projectModel == null)
{
//HttpContext.Current.Response.Redirect(linkurl("error", "?msg=" + Utils.UrlEncode("出错啦，您要浏览的页面不存在或已删除啦！")));
HttpContext.Current.Response.Redirect(linkurl("404"));
return;
}
li_claims preBuyClaim = null;
if (buyClaimId != 0)
{
preBuyClaim = context.li_claims.SingleOrDefault(c => c.id == buyClaimId);
if (preBuyClaim == null)
{
HttpContext.Current.Response.Redirect(linkurl("error", "?msg=" + Utils.UrlEncode("出错啦，您要浏览的页面不存在或已删除啦！")));
return;
}
}
Investable = new Investable {
NeedTransferClaim = preBuyClaim, Project = projectModel
};
// 浏览次数 + 1
projectModel.click += 1;
context.SubmitChanges();
var pr = GetProjectInvestmentProgress(projectModel);
//剩余金额
investmentBalance = pr.GetInvestmentBalance();
//风控信息
risk = projectModel.li_risks;
//借款人
loaner = risk.li_loaners;
//借款人企业
loaner_company = risk.li_loaners?.li_loaner_companies;
//抵押物
mortgages = projectModel.li_risks.li_risk_mortgage.Select(rm => rm.li_mortgages).ToList();
invsetorCount = projectModel.GetInvestedUserCount();
projectSum = projectModel.financing_amount;
projectDescription = projectModel.title;
//还款计划
repayment_tasks = projectModel.li_repayment_tasks
.Where(task => task.only_repay_to == null)
.OrderBy(rt => rt.should_repay_time)
.ToList();
if (Investable.NeedTransferClaim != null)
{
var ratio = Investable.NeedTransferClaim.principal / projectModel.financing_amount;
repayment_tasks = repayment_tasks.Select(src => new li_repayment_tasks
{
repay_principal = Math.Round(src.repay_principal * ratio, 2),
repay_interest = Investable.NeedTransferClaim.Parent.GetProfitingSectionDays(src,
(claimBeforeProfitingDays, claimProfitingDays, claimInvalidDays) =>
Math.Round(src.repay_interest * ratio * claimInvalidDays / (claimBeforeProfitingDays + claimProfitingDays + claimInvalidDays), 2)),
should_repay_time = src.should_repay_time,
term = src.term
}).ToList();
}
}
public static li_claims GetRootClaim(this li_claims claim)
{
return(claim.Parent == null ? claim : claim.Parent.GetRootClaim());
}
public static bool IsParentOf(this li_claims parentClaim, li_claims childClaim)
{
return(childClaim.IsChildOf(parentClaim));
}
public static Agp2pEnums.ClaimStatusEnum?GetStatusByTime(this li_claims childClaim, DateTime time)
{
return((Agp2pEnums.ClaimStatusEnum?)childClaim.GetHistoryClaimByTime(time)?.status);
}
