def create(): english = Subject.get_by_id(3) math = Subject.get_by_id(4) life_skills = Subject.get_by_id(5) tutor_1 = Tutor.get_by_id(1) tutor_2 = Tutor.get_by_id(2) start_1 = datetime.datetime(2021, 2, 1, 10, 0) end_1 = datetime.datetime(2021, 2, 1, 12, 0) duration_1 = (end_1 - start_1).seconds // 60 # convert to minute start_2 = datetime.datetime(2021, 2, 1, 11, 0) end_2 = datetime.datetime(2021, 2, 1, 13, 0) duration_2 = (end_2 - start_2).seconds // 60 # convert to minute session = Tutor_session(subject=english, tutor=tutor_1, title="Some title", price=100, duration=duration_1, start_time=start_1, end_time=end_1, max_student_capacity=10, status="Confirmed", zoom_host="", zoom_participant="") if session.save(): flash("session created") else: flash("error creating session") return render_template('home.html', errors=session.errors)
def create(): s = Subject( category=request.form['category'] ) if s.save(): flash("Subject created") else: flash("Subject not created", errors = s.errors)
def post(self): '''POST /subjects/ -> add a new subject ''' data = subjectResource.parser.parse_args() subject_name = data.get('name') subject_age = data.get('age') subject = Subject(subject_name, subject_age) subject.save() return subject.json(), 201
def create_subject(name, description, user): s = Subject() s.name = name s.description = description s.user_id = user.id session = db_session.create_session() session.add(s) session.commit() return s
def get(self, subject_id=None): ''' GET /subjects/ -> get all subjects GET /subjects/{id}/ -> get subject with id=id ''' if subject_id is not None: try: return Subject.get(id=subject_id).json() except: abort(404) else: return [ subject.json() for subject in Subject.get() ]
def get_unit_route(request, unit_id): """ Get a specific unit given an ID. """ db_conn = request['db_conn'] unit = Unit.get_latest_accepted(db_conn, unit_id) if not unit: return abort(404) # TODO-2 SPLITUP create new endpoints for these instead topics = list_topics_by_entity_id(unit_id, {}, db_conn) versions = Unit.get_versions(db_conn, unit_id) requires = Unit.list_requires(db_conn, unit_id) required_by = Unit.list_required_by(db_conn, unit_id) subjects = Subject.list_by_unit_id(db_conn, unit_id) return 200, { 'unit': unit.deliver(), # 'unit_parameters': unit.fetch_parameters(), 'topics': [deliver_topic(topic) for topic in topics], 'versions': [version.deliver() for version in versions], 'requires': [require.deliver() for require in requires], 'required_by': [require.deliver() for require in required_by], 'belongs_to': [subject.deliver() for subject in subjects], }
def instance_entities(data): """ Given a kind and some json, call insert on that kind and return the results. A little safer. """ fields = ('id', 'created', 'modified', 'entity_id', 'previous_id', 'status', 'available') entities = [] if 'cards' in data: for card_data in data['cards']: kind = card_data.get('kind') if kind in card_map: entities.push( card_map[kind](omit(card_data, fields)) ) if 'units' in data: entities = entities + [ Unit(omit(unit_data, fields)) for unit_data in data['units'] ] if 'subjects' in data: entities = entities + [ Subject(omit(subject_data, fields)) for subject_data in data['subjects'] ] return entities
def flush_entities(db_conn, descs): """ Given a list of kinds and entity_ids, return a list filled out with entities. """ output = [] for desc in descs: if desc['kind'] == 'card': card = Card.get_latest_accepted(db_conn, entity_id=desc['id']) card = flip_card_into_kind(card) if card: output.append(card) elif desc['kind'] == 'unit': output.append(Unit.get_latest_accepted( db_conn, entity_id=desc['id'] )) elif desc['kind'] == 'subject': output.append(Subject.get_latest_accepted( db_conn, entity_id=desc['id'] )) else: output.append(None) return output
def get_version(db_conn, kind, id_): if kind == 'card': card = Card.get(db_conn, id=id_) return flip_card_into_kind(card) elif kind == 'unit': return Unit.get(db_conn, id=id_) elif kind == 'subject': return Subject.get(db_conn, id=id_)
def get_recommended_subjects(request): db_conn = request['db_conn'] entity_ids = ('JAFGYFWhILcsiByyH2O9frcU', ) if config['debug']: entity_ids = ('subjectAll', ) subjects = Subject.list_by_entity_ids(db_conn, entity_ids) if not subjects: return abort(404) return 200, {'subjects': [subject.deliver() for subject in subjects]}
def get_my_recently_created_subjects(current_user, db_conn): """ Get the user's most recently created subjects. """ proposals = get_my_recent_proposals(current_user, db_conn) subject_version_ids = get_proposal_entity_versions(proposals, 'subject') subjects = Subject.list_by_version_ids(db_conn, subject_version_ids) return subjects
def show_all(): subjects = Subject.select() subject_data = [] for subject in subjects: subject = model_to_dict(subject) subject_data.append(subject) return make_response(jsonify(subject_data)), 200
def get_subject_and_chapter_name(self): obj = {} from models.subject import Subject from models.chapter import Chapter subjects = Subject.all() for s in subjects: clist = Chapter.find_all(subject_id=s.id) temp = [] for c in clist: temp.append(c.__dict__) obj[s.id] = temp return obj
def list_user_subjects_entity(user_id, params, db_conn): """ Join the user's subject_ids with subject information. Return empty list when there's no matching documents. """ # TODO-2 each subject -- needs review? # TODO-2 order by last reviewed time user_subject = get_user_subjects(user_id, db_conn) # TODO-3 limit = params.get('limit') or 10 # TODO-3 skip = params.get('skip') or 0 return Subject.list_by_entity_ids(db_conn, user_subject['subject_ids'])
def get_subject_versions_route(request, subject_id): """ Get subject versions given an ID. Paginates. """ db_conn = request['db_conn'] versions = Subject.get_versions(db_conn, entity_id=subject_id, **request['params']) return 200, { 'versions': [version.deliver(access='view') for version in versions] }
def choose_unit_route(request, subject_id, unit_id): """ Updates the learner's information based on the unit they have chosen. NEXT STATE POST Chosen Unit -> GET Learn Card """ # TODO-3 simplify this method. should it be broken up or moved to model? db_conn = request['db_conn'] current_user = get_current_user(request) if not current_user: return abort(401) unit = Unit.get_latest_accepted(db_conn, unit_id) if not unit: return abort(404) # If the unit isn't in the subject... context = get_learning_context(current_user) subject_ids = [ subject['entity_id'] for subject in Subject.list_by_unit_id(db_conn, unit_id) ] if context.get('subject', {}).get('entity_id') not in subject_ids: return abort(400) status = judge(db_conn, unit, current_user) # Or, the unit doesn't need to be learned... if status == "done": return abort(400) # Choose a card for the learner to learn card = choose_card(db_conn, current_user, unit) if card: next_ = { 'method': 'GET', 'path': '/s/cards/{card_id}/learn'.format(card_id=card['entity_id']), } else: next_ = {} set_learning_context(current_user, unit=unit.data, card=card.data if card else None, next=next_) return 200, {'next': next_}
def get_subject_route(request, subject_id): """ Get a specific subject given an ID. """ db_conn = request['db_conn'] subject = Subject.get_latest_accepted(db_conn, subject_id) if not subject: return abort(404) # TODO-2 SPLITUP create new endpoints for these instead topics = list_topics_by_entity_id(subject_id, {}, db_conn) versions = Subject.get_versions(db_conn, entity_id=subject_id) units = subject.list_units(db_conn) return 200, { 'subject': subject.deliver(), # 'subject_parameters': subject.fetch_parameters(), 'topics': [deliver_topic(topic) for topic in topics], 'versions': [version.deliver() for version in versions], 'units': [unit.deliver() for unit in units], }
def get_latest_accepted(db_conn, kind, entity_id): """ Given a kind and an entity_id, pull the latest accepted version out of the database. """ if kind == 'card': card = Card.get_latest_accepted(db_conn, entity_id) return flip_card_into_kind(card) elif kind == 'unit': return Unit.get_latest_accepted(db_conn, entity_id) elif kind == 'subject': return Subject.get_latest_accepted(db_conn, entity_id)
def new(): from models.subject import Subject subject_list = Subject.all() cookie = token_cookie() template = render_template( "chapter/edit_chapter.html", chapter=None, subjects=subject_list, token=cookie['token'], ) r = make_response(template) r.set_cookie(cookie['token'], cookie['id'], max_age=300) return r
def new(): from models.subject import Subject from models.problem import Problem subject_list = Subject.all() problem_type = Problem.get_problem_type_list() cookie = token_cookie() template = render_template( "problem/new_problem.html", subjects=subject_list, types=problem_type, token=cookie['token'], ) r = make_response(template) r.set_cookie(cookie['token'], cookie['id'], max_age=300) return r
def new(): from models.subject import Subject subject_list = Subject.all() obj = Article.get_subject_and_chapter_name() cookie = token_cookie() template = render_template( "article/edit_article.html", article=None, subjects=subject_list, obj=json_util.dumps(obj), token=cookie['token'], ) r = make_response(template) r.set_cookie(cookie['token'], cookie['id'], max_age=300) return r
def test_traverse(db_conn, units_table, users_table, responses_table, subjects_table): """ Expect to take a list of units and traverse them correctly. Basic test. """ add_test_subject(db_conn, users_table, units_table, responses_table, subjects_table) subject = Subject.get(db_conn, entity_id='subject') user = get_user({'id': 'user'}, db_conn) buckets = traverse(db_conn, user, subject) assert buckets['diagnose'][0]['entity_id'] == 'divide' assert buckets['learn'][0]['entity_id'] == 'multiply' assert buckets['review'][0]['entity_id'] == 'subtract'
def test_language(db_conn, subjects_table, units_table): """ Expect a subject to require a language. """ create_unit_a(db_conn, units_table) subject, errors = Subject.insert( db_conn, { 'name': 'Statistics', 'body': 'A beginning course focused on probability.', 'members': [{ 'id': 'A', 'kind': 'unit', }], }) assert len(errors) == 0 assert subject['language'] == 'en'
def add_problem_from_xls(cls, lists): from models.subject import Subject from models.chapter import Chapter subject = Subject.new({ "name": lists[0][0], }) chapter_id_flag = -1 chapter_id = -1 for item in lists: if int(item[1]) != chapter_id_flag: chapter = Chapter.new({ 'subject_id': subject.id, 'name': item[2] }) chapter_id = chapter.id chapter_id_flag = int(item[1]) cls.add_problem(subject.id, chapter_id, item)
def test_tags(db_conn, subjects_table, units_table): """ Expect a subject to allow tags. """ create_unit_a(db_conn, units_table) subject, errors = Subject.insert( db_conn, { 'name': 'Statistics', 'body': 'A beginning course focused on probability.', 'members': [{ 'id': 'A', 'kind': 'unit', }], 'tags': ['A', 'B', 'C'] }) assert len(errors) == 0
def test_previous(db_conn, subjects_table, units_table): """ Expect a subject to allow a previous version id. """ create_unit_a(db_conn, units_table) subject, errors = Subject.insert( db_conn, { 'name': 'Statistics', 'body': 'A beginning course focused on probability.', 'members': [{ 'id': 'A', 'kind': 'unit', }], 'previous_id': 'fdsjKO', }) assert len(errors) == 0
def test_body(db_conn, subjects_table, units_table): """ Expect a subject to require a body. """ create_unit_a(db_conn, units_table) subject, errors = Subject.insert( db_conn, { 'name': 'Statistics', 'members': [{ 'id': 'A', 'kind': 'unit', }], }) assert len(errors) == 1 subject['body'] = 'A beginning course focused on probability.' subject, errors = subject.save(db_conn) assert len(errors) == 0
def test_members(db_conn, subjects_table, units_table): """ Expect a subject to record a list of members. """ create_unit_a(db_conn, units_table) subject, errors = Subject.insert( db_conn, { 'name': 'Statistics', 'body': 'A beginning course focused on probability.', }) assert len(errors) == 0 subject['members'] = [{ 'id': 'A', 'kind': 'unit', }] subject, errors = subject.save(db_conn) assert len(errors) == 0
def add_subject_route(request, user_id, subject_id): """ Add a subject to the learner's list of subjects. """ db_conn = request['db_conn'] current_user = get_current_user(request) if not current_user: return abort(401) if user_id != current_user['id']: return abort(403) subject = Subject.get(db_conn, entity_id=subject_id) if not subject: return abort(404) user_subject = get_user_subjects(user_id, db_conn) if user_subject and subject_id in user_subject['subject_ids']: return 400, { 'errors': [{ 'name': 'subject_id', 'message': 'Subject is already added.', }], 'ref': 'kPZ95zM3oxFDGGl8vBdR3J3o', } # TODO-2 move some of this logic to the database file if user_subject: user_subject, errors = append_user_subjects(user_id, subject_id, db_conn) else: user_subject, errors = insert_user_subjects( { 'user_id': user_id, 'subject_ids': [subject_id], }, db_conn) if errors: return 400, {'errors': errors, 'ref': 'zCFUbLBTg9n2DnTkQYbqO4X9'} return 200, {'subjects': user_subject['subject_ids']}
def get_subject_units_route(request, subject_id): """ Present a small number of units the learner can choose from. NEXT STATE GET Choose Unit -> POST Choose Unit """ db_conn = request['db_conn'] # TODO-3 simplify this method. should it be part of the models? current_user = get_current_user(request) if not current_user: return abort(401) context = get_learning_context(current_user) next_ = { 'method': 'POST', 'path': '/s/subjects/{subject_id}/units/{unit_id}'.format( subject_id=context.get('subject', {}).get('entity_id'), unit_id='{unit_id}'), } set_learning_context(current_user, next=next_) subject = Subject.get_latest_accepted(db_conn, subject_id) # Pull a list of up to 5 units to choose from based on priority. buckets = traverse(db_conn, current_user, subject) units = buckets['learn'][:5] # TODO-3 Time estimates per unit for mastery. return 200, { 'next': next_, 'units': [unit.deliver() for unit in units], # For the menu, it must return the name and ID of the subject 'subject': subject.deliver(), 'current_unit_id': context.get('unit', {}).get('entity_id'), }
import sys, os sys.path.append(os.path.join(os.getcwd(), "..")) from models.collections import Collections from models.subject import Subject from persistence import mongoInterface mongoInterface.setup() collections = Collections() collections.save(mongoInterface) for collectionId, subjectsIds in collections.getCollections(): print "############################" print "# Preprocessing collection: " + collectionId print "############################\n" for subjectId in subjectsIds: try: subject = Subject(subjectId) subject.fetch() subject.parse() subject.save(mongoInterface) except (OSError, Exception) as e: print "Error: ", e mongoInterface.close()
def post(self, eventId, guardianId): '''The visitor is not an authenticated guardian''' if not SubscriptionLoginHandler.isAuthenticatedGuardian(): self.redirect('/inschrijven/') return '''The guardian is not authorized to the given''' if not self.isAuthorized(eventId, guardianId): SubscriptionLoginHandler.redirectToSubscriptionPage(self) return event = Event.get_by_id(int(eventId)) days = Day.gql("WHERE event = :1", event).fetch(999) guardian = Guardian.get_by_key_name(guardianId) students = Student.gql("WHERE guardian = :1", guardian).fetch(999, 0) students_subjects = self.getStudentsSubjects(students) notifications = [] templVal = { 'event': event, 'days': days, 'guardian': guardian, 'students': students_subjects, 'notifications': notifications } if not (event and days and guardian and students): notifications.append('U probeert een onmogelijke bewerking uit te voeren.') self.showError(templVal) return subscriptionDetailsList = SubscriptionDetails.gql("WHERE event = :1 AND guardian = :2", event, guardian).fetch(1, 0) if not subscriptionDetailsList: notifications.append('Pagina niet gevonden.') self.showError(templVal) return subscriptionDetails = subscriptionDetailsList[0] if subscriptionDetails and subscriptionDetails.requested: notifications.append('U kunt geen verzoeken meer indienen.') self.showError(templVal) return studentKeys = [str(k.replace('subject_', '')) for k in self.request.arguments() if re.match("subject_.+", k)] requests = [] dayPrefs = [] for s in students[:]: if str(s.key().name()) not in studentKeys: students.remove(s) if not students: notifications.append('U kunt geen verzoek indienen als u geen enkel vak geselecteerd heeft. ') for student in students[:]: subjectCodes = [c for c in self.request.get_all("subject_" + str(student.key().name()))] subjects = Subject.get_by_key_name(subjectCodes) if len(subjectCodes) > 3: notifications.append('U kunt maximaal 3 vakken per leerling bespreken.') if len(subjectCodes) != len(subjects): notifications.append('U probeert een onmogelijke bewerking uit te voeren.') for subject in subjects: combination = Combination.gql("WHERE class_id = :1 AND subject = :2", student.class_id, subject).fetch(1,0)[0] if not combination: notifications.append('U probeert een onmogelijke bewerking uit te voeren.') self.showError(templVal) return request = Request() request.event = event request.guardian = guardian request.student = student request.combination = combination requests.append(request) '''Process timepreference''' timePref = TimePreference() timePref.event = event timePref.guardian = guardian timePref.preference = 0 if not (self.request.get('time_pref') and (int(self.request.get('time_pref')) in [0,1,2])): notifications.append('U moet een voorkeur voor tijd aangeven.') else: timePref.preference = int(self.request.get('time_pref')) '''Check if dates from the form match the dates from the event ''' dayKeys = [long(k.replace('date_', '')) for k in self.request.arguments() if re.match("date_.+", k)] dayKeysFromStore= [day.key().id() for day in days] daysOk = True for dayKey in dayKeys: if dayKey not in dayKeysFromStore: daysOk = False notifications.append('U probeert een onmogelijke bewerking uit te voeren.') self.showError(templVal) return '''Check if the daypreference are correct filled in''' dayPrefsList = [int(self.request.get(k)) for k in self.request.arguments() if re.match("date_.+", k)] dayPrefsList.sort() dayPrefsOk = True if dayPrefsList != [1,2,3]: dayPrefsOk = False notifications.append('U moet een eerste, een tweede en een derde voorkeur aangeven') '''Process daypreferences''' if daysOk and dayPrefsOk: for day in days: dayPref = DayPreference() dayPref.day = day dayPref.guardian = guardian dayPref.rank = int(self.request.get("date_" + str(day.key().id()))) dayPrefs.append(dayPref) if notifications: path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription.html') self.response.out.write(template.render(path, templVal)) return '''Store the requests''' for request in requests: request.put() for dayPref in dayPrefs: dayPref.put() timePref.put() subscriptionDetails.requested = True subscriptionDetails.put() SubscriptionLogoutHandler.logoutGuardian() path = os.path.join(os.path.dirname(__file__), '../templates/subscription/subscription-success.html') self.response.out.write(template.render(path, templVal)) return
def get(self): # Load all Guardians path = os.path.join(os.path.dirname(__file__), 'data/voogdouder.txt') my_file = open(path) fileReader = csv.reader(my_file, delimiter=";") for row in fileReader: new_guardian = Guardian(key_name=row[0].strip()) new_guardian.title=row[1].strip() new_guardian.initials=row[2].strip() new_guardian.preposition=row[3].strip() new_guardian.lastname=row[4].strip() new_guardian.streetname=row[6].strip() new_guardian.housenumber=row[7].strip() new_guardian.city=row[8].strip() new_guardian.postalcode=row[9].strip() new_guardian.email=row[12].strip() new_guardian.save() print "Guardian " + new_guardian.key().id_or_name() + " stored" # Load all Students path = os.path.join(os.path.dirname(__file__), 'data/leerlingen.txt') my_file = open(path) fileReader = csv.reader(my_file, delimiter=";") for row in fileReader: new_student = Student(key_name=row[0].strip()) new_student.firstname=row[1].strip() new_student.preposition=row[2].strip() new_student.lastname=row[3].strip() new_student.gender=row[4].strip() new_student.class_id=row[5].strip() new_student.guardian=Guardian.all().filter("__key__ >=", Key.from_path('Guardian', row[6].strip())).get() new_student.save() print "Student " + new_student.key().id_or_name() + " stored" # Load all Teachers path = os.path.join(os.path.dirname(__file__), 'data/docenten.txt') my_file = open(path) fileReader = csv.reader(my_file, delimiter=";") for row in fileReader: new_teacher = Teacher(key_name=row[0].strip()) new_teacher.name=row[1].strip() new_teacher.boxnumber=int(row[2].strip()) new_teacher.email=row[3].strip() new_teacher.save() print "Teacher " + new_teacher.key().id_or_name() + " stored" # Load all Subjects path = os.path.join(os.path.dirname(__file__), 'data/vakken.txt') my_file = open(path) fileReader = csv.reader(my_file, delimiter=";") for row in fileReader: new_subject = Subject(key_name=row[0].strip()) new_subject.name=row[1].strip() new_subject.save() print "Subject " + new_subject.key().id_or_name() + " stored" # Load all Students path = os.path.join(os.path.dirname(__file__), 'data/docent_vak.txt') my_file = open(path) fileReader = csv.reader(my_file, delimiter=";") for row in fileReader: new_combination = Combination() new_combination.class_id=row[0].strip() new_combination.subject=Subject.all().filter("__key__ >=", Key.from_path('Subject', row[1].strip())).get() new_combination.teacher=Teacher.all().filter("__key__ >=", Key.from_path('Teacher', row[2].strip())).get() new_combination.save() print "Combination " + str(new_combination.key().id_or_name()) + " stored" self.redirect("/fix")