def get(self):
str_id = self.request.get('id')
message = self.request.get('message')
if not str_id or not message:
self.response.status_int = 400
self.response.body = "Invalid or missing id and or message."
return
devices = GqlQuery('SELECT * FROM Device WHERE __key__ = :1',
Key.from_path('Device', str_id))
if devices.count() < 1:
self.response.status_int = 404
self.response.body = "Target device not registered."
return
payload = {'registration_ids': [devices.get().token], 'data': {'message': message}}
headers = {'Content-Type': 'application/json',
'Authorization': 'key=' + API_KEY}
result = urlfetch.fetch(url = ANDROID_GCM_URL,
payload = json.dumps(payload),
method = urlfetch.POST,
headers = headers)
self.response.status_int = result.status_code
self.response.body = result.content
def evaluationMeasureOLD(self, measure):
path = os.path.join(os.path.dirname(__file__), 'viewer_templates/class_profile_evaluation.html')
userProfiles = GqlQuery("SELECT * FROM UserProfile")
exerciseThereshold = 50
videoThereshold = 70
exercisePass = 0
videoPass = 0
userPassCourse = 0
pass_course_users = []
fail_course_users = []
for userProfile in userProfiles:
if(userProfile.evaluation_exercise >= exerciseThereshold):
exercisePass += 1
if(userProfile.evaluation_video >= videoThereshold):
videoPass += 1
if(userProfile.evaluation_video >= videoThereshold and userProfile.evaluation_exercise >= exerciseThereshold):
userPassCourse += 1
pass_course_users.append(userProfile)
else:
fail_course_users.append(userProfile)
template_values = {'exercisePass': exercisePass,
'exerciseFail': userProfiles.count() - exercisePass,
'videoPass': videoPass,
'videoFail': userProfiles.count() - videoPass,
'userPassCourse': userPassCourse,
'userFailCourse': userProfiles.count() - userPassCourse,
'measureList': Utils().getMeasureList(),
'passCourseUsers': pass_course_users,
'failCourseUsers': fail_course_users
}
self.response.out.write(template.render(path, template_values))
def exercise_progress(self, usuario):
x_vid = array([0.0, 25.0, 50.0, 75.0, 100.0])
y_vid = array([0.0, 40.0, 65.0, 85.0, 100.0])
pol_exercise_progress = Polynomial.fit(x_vid, y_vid, 5)
subject_exercises = GqlQuery("SELECT * FROM ViewerExercise")
exercise_progress = 0
for subject_exercise in subject_exercises:
userExercise = GqlQuery("SELECT * FROM UserExercise WHERE exercise_model = :1 AND user = :2", subject_exercise.exercise, usuario.user).get()
if(userExercise != None):
if(userExercise._progress == 1.0):
exercise_progress += 100
else:
exercise_progress += pol_exercise_progress(userExercise._progress*100)
return int(exercise_progress/subject_exercises.count())
def get(self):
str_id = self.request.get('id')
token = self.request.get('token')
if not str_id or not token:
self.response.status_int = 400
self.response.body = "Invalid or missing id and or token."
return
objects = GqlQuery('SELECT * FROM Device WHERE __key__ = :1',
Key.from_path('Device', str_id))
if objects.count() < 1:
obj = Device(key=Key.from_path('Device', str_id), token=token)
else:
obj = objects.get()
obj.put()
self.response.status_int = 200
self.response.body = "OK"
def correct_exercise_efficiency(self, usuario):
subject_exercises = GqlQuery("SELECT * FROM ViewerExercise")
totalEfficiency = 0
totalExercises= 0
for subject_exercise in subject_exercises:
problemLogs = GqlQuery("SELECT * FROM ProblemLog WHERE exercise = :1 AND user = :2 ORDER BY time_done ASC", subject_exercise.name, usuario.user)
if(problemLogs.count() > 0 ):
totalExercises += 1
problemsTime = 0
problemsAttempt = 0
exerciseCorrect = False
for problemLog in problemLogs:
problemsTime += problemLog.time_taken
problemsAttempt += problemLog.count_attempts
if(problemLog.correct == True):
exerciseCorrect = True
break
if(exerciseCorrect == True):
if(problemsTime < 10):
totalEfficiency += 50
elif(problemsTime > 100):
totalEfficiency += 0
else:
totalEfficiency += (1 - (problemsTime/100))*50
if(problemsAttempt > 6):
totalEfficiency += 0
else:
totalEfficiency += (1 - ((problemsAttempt-1)/5))*50
if (totalExercises == 0):
totalEfficiency = 0
else:
totalEfficiency = int(totalEfficiency/totalExercises)
return totalEfficiency
def video_progress(self, usuario):
x_vid = array([0.0, 50.0, 75.0, 100.0])
y_vid = array([0.0, 30.0, 55.0, 100.0])
pol_video_progress = Polynomial.fit(x_vid, y_vid, 5)
total_video_progress = 0
subject_videos = GqlQuery("SELECT * FROM ViewerVideo")
for subject_video in subject_videos:
userVideo = GqlQuery("SELECT * FROM UserVideo WHERE video = :1 AND user = :2", subject_video.video, usuario.user).get()
if(userVideo != None):
porcentajeVideo = (userVideo.seconds_watched/userVideo.duration)*100
if(porcentajeVideo >= 100):
total_video_progress += 100
else:
total_video_progress += pol_video_progress(porcentajeVideo)
return int(total_video_progress/subject_videos.count())
def post(self):
#TODO: add comments
user = cgi.escape(self.request.get('username'))
q = GqlQuery("SELECT artist, time FROM Listen WHERE user = '******'")
if q.count(limit=1) == 0:
logging.info('Fetching data for user: %s', user)
taskqueue.add(url='/fetchdata', params={'username': user})
self.response.write('Fetching data for user ' + user + '. Please wait')
return
else:
logging.info('Already have data for user %s in datastore. Not' + \
' fetching any new data from Last.fm', user)
for y in range(1, 13):
logging.info('Getting stats for month ' + str(y))
plays = 0
artists = dict()
for x in q:
if x.time.month == y:
plays += 1
if x.artist not in artists:
artists[x.artist] = 1
else:
artists[x.artist] += 1
self.response.write('<b>' + calendar.month_name[y] + '</b>')
self.response.write('<br>Total plays: ' + str(plays))
self.response.write('<br>Total artists: ' + str(len(artists)))
self.response.write('<br><br>Top artists:<br>')
sorted_artists = sorted(artists, key=artists.get, reverse=True)
for z in range(0, 10):
self.response.write(str(z+1) + '. ' + sorted_artists[z].encode('utf-8') + ': ' + \
str(artists[sorted_artists[z]]) + '<br>')
self.response.write('<br><br>')
def cognitiveModel(self, usuario):
hintAvoidance = 0
videoAvoidance = 0
unreflectiveUser = 0
hintAbuser = 0
totalDifferentExercises = 0
subject_exercises = GqlQuery("SELECT * FROM ViewerExercise")
for subject_exercise in subject_exercises:
problemLogs = GqlQuery("SELECT * FROM ProblemLog WHERE exercise = :1 AND user = :2 ORDER BY time_done ASC", subject_exercise.name, usuario.user)
if(problemLogs.count() > 0 ):
totalDifferentExercises += 1
exercisesSameKind = 0
hintAvoidPoints = 0
videoAvoidPoints = 0
unreflectivePoints = 0
hintAbusePoints = 0
exerciseVideo = GqlQuery("SELECT * FROM ExerciseVideo WHERE exercise = :1", subject_exercise.exercise).get()
userVideo = GqlQuery("SELECT * FROM UserVideo WHERE video = :1 AND user= :2", exerciseVideo.video, usuario.user).get()
videoDate = datetime.datetime.now()
if(userVideo != None):
videoDate = userVideo.backup_timestamp
for problemLog in problemLogs:
exercisesSameKind += 1
# Video Avoidance
if(problemLog.correct == False and (problemLog.time_done < videoDate)):
videoAvoidPoints += 1
# Hint Avoidance
if(problemLog.correct == False and problemLog.count_hints == 0):
hintAvoidPoints += 1
if(problemLog.correct == False and problemLog.count_hints == 1):
hintAvoidPoints += 0.5
# Calculamos el no reflexionador
if(problemLog.correct == False):
intentoAnterior = 0
listaIntentos = problemLog.time_taken_attempts
listaIntentos.sort()
for intento in listaIntentos:
diferenciaTemporal = math.fabs(intento-intentoAnterior)
intentoAnterior = intento
#Comprobamos que sea menor de 10 segundos para considerar abuso
if(diferenciaTemporal < 10):
unreflectivePoints += 1
break
#Fin no reflexionador
#Calculo pide pistas demasiado rapido
if(problemLog.count_hints > 0):
pistaAnterior = 0
listaPistas = problemLog.hint_time_taken_list
listaPistas.sort()
for pista in listaPistas:
diferenciaTemporal = math.fabs(pista-pistaAnterior)
pistaAnterior = pista
#Comprobamos que sea menor de 10 segundos para considerar abuso
if(diferenciaTemporal < 10):
hintAbusePoints += 1
break
#Fin abusor pistas
if(problemLog.correct == True):
break
else:
continue
hintAvoidance += ((hintAvoidPoints/exercisesSameKind)*100)
videoAvoidance += ((videoAvoidPoints/exercisesSameKind)*100)
unreflectiveUser += ((unreflectivePoints/exercisesSameKind)*100)
hintAbuser += ((hintAbusePoints/exercisesSameKind)*100)
if(totalDifferentExercises != 0):
hintAvoidanceFinal = int(hintAvoidance/totalDifferentExercises)
videoAvoidanceFinal = int(videoAvoidance/totalDifferentExercises)
unreflectiveUserFinal = int(unreflectiveUser/totalDifferentExercises)
hintAbuserFinal = int(hintAbuser/totalDifferentExercises)
return [hintAvoidanceFinal, videoAvoidanceFinal,
unreflectiveUserFinal, hintAbuserFinal]
else:
return [0,0,0,0]
for badge in util_badges.badges_tematicas_no_maestro():
#print badge.exercise_names_required
listaBadgesTematicas.append(badge.name)
usuarios = GqlQuery("SELECT * FROM UserProfile ORDER BY user_id ASC")
for usuarioID in usuarios:
#print usuarioID
userData = GqlQuery("SELECT * FROM UserData WHERE user_id = :1", usuarioID).get()
#print userData.user_id
topicUserBadges = GqlQuery("SELECT * FROM UserBadge WHERE badge_name IN :1 AND user = :2 ORDER BY date ASC", listaBadgesTematicas, userData.user)
percentageSumForAllTematicBadges = 0
numberTematicBadges = topicUserBadges.count(1000)
#print "Tematic Badges %d" % numberTematicBadges
startDate = datetime.datetime(2013,8,1,0,0,1)
endDate = None
for topicUserBadge in topicUserBadges:
#print topicUserBadge
endDate = topicUserBadge.date
badge_requisites = ""
for topicBadge in util_badges.badges_tematicas_no_maestro():
if(topicBadge.name == topicUserBadge.badge_name):
badge_requisites = topicBadge.exercise_names_required
#print badge_requisites
tiempoEnVideos = 0
videos = models.VideoLog.all().filter('user ='******'user =', userData.user)
for ejercicio in ejercicios:
tiempoEnEjercicios += ejercicio.time_taken/3600
tiempoTotalVideosEjercicios = tiempoEnVideos + tiempoEnEjercicios
if(tiempoEnEjercicios != 0):
badgeEjerciciosEntreTiempo = len(allExerciseUserBadges)/tiempoEnEjercicios
else:
badgeEjerciciosEntreTiempo = 0
if(tiempoEnVideos != 0):
badgeVideosEntreTiempo = videoUserBadges.count(10000)/tiempoEnVideos
else:
badgeVideosEntreTiempo = 0
if(tiempoTotalVideosEjercicios != 0):
badgeTotalEntreTiempo = allUserBadges.count(10000)/tiempoTotalVideosEjercicios
else:
badgeTotalEntreTiempo = 0
print "%.2f %.2f %.2f" % (badgeEjerciciosEntreTiempo,badgeVideosEntreTiempo,badgeTotalEntreTiempo)
def oldEvaluation(self):
user_id = self.request.get('userId')
usuario = ViewerUser.get_by_key_name(user_id)
ejerciciosMin3 = 0
videosMin50 = 0
# Ejercicios y videos de la asignatura
subject_videos = GqlQuery("SELECT * FROM ViewerVideo")
subject_exercises = GqlQuery("SELECT * FROM ViewerExercise")
# Para cada video de la asignatura
for subject_video in subject_videos:
# Coge los ejercicios asociados a dicho video
exerciseVideos = GqlQuery("SELECT * FROM ExerciseVideo where video = :1", subject_video.video)
# Si encuentra el ejercicio asociado a dicho video
if(exerciseVideos != None):
for exerciseVideo in exerciseVideos:
# Coge el UserExercise de dicho ejercicio
userExercise = GqlQuery("SELECT * FROM UserExercise WHERE exercise_model = :1 AND user = :2", exerciseVideo.exercise, usuario.user).get()
# Si no ha encontrado el ejercicio asociado al video, mira directamente el video
if(userExercise == None):
userVideo = GqlQuery("SELECT * FROM UserVideo WHERE video = :1 AND user = :2", subject_video.video, usuario.user).get()
if(userVideo != None):
porcentaje = userVideo.seconds_watched/userVideo.duration
if(porcentaje >= 0.5):
if(subject_video.youtube_id == 'WKR3h7vBxtU' or subject_video.youtube_id == 'NwZqpCAf6o8' or subject_video.youtube_id == 'ESSg3pdsSqA'):
videosMin50 += 1/3
elif(subject_video.youtube_id == 'EQ4JVdRLxlU'):
videosMin50 += 1/4
elif(subject_video.youtube_id == '7jj6zSWEEgk'):
videosMin50 += 1/2
else:
videosMin50 += 1
# Si ha encontrado el ejercicio asociado al video, comprueba primero si el ejercicio esta bien hecho
else:
# Si tiene mas de 3 correctos, sumamos directamente ejercicio y video
if(userExercise.total_correct >= 3):
ejerciciosMin3 += 1
if(subject_video.youtube_id == 'WKR3h7vBxtU' or subject_video.youtube_id == 'NwZqpCAf6o8' or subject_video.youtube_id == 'ESSg3pdsSqA'):
videosMin50 += 1/3
elif(subject_video.youtube_id == 'EQ4JVdRLxlU'):
videosMin50 += 1/4
elif(subject_video.youtube_id == '7jj6zSWEEgk'):
videosMin50 += 1/2
else:
videosMin50 += 1
# Si tiene menos de 3 correctos, NO sumamos ejercicio y miramos video
else:
userVideo = GqlQuery("SELECT * FROM UserVideo WHERE video = :1 AND user = :2", subject_video.video, usuario.user).get()
if(userVideo != None):
porcentaje = userVideo.seconds_watched/userVideo.duration
if(porcentaje >= 0.5):
if(subject_video.youtube_id == 'WKR3h7vBxtU' or subject_video.youtube_id == 'NwZqpCAf6o8' or subject_video.youtube_id == 'ESSg3pdsSqA'):
videosMin50 += 1/3
elif(subject_video.youtube_id == 'EQ4JVdRLxlU'):
videosMin50 += 1/4
elif(subject_video.youtube_id == '7jj6zSWEEgk'):
videosMin50 += 1/2
else:
videosMin50 += 1
# Si el video no tiene un ejercicio asociado, mira directamente el video
else:
userVideo = GqlQuery("SELECT * FROM UserVideo WHERE video = :1 AND user = :2", subject_video.video, usuario.user).get()
if(userVideo != None):
porcentaje = userVideo.seconds_watched/userVideo.duration
if(porcentaje >= 0.5):
videosMin50 += 1
ejerciciosMin3 = int((ejerciciosMin3/subject_exercises.count())*100)
videosMin50 = int((videosMin50/subject_videos.count())*100)
userProfile = UserProfile.get_by_key_name(user_id)
if(userProfile == None):
userProfile = UserProfile(key_name = user_id, user = usuario.user, user_nickname = usuario.user_nickname,
user_id = usuario.user_id,
evaluation_exercise = ejerciciosMin3, evaluation_video = videosMin50)
else:
userProfile.evaluation_exercise = ejerciciosMin3
userProfile.evaluation_video = videosMin50
userProfile.put()
def get_profile_mean(self, profileName):
queryUserProfile = GqlQuery("SELECT * FROM UserProfile")
if(profileName == viewer_code.viewer_consts.EXERCISE_VIDEO_EVALUATION):
evaluation_exercise_suma = 0
evaluation_video_suma = 0
for userProfile in queryUserProfile:
evaluation_exercise_suma += userProfile.evaluation_exercise
evaluation_video_suma += userProfile.evaluation_video
evaluation_exercise_mean = int(evaluation_exercise_suma / (queryUserProfile.count()))
evaluation_video_mean = int(evaluation_video_suma / (queryUserProfile.count()))
return [evaluation_exercise_mean, evaluation_video_mean]
elif(profileName == viewer_code.viewer_consts.USE_OF_PLATFORM):
exercise_explorer_suma = 0
video_explorer_suma = 0
exercise_abandon_suma = 0
video_abandon_suma = 0
optional_suma = 0
one_correct_suma = 0
focus_videos_suma = 0
focus_exercises_suma = 0
for userProfile in queryUserProfile:
exercise_explorer_suma += userProfile.exercise_explorer
video_explorer_suma += userProfile.video_explorer
exercise_abandon_suma += userProfile.exercise_abandon
video_abandon_suma += userProfile.video_abandon
optional_suma += userProfile.optional_elements
one_correct_suma += userProfile.exercise_one_correct
focus_videos_suma += userProfile.focus_videos
focus_exercises_suma += userProfile.focus_exercises
exercise_explorer_mean = int(exercise_explorer_suma / (queryUserProfile.count()))
video_explorer_mean = int(video_explorer_suma / (queryUserProfile.count()))
exercise_abandon_mean = int(exercise_abandon_suma / (queryUserProfile.count()))
video_abandon_mean = int(video_abandon_suma / (queryUserProfile.count()))
optional_mean = int(optional_suma / (queryUserProfile.count()))
one_correct_mean = int(one_correct_suma / (queryUserProfile.count()))
focus_exercises_mean = int(focus_exercises_suma / (queryUserProfile.count()))
focus_videos_mean = int(focus_videos_suma / (queryUserProfile.count()))
return [exercise_explorer_mean, video_explorer_mean,
exercise_abandon_mean, video_abandon_mean,
optional_mean, one_correct_mean,
focus_exercises_mean, focus_videos_mean]
elif(profileName == viewer_code.viewer_consts.CORRECT_PROGRESS):
video_efficiency_suma = 0
exercise_efficiency_suma = 0
video_progress_suma = 0
exercise_progress_suma = 0
correct_exercise_suma = 0
efficiency_proficiencies_suma = 0
correct_solving_efficiency_suma = 0
for userProfile in queryUserProfile:
video_efficiency_suma += userProfile.video_efficiency
exercise_efficiency_suma += userProfile.correct_exercise_effiency
video_progress_suma += userProfile.video_progress
exercise_progress_suma += userProfile.exercise_progress
correct_exercise_suma += userProfile.correct_exercises
efficiency_proficiencies_suma += userProfile.efficiency_proficiencies
correct_solving_efficiency_suma += userProfile.correct_exercise_solving_efficiency
video_efficiency_mean = int(video_efficiency_suma / (queryUserProfile.count()))
exercise_efficiency_mean = int(exercise_efficiency_suma / (queryUserProfile.count()))
video_progress_mean = int(video_progress_suma / (queryUserProfile.count()))
exercise_progress_mean = int(exercise_progress_suma / (queryUserProfile.count()))
correct_exercise_mean = int(correct_exercise_suma / (queryUserProfile.count()))
efficiency_proficiencies_mean = int(efficiency_proficiencies_suma / (queryUserProfile.count()))
correct_solving_efficiency_mean = int(correct_solving_efficiency_suma / (queryUserProfile.count()))
return [exercise_efficiency_mean, video_efficiency_mean,
exercise_progress_mean, video_progress_mean,
correct_exercise_mean, efficiency_proficiencies_mean,
correct_solving_efficiency_mean]
elif(profileName == viewer_code.viewer_consts.TIME_DISTRIBUTION):
time_morning_suma = 0
time_afternoon_suma = 0
time_night_suma = 0
morning_efficiency_suma = 0
afternoon_efficiency_suma = 0
night_efficiency_suma = 0
constancy_mean_suma = 0
constancy_var_suma = 0
morning_efficiency_counter = 0
afternoon_efficiency_counter = 0
night_efficiency_counter = 0
for userProfile in queryUserProfile:
time_morning_suma += userProfile.time_schedule_morning
time_afternoon_suma += userProfile.time_schedule_afternoon
time_night_suma += userProfile.time_schedule_night
constancy_mean_suma += userProfile.constancy_mean
constancy_var_suma += userProfile.constancy_variance
if(userProfile.morning_schedule_efficiency != 0):
morning_efficiency_suma += userProfile.morning_schedule_efficiency
morning_efficiency_counter += 1
if(userProfile.afternoon_schedule_efficiency != 0):
afternoon_efficiency_suma += userProfile.afternoon_schedule_efficiency
afternoon_efficiency_counter += 1
if(userProfile.night_schedule_efficiency != 0):
night_efficiency_suma += userProfile.night_schedule_efficiency
night_efficiency_counter += 1
time_morning_mean = int(time_morning_suma / (queryUserProfile.count()))
#time_afternoon_mean = int(time_afternoon_suma / (queryUserProfile.count()))
time_night_mean = int(time_night_suma / (queryUserProfile.count()))
time_afternoon_mean = 100 - time_morning_mean - time_night_mean
constancy_mean_mean = int(constancy_mean_suma / (queryUserProfile.count()))
constancy_var_mean = int(constancy_var_suma / (queryUserProfile.count()))
if(morning_efficiency_counter == 0):
morning_efficiency_mean = 0
else:
morning_efficiency_mean = int(morning_efficiency_suma/morning_efficiency_counter)
if(afternoon_efficiency_counter == 0):
afternoon_efficiency_mean = 0
else:
afternoon_efficiency_mean = int(afternoon_efficiency_suma/afternoon_efficiency_counter)
if(night_efficiency_counter == 0):
night_efficiency_mean = 0
else:
night_efficiency_mean = int(night_efficiency_suma/night_efficiency_counter)
return [time_morning_mean, time_afternoon_mean, time_night_mean,
constancy_mean_mean, constancy_var_mean,
morning_efficiency_mean, afternoon_efficiency_mean, night_efficiency_mean]
elif(profileName == viewer_code.viewer_consts.EXERCISE_SOLVING_HABITS):
recommendation_listener_suma = 0
forgetful_exercises_suma = 0
hint_avoidance_suma = 0
video_avoidance_suma = 0
unreflective_user_suma = 0
hint_abuser_suma = 0
for userProfile in queryUserProfile:
recommendation_listener_suma += userProfile.recommendation_listener
forgetful_exercises_suma += userProfile.forgetful_exercises
hint_avoidance_suma += userProfile.hint_avoidance
video_avoidance_suma += userProfile.video_avoidance
unreflective_user_suma += userProfile.unreflective_user
hint_abuser_suma += userProfile.hint_abuser
recommendation_listener_mean = int(recommendation_listener_suma / (queryUserProfile.count()))
forgetful_exercises_mean = int(forgetful_exercises_suma / (queryUserProfile.count()))
hint_avoidance_mean = int(hint_avoidance_suma / (queryUserProfile.count()))
video_avoidance_mean = int(video_avoidance_suma / (queryUserProfile.count()))
unreflective_user_mean = int(unreflective_user_suma / (queryUserProfile.count()))
hint_abuser_mean = int(hint_abuser_suma / (queryUserProfile.count()))
return [recommendation_listener_mean, forgetful_exercises_mean,
hint_avoidance_mean, video_avoidance_mean,
unreflective_user_mean, hint_abuser_mean]
elif(profileName == viewer_code.viewer_consts.GAMIFICATION_HABITS):
badge_over_time_suma = 0
badge_percentage_suma = 0
for userProfile in queryUserProfile:
badge_over_time_suma += userProfile.badge_over_time
badge_percentage_suma += userProfile.badge_point_percentage
badge_over_time_mean = int(badge_over_time_suma / (queryUserProfile.count()))
badge_percentage_mean = int(badge_percentage_suma / (queryUserProfile.count()))
return [badge_over_time_mean, badge_percentage_mean]
