public void Update(EditCourseVM model)
{
var newDetail = model.OrderDetail;
var order = OrderService.GetCurrentOrder();
var orderDetail = order.OrderDetails
.First(od => od.OrderDetailID == newDetail.OrderDetailID);
if (model.IsTrackCourse)
{
UpdateTrackGroup(newDetail, orderDetail);
}
else if (orderDetail.Track_TC != null)
{
UpdateTrackPrices(order, orderDetail.Track_TC, model.PriceTypeTC,
newDetail, model.CityTC);
}
else
{
UpdateCourse(model, newDetail, orderDetail);
}
orderDetail.ClearDiscount();
orderDetail.SeatNumber = null;
var extrases = ExtrasService.GetFor(orderDetail).Select(x => x.Extras_ID);
var notAvailableExtrases = orderDetail.OrderExtras.Where(
od => !extrases.Contains(od.Extras_ID)).ToList();
for (int i = 0; i < notAvailableExtrases.Count; i++)
{
var notAvailable = notAvailableExtrases[i];
orderDetail.OrderExtras.Remove(notAvailable);
}
OrderService.SubmitChanges();
}
public static List <SelectListItem> GetAllGroups(this EditCourseVM model,
string cityTC)
{
var result = new List <SelectListItem>();
result.Add(new SelectGroupItem
{
Text = "”точнить дату позже",
Value = ((int)Groups.NotChoiceGroupID).ToString()
});
foreach (var group in model.GetGroups(cityTC))
{
result.Add(new SelectGroupItem
{
Selected = group.Group_ID == model.OrderDetail.Group_ID,
Text =
(group.DateBeg)
.NotNullToString("dd.MM.yyyy") + " " +
group.DayShift.Name + " " +
group.Complex.Name,
Value = group.Group_ID.ToString(),
DayShift = group.DayShift_TC
});
}
return(result);
}
public async Task <IActionResult> Edit(long id, EditCourseVM editCourseViewModel)
{
if (id != editCourseViewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
Course course = _mapper.Map <Course>(editCourseViewModel);
_unitOfWork.Courses.Update(course);
await _unitOfWork.SaveAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!_unitOfWork.Courses.IsExist(editCourseViewModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(List)));
}
return(View(editCourseViewModel));
}
public ActionResult EditCourse(EditCourseVM model)
{
if (model.PriceTypeTC == null)
{
model.PriceTypeTC = string.Empty;
}
EditCourseVMService.Update(model);
return(RedirectToDetails());
}
public static List <SelectListItem> GetAllCity(this EditCourseVM model)
{
return(SelectListUtil.GetSelectItemList(model.Cities,
x => x.CityName,
x => x.City_TC));
/* .AddItem(new SelectListItem
* {
* Text = "ƒистанционное обучение",
* Value = Cities.Distance,
* });*/
}
public async Task <IActionResult> EditCourse(EditCourseVM model)
{
try
{
var course = _coursesRepository.FindById(model.Id);
if (!ModelState.IsValid)
{
var facilitators = await _userManager.GetUsersInRoleAsync("Facilitator");
var selectFacilitators = facilitators.Select(p => new SelectListItem
{
Text = $"{p.FirstName} {p.MiddleName} {p.LastName}",
Value = p.Id
});
model = new EditCourseVM
{
Id = course.Id,
CourseName = course.CourseName,
Facilitators = selectFacilitators
};
model.Facilitators = selectFacilitators;
ModelState.AddModelError("", "Please fill all the required fields correctly");
return(View(model));
}
if (model.FacilitatorId != null)
{
course.FacilitatorId = model.FacilitatorId;
}
else
{
course.FacilitatorId = null;
}
course.CourseName = model.CourseName;
var isSuccess = _coursesRepository.Update(course);
if (!isSuccess)
{
ModelState.AddModelError("", "An error occured while updating the course");
return(View(model));
}
return(RedirectToAction("CourseList"));
}
catch (Exception e)
{
ModelState.AddModelError("", $"An error occured: {e}");
return(View(model));
}
}
public IHttpActionResult Edit(EditCourseVM course)
{
Course c = new CoursesRepository().Course(course.ID) as Course;
if (c == null)
{
return(BadRequest("Course id didn't match"));
}
c = new Course {
ID = course.ID, SubjectID = course.SubjectID, TeacherID = course.TeacherID
};
bool edited = new CoursesRepository().Edit(c);
if (!edited)
{
return(BadRequest("Course couldn't be edited"));
}
return(Ok(c));
}
public IActionResult Edit(EditCourseVM course)
{
if (ModelState.IsValid)
{
var teacherF = TeacherRepo.FindTeacher(course.TeacherId);
var courseToUpdate = new Course
{
Name = course.Name,
Description = course.Description,
Teacher = teacherF,
Id = course.CourseId
};
CourseRepo.UpdateCourse(courseToUpdate);
return(RedirectToAction(nameof(Index)));
}
course.Teachers = TeacherRepo.GetAll();
return(View(course));
}
// This method returns the get view for creating courses
public async Task <IActionResult> EditCourse(int id)
{
var course = _coursesRepository.FindById(id);
var facilitators = await _userManager.GetUsersInRoleAsync("Facilitator");
var selectFacilitators = facilitators.Select(p => new SelectListItem
{
Text = $"{p.FirstName} {p.MiddleName} {p.LastName}",
Value = p.Id
});
var model = new EditCourseVM
{
Id = course.Id,
CourseName = course.CourseName,
Facilitators = selectFacilitators
};
return(View(model));
}
public IActionResult Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var course = CourseRepo.FindCourse((int)id);
if (course == null)
{
return(NotFound());
}
EditCourseVM name = new EditCourseVM
{
CourseId = course.Id,
Name = course.Name,
Description = course.Description,
Teachers = TeacherRepo.GetAll(),
};
return(View(name));
}
public EditCourse(string userid, string courseid, string coursename, string coursecode)
{
InitializeComponent();
BindingContext = vm = new EditCourseVM(userid, courseid, coursename, coursecode);
}
private void UpdateCourse(EditCourseVM model, OrderDetail newDetail,
OrderDetail orderDetail)
{
if (orderDetail.Order.IsOrganization && newDetail.Count > 0)
{
orderDetail.Count = newDetail.Count;
}
orderDetail.OrgStudents = newDetail.OrgStudents;
var prices = PriceService.GetAllPricesForCourse(orderDetail.Course_TC,
orderDetail.Track_TC).AsQueryable();
string resultPriceTypeTC = null;
if (!model.CityTC.IsEmpty())
{
orderDetail.City_TC = model.CityTC;
}
if (PriceTypes.IsDistance(model.PriceTypeTC))
{
resultPriceTypeTC = model.PriceTypeTC;
orderDetail.Group_ID = null;
}
if (PriceTypes.IsIndividual(model.PriceTypeTC))
{
resultPriceTypeTC = model.PriceTypeTC;
orderDetail.Group_ID = null;
}
if (model.PriceTypeTC == string.Empty)
{
orderDetail.Group_ID = newDetail.Group_ID;
if (orderDetail.Group_ID.HasValue)
{
var group = GroupService.GetByPK(newDetail.Group_ID);
resultPriceTypeTC = OrderService.GetPriceTypeForGroup(group,
model.IsBusiness, orderDetail.Order.CustomerType);
}
else
{
var groupPrices = prices.Where(p => !p.IsDistance && !p.IsIndividual).AsQueryable();
var maxGroupPrice = groupPrices.GetDefault();
if (maxGroupPrice != null)
{
resultPriceTypeTC = maxGroupPrice.PriceType_TC;
}
}
}
if (PriceTypes.Webinars.Contains(model.PriceTypeTC))
{
resultPriceTypeTC = model.PriceTypeTC;
orderDetail.Group_ID = newDetail.Group_ID;
}
if (resultPriceTypeTC != null)
{
orderDetail.PriceType_TC = resultPriceTypeTC;
orderDetail.Price = prices.First(p => p.PriceType_TC == resultPriceTypeTC)
.Price;
}
else
{
var defaultPrice = prices.GetDefault();
orderDetail.PriceType_TC = defaultPrice.PriceType_TC;
orderDetail.Price = defaultPrice.Price;
}
}
private EditCourseVM GetCourseVM(OrderDetail orderDetail, bool isTrackCourse)
{
var courseTC = orderDetail.Track_TC ?? orderDetail.Course_TC;
var prices = PriceService.GetAllPricesForCourseFilterByCustomerTye(
courseTC, orderDetail.Order.CustomerType, null);
var cityTC = Cities.Moscow;
if (orderDetail.Group != null)
{
cityTC = orderDetail.Group.BranchOffice.TrueCity_TC;
}
else if (orderDetail.City_TC != null)
{
cityTC = orderDetail.City_TC;
}
var editCourseVM = new EditCourseVM(CityService.GetPrefixList())
{
Cities =
FilterCityByPrices(CityService
.GetAll().ToList(), prices.ToList()),
CityTC = cityTC,
/*PriceListTypes.GetCityTC(orderDetail.PriceType.PriceListType_TC)
* ?? Cities.Moscow*/
OrderDetail = orderDetail,
Prices = prices.OrderBy(p => p.Price).ToList()
};
if (PriceTypes.IsDistanceOrWebinar(orderDetail.PriceType_TC))
{
editCourseVM.CityTC = Cities.Moscow;
}
if (orderDetail.Track_TC == null)
{
var groups = GroupService
.GetGroupsForCourse(courseTC)
.ToList();
var webinarOnlyGroups = GroupService.WebinarOnly().Where(x => x.Course_TC == courseTC).ToList();
groups.AddRange(webinarOnlyGroups);
editCourseVM.Groups = groups.OrderBy(g => g.DateBeg).ToList();
}
else if (isTrackCourse)
{
editCourseVM.Groups = GroupService
.GetGroupsForCourseByPriceType(orderDetail.Course_TC,
orderDetail.PriceType_TC, orderDetail.City_TC)
.OrderBy(g => g.DateBeg).ToList();
}
else
{
editCourseVM.Groups = new List <Group>();
}
editCourseVM.IsBusiness = PriceTypes.IsBusiness(orderDetail.PriceType_TC);
if (PriceTypes.IsDistanceOrWebinar(orderDetail.PriceType_TC))
{
editCourseVM.PriceTypeTC = PriceTypes.Webinar;
}
if (orderDetail.Group.GetOrDefault(x => x.IsIntraExtramural))
{
editCourseVM.PriceTypeTC = PriceTypes.IntraExtra;
}
if (PriceTypes.IsIndividual(orderDetail.PriceType_TC))
{
editCourseVM.PriceTypeTC = PriceTypes.Individual;
}
if (editCourseVM.PriceTypeTC == null)
{
editCourseVM.PriceTypeTC = string.Empty;
}
return(editCourseVM);
}
