def test_get_by_id(self):
"""Get Module by ID."""
module = Module(title='foo', order=5, template_id='i_1')
module.save()
retrieved = Module.query.get_or_404(module.id)
assert retrieved == module
def test_add_article_with_module(self):
"""Add a module to an article."""
module = Module(title='module_article')
module.save()
article = ArticleFactory()
article.module = module
article.save()
assert isinstance(article.module_id, int)
def new_module():
type = Module_Type.select().where(
Module_Type.id == request.form['module_type'])
if not type.exists():
flash('Module type bestaat niet.', AlertType.WARNING.value)
return redirect(url_for('admin.modules'))
module = Module(type=type)
module.save()
return redirect(url_for('admin.modules'))
def newmodule():
if current_user.email not in TA_EMAILS:
abort(404)
if request.method == 'GET':
return render_template('newmodule.jinja2')
if request.method == 'POST':
name = request.form.get('name')
number = request.form.get('number')
description = request.form.get('description')
exercise = request.form.get('exercise')
module = Module(name = name, number = number, description = description, exercise = exercise)
db.session.add(module)
db.session.commit()
return render_template('newmodulesubmitted.jinja2')
def test_model_Module_basic(self):
"""Test Module model with minimum parameters"""
name = 'test module'
title = 'Test title'
url = '/test_url/'
obj = Module(name=name, title=title, url=url)
obj.save()
self.assertIsNotNone(obj.id)
obj = Module.objects.get(id=obj.id)
self.assertEquals(obj.name, name)
self.assertEquals(obj.title, title)
self.assertEquals(obj.url, url)
self.assertEquals(obj.details, '')
self.assertTrue(obj.display)
self.assertTrue(obj.system)
self.assertEqual(obj.get_absolute_url(),
'/admin/module/view/{}'.format(obj.id))
def add_module_submission():
try:
grade_id=request.form['grade_id']
semester_id = request.form['semester_id']
new_module = Module(
name=request.form['name'],
grade_id=grade_id,
semester_id=semester_id
)
Module.insert(new_module)
flash('Module ' + request.form['name'] + ' was successfully listed!')
except:
db.session.rollback()
print(sys.exc_info())
flash('An error occurred. Module ' + request.form['name'] + ' could not be listed.')
finally:
db.session.close()
query = Module.query.filter(Module.grade_id==grade_id, Module.semester_id==semester_id)
return render_template('pages/modules.html', data=query, userinfo=session['profile'])
def create_paste():
form= PasteForm(request.form)
if request.method == 'POST' :
paste= None
if form.id.data != None:
paste= Paste.query.get(form.id.data)
if paste != None:
paste.author= form.author.data
paste.content= form.content.data
paste.name= form.name.data
#remove modules
for module in paste.modules:
db.session.delete(module)
if paste == None:
paste= Paste(author= form.author.data, content= form.content.data, name= form.name.data)
db.session.add(paste)
db.session.commit()
for module in form.modules:
if module.expanded.data == 0:
#skip content of non-expanded modules
module.content.data= ""
m= Module(name= module.mod_name.data,
score= module.score.data,
content= module.content.data,
module_id= module.module_id.data,
paste_id= paste.id)
db.session.add(m)
db.session.commit()
return redirect(url_for('show_paste', paste_id=paste.id))
return "0"
def __get_module_data(self, module_link: (str, str)) -> Optional[Module]:
name, url = module_link
response: Response = self.cached_requester.cached_request(url)
if response.status_code == 404:
module = Module(url=url, name=name)
self.issues.append(f"Module {name} does not exist")
self.cache_module(module)
return module
html: BeautifulSoup = BeautifulSoup(response.content, "html.parser")
title = html.find("h1").text.rsplit("-", maxsplit=1)
name = title[0].strip()
code = title[1].strip()
info_table = html.find("table").find("tbody")
rows = info_table.find_all("tr")
basic_info = rows.pop(0).find_all("td")
levels: [str] = []
duration: str = "Unspecified"
nqf_lvl: int = 0
creds: int = 0
try:
levels_str = basic_info[0].text
duration_str = basic_info[1].text.strip()
nqf_str = basic_info[2].text[-1:].strip()
creds_str = basic_info[3].text.split(": ")[1]
levels = levels_str.split(",") if levels_str != "" else []
duration = duration_str if duration_str != "" else "Unspecified"
nqf_lvl = int(nqf_str) if nqf_str != "" else 0
creds = int(creds_str) if creds_str != "" else 0
except ValueError:
self.issues.append(f"Error for module {name}")
purpose = ""
pre_requisite = ""
co_requisite = ""
recommendation = ""
for row in rows:
data = row.find_all("td")
for data_point in data:
if "Pre-requisite:" in data_point.text:
pre_requisite = data_point.text
elif "Co-requisite:" in data_point.text:
co_requisite = data_point.text
elif "Recommendation:" in data_point.text:
recommendation = data_point.text
elif "Purpose:" in data_point.text:
purpose = data_point.text
module = Module(
url=url,
name=name,
code=code,
levels=levels,
duration=duration,
nqf_level=nqf_lvl,
credits=creds,
purpose=purpose,
pre_requisite=pre_requisite,
co_requisite=co_requisite,
recommendation=recommendation,
)
self.cache_module(module)
return module
# setup logging
if args.debug:
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
else:
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
logger = logging.getLogger(__name__)
from slugify import slugify
from models import Module
from parsers import FantasyGrounds
if __name__ == "__main__":
# create module
module = Module()
module.id = args.id or str(uuid.uuid4())
module.name = args.name or "Unknown"
module.slug = slugify(module.name)
module.author = args.author or "Unknown"
module.code = args.code
module.image = args.cover or "Cover.jpg"
# create data parser
dp = None
if args.parser == "fg":
# FantasyGrounds
dp = FantasyGrounds()
module.description = "Converted from FG"
