def get(self, request, course_id):
course = Course.objects.get(id=int(course_id))
# 查询用户是否已经学习了该课程
user_courses = UserCourse.objects.filter(user=request.user,
course=course)
if not user_courses:
# 如果没有学习该门课程就关联起来
user_course = UserCourse(user=request.user, course=course)
user_course.save()
# 相关课程推荐
# 找到学习这门课的所有用户
user_courses = UserCourse.objects.filter(course=course)
# 找到学习这门课的所有用户的id
user_ids = [user_course.user_id for user_course in user_courses]
# 通过所有用户的id,找到所有用户学习过的所有课程
all_user_courses = UserCourse.objects.filter(user_id__in=user_ids)
# 取出所有课程id
course_ids = [
all_user_course.course_id for all_user_course in all_user_courses
]
course_ids.remove(course.id)
# 通过所有课程的id,找到所有的课程，按点击量去五个
relate_courses = Course.objects.filter(
id__in=course_ids).order_by("-click_nums")[:5]
all_resources = CourseResource.objects.filter(course=course)
all_comments = CourseComments.objects.filter(
course=course).order_by("-id")
return render(
request, "course-comment.html", {
"course": course,
"all_resources": all_resources,
'all_comments': all_comments,
'relate_courses': relate_courses,
})
def get(self, request, video_id):
video = Video.objects.get(id=int(video_id))
#通过外键找到章节在找到视频对应的课程
course = video.lesson.course
course.students += 1
course.save()
#查询用户是否已经学习了该课程
user_courses = UserCourse.objects.filter(user=request.user,
course=course)
if not user_courses:
#如果没有学习该门课程就关联起来
user_course = UserCourse(user=request.user, course=course)
user_course.save()
#相关课程推荐
#找到学习这门课的所有用户id
user_course = UserCourse.objects.filter(course=course)
#找到学习这门课的所有用户id
user_ids = [user_course.user_id for user_course in user_course]
#通过所有用户的Id,找到所有用户学习过的所有课程
all_user_courses = UserCourse.objects.filter(user_id__in=user_ids)
#取出所有课程
course_ids = [
all_user_course.course_id for all_user_course in all_user_courses
]
relate_courses = Course.objects.filter(
id__in=course_ids).order_by("-click_nums")[:5]
# 资源
all_resources = CourseResource.objects.filter(course=course)
context = {
'course': course,
'all_resources': all_resources,
'relate_courses': relate_courses,
'video': video
}
return render(request, 'course/course-play.html', context)
def get(self, request, course_id):
course = Course.objects.get(id=int(course_id))
# 查询用户是否开始学习了该课，如果还未学习则，加入用户课程表
user_courses = UserCourse.objects.filter(user=request.user,
course=course)
if not user_courses:
user_course = UserCourse(user=request.user, course=course)
course.students += 1
course.save()
user_course.save()
# 从关系中取出user_id
user_ids = [user_course.user_id for user_course in user_courses]
# 这些用户学了的课程,外键会自动有id，取到字段
all_user_courses = UserCourse.objects.filter(user_id__in=user_ids)
# 取出所有课程id
course_ids = [
user_course.course_id for user_course in all_user_courses
]
# 获取学过该课程用户学过的其他课程
# .exclude(id=course.id)表示剔除
relate_courses = Course.objects.filter(
id__in=course_ids).order_by("-click_nums").exclude(
id=course.id)[:4]
# 是否收藏课程
all_resources = CourseResource.objects.filter(course=course)
all_comments = CourseComments.objects.all()
return render(
request, 'course-comment.html', {
'course': course,
'all_resources': all_resources,
'all_comments': all_comments,
"relate_courses": relate_courses,
})
def get(self, request, lesson_id):
lesson = Lesson.objects.get(id=int(lesson_id))
course = lesson.course
# 查询用户是否已经学习了该课程
user_courses = UserCourse.objects.filter(user=request.user,
course=course)
if not user_courses:
# 这里不用
# user_courses.user = request.user
# user_courses.course = course
# 因为 user，course 是外键，在 UserCourse 实际上存储的是 id ，这些 id 是已经存在的
user_courses = UserCourse(user=request.user, course=course)
user_courses.save()
# 记录用户行为日志
course_lesson = UserLesson()
course_lesson.lesson = lesson
course_lesson.user = request.user
course_lesson.save()
# lstm-arols
#seq = ['882617','883092','882609','882617','882537']
log_seq = UserLesson.objects.filter(
user=request.user).order_by('-add_time')[:5]
#print(log_seq)
pred_lessons = list()
try:
tmp = list()
for item in log_seq:
item_id = str(item.lesson.arols_id)
#print(item_id)
if item_id in word_vectors.vocab:
tmp.append(word_vectors[item_id])
tmp = np.asarray(tmp)
if len(tmp) == window_size:
pred_vec = lstm_model.predict(
tmp.reshape(1, window_size, vector_size))
pred_set = word_vectors.most_similar(positive=pred_vec, topn=5)
for rmd_lesson in pred_set:
pred_lessons.append(rmd_lesson[0])
except Exception as e:
print(e)
# 得出学过该课程的同学还学过的课程
user_courses = UserCourse.objects.filter(course=course)
user_ids = [user_course.user.id for user_course in user_courses]
all_user_courses = UserCourse.objects.filter(user_id__in=user_ids)
course_ids = [
user_course.course.id for user_course in all_user_courses
]
relate_courses = Course.objects.filter(
id__in=course_ids).order_by('-click_nums')[:5]
all_resources = CourseResource.objects.filter(course=course)
return render(
request, 'course-lesson.html', {
'lesson': lesson,
'course': course,
'all_resources': all_resources,
'relate_courses': relate_courses,
'pred_lessons': pred_lessons,
})
def post(self, request):
course_id = request.POST.get("course_id", "")
course = Course.objects.get(id=int(course_id))
course.students += 1
course.save()
user_name = request.POST.get("username", "")
pass_word = request.POST.get("password", "")
print("user_name = %s, pass_word = %s" % (user_name, pass_word))
user = authenticate(username=user_name, password=pass_word)
# 查询用户是否已经关联了该课程
user_cs = UserCourse.objects.filter(user=user, course=course)
print(user_cs)
if not user_cs:
user_course = UserCourse(user=user, course=course)
user_course.save()
user_courses = UserCourse.objects.filter(course=course)
user_ids = [user_course.user.id for user_course in user_courses]
all_user_courses = UserCourse.objects.filter(
user_id__in=user_ids) # user_in在列表里面
# 所有课程id
course_ids = [
user_course.course.id for user_course in all_user_courses
]
# 获取最近学过该课程的用户的其他课程
relate_courses = Course.objects.filter(
id__in=course_ids).order_by('-click_nums')[:5]
all_resources = CourseResourse.objects.filter(course=course)
# 转换为courselist
courses = []
courses.append({
"org_name": course.course_org.name,
'teacher': course.teacher.name,
'name': course.name,
'desc': course.desc,
'degree': course.detail,
'learn_times': course.learn_times,
'students': course.students,
'fav_nums': course.fav_nums,
'image': str(course.image),
'click_nums': course.click_nums,
'category': course.category,
'is_banner': course.is_banner,
'youneed_know': course.youneed_know,
'teacher_tell': course.teacher_tell,
'tag': course.tag,
'add_time': course.add_time
})
all_resources = course_Resourse_list(all_resources)
relate_courses = course_list(relate_courses)
return JsonResponse(
{
"status": 200,
'data': {
'course': courses,
'all_resources': all_resources,
'relate_courses': relate_courses,
}
},
json_dumps_params={'ensure_ascii': False})
def get(self, request, course_id):
course = Course.objects.get(id=int(course_id))
all_resources = CourseResource.objects.filter(course=course)
all_comments = CourseComments.objects.filter(course=course).order_by('-add_time')
# 查询用户是否已经关联了该课程
user_courses = UserCourse.objects.filter(user=request.user, course=course)
if not user_courses:
user_course = UserCourse(user=request.user, course=course)
user_course.save()
# 该用户评分的所有课程的关联
all_currentuser_courses = CourseScores.objects.filter(user=request.user)
# 用户已评分课程的id
all_currentuser_courses_ids = [all_currentuser_course.course.id for all_currentuser_course in all_currentuser_courses]
# 所有课程
all_courses = Course.objects.all()
# 所有课程的id
all_courses_ids = [all_course.id for all_course in all_courses]
# 该用户没有评分的课程的id，差集
all_currentuser_notcourses_ids = list(set(all_courses_ids).difference(set(all_currentuser_courses_ids)))
# 建立一个双重列表
if len(all_currentuser_courses_ids) > 0 and len(all_currentuser_notcourses_ids) > 0:
xx = max(all_currentuser_courses_ids) + 1
yy = max(all_currentuser_notcourses_ids) + 1
# 计算 R(ij)
R = []
# 统计同时对i和j评分的用户数量
N = []
for x in range(xx):
RY = []
NY = []
for y in range(yy):
RY.append(0)
NY.append(0)
R.append(RY)
N.append(NY)
for i in all_currentuser_courses_ids:
for j in all_currentuser_notcourses_ids:
# i是已评分，j是没评分
# 对i评分过的用户
scores_is = CourseScores.objects.filter(course_id=i)
# 这些用户的id
scores_i_ids = [scores_i.user.id for scores_i in scores_is]
# 对j评分过的用户
scores_js = CourseScores.objects.filter(course_id=j)
# 这些用户的id
scores_j_ids = [scores_j.user.id for scores_j in scores_js]
# 两者的交集就是同时给i和j评分的用户的id
scores_ij_ids = list(set(scores_i_ids).intersection(set(scores_j_ids)))
# 统计这些用户的数量，得到分母
count_scores_ij = len(scores_ij_ids)
N[i][j] = count_scores_ij
# 计算分子
count = 0
# 遍历对i和j都评分过的用户
for id in scores_ij_ids:
# 用户对i的评分
rui = CourseScores.objects.get(user_id=id, course_id=i).scores
# 用户对j的评分
ruj = CourseScores.objects.get(user_id=id, course_id=j).scores
# 得到分子
count = count + (rui - ruj)
# 相除得到 R(ij)
if count_scores_ij != 0:
R[i][j] = count/count_scores_ij
else:
R[i][j] = count
# 计算预测评分 P(ij)
P = []
for y in range(yy):
P.append(0)
# 此时的用户是request.user，要对每个j进行预测评分
for j in all_currentuser_notcourses_ids:
# 分母是累加得到的
count_all_users = 0
# 分子同样是累加得到的
count_all_users_scores = 0
for i in all_currentuser_courses_ids:
# 累加得到分母
count_all_users = count_all_users + N[i][j]
# 计算分子
# 先取得 ri
ri = CourseScores.objects.get(user=request.user, course_id=i).scores
count_all_users_scores = count_all_users_scores + N[i][j] * (ri - R[i][j])
# 通过累加后的分子除以累加后的分母，得到关于j的预测评分
if count_all_users != 0:
P[j] = count_all_users_scores/count_all_users
else:
P[j] = count_all_users_scores
P_arr = np.array(P)
P_Big = np.argsort(-P_arr)[:5] # 逆序输出前5位
relate_courses = Course.objects.filter(id__in=P_Big)
else:
user_courses = UserCourse.objects.filter(course=course)
# 学习该课程的所有用户id
user_ids = [user_course.user.id for user_course in user_courses]
# 通过所有的用户id，取出这些id相关联的所有课程，此时每个课程都包含了一堆信息，例如：课程名，添加时间等等
all_user_courses = UserCourse.objects.filter(user_id__in=user_ids) # _id是通过user这个外键取id，__in是因为传进去的是一个list
# 取出所有课程的id
course_ids = [user_course.course.id for user_course in all_user_courses]
# 排序取出点击数排在前5的课程
relate_courses = Course.objects.filter(Q(id__in=course_ids)&~Q(id=course.id)).order_by('-click_nums')[:5]
return render(request, 'course-comment.html', {
'course': course,
'course_resources': all_resources,
'all_comments': all_comments,
'relate_courses': relate_courses
})
