def deleteCourse():
form = courseNumForm(request.form)
con = sql.connect("studentdb.db")
cur = con.cursor()
if request.method == 'POST':
courseNumNew = form.courseNumNew.data
cur.execute("SELECT * FROM course WHERE courseNum = ?",
(courseNumNew, ))
if cur.fetchone() is None and form.validate():
flash('Course not found', 'error')
return render_template("deleteCourse.html", form=form)
elif form.validate() and cur.fetchone is not None:
student = models.Course(courseNum=courseNumNew,
coursename="",
coursecode="")
student.delete()
flash('Course Successfully deleted', 'success')
return render_template("deleteCourse.html", form=form)
elif not form.validate():
flash('error in delete operation', 'error')
return render_template("deleteCourse.html", form=form)
else:
return render_template("deleteCourse.html", form=form)
def post(self):
""" Create a Course """
body = json.loads(self.request.body)
university = models.university_key(body['university']).get()
if not university:
pass #TODO: Error
course = models.Course()
course.department = body['department'].upper()
course.number = body['number']
course.name = body['name']
course_key = models.course_key(models.course_id(dept=body['department'].upper(), number=body['number']))
university.courses.append(course_key)
if course_key.get():
self.abort(409, detail="Course already exists") # 409: Conflict
else:
course.key = course_key
""" Create a Cache Object for this Course """
# TODO: Create
course.put()
university.put()
# Signal that cache is out of date
can_use_cache = models.can_cache_courses_key().get()
can_use_cache.put() # it will auto-update-time
self.response.set_status(201) # 201: Entity Created
def post(self, course_id=None):
values = [
self.get_argument(field, None) for field in models.Course.fields
]
course = models.Course(values)
use_old_holes = self.get_argument('use_old_holes', False)
try:
course.save()
self.db.generate_default_holes(course.id, course.holes)
if use_old_holes:
self.redirect("/course/{}/reuse_holes_from/{}/".format(
course.id, course_id))
else:
self.redirect("/course/{}/update_holes".format(course.id))
except Exception as e:
raise e
self.render(
"new_course.html",
tittle="Uusi rata",
terrains=self.db.terrains(),
course=course,
new_layout=True,
use_old_holes=use_old_holes,
message="Rata on jo tietokannassa!",
# For template
all_players=models.players(),
course_name_dict=self.db.course_name_dict(),
active_games=models.games({'active': True}),
user=self.get_current_user(),
)
def _attempt_scrape(semester_uq_id, course_code):
try:
semester = Session().query(
models.Semester
).filter(
models.Semester.uq_id == semester_uq_id
).one()
except NoResultFound:
raise APINotFoundException("Semester doesn't exist")
# Don't scrape if we've already got it
try:
offering = Session().query(
models.Offering
).join(
models.Course,
models.Offering.course_id == models.Course.id,
).filter(
models.Course.course_code == course_code,
models.Offering.semester_id == semester.id,
).one()
# If we got to here, the offering has already been scraped and we should abort
raise APIFailureException("Offering has already been scraped")
except NoResultFound:
# this is what we want
pass
# Actual scrape
assessment_items = scraper.scrape_assessment(semester.semester, course_code)
try:
course = Session().query(
models.Course
).filter(
models.Course.course_code == course_code
).one()
except NoResultFound:
course = models.Course(course_code)
Session().add(course)
Session().commit()
session = Session()
offering = models.Offering(
course_id=course.id,
semester_id=semester.id,
)
session.add(offering)
session.flush()
# Add assessment items
for item in assessment_items:
session.add(models.AssessmentItem(
offering_id=offering.id,
task_name=item['task'],
weight=item['weight'],
))
session.commit()
return offering
def addercourse():
form = courseForms(request.form)
if request.method == 'POST':
con = sql.connect("studentdb.db")
cur = con.cursor()
courseNumNew = form.courseNumNew.data
coursenameNew = form.coursenameNew.data
coursecodeNew = form.coursecodeNew.data
cur.execute("SELECT * FROM course WHERE courseNum = ?",
(courseNumNew, ))
if cur.fetchone() is not None:
flash('Course id already taken', 'error')
return render_template("addcourse.html", form=form)
elif not form.validate():
flash('Please fill up the whole form', 'error')
return render_template("addcourse.html", form=form)
elif form.validate():
student = models.Course(courseNum=courseNumNew,
coursename=coursenameNew,
coursecode=coursecodeNew)
student.addcourse()
flash('Course successfully added', 'success')
return render_template("studentDatabase.html")
else:
return render_template("addcourse.html", form=form)
con.close()
def deletecourse():
form = DeleteCourse(request.form)
if request.method == 'POST' and form.validate():
course = models.Course(c_id=form.del_cid.data)
course.cdelete()
return redirect('/course')
else:
return render_template('cdelete.html', form=form)
def searchcourse():
form = SearchCourse(request.form)
if request.method == 'POST' and form.validate():
course = models.Course(c_id=form.search_cid.data)
course = course.csearch()
return render_template('cprofile.html', data=course)
else:
return render_template('csearch.html', form=form)
def addcourse():
form = AddCourse(request.form)
if request.method == 'POST' and form.validate():
course = models.Course(c_id=form.c_id.data,
c_name=form.c_name.data,
c_college=form.c_college.data)
course.cadd()
return redirect('/course')
else:
return render_template('cadd.html', form=form)
def setUp(self):
self.course = models.Course("CPSC", "210")
self.assertEqual(self.course.department, "CPSC")
self.assertEqual(self.course.course_number, "210")
self.activity = models.Section("L1A", models.SectionType.LAB)
self.assertEqual(self.activity.is_lab(), True)
self.course.add_section(self.activity)
self.assertEquals(len(self.course.get_sections()), 1)
def updatecourse():
form = UpdateCourse(request.form)
if request.method == 'POST' and form.validate():
course = models.Course(c_id=form.new_cid.data,
c_name=form.new_cname.data,
c_college=form.new_ccollege.data)
course.cupdate()
return redirect('/course')
else:
return render_template('cupdate.html', form=form)
def post(self):
name = request.form.get("name", "")
description = request.form.get("description", "")
course = models.Course(name,description)
try:
self.db.insertCourse(course)
except Exception as e:
print(e)
logging.exception("Connection to database failed")
return flask.redirect("/")
return flask.redirect("/admin/")
def addCourse():
form = AddCourse(request.form)
if request.method == 'POST' and form.validate():
courseId = form.courseId.data
courseName = form.courseName.data
course = models.Course(courseId=courseId, courseName=courseName)
course.add()
flash('A course has been successfully added', 'success')
return render_template('addCourse.html', form=form)
return render_template('addCourse.html', form=form)
def post(self):
name = flask.request.form.get('name')
f = flask.request.files.get('students')
title = flask.request.form.get('title')
course = models.Course(name, title)
course.teacher_id = current_user.id
models.db.session.add(course)
models.db.session.commit()
author = models.User.query.filter_by(id=course.teacher_id).first()
if f:
course.set_students(f)
return render_template("course.html", course=course, author=author)
def add_course():
form = forms.CourseEditForm()
if form.validate_on_submit():
course = models.Course(
name=form.name.data,
description=form.description.data,
requirements=form.requirements.data,
upload_required=form.upload_required.data,
open_for_applications=form.open_for_applications.data)
course.save()
flash('Course created successfully.', 'success')
return redirect('courses')
return render_template('edit_course.html', form=form, is_new=True)
def deleteCourse(courseId):
cur = mysql.connection.cursor()
cur.execute('SELECT * FROM Student WHERE courseId = %s', [courseId])
if cur.fetchone() is not None:
flash(
'There are still Students enrolled in this course. Delete the Students first.',
'error')
return redirect(url_for('listCourse'))
else:
course = models.Course(courseId=courseId, courseName="")
course.delete()
flash('Successfully Deleted', 'success')
return render_template('deleteSuccess.html')
return redirect(url_for('listCourse'))
def get(self, course_id=None):
course = models.course(course_id) if course_id else models.Course([])
self.render(
"new_course.html",
tittle="Uusi rata",
terrains=self.db.terrains(),
course=course,
new_layout=True,
use_old_holes=bool(course_id),
message="",
# For template
all_players=models.players(),
course_name_dict=self.db.course_name_dict(),
active_games=models.games({'active': True}),
user=self.get_current_user(),
)
def getCourses(self, limit=10, index=0):
cursor = self.connection.cursor()
get_query = "SELECT subjectId, name,description FROM subjects LIMIT %s OFFSET %s"
cursor.execute(get_query, (limit, index))
courses = cursor.fetchall()
if not courses:
cursor.close()
return None
tab = []
for course in courses:
c = models.Course(subjectId=course[0],
name=course[1],
description=course[2])
tab.append(c)
cursor.close()
return tab
def makeObject(dirpath, filename):
f = open(os.sep.join([dirpath, filename]), 'r')
sections_added = []
for line in f:
fields = line.split("|")
fields[len(fields) - 1] = fields[len(fields) -
1][:-1] # getting rid of newline
pName = fields[0]
if not pName:
continue
if pName == "":
continue
CID = fields[1]
if CID == "NONE":
continue
if all(float(field) == 0.0 for field in fields[2:]):
continue
# check if rating lengths too small
if len(fields[2:]) < 8:
continue
if len(fields[10:]) < 2:
continue
# if the section is already added ,skip for now
if any(CID in s.courseID for s in sections_added):
continue
newSection = m.Section(CID, pName, fields[2:10], fields[10:12])
courseID = filename + CID
if courseID not in courseDict:
courseDict[courseID] = m.Course(courseID)
currCourse = courseDict[courseID]
currCourse.add_section(newSection)
#Check if professor in dictionary and add it
if pName not in professorDict:
professorDict[pName] = m.Professor(pName)
currProfessor = professorDict[pName]
currProfessor.add_section(newSection)
sections_added.append(newSection)
def updateCourse(courseId):
cur = mysql.connection.cursor()
cur.execute("SELECT * FROM Course WHERE courseId = %s", [courseId])
row = cur.fetchone()
form = UpdateCourse(request.form)
if request.method == 'POST' and form.validate():
courseName = request.form['courseName']
course = models.Course(courseId=courseId, courseName=courseName)
course.update()
cur.close()
flash('Successfully Updated', 'success')
return render_template('updateCourse.html', form=form, row=row)
return render_template('updateCourse.html', form=form, row=row)
def submit():
app.logger.debug(request.form.getlist('categories'))
# get Idea form from models.py
course_form = models.CourseForm(request.form)
if request.method == "POST" and course_form.validate():
# get form data - create new idea
course = models.Course()
course.title = request.form.get('title')
course.slug = slugify(course.title)
course.description = request.form.get('description', '')
course.instructor = request.form.get('instructor')
course.semester = request.form.get('semester')
course.year = request.form.get('year')
course.categories = request.form.getlist('categories')
course.units = request.form.get('units')
course.save()
return redirect('/courses/%s' % course.slug)
else:
if request.form.getlist('categories'):
for c in request.form.getlist('categories'):
course_form.categories.append_entry(c)
templateData = {
'courses': models.Course.objects(),
'categories': categories,
'form': course_form
}
return render_template("submit.html", **templateData)
def course_new():
try:
coursename = request.json['coursename']
startdate = request.json['startdate']
finishdate = request.json['finishdate']
numberlectures = request.json['numberlectures']
startdate = datetime.strptime(startdate, '%Y-%m-%d').date()
finishdate = datetime.strptime(finishdate, '%Y-%m-%d').date()
except (KeyError, ValueError) as e:
return jsonify({
"status":"error",
"error": str(e),
}), 400
course = models.Course(coursename, startdate, finishdate, numberlectures)
db.session.add(course)
db.session.commit()
return jsonify({
"status":"ok",
"course_id": course.id
})
def input():
app.logger.debug(request.form.getlist('categories'))
# get Idea form from models.py
course_form = models.CourseForm(request.form)
request.method == "POST" and course_form.validate()
# get form data - create new idea
course = models.Course()
course.title = request.form.get('title')
course.slug = slugify(course.title)
course.description = request.form.get('description','')
course.instructor = request.form.get('instructor')
course.semester = request.form.get('semester')
course.year = request.form.get('year')
course.categories = request.form.getlist('categories')
course.units = request.form.get('units')
course.save()
return redirect('/courses/%s' % course.slug)
def post(self):
User = users.get_current_user()
if User:
student = db.GqlQuery("SELECT * FROM Student WHERE user = :1",
User).get()
info = json.loads(self.request.body)
logging.warning(info)
if student == None:
self.response.out.write("student is null")
return
dup_course = db.GqlQuery(
"SELECT * FROM Course WHERE ANCESTOR IS :1 AND id = :2",
models.student_key(User), int(info["courseId"])).get()
if dup_course != None:
logging.warning("duplicate course")
self.response.out.write("already in this course")
return
# create the courses calendar if it doesn't already exist
if student.calID is None or student.calID == "":
logging.warning('student calID is in fact empty')
self.response.out.write(
"student calendar is empty in api, not adding course")
return
else:
logging.warning('student id is something else, it is %s' %
student.calID)
courseInfo = utils.createClassEvent(info)
logging.warning(courseInfo)
event = courseInfo["event"]
request = service.events().insert(calendarId=student.calID,
body=event)
response = request.execute(http=decorator.http())
logging.warning(json.dumps(response))
newCourse = models.Course(parent=models.student_key(User))
newCourse.id = info["courseId"]
newCourse.code = info["code"]
newCourse.number = info["number"]
newCourse.section = info["section"]
newCourse.type = info["type"]
newCourse.title = info["title"]
newCourse.days = courseInfo["days"]
newCourse.start_time = info["start_time"]
newCourse.end_time = info["end_time"]
newCourse.start = info["start"]
newCourse.end = info["end"]
newCourse.location = info["location"]
newCourse.instructor = info["instructor"]
newCourse.prof_email = info["prof_email"]
newCourse.site_link = info["site_link"]
newCourse.eventid = response["id"]
newCourse.eventseq = response["sequence"]
newCourse.semester_id = "SP13" # should not be hardcoded in the future
newCourse.put()
# respond with changes so backbone knows the id
self.response.out.write(json.dumps(models.serialize(newCourse)))
else:
self.response.out.write("['auth':'fail']")
class UploadHandler(webapp2.RequestHandler):
def getSize(self, fileobject):
fileobject.seek(0, 2) # move the cursor to the end of the file
size = fileobject.tell()
return size
def get(self):
template = main.jinja_env.get_template("templates/upload.html")
values = {
"departments": models.DEPARTMENT_NAMES,
"depts": models.DEPARTMENTS,
"types": models.FILE_TYPES
}
termcodes = []
this_year = date.today().year + 1
this_month = date.today().month
for year in range(this_year, this_year - 3, -1):
yearcode = year * 100
for quarter, value in [('Spring', 30), ("Winter", 20),
("Fall", 10)]:
termcodes.append({
"term":
quarter + " " + str(year - 1) + "-" + str(year),
"code":
yearcode + value
})
values["termcodes"] = termcodes
if 1 <= this_month <= 2:
# Winter Quarter
values["termcodes"] = termcodes[4:]
elif 3 <= this_month <= 6:
# Spring Quarter
values["termcodes"] = termcodes[3:]
elif 7 <= this_month <= 8:
# Summer
pass
elif 9 <= this_month <= 11:
# Fall Quarter
values["termcodes"] = termcodes[2:]
elif this_month == 12:
# Winter Quarter
values["termcodes"] = termcodes[1:]
hash = self.request.params.get('msg')
if hash:
if hash == 'success':
values[
'msg'] = 'Congrats! The file was uploaded. The chapter applauds your committment to academic success.'
elif hash == 'retry':
values[
'msg'] = 'The file needs to be less than 10MB or the request was bad. Please try submitting again, or shrinking the file down.'
elif hash == 'error':
values[
'msg'] = 'Error uploading file! Please contact Tech if this is a problem'
self.response.out.write(template.render(values))
def post(self):
client = gdata.sites.client.SitesClient(source='rosefiji-fijifiles-v1',
site='fiji-files',
domain='rosefiji.com')
import os.path
folder = os.path.dirname(os.path.realpath(__file__))
file_path = os.path.join(folder, 'credentials.json')
credentials = ServiceAccountCredentials.from_json_keyfile_name(
file_path, scopes)
credentials._kwargs['sub'] = '*****@*****.**'
auth2token = gdata.gauth.OAuth2TokenFromCredentials(credentials)
auth2token.authorize(client)
dept = self.request.params.get('department')
file_id = models.get_upload_number()
uri = '%s?kind=%s' % (client.MakeContentFeedUri(),
'filecabinet&path=/' + dept)
feed = client.GetContentFeed(uri=uri)
f = self.request.params.get('file')
ext = f.filename.split(".")[-1].upper()
media = gdata.data.MediaSource(
file_handle=f.file.read(),
content_type=gdata.docs.service.SUPPORTED_FILETYPES.get(ext)
or 'application/octet-stream',
content_length=self.getSize(self.request.params.get('file').file))
try:
urlfetch.set_default_fetch_deadline(30)
attachment = client.UploadAttachment(
media,
feed.entry[0],
title=file_id,
description='UPLOADED TO NEW FIJI FILES SITE')
except Exception, e:
logging.exception(e)
self.redirect('/upload?msg=retry')
return
try:
course_dept = dept
course_number = int(self.request.params.get("courseNumber"))
course_key = ndb.Key("Course", course_dept + str(course_number))
course = course_key.get()
if not course:
course = models.Course(key=course_key,
department=course_dept,
course_number=course_number)
course.put()
file_to_add = models.File(
parent=course_key,
professor=self.request.params.get("professor"),
file_type=self.request.params.get("type"),
termcode=int(self.request.params.get("termcode")),
url="https://sites.google.com/a/rosefiji.com/fiji-files/" +
dept + "/" + file_id,
delete_url=str(attachment.get_edit_link().href),
comments=self.request.params.get("comments"))
file_to_add.put()
self.redirect('/upload?msg=success')
except Exception, e:
logging.exception(e)
self.redirect('/upload?msg=error')
def review():
majorCodes = db.session.query(models.MajorCodes).all()
programs = db.session.query(models.Program).all()
allUsers = db.session.query(models.Users).all()
db.session.close()
form = forms.WriteReview()
# setting up the form
form.majorCode.choices = sorted([(m.duke_major_code, m.duke_major_code) for m in majorCodes])
if form.validate_on_submit():
dateTimeObj = datetime.now()
timestampStr = dateTimeObj.strftime("%d-%b-%Y (%H:%M:%S.%f)")
id = timestampStr
u_email = session.get('user_email')
# get form responses
duke_major_code = form.majorCode.data
duke_code = str(duke_major_code) + " " + str(form.courseNumber.data)
course_name = form.course.data
rating = form.rating.data
difficulty = form.difficulty.data
content = form.thoughts.data
user = db.session.query(models.Users).filter(Users.email == u_email).one()
program_name = user.program_name
for p in programs:
if p.program_name == program_name:
country = p.country
break
# check for errors
if request.method == 'POST':
error = None
user = db.session.query(models.Users).filter(Users.email == u_email).first()
specifcUserReviews = db.session.query(models.Review).filter(Review.u_email == u_email)\
.join(models.Course, Course.id == Review.course_id).filter(Course.course_name == course_name).all()
if len(specifcUserReviews) != 0:
error = 'You have already written a review for this class.'
flash(error)
return redirect(url_for('review'))
# check if the course already exists
courses = db.session.query(models.Course).filter(Course.course_name == course_name)\
.filter(Course.program_name == program_name).filter(Course.duke_code == duke_code).all()
course_id = None
for course in courses:
if course.course_name == course_name and course.program_name == program_name and course.duke_code == duke_code:
course_id = course.id
break
if course_id == None:
new_course = models.Course(duke_code=duke_code, course_name=course_name, program_name=program_name)
db.session.add(new_course)
db.session.flush()
db.session.commit()
course_id = new_course.id
new_review = models.Review(id=id, country=country, duke_major_code=duke_major_code, u_email=u_email, course_id=course_id , rating=rating, difficulty=difficulty, content=content)
db.session.add(new_review)
db.session.flush()
db.session.commit()
flash('New entry was successfully posted')
return render_template('submitted.html', form=form)
return render_template('review.html', form=form)
#%% s = Session() #%% u = models.User(lms_user='******', is_prof=True, token='alks') s.add(u) s.commit() # %% print(sess.query(models.User).all()) # %% u = s.query(models.User).first() c = models.Course(name='test', responsible=u) s.add(c) s.commit() # %% a = models.Activity(course_specific_id='at1', course=c) s.add(a) s.commit() #%% u2 = models.User(lms_user='******', is_prof=False, token='alks2') s.add(u2) sub = models.Submission(sender_id=u2.id, activity_id=a.id, content='sdlkfjsdlfsdlfjsdkl') s.add(sub) s.commit()
def add_course(name, announcement):
if find_course(convert(name)):
return False
course = m.Course(name=name, text=convert(name), announcement=announcement)
course.save()
return True
def initialize_test_database():
config = load_config_file("tests/test_config.json")
database = db.Database(
config['database'],
config['host'],
config['user'],
config['password'],
)
models.DATABASE = database
# Initialize courses
course = models.Course({'name': 'A-Rata', 'holes': 18})
course.save()
database.generate_default_holes(course.id, course.holes)
course2 = models.Course({'name': 'B-Rata', 'holes': 12})
course2.save()
database.generate_default_holes(course2.id, course2.holes)
short_course = models.Course({'name': 'Lyhyt rata', 'holes': 6})
short_course.save()
database.generate_default_holes(short_course.id, short_course.holes)
# Initialize players
visitor = models.Player({'name': 'Visitor'})
visitor.save()
member = models.Player({'name': 'Club member', 'member': True})
member.save()
user = models.Player({
'name': 'ordinary user',
'member': True,
'priviledges': 'member',
'user_name': 'ordinary',
'password': '******',
})
user.set_password()
user.save()
admin = models.Player({
'name': 'Admin',
'member': True,
'priviledges': 'admin',
'user_name': 'admin',
'password': '******',
})
admin.set_password()
admin.save()
# Cups
cup1 = models.Cup({
'name': 'EsKo Cup',
'month': 6,
'year': 2017,
'course': course.id,
'max_par': 15,
})
cup1.save()
cup2 = models.Cup({
'name': 'EsKo Cup',
'month': 7,
'year': 2017,
'course': course2.id,
'max_par': 20,
})
cup2.save()
# Special rules
rule_set1 = models.RuleSet({
'name':
"Shotput",
'description':
"Instead of disc playing with shotputs.",
})
rule_set1.save()
generate_game_and_results(database,
course.id, [member.id],
game_time=datetime.timedelta(minutes=90))
generate_game_and_results(database,
course.id, [member.id, visitor.id],
game_time=datetime.timedelta(minutes=110))
generate_game_and_results(database,
course.id, [member.id],
game_time=datetime.timedelta(minutes=95))
