/// <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));
}
/// <summary>
/// 新手标第一期逻辑（停用）
/// </summary>
/// <param name="projectTransactionId"></param>
public static void CheckNewbieInvest(int projectTransactionId)
{
var context = new Agp2pDataContext();
var ptr = context.li_project_transactions.Single(tr => tr.id == projectTransactionId);
var project = ptr.li_projects;
if (!project.IsNewbieProject1())
{
return;
}
if (project.repayment_type != (int)Agp2pEnums.ProjectRepaymentTypeEnum.DaoQi)
{
throw new InvalidOperationException("新手标只考虑了到期还款付息的情况");
}
if (project.li_repayment_tasks.Any(r => r.only_repay_to == ptr.investor))
{
throw new InvalidOperationException("已经创建过此投资者的回款计划");
}
// 创建针对单个用户的还款计划
var finalProfitRate = 0.1m;// project.GetFinalProfitRate(ptr.create_time); // 暂时写死利率为 1/10，即投资 100 元有 10 元
var ta = new li_repayment_tasks
{
project = project.id,
repay_interest = Math.Round(finalProfitRate * ptr.principal, 2),
repay_principal = ptr.principal,
status = (byte)Agp2pEnums.RepaymentStatusEnum.Unpaid,
term = 1,
should_repay_time = project.CalcRepayTimeByTerm(1, ptr.create_time),
only_repay_to = ptr.investor
};
context.li_repayment_tasks.InsertOnSubmit(ta);
// 修改代收利息，添加钱包历史
var wallet = ptr.dt_users.li_wallets;
wallet.profiting_money += ta.repay_interest;
wallet.last_update_time = ptr.create_time;
var history = TransactionFacade.CloneFromWallet(wallet, Agp2pEnums.WalletHistoryTypeEnum.InvestSuccess);
history.li_project_transactions = ptr;
context.li_wallet_histories.InsertOnSubmit(history);
// 如果体验标完成了，则设置为完成
if (project.financing_amount == project.investment_amount)
{
project.status = (int)Agp2pEnums.ProjectStatusEnum.RepayCompleteIntime;
project.invest_complete_time = ptr.create_time;
project.complete_time = ptr.create_time;
}
context.SubmitChanges();
}
public static int GetProfitingDaysByTime(this li_repayment_tasks task, DateTime?moment = null)
{
Debug.Assert(task.IsUnpaid());
var startTime = moment.GetValueOrDefault(DateTime.Now).Date;
Debug.Assert(task.GetStartProfitingTime().Date <= startTime);
Debug.Assert(startTime <= task.should_repay_time.Date);
return((int)(startTime - task.GetStartProfitingTime().Date).TotalDays);
}
protected string GetRepaymentTaskType(li_repayment_tasks repayment)
{
var trType = repayment.repay_interest != 0 && repayment.repay_principal != 0
? Agp2pEnums.WalletHistoryTypeEnum.RepaidPrincipalAndInterest
: (repayment.repay_interest != 0
? Agp2pEnums.WalletHistoryTypeEnum.RepaidInterest
: Agp2pEnums.WalletHistoryTypeEnum.RepaidPrincipal);
return(Utils.GetAgp2pEnumDes(trType));
}
public static DateTime GetStartProfitingTime(this li_repayment_tasks task)
{
if (task.term == 1)
{
return(task.li_projects.make_loan_time.Value);
}
var prevTask = task.li_projects.li_repayment_tasks.OrderByDescending(ta => ta.should_repay_time)
.First(ta => ta.should_repay_time < task.should_repay_time);
return(prevTask.should_repay_time);
}
private List <li_project_transactions> getRepayTransactions(li_repayment_tasks repayment)
{
var pro = repayment.li_projects;
List <li_project_transactions> profiting;
if (repayment.status >= (int)Agp2pEnums.RepaymentStatusEnum.ManualPaid)
{
// 查询所有收益记录
profiting = pro.li_project_transactions.Where(
t =>
t.create_time == repayment.repay_at && t.type != (int)Agp2pEnums.ProjectTransactionTypeEnum.Invest &&
t.status == (int)Agp2pEnums.ProjectTransactionStatusEnum.Success).ToList();
}
else
{
profiting = TransactionFacade.GenerateRepayTransactions(repayment, repayment.should_repay_time); // 临时预计收益
}
return(profiting);
}
public static int GetTotalProfitingDays(this li_repayment_tasks task)
{
return((int)(task.should_repay_time.Date - task.GetStartProfitingTime().Date).TotalDays);
}
