def Generator(request): allofem = Assignment.objects.all() for a in allofem: a.delete() pref = UserProfile.objects.all() opt_dict = {} for stu in pref: opt_dict[stu]= [stu.option1, stu.option2, stu.option3, stu.option4, stu.option5] courses = Course.objects.all() results = {} caps = {} for i in courses: caps[mkkey(i.name,i.available)]= i.max_cap for i in courses: results[mkkey(i.name, i.available)]= [] for stu in pref: for i in range(5): if canassign(opt_dict[stu][i], stu.user, str(stu.grade), caps, results): results[mkkey(opt_dict[stu][i], str(stu.grade))].append(stu.user) else: continue for i in results.keys(): for j in results[i]: assignment = Assignment() assignment.user = j assignment.class_name = i assignment.save() return HttpResponseRedirect(reverse('showassignments'))
class TestModelAssignment(unittest.TestCase): def setUp(self): sys.path.insert(0, "../../src") from models import Assignment start_date = datetime.date(2000, 5, 5) due_date = datetime.date(2020, 12, 12) self.assignment1 = Assignment(1) self.assignment2 = Assignment(2, start_date, due_date) def test_assignment_start_date(self): answer1 = datetime.date(2000, 1, 1) answer2 = datetime.date(2000, 5, 5) self.assertEqual(self.assignment1.start_date, answer1) self.assertEqual(self.assignment2.start_date, answer2) def test_assignment_due_date(self): due_date1 = datetime.date(2000, 1, 1) due_date2 = datetime.date(2020, 12, 12) self.assertEqual(self.assignment1.end_date, due_date1) self.assertEqual(self.assignment2.end_date, due_date2) def test_assignment_id(self): self.assertEqual(self.assignment1.assignment_id, 1) self.assertEqual(self.assignment2.assignment_id, 2) def test_assignment_repr(self): self.assertEqual(self.assignment1.__repr__(), "Assignment 1") self.assertEqual(self.assignment2.__repr__(), "Assignment 2")
def make_assignment_with_pk_vals(quarter, year, assign): assignment = Assignment() assignment.year = year assignment.quarter = quarter assignment.number = assign return assignment
def setUp(self): sys.path.insert(0, "../../src") from models import Assignment start_date = datetime.date(2000, 5, 5) due_date = datetime.date(2020, 12, 12) self.assignment1 = Assignment(1) self.assignment2 = Assignment(2, start_date, due_date)
def assignment_insert(self, assignment): """ Add or update an assignment owned by the given user """ if assignment.from_datastore: assignment_with_parent = assignment else: assignment_with_parent = Assignment(parent = main.get_parent_key(endpoints.get_current_user()), name = assignment.name) assignment_with_parent.put() return assignment_with_parent
def test_optional_field(self): testsubject = Subject(name = "testname", description = "testdescription", link = "http://www.google.ro/") testsubject.save() now = datetime.datetime.utcnow().replace(tzinfo=utc) testassignment = Assignment(subject_id = testsubject, name="test", text = "asda", deadline = now) testassignment.save() testsubject.delete() testassignment.delete()
def post(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url(self.request.uri)) return next_active_assignemnt = None if (self.request.get('type') == 'Student'): rose_username = self.request.get('rose_username') new_student = Student(parent=get_parent_key(user), id=rose_username, first_name=self.request.get('first_name'), last_name=self.request.get('last_name'), rose_username=rose_username, team=self.request.get('team')) new_student.put() elif (self.request.get('type') == 'Assignment'): active_assignment = Assignment(parent=get_parent_key(user), name=self.request.get('assignment_name')) if len(self.request.get('assignment_entity_key')) > 0: assignment_key = ndb.Key(urlsafe=self.request.get('assignment_entity_key')) if assignment_key: assignment = assignment_key.get() if assignment: active_assignment = assignment active_assignment.name = self.request.get('assignment_name') active_assignment.put() next_active_assignemnt = active_assignment.key.urlsafe() elif (self.request.get('type') == 'SingleGradeEntry'): assignment_key = ndb.Key(urlsafe=self.request.get('assignment_key')) student_key = ndb.Key(urlsafe=self.request.get('student_key')) student = student_key.get() score = int(self.request.get('score')) new_grade_entry = GradeEntry(parent=assignment_key, id=student.rose_username, assignment_key=assignment_key, student_key=student_key, score=score) new_grade_entry.put() next_active_assignemnt = assignment_key.urlsafe() elif (self.request.get('type') == 'TeamGradeEntry'): assignment_key = ndb.Key(urlsafe=self.request.get('assignment_key')) score = int(self.request.get('score')) team = self.request.get('team') student_query = Student.query(Student.team==team, ancestor=get_parent_key(user)) for student in student_query: new_grade_entry = GradeEntry(parent=assignment_key, id=student.rose_username, assignment_key=assignment_key, student_key=student.key, score=score) new_grade_entry.put() next_active_assignemnt = assignment_key.urlsafe() if next_active_assignemnt: self.redirect("/?active_assignemnt=" + next_active_assignemnt) else: self.redirect("/")
def module003_assignment_course(course_id): form = AssigmentForm() course = Course.query.filter_by(id=course_id).first() follow = Follow.query.filter( and_(Follow.course_id == course_id, Follow.user_id == current_user.id)).first() assignments = Assignment.query.filter_by(course_id=course_id) if follow: if request.method == 'POST': if form.validate_on_submit(): if form.never_expire.data: assignment = Assignment(course_id=course_id, author_id=current_user.id, name=form.name.data, descripcion=form.descripcion.data) else: assignment = Assignment( course_id=course_id, author_id=current_user.id, name=form.name.data, descripcion=form.descripcion.data, date_expire=datetime.datetime.combine( form.date_expire.data, form.time_expire.data)) try: db.session.add(assignment) db.session.commit() flash("Assignment created") except: db.session.rollback() flash("Error creating Assignment!") return redirect( url_for('module003.module003_assignment_course', course_id=course.id)) else: if current_user.profile in ('admin', 'staff', 'student'): follows = Follow.query.filter_by(user_id=current_user.id) return render_template("module003_assignment_especifico.html", form=form, module="module003", rows=follows, course=course, assignments=assignments) else: flash("Access denied!") return redirect(url_for('index')) else: flash("Access denied!") # abort(404,description="Access denied!") return redirect(url_for('index'))
def get_assignments(user): """ Gets all of the assignments for this user and makes a key map for them. """ assignments = Assignment.query(ancestor=get_parent_key(user)).order(Assignment.name).fetch() assignments_map = {} for assignment in assignments: assignments_map[assignment.key] = assignment return assignments, assignments_map
def post(self): if bool(self.request.get('choice')): ndb.delete_multi(Student.query().fetch(keys_only=True)) ndb.delete_multi(Assignment.query().fetch(keys_only=True)) ndb.delete_multi(Setting.query().fetch(keys_only=True)) self.redirect('/admin')
def add_lesson_to_course(courseID): """Adds a lesson to a course""" form = request.form course = Course.query.get(courseID) try: lesson = Lesson(course_id=courseID, title=form.get("title"), num=form.get("num"), date_due=form.get("date_due")) db.session.add(lesson) db.session.commit() for student in course.students_enrolled: assignment = Assignment(student_enrollment_id=student.id, lesson_id=lesson.id, complete=False, turned_in=False) db.session.add(assignment) db.session.commit() flash("Successfully added lesson") except: flash("Failed to add lesson") return redirect("/")
def assginment_no_exists(form, field): if Assignment.select().where(Assignment.name == field.data).exists(): print("x============x") pass else: raise ValidationError('Assignment does not exist!')
def get(self,slug): cookie = self.request.cookies.get('CookieProtocolServices') if cookie: session = ndb.Key(urlsafe=str(cookie)).get() user = session.key.parent().get() page = Page.query(Page.slug == slug).get() assignments = Assignment.query( Assignment.active == True, Assignment.user == user.key, Assignment.completed == False).order( -Assignment.when).fetch(10) if page: #TODO: Manage subscriptions template = JINJA_ENVIRONMENT.get_template('app.html') self.response.write(template.render( {'auth': True, 'page': page, 'user': user, 'homepage': user.subscription.get().startpage, 'assignments': assignments, 'text': process_text(page.text)})) else: template = JINJA_ENVIRONMENT.get_template('404.html') self.response.write(template.render({})) else: self.redirect('/login')
def delete_assign_by_number(quarter,year,number): assgn = Assignment.query( Assignment.quarter == quarter, Assignment.year == year, Assignment.number == number, ).get() assgn.key.delete()
def get(self): user, logout = check_user(users.get_current_user()) if user: if self.request.get('id'): t = ndb.Key(urlsafe=self.request.get('id')).get() u = t.to_dict() t.revised = True t.put() else: cursor = None u = [] more = True while more: d, curs, more = Assignment.query( Assignment.active == True).order( -Assignment.when).fetch_page( 100, start_cursor=cursor) for ditem in d: u.append(ditem.to_dict()) self.response.out.headers['Content-Type'] = 'application/json' self.response.out.write(json.dumps({'data':u}))
def get_assign_n(quarter, year, n): assigns = Assignment.query( Assignment.quarter == quarter, Assignment.year == year, ).order(Assignment.number).fetch() try: return assigns[n] except IndexError: return None
def get_active_assign_with_latest_fade_in_date(quarter, year): assigns_after_now = Assignment.query( Assignment.quarter == quarter, Assignment.year == year, Assignment.fade_in_date < dt.now() - td(hours=7) ).order(Assignment.fade_in_date).fetch() try: return assigns_after_now[-1] except IndexError: return None
def get_active_assign_with_earliest_eval_due_date(quarter, year): evals_after_now = Assignment.query( Assignment.quarter == quarter, Assignment.year == year, Assignment.eval_date > dt.now() - td(hours=7) ).order(Assignment.eval_date).fetch() if len(evals_after_now) > 0: return evals_after_now[0] else: return None
def post(self): parser = reqparse.RequestParser() parser.add_argument( "sid", type=str, required=True, ) parser.add_argument( "ordinal", type=str, choices=assignment_function_mapping.keys(), required=True, ) parser.add_argument( "answers", required=True, action="append", ) try: args = parser.parse_args() except Exception: raise ParameterMissing correctnesses = assignment_function_mapping[args.ordinal](args.answers) if args.sid: past_assignment = Assignment.query.filter_by( sid=args.sid, ordinal=args.ordinal, ).first() if past_assignment is not None: updated_correctenesses = self._merge_correctnesses( self._deserialize_correctnesses( past_assignment.correctnesses, ), correctnesses, ) past_assignment.correctnesses = self._serialize_correctnesses( updated_correctenesses, ) db.session.commit() else: assignment = Assignment( sid=args.sid, ordinal=args.ordinal, correctnesses=self._serialize_correctnesses(correctnesses), ) db.session.add(assignment) db.session.commit() return { "correctnesses": correctnesses, }
def get(self): cookie = self.request.cookies.get('CookieProtocolServices') admin, logout = check_user(users.get_current_user()) if cookie: session = ndb.Key(urlsafe=str(cookie)).get() user = session.key.parent().get() assignments = Assignment.query( Assignment.active == True, Assignment.user == user.key, Assignment.completed == False).order( -Assignment.when).fetch(10) template = JINJA_ENVIRONMENT.get_template('user.html') self.response.write(template.render( {'auth': False, 'user': user.to_dict(), 'assignments': assignments})) elif admin: user = ndb.Key(urlsafe=self.request.get('id')).get() assignments = Assignment.query( Assignment.user == user.key, Assignment.completed == False).order( -Assignment.when).fetch(10) template = JINJA_ENVIRONMENT.get_template('user.html') self.response.write(template.render( {'auth': True, 'user': user.to_dict(), 'assignments': assignments})) else: self.redirect('/login?to={}'.format(slug))
def add(): if request.method == "GET": course_num = request.args['courseNum'] return render_template("addAssignment.html", course_num=course_num) name = request.form.get('assignment') course_num = request.form.get('courseNum') newAssignment = Assignment(name=name, class_id=course_num) db_session.add(newAssignment) db_session.commit() db_session.add(Grade(grade=0, assignment_id=newAssignment.id)) db_session.commit() return redirect(url_for('search', courseNum=course_num))
def post(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url(self.request.uri)) if (self.request.get('type') == 'Assignment'): new_assignment = Assignment(assignment_name = self.request.get('assignment_name'), owner=user) new_assignment.put() else: an_assignment_key = ndb.Key(Assignment, int(self.request.get('assignment_id'))) assignment_for_entry = an_assignment_key.get() if assignment_for_entry is None: raise endpoints.NotFoundException('Assignment id not found') if user != assignment_for_entry.owner: raise endpoints.ForbiddenException("You can only edit/create grade entries in your own Assignments.") new_grade_entry = GradeEntry(student_name = self.request.get('student_name'), score = self.request.get('score'), assignment_id = int(self.request.get('assignment_id')), parent = assignment_for_entry.key, owner=user) new_grade_entry.put() time.sleep(0.5) self.redirect('/')
def get_inactive_assigns(quarter, year): all_assigns = Assignment.query( Assignment.quarter == quarter, Assignment.year == year ).order(Assignment.fade_in_date).fetch() to_return = [] for i in range(len(all_assigns) - 1, -1, -1): if all_assigns[i].fade_out_date < dt.now() - td(hours=7) or all_assigns[i].fade_in_date > dt.now() - td(hours=7): to_return.append(all_assigns[i]) return to_return
def get_active_eval_assigns(quarter, year): assigns_before_now = Assignment.query( Assignment.quarter == quarter, Assignment.year == year, Assignment.eval_date > dt.now() - td(hours=7) ).order(Assignment.eval_date).fetch() to_return = [] for i in range(len(assigns_before_now)): if assigns_before_now[i].eval_open_date < dt.now() - td(hours=7): to_return.append(assigns_before_now[i]) return to_return
def post(self): """ Creates an assignment """ data = request.json title = data.get('title') start_date = data.get('start_date')[:10] + " 00:00:00" due_date = data.get('due_date')[:10] + " 23:59:59" group_id = data.get('group_id') problem_id = data.get('problem_id') new_assignment = Assignment(title=title, start_date=start_date, due_date=due_date, group_id=group_id, problem_id=problem_id) db.session.add(new_assignment) db.session.commit() return new_assignment, 201
def get(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url(self.request.uri)) else: assignments_with_grades = []; assignment_query = Assignment.query().order(Assignment.assignment_name).filter(Assignment.owner_email == user.email().lower()) for an_assignment in assignment_query: grade_entry_query = GradeEntry.query().order(GradeEntry.student_name).filter(GradeEntry.owner_email == user.email().lower()).filter(GradeEntry.assignment_id == an_assignment.id) assignments_with_grades.append({'assignment_name': an_assignment.assignment_name, 'grade_entries': grade_entry_query}) self.response.out.write(template.render('templates/graderecorder.html', {'assignments_with_grades': assignments_with_grades, 'assignments': assignment_query, 'use_hardcoded_roster': True, 'user_email': user.email(), 'logout_link': users.create_logout_url("/")}))
def add_staff(): if "staff_id" not in session: abort(401) if not request.form["request_id"]: abort(404) # Get all the data from the single select element value, we need event request id and staff id staff = Staff.query.filter_by(staff_id=session["staff_id"]).first() eventRequest = EventRequest.query.filter_by(request_id=request.form["request_id"]).first() if staff == None or eventRequest == None: # Make sure both exist in the DB, for FK validation abort(404) assign = Assignment(eventRequest.request_id, staff.staff_id) db.session.add(assign) db.session.commit() flash("Staff " + staff.username + " assigned to event " + str(eventRequest) + " successfully!") return redirect(url_for('staff'))
def createNewRecord(eventID=None): """ return a reference to a newly created record or elss None""" eventID = cleanRecordID(eventID) rec = None if eventID > 0: #test that countEvent record exits cnt = CountEvent.query.filter(CountEvent.ID == eventID).count() if cnt > 0: rec = Assignment(eventID, getUID()) db.session.add(rec) else: flash( printException( "Invalid countEvent ID during Count Event creation.", "error")) return rec
def setUp(self): db.drop_all() db.create_all() teacher = Teacher.seed_db(name="teacher_name", username="******", password="******") db.session.add(teacher) student = Student.seed_db(name="student_name", username="******", password="******", teacher_id=1) db.session.add(student) assignment = Assignment(title='title', body='body', teacher_id=1) db.session.add(assignment) one = StudentAssignment(assignment_id=assignment.id, student_id=student.id) db.session.add(one) db.session.commit()
def homework_upload(): # Save the file file = request.files['homework'] file2 = request.files['homeworksrc'] filename = str(uuid.uuid4()) file.save( os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(filename + '.jar'))) file2.save( os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(filename + '.zip'))) # Add file to the database of assignments assignment = Assignment(id=filename, name=file.filename) models.db.session.add(assignment) models.db.session.commit() return redirect('/')
def new_assignment(): ''' Create new assignment ''' form = AssignmentForm() if form.validate_on_submit(): my_assignment = Assignment() form.populate_obj(my_assignment) db.session.add(my_assignment) try: db.session.commit() # User info flash('Assignment created correctly', 'success') return redirect(url_for('assignments')) except: db.session.rollback() flash('Error generating assignment.', 'danger') return render_template('web/new_assignment.html', form=form)
def addassignment(): """ Utility view for adding assignments. """ req_json = request.get_json(silent=True) if not req_json: return "Assignment addition failed." if req_json['key'] != SECRET_KEY: return "Assignment addition failed; key incorrect." assignment = Assignment(title=req_json['title'], desc=req_json['desc'], visible=req_json['visible'], date_due=datetime.date.fromordinal( req_json['date_due'])) db.session.add(assignment) db.session.commit() if assignment.visible: send_email_users_new_asgn(assignment) return "Added assignment " + str(assignment) + " successfully."
def add_assignments(enrollmentID): """This is a helper function that adds all the assignments to an enrolled student""" enroll = Enrollment.query.get(enrollmentID) lessons = Lesson.query.filter(Lesson.course_id == enroll.course.id) assigned_lessons = [assigned.lesson for assigned in enroll.assignemnts] for lesson in lessons: if not lesson in assigned_lessons: assignment = Assignment(student_enrollment_id=enrollmentID, lesson_id=lesson.id, complete=False, turned_in=False) db.session.add(assignment) db.session.commit()
def assign(a, b): body = request.get_json() reviewer_id = body.get('reviewer_id', None) project_id = body.get('project_id', None) try: reviewer = Reviewer.query.filter_by(id=reviewer_id).one_or_none() project = Project.query.filter_by(id=project_id).one_or_none() previous_assignments = Assignment.query.filter( Assignment.reviewer_id == reviewer_id, Assignment.project_id == project_id).count() if previous_assignments > 0: raise AuthError({ 'code': 'Bad request', 'description': "this assignment is already existent" }, 400) if reviewer is None: raise AuthError({ 'code': 'Bad request', 'description': "reviewer does not exist" }, 400) if project is None: raise AuthError({ 'code': 'Bad request', 'description': "project does not exist" }, 400) assignment = Assignment() assignment.reviewer_id = reviewer_id assignment.project_id = project_id assignment.insert() return jsonify({ 'success': True, 'assignment': assignment.format() }) except Exception as e: print("exception error post reviewer", e) print(e) if isinstance(e, AuthError): raise e abort(422)
def new_assignment(course_id): course = Course.query.get(course_id) if request.method == "POST": name = request.form.get('name', None) description = request.form.get('description', None) due_at = request.form.get('due-at', None) display_at = request.form.get('display-at', None) file_ = request.files.get('file', None) if name and due_at and display_at: assignment = Assignment(name=name, description=description) assignment.due_at = parse(due_at) assignment.display_at = parse(display_at) if file_: filename = assignment_descs.save(file_) assignment.description_filename = filename course.add_assignment(assignment) assignment.save() return redirect(url_for('list_assignments', course_id=course_id)) return render_template('assignment/new.html', course=course)
def get(self): user = users.get_current_user() if not user: self.redirect(users.create_login_url(self.request.uri)) else: grades = []; assignment_query = Assignment.query().order(Assignment.assignment_name).filter(Assignment.owner == user) for an_assignment in assignment_query: assignment_dict = {'assignment_name': an_assignment.assignment_name} grade_entries = [] grade_entry_query = GradeEntry.query().order(GradeEntry.student_name).filter(GradeEntry.owner == user).filter(GradeEntry.assignment_id == an_assignment.id) for a_grade_entry in grade_entry_query: self.add_team_individuals(a_grade_entry, grade_entries) # grade_entries.append(a_grade_entry) assignment_dict['grade_entries'] = sorted(grade_entries, key=operator.attrgetter('student_name')) grades.append(assignment_dict) self.response.out.write(template.render('templates/graderecorder.html', {'grades': grades, 'assignments': assignment_query, 'use_hardcoded_roster': True, 'user_email': user.email(), 'logout_link': users.create_logout_url("/")}))
def load_homework(file_name): """ load homework from a unique csv file in the data folder file_name: the name of the csv file """ path = "../data/" + file_name data = pd.read_csv(path) tprint("Homeworks", data) homework_list = [] for index, row in data.iterrows(): a_assignment = Assignment( cname=row["class"], desc=row["description"], duration=row["duration"], due=row["due"], ) homework_list.append(a_assignment) return homework_list, data
def module003_create(): form = AssignmentCreateForm() if request.method == 'POST': try: course = Course.query.get(form.course_id.data) assignment = Assignment(title=form.title.data, body=form.description.data, date_expire=datetime.datetime.combine( form.date_expire.data, form.time_expire.data), course_id=course.id, course_name=course.name, institution_name=course.institution_name, user_id=current_user.id) db.session.add(assignment) db.session.commit() flash("Tarea creda con exito") except: flash("Error creando tarea") for course in Course.query.filter_by(user_id=current_user.id): form.course_id.choices += [ (course.id, str(course.id) + ' - ' + course.institution_name + ' - ' + course.name) ] assignments = Assignment.query.filter( Assignment.user_id == current_user.id) return render_template("module003_create.html", module='module003', form=form, rows=assignments)
def create_assignment_rpc(course, name, file, command, batch_size, grading_base): assignment: Assignment = Assignment.query.filter_by( name=name, course=course, endpoint=get_endpoint(course=course)).one_or_none() if not assignment: assignment = Assignment( name=name, assignment_secret=new_secret(), course=course, endpoint=get_endpoint(course=course), ) db.session.add(assignment) assignment.file = file assignment.command = command assignment.last_modified = int(time.time()) assignment.batch_size = batch_size assignment.grading_base = grading_base db.session.commit() return assignment.assignment_secret
import re from models import Assignment, Problem file = open("management/commands/sample.tex", "r") data = file.read() m = re.search(r"assignment{(.*)}", data) name = m.group(1) m = re.search(r"duedate{(.*)}", data) due_date = m.group(1) asgt = Assignment(name=name, due_date=due_date) asgt.save() problems = [] problem_locs = [m.end() for m in re.finditer("begin{problem}", data)] for loc in problem_locs: p = Problem() m = re.search(r"\[(.*)\]", data[loc:]) p.name = m.group(1) n = re.search(r"\[(.*)\]", data[loc+m.end():]) p.points = n.group(1) o = re.search(r"([^]]*)\\end{problem}", data[loc + m.end() + n.end():]) p.solution = o.group(1) p.save() asgt.problems.add(p)
def _create_or_add_assignment(self, assignment_name, parentnode, extras): # NOTE: Set default publishing_time two seconds after start_time to # make sure it evaluates as "within" the period. publishing_time = parentnode.start_time + timedelta(seconds=2) assignment = Assignment(parentnode=parentnode, short_name=assignment_name, long_name=assignment_name.capitalize(), publishing_time=publishing_time) try: assignment.full_clean() assignment.save() except ValidationError: assignment = Assignment.objects.get(parentnode=parentnode, short_name=assignment_name) # add the users (only admins allowed in subject) for admin in extras['admin']: assignment.admins.add(self._create_or_add_user(admin)) if extras['pub']: assignment.publishing_time += timedelta(days=int(extras['pub'][0])) if extras['anon']: if extras['anon'][0] == 'true': assignment.anonymous = True elif extras['anon'][0] == 'false': assignment.anonymous = False else: raise ValueError("anon must be 'true' or 'false'") if extras['ln']: assignment.long_name = extras['ln'][0] assignment.full_clean() assignment.save() vars(self)[parentnode.parentnode.short_name + '_' + # subject parentnode.short_name + '_' + # period assignment.short_name] = assignment return assignment
def _create_or_add_assignment(self, assignment_name, parentnode, extras): # NOTE: Set default publishing_time two seconds after start_time to # make sure it evaluates as "within" the period. publishing_time = parentnode.start_time + timedelta(seconds=2) if extras['delivery_types']: deliverytype_alias = extras['delivery_types'][0] typemap = {'electronic': deliverytypes.ELECTRONIC, 'nonelectronic': deliverytypes.NON_ELECTRONIC} delivery_types = typemap[deliverytype_alias] else: delivery_types = deliverytypes.ELECTRONIC assignment = Assignment(parentnode=parentnode, short_name=assignment_name, long_name=assignment_name.capitalize(), publishing_time=publishing_time, delivery_types=delivery_types, max_points=200) try: assignment.full_clean() assignment.save() except ValidationError: assignment = Assignment.objects.get(parentnode=parentnode, short_name=assignment_name) # add the users (only admins allowed in subject) for admin in extras['admin']: assignment.admins.add(self._create_or_add_user(admin)) if extras['pub']: assignment.publishing_time += timedelta(days=int(extras['pub'][0])) if extras['anon']: if extras['anon'][0] == 'true': assignment.anonymous = True elif extras['anon'][0] == 'false': assignment.anonymous = False else: raise ValueError("anon must be 'true' or 'false'") if extras['ln']: assignment.long_name = extras['ln'][0] if extras['first_deadline']: days = int(extras['first_deadline'][0]) assignment.first_deadline = assignment.publishing_time if days == 0: assignment.first_deadline += timedelta(seconds=1) else: assignment.first_deadline += timedelta(days=days) assignment.full_clean() assignment.save() vars(self)[parentnode.parentnode.short_name + '_' + # subject parentnode.short_name + '_' + # period assignment.short_name] = assignment return assignment
from datetime import datetime, timedelta import logging from models import Exam, Assignment from FCM import sendNotification from apiMethods import createNotification logging.basicConfig(level=logging.DEBUG) LOG = logging.getLogger(__name__) date = (datetime.now() + timedelta(days=7)) date = date.strftime('%d-%m-%Y') LOG.info(date) examList = Exam.query(Exam.dueDate == date).fetch() LOG.info(str(examList)) assignmentList = Assignment.query(Assignment.dueDate == date).fetch() for exam in examList: LOG.info(str(exam)) sendNotification(exam.courseId.urlsafe(), exam.key.urlsafe(), 'exam', 'Warning!!! Exam ahead', 'There is a exam next week') course = exam.courseId.get() title = course.courseName notificationText = 'There is a exam next week' createNotification(course.studentIds, title, notificationText, 'exam', exam.key.urlsafe(), course.key.urlsafe()) for assignment in assignmentList: LOG.info(str(assignment)) sendNotification(assignment.courseId.urlsafe(),
def create_from_path(path): """ Create a Node, Subject, Period, Assignment or AssignmentGroup from ``path``. Examples:: assignmentgroup = create_from_path( 'ifi:inf1100.spring05.oblig1.student1,student2') oblig1 = create_from_path( 'ifi:inf1100.spring05.oblig1') """ split = path.split(':', 1) nodes = split[0].split('.') for nodename in nodes: node = Node(short_name=nodename, long_name=nodename.capitalize()) try: node.clean() node.save() except: node = Node.objects.get(short_name=nodename) last = node if len(split) != 2: return last pathsplit = split[1].split('.') # Subject subjectname = pathsplit[0] subject = Subject(parentnode=node, short_name=subjectname, long_name=subjectname.capitalize()) try: subject.clean() subject.save() except: subject = Subject.objects.get(short_name=subjectname) last = subject # Period if len(pathsplit) > 1: periodname = pathsplit[1] period = Period(parentnode=subject, short_name=periodname, long_name=periodname.capitalize(), start_time=datetime.now(), end_time=datetime.now() + timedelta(10)) try: period.clean() period.save() except: period = Period.objects.get(parentnode=subject, short_name=periodname) last = period # Assignment if len(pathsplit) > 2: assignmentname = pathsplit[2] assignment = Assignment(parentnode=period, short_name=assignmentname, long_name=assignmentname.capitalize(), publishing_time=datetime.now()) assignment.clean() try: assignment.save() except: assignment = Assignment.objects.get(parentnode=period, short_name=assignmentname) last = assignment # Candidates if len(pathsplit) > 3: usernames = pathsplit[3].split(',') users = [] for u in usernames: user = User(username=u) try: user.save() except: user = User.objects.get(username=u) users.append(user) assignment_group = AssignmentGroup(parentnode=assignment) assignment_group.clean() assignment_group.save() for user in users: assignment_group.candidates.add(Candidate(student=user)) last = assignment_group return last
def testAssignment(self): what = Assignment(123) what.setDescription("aerobic in aer liber") what.setDeadline("martiembrie 201B") what.setGrade(5.1231231231231231231231231) assert what.getStudentID() == 123 assert what.getDescription() == "aerobic in aer liber" assert what.getDeadline() == "martiembrie 201B" assert what.getGrade() == 5.1231231231231231231231231
def get_current_assignments(session): return Assignment.get_current_assignments(session)
def _create_or_add_assignment(self, assignment_name, parentnode, extras): assignment = Assignment(parentnode=parentnode, short_name=assignment_name, long_name=assignment_name.capitalize(), publishing_time=parentnode.start_time) try: assignment.full_clean() assignment.save() except: assignment = Assignment.objects.get(parentnode=parentnode, short_name=assignment_name) # add the users (only admins allowed in subject) for admin in extras['admin']: assignment.admins.add(self._create_or_add_user(admin)) if extras['pub']: assignment.publishing_time += timedelta(days=int(extras['pub'][0])) if extras['anon']: if extras['anon'][0] == 'true': assignment.anonymous = True elif extras['anon'][0] == 'false': assignment.anonymous = False else: raise ValueError("anon must be 'true' or 'false'") assignment.full_clean() assignment.save() vars(self)[parentnode.parentnode.short_name + '_' + # subject parentnode.short_name + '_' + # period assignment.short_name] = assignment return assignment
def get_assign_by_number(quarter, year, number): return Assignment.query( Assignment.quarter == quarter, Assignment.year == year, Assignment.number == number, ).get()
def get_assigns_for_quarter(quarter, year): return Assignment.query( Assignment.quarter == quarter, Assignment.year == year, )
def get_all_assign(quarter, year): return Assignment.query( Assignment.quarter == quarter, Assignment.year == year ).order(Assignment.number).fetch()
def _create_or_add_assignment(self, assignment_name, parentnode, extras): assignment = Assignment(parentnode=parentnode, short_name=assignment_name, long_name=assignment_name.capitalize(), publishing_time=parentnode.start_time) try: assignment.full_clean() assignment.save() except ValidationError: assignment = Assignment.objects.get(parentnode=parentnode, short_name=assignment_name) # add the users (only admins allowed in subject) for admin in extras['admin']: assignment.admins.add(self._create_or_add_user(admin)) if extras['pub']: assignment.publishing_time += timedelta(days=int(extras['pub'][0])) if extras['anon']: if extras['anon'][0] == 'true': assignment.anonymous = True elif extras['anon'][0] == 'false': assignment.anonymous = False else: raise ValueError("anon must be 'true' or 'false'") assignment.full_clean() assignment.save() vars(self)[parentnode.parentnode.short_name + '_' + # subject parentnode.short_name + '_' + # period assignment.short_name] = assignment return assignment
def assignment_list(self, query): """ List all the assignments owned by the given user """ user = endpoints.get_current_user() assignments = Assignment.query(ancestor=main.get_parent_key(user)).order(Assignment.name) return assignments