# Class to update the student's TopicProgress
class TopicProgressUpdate(Resource):
method_decorators = [
roles_accepted("Student"), topic_exists, module_exists
]
# Function to update the student's completed module
@module_is_complete
@module_in_inprogress
def put(self, topic_id, module_id):
user_data = session["profile"]
student = Student.query.get(user_data["student_id"])
module = Module.query.get(module_id)
student.completed_modules.append(module)
student.inprogress_modules.remove(module)
db.session.commit()
return {
"message": "Successfully updated student completed modules"
}, 202
api.add_resource(TopicProgress, "/topics/<int:topic_id>/progress")
api.add_resource(TopicProgressAdd,
"/topics/<int:topic_id>/progress/<int:module_id>/add")
api.add_resource(TopicProgressUpdate,
"/topics/<int:topic_id>/progress/<int:module_id>")
from flask import render_template
from flask import redirect
from flask import send_from_directory
from backend import app
from backend import rest
from backend import api
import os
import logging
logger = logging.getLogger(__name__)
api.add_resource(rest.Users, '/users')
api.add_resource(rest.User, '/users/<string:username>')
# api.add_resource(rest.ChangePassword,
# '/users/<string:username>/set_password')
# api.add_resource(rest.ResetPassword,
# '/users/<string:username>/reset_password')
api.add_resource(rest.Groups, '/groups')
api.add_resource(rest.Group, '/groups/<string:group_name>')
api.add_resource(rest.Images, '/images')
api.add_resource(rest.Image, '/images/<string:id>')
api.add_resource(rest.Sessions, '/sessions')
api.add_resource(rest.Session, '/sessions/<string:session_id>')
api.add_resource(rest.Computers, '/computers')
api.add_resource(rest.Computer, '/computers/<string:computer_id>')
api.add_resource(rest.Bookings, '/bookings')
api.add_resource(rest.Booking, '/bookings/<string:booking_id>')
@app.route('/')
from backend import api, resources, app
from random import randint
import requests
from flask import render_template, jsonify
@app.route('/api/random')
def random_number():
response = {'randomNumber': randint(1, 100)}
return jsonify(response)
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def catch_all(path):
if app.debug:
return requests.get('http://localhost:8080/{}'.format(path)).text
return render_template("index.html")
api.add_resource(resources.UserRegistration, '/api/registration')
api.add_resource(resources.UserLogin, '/api/login')
api.add_resource(resources.AuditCheck, '/api/audit')
student.inprogress_topics.append(topic)
student.incomplete_topics.remove(topic)
db.session.commit()
return {"message": "Topic added!"}, 201
# Class to update a track progress
class TrackProgressUpdate(Resource):
method_decorators = [roles_accepted("Student"), topic_exists]
# Function to update the student's completed topic
@can_complete_topic
@has_completed_topic
def put(self, topic_id):
user_data = session["profile"]
student = Student.query.get(user_data["student_id"])
topic = Topic.query.get(topic_id)
student.completed_topics.append(topic)
student.inprogress_topics.remove(topic)
db.session.commit()
return {"message": "Student topic successfully updated!"}
api.add_resource(TrackProgress, "/tracks/<int:track_id>/progress")
api.add_resource(TrackProgressAdd, "/tracks/progress/<int:topic_id>/add_topic")
api.add_resource(TrackProgressUpdate, "/tracks/progress/<int:topic_id>")
db.session.commit()
return {"message": "Activity successfully updated"}, 200
# Function to delete a activity!!
@activity_exists_in_github
def delete(self):
data = request.get_json()
activity = Activity.query.filter_by(filename=data["filename"]).first()
db.session.delete(activity)
db.session.commit()
return {"message": "Activity successfully deleted"}, 200
# This class is used to get a specific activity based on id
class ActivityGetSpecific(Resource):
method_decorators = [user_session_exists, activity_exists]
def get(self, activity_id):
activity = Activity.query.get(activity_id)
activity.cards.sort(key=lambda x: x.order)
return ActivitySerializer(activity).data
# Creates the routes for the classes
api.add_resource(ActivityCRUD, "/activities")
api.add_resource(ActivityGetSpecific, "/activities/<int:activity_id>")
user_data = session["profile"]
checkpoint_prog = CheckpointProgress.query.filter_by(
checkpoint_id=checkpoint_id,
student_id=user_data["student_id"]).first()
return get_checkpoint_data(checkpoint_prog)
# Function to return data on a single checkpoint
@checkpoint_progress_exist
@valid_checkpoint_progress_data
@multiple_choice_is_completed
def put(self, checkpoint_id):
data = request.form
user_data = session["profile"]
checkpoint_prog = CheckpointProgress.query.filter_by(
checkpoint_id=checkpoint_id,
student_id=user_data["student_id"]).first()
fill_in_checkpoint_progress(data, checkpoint_prog)
db.session.commit()
is_activity_completed(checkpoint_prog.activity_progress_id,
checkpoint_prog.student_id)
db.session.commit()
return get_checkpoint_data(checkpoint_prog)
# Creates the routes for the classes
api.add_resource(CheckpointProgressSubmit,
"/checkpoints/<int:checkpoint_id>/progress")
# This class is used to delete an badge with a POST request
class BadgeDelete(Resource):
method_decorators = [badge_delete]
# Function to delete a badge!!
def post(self):
contentful_data = request.get_json()
badge = Badge.query.filter_by(
contentful_id=contentful_data["entityId"]).first()
db.session.delete(badge)
db.session.commit()
return {"message": "Badge successfully deleted"}, 200
# Function to get a specific Badge based on badge id
class BadgeGetSpecific(Resource):
method_decorators = [badge_exists, user_session_exists]
def get(self, badge_id):
badge = Badge.query.get(badge_id)
return badge_schema.dump(badge)
# Creates the routes for the classes
api.add_resource(BadgeCRUD, "/badges")
api.add_resource(BadgeDelete, "/badges/delete")
api.add_resource(BadgeGetSpecific, "/badges/<int:badge_id>")
class CardGetHints(Resource):
method_decorators = [
user_session_exists,
roles_accepted("Student"), activity_prog_exists, card_exists,
card_exists_in_activity
]
# Function to unlock the next card
# @card_is_unlockable
def put(self, activity_id, card_id):
user_data = session["profile"]
card = Card.query.get(card_id)
student_activity_prog = ActivityProgress.query.filter_by(
student_id=user_data["student_id"],
activity_id=activity_id).first()
unlock_card(student_activity_prog, card)
student_activity_prog.last_card_unlocked = card.id
db.session.commit()
is_activity_completed(student_activity_prog.id,
user_data["student_id"])
db.session.commit()
return {"message": "Card successfully updated"}, 200
# Creates the routes for the classes
api.add_resource(CardCRUD, "/cards")
api.add_resource(CardGetSpecific, "/cards/<int:card_id>")
api.add_resource(CardGetHints,
"/activities/<int:activity_id>/cards/<int:card_id>")
"suggested_activity"] = update_student_suggested_activity(
student)
student.meta.user.last_seen = datetime.utcnow()
db.session.commit()
else:
student_data = StudentSerializer(student).data
student_data[
"suggested_activity"] = update_student_suggested_activity(
student)
return student_data
# Function to edit student_data
@is_same_student
@valid_update_data
def put(self, student_id):
data = request.get_json()
student = Student.query.get(student_id)
student.suggested_activity_id = data["suggested_activity"]["id"]
student.suggested_module_id = data["suggested_activity"]["module_id"]
student_data = StudentSerializer(student).data
student_data["suggested_activity"] = data["suggested_activity"]
db.session.commit()
return student_data
# Creates the routes for the classes
api.add_resource(StudentData, "/students/<int:student_id>")
api.add_resource(StudentClassroom, "/students/classrooms")
# Function to edit a criteria
@valid_criteria_form
@criteria_exists_in_github
def put(self):
data = request.get_json()
criteria = Criteria.query.filter_by(
checkpoint_id=data["checkpoint_id"],
criteria_key=data["criteria_key"]).first()
edit_criteria(criteria, data)
db.session.commit()
return {"message": "Criteria successfully updated"}, 200
# Function to delete a criteria
@criteria_exists_in_github
def delete(self):
data = request.get_json()
criteria = Criteria.query.filter_by(
checkpoint_id=data["checkpoint_id"],
criteria_key=data["criteria_key"]).first()
db.session.delete(criteria)
db.session.commit()
return {"message": "Criteria successfully deleted"}, 200
# Creates the routes for the classes
api.add_resource(CriteriaCRUD, "/criteria")
db.session.commit()
return {"message": "MCChoice successfully updated"}, 200
# Function to delete a mc_choice!!
@mc_choice_exists_in_github
def delete(self):
data = request.get_json()
mc_choice = get_mc_choice(data)
db.session.delete(mc_choice)
db.session.commit()
return {"message": "MCChoice successfully deleted"}, 200
# Function to get a specific MCChoice based on mc_choice id
class MCChoiceGetSpecific(Resource):
method_decorators = [user_session_exists, mc_choice_exists]
def get(self, mc_choice_id):
mc_choice = MCChoice.query.get(mc_choice_id)
return mc_choice_schema.dump(mc_choice)
# Creates the routes for the classes
api.add_resource(MCChoiceCRUD, "/mc_choices")
api.add_resource(MCChoiceGetSpecific, "/mc_choices/<int:mc_choice_id>")
method_decorators = [user_session_exists, event_exists]
# Function to let a user rsvp for an event
@has_rsvp
def put(self, event_id):
user_data = session["profile"]
user = User.query.get(user_data["user_id"])
event = Event.query.get(event_id)
event.rsvp_list.append(user)
db.session.commit()
return {"message": user.name + " has RSVP'd for " + event.name}, 201
# Function to let a user leave an event
@in_rsvp
def delete(self, event_id):
user_data = session["profile"]
user = User.query.get(user_data["user_id"])
event = Event.query.get(event_id)
event.rsvp_list.remove(user)
db.session.commit()
return {"message": "Successfully left the RSVP list"}, 200
# Creates the routes for the classes
api.add_resource(EventCRUD, "/events/<int:event_id>")
api.add_resource(EventCreate,
"/organizations/<int:organization_id>/events/create")
api.add_resource(EventJoin, "/events/<int:event_id>/rsvp")
from backend.users.schemas import UserSerializer
from backend.models import User
from flask import Blueprint, session
from flask_restful import Resource
# Blueprint for users
user_bp = Blueprint("user", __name__)
# Class to handle information regarding the User model
class UserData(Resource):
method_decorators = [user_session_exists, user_exists]
def get(self, user_id):
user = User.query.get(user_id)
return UserSerializer(user).data
# Class to return the user meta data
class MetaData(Resource):
def get(self):
if "profile" in session:
return session["profile"]
else:
return {}, 401
api.add_resource(UserData, "/users/<int:user_id>")
api.add_resource(MetaData, "/meta")
}, 200
# Class to handle the activity progress' hints
class ActivityProgressHints(Resource):
method_decorators = [
user_session_exists,
roles_accepted("Student"), activity_exists, hint_exists
]
# Function to unlock a hint by its hint_id
@activity_prog_exists
def put(self, activity_id, hint_id):
user_data = session["profile"]
student_activity_prog = ActivityProgress.query.filter_by(
student_id=user_data["student_id"],
activity_id=activity_id).first()
hint = Hint.query.get(hint_id)
unlock_message = unlock_hint(student_activity_prog, hint)
db.session.commit()
return {"message": unlock_message}, 200
# Creates the routes for the classes
api.add_resource(ActivityProgressUpdate,
"/activities/<int:activity_id>/progress")
api.add_resource(ActivityProgressHints,
"/activities/<int:activity_id>/hints/<int:hint_id>")
db.session.commit()
return {"message": "Track successfully deleted"}, 200
# Class to get all tracks
class TrackFetchAll(Resource):
method_decorators = [user_session_exists]
# Function to get all tracks
def get(self):
tracks = Track.query.all()
return tracks_schema.dump(tracks)
# Function to get a specific Track based on track id
class TrackGetSpecific(Resource):
method_decorators = [user_session_exists, track_exists]
def get(self, track_id):
track = Track.query.get(track_id)
return track_schema.dump(track)
# Creates the routes for the classes
api.add_resource(TrackCRUD, "/tracks")
api.add_resource(TrackFetchAll, "/tracks/all")
api.add_resource(TrackGetSpecific, "/tracks/<int:track_id>")
class HintGetSpecific(Resource):
method_decorators = [user_session_exists, hint_exists]
def get(self, hint_id):
hint = Hint.query.get(hint_id)
return hint_schema.dump(hint)
# Function to handle data on HintStatus
class HintStatusData(Resource):
method_decorators = [user_session_exists, hint_exists]
def get(self, hint_id):
user_data = session["profile"]
hint = Hint.query.get(hint_id)
activity_id = get_activity_id(hint)
activity_prog = ActivityProgress.query.filter_by(
student_id=user_data["student_id"],
activity_id=activity_id).first()
hint_status = HintStatus.query.filter_by(
activity_progress_id=activity_prog.id, hint_id=hint_id).first()
return hint_status_schema.dump(hint_status)
# Creates the routes for the classes
api.add_resource(HintCRUD, "/hints")
api.add_resource(HintGetSpecific, "/hints/<int:hint_id>")
api.add_resource(HintStatusData, "/hints/<int:hint_id>/progress")
db.session.commit()
return {"message": "Topic successfully updated"}, 200
# Function to delete a topic!!
@topic_exists_in_github
def delete(self):
data = request.get_json()
topic = Topic.query.filter_by(filename=data["filename"]).first()
db.session.delete(topic)
db.session.commit()
return {"message": "Topic successfully deleted"}, 200
# Function to get a specific Topic based on topic id
class TopicGetSpecific(Resource):
method_decorators = [user_session_exists, topic_exists]
def get(self, topic_id):
topic = Topic.query.get(topic_id)
return TopicSerializer(topic).data
# Creates the routes for the classes
api.add_resource(TopicCRUD, "/topics")
api.add_resource(TopicGetSpecific, "/topics/<int:topic_id>")
db.session.commit()
return {"message": "Module successfully updated"}, 200
# Function to delete a module!!
@module_exists_in_github
def delete(self):
data = request.get_json()
module = Module.query.filter_by(filename=data["filename"]).first()
db.session.delete(module)
db.session.commit()
return {"message": "Module successfully deleted"}, 200
# Function to get a specific Module based on module id
class ModuleGetSpecific(Resource):
method_decorators = [user_session_exists, module_exists]
def get(self, module_id):
module = Module.query.get(module_id)
return module_schema.dump(module)
# Creates the routes for the classes
api.add_resource(ModuleCRUD, "/modules")
api.add_resource(ModuleGetSpecific, "/modules/<int:module_id>")
teacher = Teacher.query.get(teacher_id)
return TeacherSerializer(teacher).data
# Class to grade the Student's assignments
class TeacherAssignments(Resource):
method_decorators = [user_session_exists, roles_required("Teacher")]
# This route is used to grade an activity
@activity_prog_grading_format
@submitted_activity_prog_exist
@is_activity_graded
def put(self, activity_id):
data = request.get_json()
activity_progress = ActivityProgress.query.filter_by(
activity_id=activity_id, student_id=data["student_id"]).first()
grade_activity(activity_progress, data)
complete_modules(activity_progress)
db.session.commit()
# send_graded_activity_email(activity_progress.student.username)
# pusher_activity(activity_progress)
return {"message": "Student Activity has been graded"}, 200
# Creates the routes for the classes
api.add_resource(TeacherAssignments, "/teachers/<int:activity_id>/grade")
api.add_resource(TeacherFetchData, "/teachers/<int:teacher_id>")
db.session.commit()
return {"message": "Concept successfully updated"}, 200
# Function to delete a concept!!
@concept_exists_in_github
def delete(self):
data = request.get_json()
concept = Concept.query.filter_by(filename=data["filename"]).first()
db.session.delete(concept)
db.session.commit()
return {"message": "Concept successfully deleted"}, 200
# Function to get a specific Concept based on concept id
class ConceptGetSpecific(Resource):
method_decorators = [user_session_exists, concept_exists]
def get(self, concept_id):
concept = Concept.query.get(concept_id)
return concept_schema.dump(concept)
# Creates the routes for the classes
api.add_resource(ConceptCRUD, "/concepts")
api.add_resource(ConceptGetSpecific, "/concepts/<int:concept_id>")
module_progresses_bp = Blueprint("module_progresses", __name__)
# Class for module progress
class ModuleProgressData(Resource):
method_decorators = [roles_required("Student"), module_prog_exists]
# Function to display a student's module progress
def get(self, module_id):
user_data = session["profile"]
module_progress = ModuleProgress.query.filter_by(module_id=module_id,
student_id=user_data["student_id"]).first()
return ModuleProgressSerializer(module_progress).data
# Function to update a student's completed activities
@valid_update_data
@activity_projects_exists
def put(self, module_id):
data = request.get_json()
user_data = session["profile"]
module_progress = ModuleProgress.query.filter_by(module_id=module_id,
student_id=user_data["student_id"]).first()
module_progress.chosen_projects = update_chosen_projects(data["chosen_project_ids"])
db.session.commit()
return ModuleProgressSerializer(module_progress).data
api.add_resource(ModuleProgressData, "/modules/<int:module_id>/progress")
from flask import render_template
from flask import redirect
from flask import send_from_directory
from backend import app
from backend import rest
from backend import api
import os
import logging
logger = logging.getLogger(__name__)
api.add_resource(rest.Users, '/users')
api.add_resource(rest.User, '/users/<string:username>')
# api.add_resource(rest.ChangePassword,
# '/users/<string:username>/set_password')
# api.add_resource(rest.ResetPassword,
# '/users/<string:username>/reset_password')
api.add_resource(rest.Groups, '/groups')
api.add_resource(rest.Group, '/groups/<string:group_name>')
api.add_resource(rest.Images, '/images')
api.add_resource(rest.Image, '/images/<string:id>')
api.add_resource(rest.Sessions, '/sessions')
api.add_resource(rest.Session, '/sessions/<string:session_id>')
api.add_resource(rest.Computers, '/computers')
api.add_resource(rest.Computer, '/computers/<string:computer_id>')
api.add_resource(rest.Bookings, '/bookings')
api.add_resource(rest.Booking, '/bookings/<string:booking_id>')
@app.route('/')
@app.route('/index.html')
from backend import app, api
# Controllers Imports
from backend.api.User.Controller.UserController import UserController
from backend.api.Alerts.Controller.AlertsController import AlertsController
from backend.api.Devices.Controller.DevicesController import DevicesController
from backend.api.Monitor.Controller.MonitorController import MonitorController
from backend.api.RecoverPassword.Controller.RecoverPasswordController import RecoverPasswordController
from backend.api.ResultsMetrics.Controller.ResultsMetricsController import ResultsMetricsController
from backend.api.Sensor.Controller.SensorController import SensorController
from backend.api.UserSettings.Controller.UserSettingsController import UserSettingsController
from backend.api.HealthCheck import HealthCheck
# Locals Imports
import backend.constants as const
api.add_resource(AlertsController, '/api/alerts/')
api.add_resource(DevicesController, '/api/devices/')
api.add_resource(MonitorController, '/api/monitor/')
api.add_resource(RecoverPasswordController, '/api/recoverpassword/')
api.add_resource(ResultsMetricsController, '/api/resultsmetrics/')
api.add_resource(SensorController, '/api/sensor/')
api.add_resource(HealthCheck, '/api/')
api.add_resource(UserController, '/api/user/', '/api/user/<int:id_cliente>')
api.add_resource(UserSettingsController, '/api/usersettings/')
if __name__ == '__main__':
app.run(debug=False, host=const.HOST_DEFAULT, port=const.PORT_DEFAULT)
method_decorators = [user_session_exists, organization_exists]
# Function to remove a user from an organization
# Only owners can kick people out
@owns_organization
@exist_in_organization
def delete(self, organization_id):
data = request.get_json()
username = data["username"]
user = User.query.filter_by(username=username).first()
organization = Organization.query.get(organization_id)
remove_user(organization, user)
db.session.commit()
return {
"message": "Removed " + user.name + " from " + organization.name
}, 200
# Creates the routes for the classes
api.add_resource(OrganizationCRUD, "/organizations/<int:organization_id>")
api.add_resource(OrganizationCreate, "/organizations/create")
api.add_resource(OrganizationInviteOwners,
"/organizations/<int:organization_id>/invite")
api.add_resource(OrganizationInviteConfirm, "/organizations/<string:token>")
api.add_resource(OrganizationMembership,
"/organizations/<int:organization_id>/membership")
api.add_resource(OrganizationRemove,
"/organizations/<int:organization_id>/remove")
return {"message": "Checkpoint successfully updated"}, 200
# Function to delete a checkpoint
@checkpoint_exists_in_github
def delete(self):
data = request.get_json()
checkpoint = Checkpoint.query.filter_by(
filename=data["filename"]).first()
db.session.delete(checkpoint)
db.session.commit()
return {"message": "Checkpoint successfully deleted"}, 200
# This class is used to get a specific checkpoint based on id
class CheckpointGetSpecific(Resource):
method_decorators = [user_session_exists, checkpoint_exists]
# Function to return data on a single checkpoint
def get(self, checkpoint_id):
checkpoint = Checkpoint.query.get(checkpoint_id)
return checkpoint_schema.dump(checkpoint)
# Creates the routes for the classes
api.add_resource(CheckpointCRUD, "/checkpoints")
api.add_resource(CheckpointGetSpecific, "/checkpoints/<int:checkpoint_id>")
@app.before_request
def before_request():
g.user = None
if "id" in session:
g.user = User.query.get(session["id"])
@app.after_request
def after_request(response):
db.session.remove()
return response
@github.access_token_getter
def token_getter():
oauth_user = g.user
if oauth_user is not None:
return oauth_user.github_access_token
# Creates the routes for the classes
api.add_resource(Ping, "/ping")
api.add_resource(Protected, "/protected")
api.add_resource(UserIsAdmin, "/isAdmin")
api.add_resource(UserIsStudent, "/isStudent")
api.add_resource(UserIsTeacher, "/isTeacher")
api.add_resource(UserOAuthLoginHandler, "/login")
api.add_resource(UserOAuthLogoutHandler, "/logout")
db.session.commit()
return {"message": "Step successfully updated"}, 200
# Function to delete a step!!
@step_exists_in_github
def delete(self):
data = request.get_json()
step = get_step_from_patent(data)
db.session.delete(step)
db.session.commit()
return {"message": "Step successfully deleted"}, 200
# Function to get a specific Step based on step id
class StepGetSpecific(Resource):
method_decorators = [user_session_exists, step_exists]
def get(self, step_id):
step = Step.query.get(step_id)
return step_schema.dump(step)
# Creates the routes for the classes
api.add_resource(StepCRUD, "/steps")
api.add_resource(StepGetSpecific, "/steps/<int:step_id>")
if data["ref"] == "refs/heads/master":
files = get_files(data["commits"])
files_to_change = files[0]
files_to_delete = files[1]
for filename in files_to_delete.keys():
if filename in files_to_change:
files_to_change.pop(filename)
stored_files = store_files(files_to_change)
topic_files = stored_files[0]
module_files = stored_files[1]
activity_files = stored_files[2]
concept_files = stored_files[3]
card_files = stored_files[4]
checkpoint_files = stored_files[5]
test_case_files = stored_files[6]
parse_files(topic_files, module_files, activity_files,
concept_files, card_files, checkpoint_files,
test_case_files)
delete_files(files_to_delete)
if "tracks.json" in files_to_change:
edit_test_json(files_to_change["tracks.json"])
return "Github Successfully Synced", 200
api.add_resource(ReceiveMerge, "/merge")
