/// <summary>
/// 根据学生ID、父阶段英文名，从数据库返回StudentApplyStageWrap
/// </summary>
/// <param name="studentID"></param>
/// <param name="parentNameEn"></param>
/// <returns></returns>
public StudentApplyStageWrap GetStudentApplyStageWrapItem(string studentID, string parentNameEn)
{
if (!IsGuidStringValid(studentID))
{
return(null);
}
Guid _StudentID = new Guid(studentID);
StudentApplyStageEntity parentStage = repository.StudentApplyStage.FirstOrDefault(s => s.StudentID == _StudentID && s.StageNameEn == parentNameEn);
return(new StudentApplyStageWrap
{
ParentStage = parentStage,
ChildStages = repository.StudentApplyStage
.Where(s => s.StudentID == _StudentID && s.ParentNo == parentStage.StageNo)
.OrderBy(s => s.StageNo)
.ToList()
});
}
/// <summary>
/// 开始新的申请期
/// </summary>
/// <param name="parentStageNo"></param>
/// <param name="studentID"></param>
public void StartParentStage(int parentStageNo, Guid studentID)
{
List <StudentApplyStageEntity> resultList = new List <StudentApplyStageEntity>();
StudentApplyStageEntity parentStage = repository.StudentApplyStage.SingleOrDefault(s => s.StudentID == studentID && s.StageNo == parentStageNo);
IEnumerable <StudentApplyStageEntity> childStages = repository.StudentApplyStage.Where(s => s.StudentID == studentID && s.ParentNo == parentStageNo);
if (parentStage == null)
{
return;
}
parentStage.Percentage = 1;
parentStage.CurrentOption = parentStage.BeginOption;
resultList.Add(parentStage);
//如果子阶段无时间限制，则所有子阶段Percentage 均设为1
//否则，仅设置第一个子阶段的Percentage 为1
if (parentStage.IsDateSameWithParent)
{
foreach (StudentApplyStageEntity childItem in childStages)
{
childItem.Percentage = 1;
childItem.CurrentOption = childItem.BeginOption;
}
resultList.AddRange(childStages);
}
else
{
int minChildNo = childStages.Min(s => s.StageNo);
StudentApplyStageEntity firstChild = childStages.SingleOrDefault(s => s.StageNo == minChildNo);
firstChild.Percentage = 1;
firstChild.CurrentOption = firstChild.BeginOption;
resultList.Add(firstChild);
}
//保存到数据库中
repository.UpdateStudentApplyStages(resultList);
}
/// <summary>
/// 获取并设置下一子阶段信息，仅在当前子阶段完成，而其他兄弟子阶段未全部完成才调用
/// </summary>
/// <param name="currentChildStage"></param>
/// <returns></returns>
public string ChildStageFinishHandler_GetNextSibling(StudentApplyStageEntity currentChildStage)
{
Guid studentID = currentChildStage.StudentID;
IEnumerable <StudentApplyStageEntity> siblingChild = repository.StudentApplyStage
.Where(s => s.StudentID == studentID && s.ParentNo == currentChildStage.ParentNo && s.StageClass == 2 && s.StageNo != currentChildStage.StageNo);
StudentApplyStageEntity nextChild;
//如果兄弟阶段的Percent 都不为0，则选取第一个未完成的阶段
//否则，选取第一个未开始的阶段，Percent 为0
if (siblingChild.Count(s => s.Percentage == 0) <= 0)
{
nextChild = siblingChild.Where(s => s.Percentage > 0 && s.Percentage < 100).OrderBy(s => s.StageNo).First();
}
else
{
nextChild = siblingChild.Where(s => s.Percentage == 0).OrderBy(s => s.StageNo).First();
nextChild.Percentage = 1;
nextChild.CurrentOption = nextChild.BeginOption;
repository.SaveStudentApplyStage(nextChild);
}
return(nextChild.StageNameEn);
}
public StageSubmitCBModel ChildStageFinishHandler(StudentApplyStageEntity childStage)
{
//dynamic resultObject = new ExpandoObject();
StageSubmitCBModel resultData = new StageSubmitCBModel();
StudentApplyStageEntity parentStage = repository.StudentApplyStage.SingleOrDefault(s => s.StudentID == childStage.StudentID && s.StageNo == childStage.ParentNo);
parentStage.Percentage = UpdateParentPercentage(parentStage.StageNo, parentStage.StudentID);
if (parentStage.Percentage == 100)
{
resultData.IsParentComplete = true;
resultData.NextParentNameEn = ChildStageFinishHandler_GetNextParent(parentStage);
}
else
{
resultData.IsParentComplete = false;
resultData.NextSiblingNameEn = ChildStageFinishHandler_GetNextSibling(childStage);
}
repository.SaveStudentApplyStage(parentStage);
return(resultData);
}
/// <summary>
///
/// </summary>
/// <param name="stageNo">当前阶段ID</param>
/// <param name="refBeginDate">基准开始日期</param>
/// <param name="refEndDate">基准结束日期</param>
/// <param name="currentDetail">当前阶段Detail</param>
/// <param name="studentID">学生ID</param>
/// <param name="isDateSameWithParent">是否和父阶段日期一样</param>
/// <returns></returns>
StudentApplyStageEntity CalApplyStage(
int stageNo,
DateTime refBeginDate,
DateTime?refEndDate,
ApplyStageVersionDetailEntity currentDetail,
Guid studentID,
bool isDateSameWithParent,
DateTime signDate)
{
StudentApplyStageEntity applyStage = new StudentApplyStageEntity
{
ID = Guid.NewGuid(),
StudentID = studentID,
StageNo = stageNo,
StageName = currentDetail.StageName,
StageNameEn = currentDetail.StageNameEn,
StageClass = currentDetail.StageClass,
ParentNo = currentDetail.ParentNo,
IsForbid = currentDetail.IsForbid,
StatusOption = currentDetail.StatusOption,
BeginOption = currentDetail.BeginOption,
EndOption = currentDetail.EndOption,
CurrentOption = currentDetail.BeginOption,
CanForbid = currentDetail.CanForbid,
CanChangeDate = currentDetail.CanChangeDate,
CanChangeName = currentDetail.CanChangeName,
IsDateSameWithParent = currentDetail.IsDateSameWithParent
};
//如果当前阶段的日期与父阶段一样，则直接赋值即可
if (isDateSameWithParent)
{
applyStage.BeginDate = refBeginDate;
applyStage.EndDate = Convert.ToDateTime(refEndDate);
}
else
{
//如果当前阶段的开始日期需要计算，则在基准开始日期上加上给定天数
if (Convert.ToBoolean(currentDetail.IsCalBeginDate))
{
applyStage.BeginDate = refBeginDate.AddDays(Convert.ToInt16(currentDetail.BeginDate));
}
else //否则，则拼接年、月、日 来计算日期。下面算法的结果是，计算出给定月份的最后一天的日期值
{
int year = (signDate.Month > currentDetail.BeginDate) ? signDate.Year + 1 : signDate.Year;
int month = Convert.ToInt16(currentDetail.BeginDate) + 1;
if (month > 12)
{
year += 1;
month = 1;
}
int day = 1;
applyStage.BeginDate = new DateTime(year, month, day).AddDays(-1);
}
//如果当前阶段的结束日期需要计算，则在基准结束日期上加上给定天数
if (Convert.ToBoolean(currentDetail.IsCalEndDate))
{
applyStage.EndDate = applyStage.BeginDate.AddDays(Convert.ToInt16(currentDetail.EndDate));
}
else //否则，则拼接年、月、日 来计算日期。下面算法的结果是，计算出给定月份的最后一天的日期值
{
int year = (signDate.Month > currentDetail.EndDate) ? signDate.Year + 1 : signDate.Year;
int month = Convert.ToInt16(currentDetail.EndDate) + 1;
if (month > 12)
{
year += 1;
month = 1;
}
int day = 1;
applyStage.EndDate = new DateTime(year, month, day).AddDays(-1);
}
}
return(applyStage);
}
/// <summary>
/// 根据VersionDetailList 计算出ApplySchedule，新的哦！
/// </summary>
/// <param name="VersionDetailList"></param>
/// <returns></returns>
List <StudentApplyStageWrap> CalApplyStageWrapList(Guid studentID, DateTime signDate, Guid versionID)
{
//函数的返回值
List <StudentApplyStageWrap> applyStageWrapList = new List <StudentApplyStageWrap>();
//定义函数中会用到的两个局部变量
StudentApplyStageEntity parentStage = null;
StudentApplyStageEntity childStage = null;
//用于暂时性的存储已经完成初始化的ApplyStage的List
List <StudentApplyStageEntity> resultStageList = new List <StudentApplyStageEntity>();
//根据版本ID 从数据库中获取IsForbid 为false 的 VersionDetailList
List <ApplyStageVersionDetailEntity> versionDetailList =
repository.ApplyStageVersionDetail
.Where(a => a.VersionID == versionID && a.IsForbid == false)
.ToList();
//获取StageClass = 1 的StageNo数组
int[] parentStageArray = versionDetailList.Where(a => a.StageClass == 1).OrderBy(a => a.StageNo).Select(a => a.StageNo).ToArray();
//遍历父阶段
for (int i = 0; i < parentStageArray.Length; i++)
{
//下面初始化两个局部变量
DateTime refBeginDate = DateTime.Now;
DateTime refEndDate = DateTime.Now;
int parentStageNo = parentStageArray[i];
//根据StageNo 取出VersionDetail
ApplyStageVersionDetailEntity currentParentDetail = versionDetailList.SingleOrDefault(v => v.StageNo == parentStageNo);
//如果当前父阶段为同辈阶段的第一个，则基准开始时间设为签约日期
if (i == 0 || currentParentDetail.IsCalBeginDate == false)
{
refBeginDate = signDate;
}
else //否则，基准开始日期为兄长阶段的结束日期
{
refBeginDate = resultStageList.SingleOrDefault(s => s.StageNo == Convert.ToInt16(parentStageArray[i - 1])).EndDate;
}
//父阶段调用该方法时，最后一个参数全为false
parentStage = CalApplyStage(parentStageNo, refBeginDate, null, currentParentDetail, studentID, false, signDate);
if (parentStage.BeginDate > parentStage.EndDate)
{
parentStage.EndDate = parentStage.BeginDate.AddMonths(1);
}
//获取当前阶段的子阶段的StageNo 数组
int[] childClass = versionDetailList.Where(a => a.ParentNo == parentStageNo && a.IsForbid == false).OrderBy(a => a.StageNo).Select(a => a.StageNo).ToArray();
for (int j = 0; j < childClass.Length; j++)
{
//将子阶段的StageNo 由字符串转换为数字
int childStageNo = childClass[j];
//根据StageNo 取出VersionDetail
ApplyStageVersionDetailEntity currentChildDetail = versionDetailList.SingleOrDefault(v => v.StageNo == childStageNo);
//如果子阶段的开始结束日期与父阶段一样的话，基准开始结束日期均与父阶段一致
if (currentChildDetail.IsDateSameWithParent)
{
childStage = CalApplyStage(childStageNo, parentStage.BeginDate, parentStage.EndDate, currentChildDetail, studentID, true, signDate);
}
else
{
//如果当前子阶段为同辈阶段的第一个，则基准开始时间设为父阶段的开始日期
if (j == 0)
{
refBeginDate = parentStage.BeginDate;
}
else //否则，基准开始日期为兄长阶段的结束日期
{
refBeginDate = resultStageList.SingleOrDefault(s => s.StageNo == childClass[j - 1]).EndDate;
}
childStage = CalApplyStage(childStageNo, refBeginDate, null, currentChildDetail, studentID, false, signDate);
}
//把当前阶段的信息存储到resultStageList中，同辈间遍历的时候会用到
resultStageList.Add(childStage);
}
//如果当前父阶段的子阶段有时间限制，则把最后一个子阶段的EndDate值赋给父阶段的EndDate
if (!currentParentDetail.IsDateSameWithParent && childClass.Length > 0)
{
parentStage.EndDate = resultStageList.SingleOrDefault(s => s.StageNo == childClass.Last()).EndDate;
}
//把当前阶段的信息存储到resultStageList中，同辈间遍历的时候会用到
resultStageList.Add(parentStage);
}
//最后，将resultStageList 按封装成StudentApplyStageWrap 对象列表
foreach (StudentApplyStageEntity parentStageItem in resultStageList.Where(s => s.ParentNo == 1))
{
applyStageWrapList.Add(new StudentApplyStageWrap {
ParentStage = parentStageItem,
ChildStages = resultStageList
.Where(s => s.ParentNo == parentStageItem.StageNo)
.OrderBy(r => r.StageNo)
.ToList()
});
}
return(applyStageWrapList);
}
