private IEnumerable <Course> GetCourses(string RelationObject_ID,
string RelationObjectType)
{
IQueryable <Course> courseQuery = null;
if (RelationObjectType == null)
{
courseQuery = new List <Course>().AsQueryable();//Repository.GetAll();
}
else
{
var relationObjectType = ContextProvider.GetTypeByTableName(
RelationObjectType);
/* if (obj.RelationObject_ID is string[])
* obj.RelationObject_ID = (obj.RelationObject_ID as string[]).First();*/
var relationObjectID =
LinqToSqlUtils.CorrectPKType(RelationObject_ID, relationObjectType);
courseQuery = SiteObjectService
.GetByRelationObject <Course>(relationObjectType, relationObjectID);
ViewData["SiteObject"] = SORepository.GetAll().First(so =>
so.ID.Equals(relationObjectID) &&
so.Type == RelationObjectType);
}
return(courseQuery.Where(c => c.IsActive)
.OrderBy(c => c.WebSortOrder)
.Select(c => new { c.Course_TC, c.Name })
.ToList()
.Select(c => new Course
{
Course_TC = c.Course_TC,
Name = c.Name
}));
}
private void Check()
{
UpdateActiveByActualDate();
var blockWithoutContentCount = BlockCreator.GetBlocksWithoutContent().Count;
var outdatedRelationCount = SiteObjectService.GetRelationWithNotActive().Count;
if (blockWithoutContentCount > 0 || outdatedRelationCount > 0)
{
SendMail(CreateBody(blockWithoutContentCount, outdatedRelationCount));
}
}
protected override List <object> GetValuesForRow(Product item)
{
var values = base.GetValuesForRow(item);
var vendors = SiteObjectService.GetSingleRelation <Vendor>(item);
var entityLinks = new ListVM.EntityLinkList();
var metaData = MetaDataProvider.Get(typeof(Vendor));
foreach (var vendor in vendors)
{
entityLinks.Add(new ListVM.EntityLink(vendor, metaData, Url));
}
values.Add(entityLinks);
return(values);
}
public ActionResult SiteObjectEdit(string typeName, object id)
{
var entityType = typeof(SpecialistDataContext).Assembly.GetTypes()
.Where(t => t.FullName == typeName).First();
var type = LinqToSqlUtils.GetTableName(entityType);
var siteObject = SiteObjectService
.GetBy(type, LinqToSqlUtils.CorrectPKType(id, entityType));
if (siteObject == null)
{
return(Redirect(Request.UrlReferrer.AbsoluteUri));
}
return(View(ViewNames.EditRelationList, new EditVM(siteObject,
MetaDataProvider.Get(typeof(SiteObject)))));
}
List <string> GetCourseTagLinks(Course c)
{
var x1 = SiteObjectService.GetSingleRelation <Vendor>(c).ToList()
.Select(x => H.Anchor(Html.GetUrlFor(x), x.Name));
var x2 = SiteObjectService.GetSingleRelation <Section>(c).ToList()
.Select(x => H.Anchor(Html.GetUrlFor(x), x.Name));
var x3 = SiteObjectService.GetSingleRelation <Product>(c).ToList()
.Select(x => H.Anchor(Html.GetUrlFor(x), x.Name));
var x4 = SiteObjectService.GetSingleRelation <Profession>(c).ToList()
.Select(x => H.Anchor(Html.GetUrlFor(x), x.Name));
var x5 = SiteObjectService.GetSingleRelation <SiteTerm>(c).ToList()
.Select(x => H.Anchor(Html.GetUrlFor(x), x.Name));
return(x1.Concat(x2).Concat(x3).Concat(x4).Concat(x5)
.Select(x => x.AbsoluteHref().ToString()).ToList());
}
public ActionResult VideoFor(object obj)
{
var model = new List <Video>();
if (obj is Course)
{
model = SiteObjectService.GetDoubleRelation <Video>(obj)
.IsActive().ToList();
}
else
{
model = SiteObjectService.GetByRelationObject <Video>(obj)
.IsActive().ToList();
}
return(View(PartialViewNames.VideoBlock,
model.OrderByDescending(x => x.VideoID).ToList()));
}
public MobileCourseVM GetMobileByUrlName(string urlName)
{
var course = CourseService.GetByUrlName(urlName);
if (course == null)
{
return(null);
}
var section = SiteObjectService.GetSingleRelation <Section>(course)
.IsActive().OrderBy(x => x.IsMain).FirstOrDefault();
var model = new MobileCourseVM {
Course = course,
Groups = GroupService.GetGroupsForCourse(course.Course_TC).ToList(),
Section = section
};
model.Prices = PriceService.GetAllPricesForCourse(course.Course_TC, null);
return(model);
}
public List <TagWithEntity> GetTags(string courseTC)
{
var result = new List <TagWithEntity>();
var course = new Course {
Course_TC = courseTC
};
var products = SiteObjectService.GetSingleRelation <Product>(course);
foreach (var product in products)
{
result.Add(new TagWithEntity(product, 1 /*SiteObjectRelationService.GetWeight(product)*/));
}
var siteTerms = SiteObjectService.GetSingleRelation <SiteTerm>(course);
foreach (var siteTerm in siteTerms)
{
result.Add(new TagWithEntity(siteTerm, 1 /*SiteObjectRelationService.GetWeight(siteTerm)*/));
}
return
(result.Cast <TagWithEntity <object> >().ToList().Normalization().Cast <TagWithEntity>().ToList());
}
public TrackVM GetByUrlName(string urlName)
{
var track = TrackService.GetByUrlName(urlName);
if (track == null)
{
return(null);
}
var courseTC = track.Course_TC;
// var certifications = CertificationService.
// GetAllForCourse(courseTC);
var sections = SiteObjectService.GetSingleRelation <Section>(track)
.IsActive().ByWebOrder().ToList();
var prices = PriceService.GetAllPricesForCourse(courseTC, null);
var courseTCs = _.List(courseTC);
courseTCs.AddRange(CourseService.GetActiveTrackCourses().GetValueOrDefault(track.Course_TC)
?? new List <string>());
var certTypes = CourseCertificateService.GetAll(x => courseTCs.Contains(x.Course_TC))
.Select(x => new { x.Course_TC, x.CertType }).Distinct().ToList().Where(x =>
x.Course_TC != courseTC || x.CertType.CertTypeName.Contains(CertTypes.InterName))
.Select(x => x.CertType).ToList();
var trackDetailsVM =
new TrackVM {
Certifications = new List <Certification>(),
Course = track,
Prices = prices,
Sections = sections,
CertTypeList = certTypes,
CompleteCourseCount = StudentInGroupService.CompleteCountForTracks()
.GetValueOrDefault(track.ParentCourse_TC)
};
return(trackDetailsVM);
}
public ActionResult RelationList(string type, object id, bool?linkCreator)
{
var entityType = ContextProvider.GetTypeByTableName(type);
var siteObject = SiteObjectService
.GetBy(type, LinqToSqlUtils.CorrectPKType(id, entityType));
foreach (var objectRelation in siteObject.ObjectRelations)
{
var entityTypeForObject =
ContextProvider.GetTypeByTableName(objectRelation.RelationObjectType);
if (objectRelation.RelationObject == null)
{
continue;
}
objectRelation.RelationObject.Entity = DynamicRepository
.GetByPK(entityTypeForObject,
LinqToSqlUtils.CorrectPKType(
objectRelation.RelationObject_ID, entityTypeForObject));
}
var model = new RelationListVM {
EntityType = entityType,
SiteObject = new SiteObject {
ID = id, Type = type
},
ForLinkCreator = linkCreator.GetValueOrDefault(),
};
if (model.Sortable)
{
model.Relations = siteObject.ObjectRelations.OrderBy(x => x.RelationOrder).ToList();
}
else
{
model.Relations = siteObject.ObjectRelations
.OrderBy(x => x.RelationObject.GetOrDefault(y => y.Name)).ToList();
}
return(PartialView(PartialViewNames.RelationListControl, model));
}
public ActionResult Search(string typeName, int id, int?pageIndex)
{
if (!pageIndex.HasValue)
{
return(RedirectToAction(() => Search(typeName, id, 1)));
}
var type = SiteObject.GetType(typeName);
if (type == null)
{
return(null);
}
var news = SiteObjectService.GetByRelationObject <News>(type, id)
.IsActive().OrderByDescending(n => n.PublishDate)
.ToPagedList(pageIndex.GetValueOrDefault(1) - 1, 5);
return(View(
new RelationNewsVM {
News = news,
SiteObject = SiteObjectService.GetBy(
LinqToSqlUtils.GetTableName(type), id)
}));
}
public CourseVM GetByUrlName(string urlName)
{
var cityTC = UserSettingsService.CityTC;
var course = CourseService.GetByUrlName(urlName);
if (course == null)
{
return(null);
}
var courseTC = course.Course_TC;
var nextCourseTCList = CourseService.GetNextCourseTCs(_.List(course.ParentCourse_TC));
var nextCourses = CourseService.GetCourseLinkList(nextCourseTCList).ToList()
.OrderBy(x => nextCourseTCList.IndexOf(x.CourseTC)).ToList();
var notSecondCourseDiscount = CourseService.NotSecondCourses();
var secondCourse = SecondCourse(courseTC, nextCourses.Where(x => !notSecondCourseDiscount.Contains(x.CourseTC)).FirstOrDefault());
var successStories = SuccessStoryService.GetAll(x => x.Course_TC == courseTC).Take(1)
.OrderByDescending(x => x.SuccessStoryID).ToList();
var responceCount = successStories.Any() ? 1 : 2;
var responseQuery = ResponseService.GetAllForCourse(courseTC);
var responses = responseQuery
.Where(x => x.Rating >= ResponseRating.Good)
.GetRandom(responceCount).ToList();
if (responses.Count < responceCount)
{
responses.AddRange(responseQuery
.Where(x => x.Rating == ResponseRating.Common)
.GetRandom(responceCount - responses.Count));
}
if (!responses.Any())
{
responses = ResponseService.GetAll(x => x.IsActive &&
x.Type == RawQuestionnaireType.OrganizingComment)
.Take(responceCount).ToList();
}
var responseTotalCount = responseQuery.Count();
var nearestGroups = GroupService.GetNearestGroups(course, cityTC);
var trainers = nearestGroups.All
.Select(x => x.Teacher).Where(e => e != null && e.SiteVisible)
.Distinct(x => x.Employee_TC).ToList();
var morningDiscount = NearestGroupSet.HasMorningDiscount(nearestGroups.All);
var product = SiteObjectService.GetSingleRelation <Product>(course)
.IsActive().OrderByDescending(x => x.WebSortOrder).FirstOrDefault();
var prices = PriceService.GetAllPricesForCourse(course.Course_TC, null);
var certifications = CertificationService.GetAllForCourse(courseTC);
var vacancies = SuperJobService.GetVacancies(
SiteObjectRelationService.GetRelation(
typeof(Course), _.List(courseTC),
typeof(Profession))
.Select(sor => (int)sor.RelationObject_ID)
.ToList(), cityTC);
var withWebinar = PriceService.CourseWithWebinar();
var discount30 = Discount30Courses();
var actions = GetActionOnCoursePages().Where(x => {
var courseTCList = EntityUtils.GetCourseTCs(x, withWebinar);
return(!courseTCList.Any() || courseTCList.Contains(courseTC) ||
(x.MarketingAction_ID == 150 && discount30.Contains(courseTC)));
}).OrderBy(x => x.WebSortOrder).ToList();
if (course.IsExpensive)
{
actions = actions.Where(x => !x.CourseTCList.IsEmpty()).ToList();
}
var preTestIds = course.CoursePrerequisites.Select(x => x
.Test_ID.GetValueOrDefault())
.Where(x => x > 0).ToList();
var preTests = preTestIds.Any()
? TestService.GetAll(x =>
preTestIds.Contains(x.Id)).ToList()
: new List <Test>();
var sections = SiteObjectService.GetSingleRelation <Section>(course)
.IsActive().Where(x => !Sections.NotImportant.Contains(x.Section_ID)).ByWebOrder().ToList();
var tests = SiteObjectService.GetByRelationObject <Test>(course)
.Where(x => x.Status == TestStatus.Active).ToList();
var visitedCourseTCs = UserSettingsService.VisitedCourses.Except(_.List(courseTC)).ToList();
var visitedCourses = CourseService.GetCourseLinkList(visitedCourseTCs).ToList();
visitedCourseTCs.Insert(0, courseTC);
UserSettingsService.VisitedCourses = visitedCourseTCs;
var courseContentTC = courseTC == "сопсв-ю" && Htmls.IsSecond ? CourseTC.WebText : courseTC;
var courseContents = CourseContentService.GetAll(x => x.Course_TC == courseContentTC).ToList();
var certTypes = course.CourseCertificates.Select(cc => cc.CertType).Where(x => x.IsVisible).ToList();
var hasTracks = TrackService.GetAllTracksWithCourse(courseTC).Any();
var courseDetailsVM =
new CourseVM {
Course = course,
SecondCourse = secondCourse,
CourseInDiplom = CourseService.CoursesInDiploms().Contains(courseTC),
PrerequisiteTests = preTests,
HasPaperBook = ExtrasService.CoursesWithPaperBook().Contains(courseTC),
Actions = actions,
HasTracks = hasTracks,
CourseContents = courseContents,
Tests = tests,
MaxDiscount = GroupService.GetGroupsForCourse(courseTC)
.Where(x => !x.IsOpenLearning).Select(x => x.Discount).Max(),
CompleteCourseCount = CompleteCountForCourses().GetValueOrDefault(courseTC),
Responses = responses.ToList(),
SuccessStories = successStories,
NextCourses = nextCourses.ToList(),
WebinarDiscount = PriceService.WebinarDiscouns().GetValueOrDefault(courseTC),
NearestGroups = nearestGroups,
Certifications = certifications,
Prices = prices,
MorningDiscount = morningDiscount,
Trainers = trainers.ToList(),
Vacancies = vacancies.ToList(),
ResponseTotalCount = responseTotalCount,
UnlimitPrice = PriceService.GetUnlimitPrice(courseTC),
Sections = sections,
Product = product,
VisitedCourses = visitedCourses,
CertTypeList = certTypes,
WebinarDiscounts = PriceService.WebinarDiscouns()
};
return(courseDetailsVM);
}
public GroupVM GetGroup(decimal groupID)
{
var group = GroupService.GetByPK(groupID);
if (group == null)
{
return(null);
}
var user = AuthService.CurrentUser;
var sglList = new List <StudentInGroupLecture>();
StudentInGroup studentInGroup = null;
if (user.GetOrDefault(x => x.IsStudent))
{
studentInGroup = GetSig(groupID);
if (studentInGroup != null)
{
sglList = GetSqlList(studentInGroup);
}
}
var lectureOffset = 0;
var lecturesGroup = group.IsOpenLearning
? GroupService.GetByPK(group.MegaGroup_ID.Value) : group;
var lectures = lecturesGroup.Lectures.OrderBy(l => l.LectureDateBeg).ToList();
var lecturesVM = lectures.Select(l => {
var lectureHours = GetLectureHours(l);
lectureOffset += lectureHours;
return(new GroupVM.LectureVM
{
Lecture = l,
Contents = GetContent(group.Course, lectureOffset - lectureHours,
lectureHours),
StudentLecture = sglList.FirstOrDefault(
sgl => sgl.Lecture_ID == l.Lecture_ID)
});
}).ToList();
var groupFiles = @group.GroupFiles.Select(g => g.UserFile).ToList();
var groupUserFiles = groupFiles.Select(x => x.UserFileID);
var fileList = new FileListVM {
Group = group,
Files = groupFiles,
UserFiles = FileVMService.GetUserFiles(null)
.Where(x => !groupUserFiles.Contains(x.UserFileID)).ToList()
};
var tests = SiteObjectService.GetByRelationObject <Test>(group.Course).ToList();
var testAfterComplete = new List <Test>();
if (studentInGroup != null)
{
var isBegin = group.DateBeg.GetValueOrDefault() + group.TimeBeg.GetValueOrDefault().TimeOfDay <= DateTime.Now;
if (group.Course_TC == CourseTC.DpCons && isBegin)
{
testAfterComplete = TestService.CourseTests()
.GetValueOrDefault(studentInGroup.Track_TC) ?? new List <Test>();
}
else
{
testAfterComplete = TestService.CourseTests()
.GetValueOrDefault(@group.Course_TC) ?? new List <Test>();
}
}
var trainerUserId = group.Teacher.GetOrDefault(x =>
x.User.GetOrDefault(y => y.UserID));
var trainerCourseInfo = UserCourseInfoService.FirstOrDefault(x =>
x.UserID == trainerUserId && x.Course_TC == group.Course_TC)
.GetOrDefault(x => x.Description);
var sigId = studentInGroup.GetOrDefault(x => x.StudentInGroup_ID);
var IsCertExists = CertificateService.GetAll(x =>
x.StudentInGroup_ID == sigId).Any();
var isUnlimit = studentInGroup.GetOrDefault(x => x.IsUnlimit);
var r = GetHideVideo(studentInGroup, sglList, group);
var hideVideo = r.Item1;
var hideForUnlimit = r.Item2;
var canAccessVideo = r.Item3;
return(new GroupVM
{
Group = group,
TrainerCourseInfo = trainerCourseInfo,
Lectures = lecturesVM,
LastMessages = GetLastMessages(groupID),
FileList = fileList,
CanAccessVideo = canAccessVideo,
Tests = tests,
TestsAfterComplete = testAfterComplete,
StudentInGroup = studentInGroup,
IsCertExists = IsCertExists,
User = user,
HideForUnlimit = hideForUnlimit,
HideVideo = hideVideo,
IsUnlimit = isUnlimit,
Progress = GetProgress(lectures, group, studentInGroup)
});
}
private void SetSiteObject(object id, EditVM editVM)
{
var siteObjectType = LinqToSqlUtils.GetTableName(MetaData.EntityType);
editVM.SiteObject = SiteObjectService.GetBy(siteObjectType, id);
}
