/// <summary>
/// 从PlanCourse取出一个当前累积权值最小，并且没有被处理过的节点
/// </summary>
/// <returns></returns>
private Node GetMinWeightRudeNode(PlanCourse planCourse, List <Node> nodeList, string originID)
{
double weight = double.MaxValue;
Node destNode = null;
foreach (Node node in nodeList)
{
if (node.ID == originID)
{
continue;
}
PassedPath pPath = planCourse[node.ID];
if (pPath.BeProcessed)
{
continue;
}
if (pPath.Weight < weight)
{
weight = pPath.Weight;
destNode = node;
}
}
return(destNode);
}
public RoutePlanResult GetShortestTimePath(string originID, string destID)
{
PlanCourse planCourse = new PlanCourse(nodeList, originID);
Node curNode = GetMinWeightRudeNode(planCourse, originID);
#region 计算过程
while (curNode != null)
{
PassedPath curPath = planCourse[curNode.ID];
foreach (Edge edge in curNode.EdgeList)
{
//已选取的顶点则不必考虑
if (curPath.PassedIDList.Contains(edge.EndNodeID)) continue;
PassedPath targetPath = planCourse[edge.EndNodeID];
double tempWeight = curPath.Weight + edge.Weight;
if (tempWeight < targetPath.Weight)
{
targetPath.Weight = tempWeight;
targetPath.PassedIDList.Clear();
for (int i = 0; i < curPath.PassedIDList.Count; i++)
{
targetPath.PassedIDList.Add(curPath.PassedIDList[i].ToString());
}
targetPath.PassedIDList.Add(curNode.ID);
}
}
//标志为已处理
planCourse[curNode.ID].BeProcessed = true;
//获取下一个未处理节点
curNode = GetMinWeightRudeNode(planCourse, originID);
}
#endregion
//表示规划结束
return this.GetResult(planCourse, destID);
}
//从PlanCourse取出一个当前累积权值最小，并且没有被处理过的节点
private UnitStar GetMinWeightRudeNode(PlanCourse planCourse, List <UnitStar> nodeList, int originID)
{
double weight = double.MaxValue;
UnitStar destNode = null;
foreach (UnitStar node in nodeList)
{
if (node.UnitId == originID)
{
continue;
}
PassedPath pPath = planCourse[node.UnitId];
if (pPath.BeProcessed)
{
continue;
}
if (pPath.Weight < weight)
{
weight = pPath.Weight;
destNode = node;
}
}
return(destNode);
}
private void ChangeDegreeProgram(Plan plan)
{
List <PlanCourse> plans = Request <PlanCourse> .GetAll("A", "B").Where(i => i.planID == plan.ID).ToList();//planCourses.Where(i => i.planID == plan.ID).ToList();
foreach (PlanCourse planCourse in plans)
{
Request <PlanCourse> .Delete(planCourse.ID, "A", "B");
}
Dictionary <int, int> semesterOrders = new Dictionary <int, int>();
Dictionary <int, int> semesterMap = new Dictionary <int, int>();
int nowSem = 1;
List <Semester> semesterList = Request <Semester> .GetAll("A", "B").Where(i => i.ID >= plan.semesterID).ToList();
foreach (Semester sem in semesterList)
{
if (sem.standard == true)
{
semesterMap.Add(nowSem, sem.ID);
semesterOrders.Add(nowSem, 0);
nowSem++;
}
}
List <RequiredCourse> requirements = plan.degreeProgram.requiredCourses.ToList();
foreach (RequiredCourse req in requirements)
{
PlanCourse pcourse = new PlanCourse();
pcourse.planID = plan.ID;
int order = semesterOrders[req.semester];
pcourse.order = order;
semesterOrders[req.semester] = order + 1;
pcourse.semesterID = semesterMap[req.semester];
pcourse.courseID = req.courseID;
pcourse.credits = req.course.courseHours;
Request <PlanCourse> .Add(pcourse, "A", "B");
}
List <ElectiveCourse> elects = plan.degreeProgram.electiveCourses.ToList();
foreach (ElectiveCourse elect in elects)
{
PlanCourse pcourse = new PlanCourse();
pcourse.planID = plan.ID;
int order = semesterOrders[elect.semester];
pcourse.order = order;
semesterOrders[elect.semester] = order + 1;
pcourse.semesterID = semesterMap[elect.semester];
pcourse.electiveListID = elect.electiveListID;
pcourse.credits = elect.credits.ToString();
Request <PlanCourse> .Add(pcourse, "A", "B");
}
}
PlanCourse _planCourseQueue_Get(PlanCourse partialPlanCourse)
{
PlanCourse PlanCourse = _context.PlanCourses.Where(c => c.ID == partialPlanCourse.ID)
.Include(pc => pc.plan)
.Include(pc => pc.plan.degreeProgram)
.Include(pc => pc.plan.planCourses.Select(s => s.course.prerequisites))
.Include(pc => pc.plan.planCourses.Select(s => s.course.prerequisiteFor))
.Include(pc => pc.plan.semester)
.Include(pc => pc.plan.user)
.Include(pc => pc.semester)
.Include(pc => pc.electiveList)
.Include(pc => pc.course)
.First();
return(PlanCourse);
}
//获取权值最小的路径
public RoutePlanResult Paln(List <UnitStar> nodeList, int originID, int destID)
{
PlanCourse planCourse = new PlanCourse(nodeList, originID);
UnitStar curNode = this.GetMinWeightRudeNode(planCourse, nodeList, originID);
#region 计算过程
while (curNode != null)
{
PassedPath curPath = planCourse[curNode.UnitId];//获取当前计算节点的路径
foreach (Edge edge in curNode.EdgeList)
{
//Debug.Log("curPath:" + curPath.CurNodeID + " targetPath:" + edge.EndNodeID);
PassedPath targetPath = planCourse[edge.EndNodeID]; //获取目标计算节点的路径
if (targetPath == null) //回溯到原点，没有意义
{
continue;
}
double tempWeight = curPath.Weight + edge.Weight; //算出当前计算节点的权重加上边的权重
if (tempWeight < targetPath.Weight) //如果小于直接到目标节点的权重，则更新
{
targetPath.Weight = tempWeight; //
targetPath.PassedIDList.Clear();
for (int i = 0; i < curPath.PassedIDList.Count; i++)
{
targetPath.PassedIDList.Add(curPath.PassedIDList[i]);
}
targetPath.PassedIDList.Add(curNode.UnitId);
}
}
//标志为已处理
planCourse[curNode.UnitId].BeProcessed = true;
//获取下一个未处理节点
curNode = this.GetMinWeightRudeNode(planCourse, nodeList, originID);
}
#endregion 计算过程
//表示规划结束
return(this.GetResult(planCourse, destID));
}
/// <summary>
/// 获取权值最小的路径
/// </summary>
/// <param name="nodeList"></param>
/// <param name="originID"></param>
/// <param name="destID"></param>
/// <returns></returns>
public RoutePlanResult Paln(List <Node> nodeList, string originID, string destID)
{
//初始化起始节点到其他节点的路径表(权值，经过的节点，是否被处理）
//同时初始化其他节点的路径表
PlanCourse planCourse = new PlanCourse(nodeList, originID);
Node curNode = this.GetMinWeightRudeNode(planCourse, nodeList, originID);
#region 计算过程
while (curNode != null)
{
PassedPath curPath = planCourse[curNode.ID];
foreach (Edge edge in curNode.EdgeList)
{
PassedPath targetPath = planCourse[edge.EndNodeID];
double tempWeight = curPath.Weight + edge.Weight;
if (tempWeight < targetPath.Weight)
{
targetPath.Weight = tempWeight;
targetPath.PassedNodeList.Clear();
for (int i = 0; i < curPath.PassedNodeList.Count; i++)
{
targetPath.PassedNodeList.Add(curPath.PassedNodeList[i]);
}
targetPath.PassedNodeList.Add(curNode);
}
}
//标志为已处理
planCourse[curNode.ID].BeProcessed = true;
//获取下一个未处理节点
curNode = this.GetMinWeightRudeNode(planCourse, nodeList, originID);
}
#endregion
//表示规划结束
return(this.GetResult(planCourse, destID));
}
public ActionResult SaveCourseInfo(int ID, int?courseID, string notes)
{
if (ModelState.IsValid)
{
PlanCourse pcourseAttached = Request <PlanCourse> .GetItemByID(ID, "A", "B");
Plan planAttached = Request <Plan> .GetItemByID(pcourseAttached.planID, "A", "B");
if (webSecurity.CurrentUser.IsInRole("Advisor") || planAttached.userID == webSecurity.CurrentUserId)
{
pcourseAttached.notes = notes;
pcourseAttached.courseID = courseID;
Request <PlanCourse> .Update(pcourseAttached, pcourseAttached, "A", "B");
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
public ActionResult UpdateCourseInfo(int id = 0)
{
if (id > 0)
{
//PlanCourse pcourse = planCourses.Find(id);
PlanCourse pcourse = _planCourseProducer.Get(new PlanCourse()
{
ID = id
});
if (pcourse != null)
{
//Plan planAttached = plans.Find(pcourse.planID);
Plan planAttached = pcourse.plan;
if (webSecurity.CurrentUser.IsInRole("Advisor") || planAttached.userID == webSecurity.CurrentUserId)
{
if (pcourse.electiveListID != null)
{
List <DropdownCourse> courses = new List <DropdownCourse>();
List <ElectiveListCourse> elistCourses = pcourse.electiveList.courses.ToList();
foreach (ElectiveListCourse elistc in elistCourses)
{
DropdownCourse now = new DropdownCourse();
now.ID = elistc.courseID;
now.courseHeader = elistc.course.courseHeader;
courses.Add(now);
}
if (pcourse.courseID != null)
{
ViewBag.courseID = new SelectList(courses.AsEnumerable(), "ID", "courseHeader", pcourse.courseID);
}
else
{
ViewBag.courseID = new SelectList(courses.AsEnumerable(), "ID", "courseHeader");
}
}
return(PartialView("PlanCourseFormPartial", new PlanCourseEdit(pcourse)));
}
}
}
return(HttpNotFound());
}
/// <summary>
/// 从PlanCourse表中取出目标节点的PassedPath，这个PassedPath即是规划结果
/// </summary>
/// <returns></returns>
private RoutePlanResult GetResult(PlanCourse planCourse, string destID)
{
PassedPath pPath = planCourse[destID];
if (pPath.Weight == int.MaxValue)
{
RoutePlanResult result1 = new RoutePlanResult(null, int.MaxValue);
return(result1);
}
Node[] passedNodeIDs = new Node[pPath.PassedNodeList.Count];
for (int i = 0; i < passedNodeIDs.Length; i++)
{
passedNodeIDs[i] = pPath.PassedNodeList[i];
}
RoutePlanResult result = new RoutePlanResult(passedNodeIDs, pPath.Weight);
return(result);
}
public ActionResult SaveCourseInfo(int ID, int?courseID, string notes)
{
if (ModelState.IsValid)
{
//PlanCourse pcourseAttached = planCourses.Find(ID);
PlanCourse pcourseAttached = _planCourseProducer.Get(new PlanCourse()
{
ID = ID
});
//Plan planAttached = plans.Find(pcourseAttached.planID);
Plan planAttached = pcourseAttached.plan;
if (webSecurity.CurrentUser.IsInRole("Advisor") || planAttached.userID == webSecurity.CurrentUserId)
{
pcourseAttached.notes = notes;
pcourseAttached.courseID = courseID;
//planCourses.UpdateValues(pcourseAttached, pcourseAttached);
//planCourses.SaveChanges();
_planCourseProducer.Update(pcourseAttached);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
public PlanCourseEdit(PlanCourse pcourse)
{
ID = pcourse.ID;
if (pcourse.courseID != null)
{
courseID = (int)pcourse.courseID;
courseHeader = pcourse.course.courseHeader;
}
else
{
courseID = null;
courseHeader = null;
}
if (pcourse.electiveListID != null)
{
electiveListName = pcourse.electiveList.electiveListName;
}
else
{
electiveListName = null;
}
notes = pcourse.notes;
}
//从PlanCourse表中取出目标节点的PassedPath，这个PassedPath即是规划结果
private RoutePlanResult GetResult(PlanCourse planCourse, int destID)
{
PassedPath pPath = planCourse[destID];
if (pPath.Weight == int.MaxValue)
{
RoutePlanResult result1 = new RoutePlanResult();
result1.Weight = int.MaxValue;
return(result1);
}
List <UnitStar> passedStars = new List <UnitStar>();
for (int i = 0; i < pPath.PassedIDList.Count; i++)
{
passedStars.Add(MogoWorld.m_dataMapManager.GetUnitStarById(pPath.PassedIDList[i]));
}
RoutePlanResult result = new RoutePlanResult();
result.PassedStars = passedStars;
result.Weight = pPath.Weight;
return(result);
}
public ActionResult MoveCourse(int ID, int semester, int order)
{
PlanCourse pcourseAttached = Request <PlanCourse> .GetItemByID(ID, "A", "B");
Plan planAttached = Request <Plan> .GetItemByID(pcourseAttached.planID, "A", "B");
if (webSecurity.CurrentUser.IsInRole("Advisor") || planAttached.userID == webSecurity.CurrentUserId)
{
if (Request <Semester> .GetItemByID(semester, "A", "B") != null)
{
int oldSemester = pcourseAttached.semesterID;
int oldOrder = pcourseAttached.order;
if (semester != oldSemester)
{
List <PlanCourse> moveUp = planAttached.planCourses.Where(s => s.semesterID == oldSemester).ToList();
foreach (PlanCourse pc in moveUp)
{
if (pc.order > oldOrder)
{
pc.order = pc.order - 1;
Request <PlanCourse> .Update(pc, pc, "A", "B");
}
}
List <PlanCourse> moveDown = planAttached.planCourses.Where(s => s.semesterID == semester).ToList();
foreach (PlanCourse pc in moveDown)
{
if (pc.order >= order)
{
pc.order = pc.order + 1;
Request <PlanCourse> .Update(pc, pc, "A", "B");
}
}
}
else
{
if (oldOrder < order)
{
List <PlanCourse> moveUp = planAttached.planCourses.Where(s => s.semesterID == oldSemester).ToList();
foreach (PlanCourse pc in moveUp)
{
if (pc.order > oldOrder && pc.order <= order)
{
pc.order = pc.order - 1;
Request <PlanCourse> .Update(pc, pc, "A", "B");
}
}
}
else if (oldOrder > order)
{
List <PlanCourse> moveDown = planAttached.planCourses.Where(s => s.semesterID == oldSemester).ToList();
foreach (PlanCourse pc in moveDown)
{
if (pc.order >= order && pc.order < order)
{
pc.order = pc.order + 1;
Request <PlanCourse> .Update(pc, pc, "A", "B");
}
}
}
}
pcourseAttached.semesterID = semester;
if (order < 7)
{
pcourseAttached.order = order;
}
else
{
pcourseAttached.order = 7;
}
Request <PlanCourse> .Update(pcourseAttached, pcourseAttached, "A", "B");
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
public Object Add()
{
try
{
if (request.Type == ModelType.Course)
{
Course value = (request as Request <Course>).RequestedMembers.First();
return(new Response <Course>(request as Request <Course>, courses.AddAndSave(value)));
}
if (request.Type == ModelType.DegreeProgram)
{
DegreeProgram value = (request as Request <DegreeProgram>).RequestedMembers.First();
return(new Response <DegreeProgram>(request as Request <DegreeProgram>, degreePrograms.AddAndSave(value)));
}
if (request.Type == ModelType.ElectiveCourse)
{
ElectiveCourse value = (request as Request <ElectiveCourse>).RequestedMembers.First();
return(new Response <ElectiveCourse>(request as Request <ElectiveCourse>, electiveCourses.AddAndSave(value)));
}
if (request.Type == ModelType.ElectiveList)
{
ElectiveList value = (request as Request <ElectiveList>).RequestedMembers.First();
return(new Response <ElectiveList>(request as Request <ElectiveList>, electiveLists.AddAndSave(value)));
}
if (request.Type == ModelType.ElectiveListCourse)
{
ElectiveListCourse value = (request as Request <ElectiveListCourse>).RequestedMembers.First();
return(new Response <ElectiveListCourse>(request as Request <ElectiveListCourse>, electiveListCourses.AddAndSave(value)));
}
if (request.Type == ModelType.Plan)
{
Plan value = (request as Request <Plan>).RequestedMembers.First();
return(new Response <Plan>(request as Request <Plan>, plans.AddAndSave(value)));
}
if (request.Type == ModelType.PlanCourse)
{
PlanCourse value = (request as Request <PlanCourse>).RequestedMembers.First();
return(new Response <PlanCourse>(request as Request <PlanCourse>, planCourses.AddAndSave(value)));
}
if (request.Type == ModelType.PrerequisiteCourse)
{
PrerequisiteCourse value = (request as Request <PrerequisiteCourse>).RequestedMembers.First();
return(new Response <PrerequisiteCourse>(request as Request <PrerequisiteCourse>, prerequisiteCourses.AddAndSave(value)));
}
if (request.Type == ModelType.RequiredCourse)
{
RequiredCourse value = (request as Request <RequiredCourse>).RequestedMembers.First();
return(new Response <RequiredCourse>(request as Request <RequiredCourse>, requiredCourses.AddAndSave(value)));
}
if (request.Type == ModelType.Semester)
{
Semester value = (request as Request <Semester>).RequestedMembers.First();
return(new Response <Semester>(request as Request <Semester>, semesters.AddAndSave(value)));
}
}
catch
{
return(null);
}
return(null);
}
/// <summary>
/// 从PlanCourse取出一个当前累计权值最小，并且没有被处理过的节点
/// </summary>
/// <param name="planCourse">迪克斯特拉(Dikastra)算法中，一个顶点到所有其他顶点的最短路径</param>
/// <param name="originID">北京地铁所有路线的车站</param>
/// <returns>从当前站点可达通路的权重最小的边的节点</returns>
private Node GetMinWeightRudeNode(PlanCourse planCourse, string originID)
{
double weight = double.MaxValue;
Node destNode = null;
foreach (Node node in nodeList)
{
if (node.ID == originID)
continue;
PassedPath pPath = planCourse[node.ID];
if (pPath.BeProcessed)
continue;
if (pPath.Weight < weight)
{
weight = pPath.Weight;
destNode = node;
}
}
return destNode;
}
public Object Update()
{
try
{
if (request.Type == ModelType.Course)
{
Course value = (request as Request <Course>).RequestedMembers[0];
Course replace = (request as Request <Course>).RequestedMembers[1];
return(new Response <Course>(request as Request <Course>, courses.UpdateAndSave(value, replace)));
}
if (request.Type == ModelType.DegreeProgram)
{
DegreeProgram value = (request as Request <DegreeProgram>).RequestedMembers[0];
DegreeProgram replace = (request as Request <DegreeProgram>).RequestedMembers[1];
return(new Response <DegreeProgram>(request as Request <DegreeProgram>, degreePrograms.UpdateAndSave(value, replace)));
}
if (request.Type == ModelType.ElectiveCourse)
{
ElectiveCourse value = (request as Request <ElectiveCourse>).RequestedMembers[0];
ElectiveCourse replace = (request as Request <ElectiveCourse>).RequestedMembers[1];
return(new Response <ElectiveCourse>(request as Request <ElectiveCourse>, electiveCourses.UpdateAndSave(value, replace)));
}
if (request.Type == ModelType.ElectiveList)
{
ElectiveList value = (request as Request <ElectiveList>).RequestedMembers[0];
ElectiveList replace = (request as Request <ElectiveList>).RequestedMembers[1];
return(new Response <ElectiveList>(request as Request <ElectiveList>, electiveLists.UpdateAndSave(value, replace)));
}
if (request.Type == ModelType.ElectiveListCourse)
{
ElectiveListCourse value = (request as Request <ElectiveListCourse>).RequestedMembers[0];
ElectiveListCourse replace = (request as Request <ElectiveListCourse>).RequestedMembers[1];
return(new Response <ElectiveListCourse>(request as Request <ElectiveListCourse>, electiveListCourses.UpdateAndSave(value, replace)));
}
if (request.Type == ModelType.Plan)
{
Plan value = (request as Request <Plan>).RequestedMembers[0];
Plan replace = (request as Request <Plan>).RequestedMembers[1];
return(new Response <Plan>(request as Request <Plan>, plans.UpdateAndSave(value, replace)));
}
if (request.Type == ModelType.PlanCourse)
{
PlanCourse value = (request as Request <PlanCourse>).RequestedMembers[0];
PlanCourse replace = (request as Request <PlanCourse>).RequestedMembers[1];
return(new Response <PlanCourse>(request as Request <PlanCourse>, planCourses.UpdateAndSave(value, replace)));
}
if (request.Type == ModelType.PrerequisiteCourse)
{
PrerequisiteCourse value = (request as Request <PrerequisiteCourse>).RequestedMembers[0];
PrerequisiteCourse replace = (request as Request <PrerequisiteCourse>).RequestedMembers[1];
return(new Response <PrerequisiteCourse>(request as Request <PrerequisiteCourse>, prerequisiteCourses.UpdateAndSave(value, replace)));
}
if (request.Type == ModelType.RequiredCourse)
{
RequiredCourse value = (request as Request <RequiredCourse>).RequestedMembers[0];
RequiredCourse replace = (request as Request <RequiredCourse>).RequestedMembers[1];
return(new Response <RequiredCourse>(request as Request <RequiredCourse>, requiredCourses.UpdateAndSave(value, replace)));
}
if (request.Type == ModelType.Semester)
{
Semester value = (request as Request <Semester>).RequestedMembers[0];
Semester replace = (request as Request <Semester>).RequestedMembers[1];
return(new Response <Semester>(request as Request <Semester>, semesters.UpdateAndSave(value, replace)));
}
}
catch
{
return(null);
}
return(null);
}
/// <summary>
/// 从PlanCourse表中取出目标及诶单的PassedPath，这个PassedPath即是规划结果
/// </summary>
/// <param name="planCourse">迪克斯特拉(Dikastra)算法中，一个顶点到所有其他顶点的最短路径</param>
/// <param name="destID">目标车站ID</param>
/// <returns>到达目的站点的路线</returns>
private RoutePlanResult GetResult(PlanCourse planCourse, string destID)
{
PassedPath pPath = planCourse[destID];
if (pPath.Weight == int.MaxValue)
{
RoutePlanResult result1 = new RoutePlanResult(null, int.MaxValue);
return result1;
}
string[] passedNodeIDs = new string[pPath.PassedIDList.Count + 1];
for (int i = 0; i < passedNodeIDs.Length - 1; i++)
{
passedNodeIDs[i] = pPath.PassedIDList[i].ToString();
}
passedNodeIDs[passedNodeIDs.Length - 1] = pPath.CurNodeID;
RoutePlanResult result = new RoutePlanResult(passedNodeIDs, pPath.Weight);
return result;
}
PlanCourse _planCourseQueue_Create(PlanCourse data)
{
return(Create(data));
}
void _planCourseQueue_Update(PlanCourse data)
{
Update(data);
}
void _planCourseQueue_Remove(PlanCourse data)
{
Remove(data);
}
public ActionResult MoveCourse(int ID, int semester, int order)
{
//PlanCourse pcourseAttached = planCourses.Find(ID);
PlanCourse pcourseAttached = _planCourseProducer.Get(new PlanCourse {
ID = ID
});
//Plan planAttached = plans.Find(pcourseAttached.planID);
Plan planAttached = pcourseAttached.plan;
if (webSecurity.CurrentUser.IsInRole("Advisor") || planAttached.userID == webSecurity.CurrentUserId)
{
//if (semesters.Find(semester) != null)
if (_semesterProducer.Get(new Semester()
{
ID = semester
}) != null)
{
int oldSemester = pcourseAttached.semesterID;
int oldOrder = pcourseAttached.order;
if (semester != oldSemester)
{
List <PlanCourse> moveUp = planAttached.planCourses.Where(s => s.semesterID == oldSemester).ToList();
//List<PlanCourse> moveUp =
foreach (PlanCourse pc in moveUp)
{
if (pc.order > oldOrder)
{
pc.order = pc.order - 1;
//planCourses.UpdateValues(pc, pc);
_planCourseProducer.Update(pc);
}
}
List <PlanCourse> moveDown = planAttached.planCourses.Where(s => s.semesterID == semester).ToList();
foreach (PlanCourse pc in moveDown)
{
if (pc.order >= order)
{
pc.order = pc.order + 1;
//planCourses.UpdateValues(pc, pc);
_planCourseProducer.Update(pc);
}
}
}
else
{
if (oldOrder < order)
{
List <PlanCourse> moveUp = planAttached.planCourses.Where(s => s.semesterID == oldSemester).ToList();
foreach (PlanCourse pc in moveUp)
{
if (pc.order > oldOrder && pc.order <= order)
{
pc.order = pc.order - 1;
//planCourses.UpdateValues(pc, pc);
_planCourseProducer.Update(pc);
}
}
}
else if (oldOrder > order)
{
List <PlanCourse> moveDown = planAttached.planCourses.Where(s => s.semesterID == oldSemester).ToList();
foreach (PlanCourse pc in moveDown)
{
if (pc.order >= order && pc.order < order)
{
pc.order = pc.order + 1;
//planCourses.UpdateValues(pc, pc);
_planCourseProducer.Update(pc);
}
}
}
}
pcourseAttached.semesterID = semester;
if (order < 7)
{
pcourseAttached.order = order;
}
else
{
pcourseAttached.order = 7;
}
//planCourses.UpdateValues(pcourseAttached, pcourseAttached);
//planCourses.SaveChanges();
_planCourseProducer.Update(pcourseAttached);
return(new HttpStatusCodeResult(HttpStatusCode.OK));
}
}
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
private void ChangeDegreeProgram(Plan plan)
{
//List<PlanCourse> plans = planCourses.Where(i => i.planID == plan.ID.ToList();
List <PlanCourse> plans = _planCourseProducer.GetAll().Where(pc => pc.planID == plan.ID).ToList();
foreach (PlanCourse planCourse in plans)
{
_planCourseProducer.Remove(planCourse);
//planCourses.Remove(planCourse);
//planCourses.SaveChanges();
}
Dictionary <int, int> semesterOrders = new Dictionary <int, int>();
Dictionary <int, int> semesterMap = new Dictionary <int, int>();
int nowSem = 1;
//List<Semester> semesterList = semesters.Where(i => i.ID >= plan.semesterID).ToList();
List <Semester> semesterList = _semesterProducer.GetAll().Where(s => s.ID >= plan.semesterID).ToList();
foreach (Semester sem in semesterList)
{
if (sem.standard == true)
{
semesterMap.Add(nowSem, sem.ID);
semesterOrders.Add(nowSem, 0);
nowSem++;
}
}
List <RequiredCourse> requirements = plan.degreeProgram.requiredCourses.ToList();
foreach (RequiredCourse req in requirements)
{
PlanCourse pcourse = new PlanCourse();
pcourse.planID = plan.ID;
int order = semesterOrders[req.semester];
pcourse.order = order;
semesterOrders[req.semester] = order + 1;
pcourse.semesterID = semesterMap[req.semester];
pcourse.courseID = req.courseID;
pcourse.credits = req.course.courseHours;
_planCourseProducer.Create(pcourse);
//planCourses.Add(pcourse);
//planCourses.SaveChanges();
}
List <ElectiveCourse> elects = plan.degreeProgram.electiveCourses.ToList();
foreach (ElectiveCourse elect in elects)
{
PlanCourse pcourse = new PlanCourse();
pcourse.planID = plan.ID;
int order = semesterOrders[elect.semester];
pcourse.order = order;
semesterOrders[elect.semester] = order + 1;
pcourse.semesterID = semesterMap[elect.semester];
pcourse.electiveListID = elect.electiveListID;
pcourse.credits = elect.credits.ToString();
_planCourseProducer.Create(pcourse);
//planCourses.Add(pcourse);
//planCourses.SaveChanges();
}
}
