def deleteProject(cls, id):
project = Database.find_one(collection='projects', query={'_id': id})
if project != None: # edit if element exists
Vulnerability.deleteVulnerabilitiesOfProject(report_id=id)
Database.delete_one(collection='projects', query={"_id": id})
return True
else:
return False
def register_user(name, email, password):
if User.get_by_email(email) is None:
user = User(name, email, User.hash_password(password))
Database.insert("users", user.json())
session['email'] = email
return True
else:
return False
def deleteVulnerability(cls, id):
vuln = Database.find_one(collection='vulnerabilities',
query={'_id': id})
if vuln != None: # edit if element exists
Database.delete_one(collection='vulnerabilities',
query={"_id": id})
return True
else:
return False
def editProject(cls, id, newObj):
project = Database.find_one(collection='projects', query={'_id': id})
print(project)
if project != None: # edit if element exists
project = Database.update_one(collection='projects',
obj=project,
newObj={"$set": newObj.json()})
return True
else:
return False
def getProjectNumbersOfVulnerabilities(cls):
nos_vulns = []
projects = Database.find(collection='projects', query={})
for project in projects:
no_vulns = Database.find(collection='vulnerabilities',
query={'report_id': project["_id"]})
if no_vulns != None:
nos_vulns.append(no_vulns.count())
return nos_vulns
def deleteVulnerabilitiesOfProject(cls, report_id):
vuln = Database.find(collection='vulnerabilities',
query={'report_id': report_id})
if vuln != None: # edit if element exists
print(
Database.delete_many(collection='vulnerabilities',
query={"report_id": report_id}))
return True
else:
return False
def editVulnerability(cls, id, newObj):
vulnerability = Database.find_one(collection='vulnerabilities',
query={'_id': id})
#print(vulnerability)
if vulnerability != None: # edit if element exists
vulnerability = Database.update_one(collection='vulnerabilities',
obj=vulnerability,
newObj={"$set": newObj.json()})
return True
else:
return False
def remove_item():
cart = ShoppingCart.find_by_user_id(session["email"])
cart_ids = cart.shopping_list
cart_ids.remove(request.form["remove"])
Database.update(ShoppingCartConstants.COLLECTION,
{"user_email": session["email"]}, cart.json(cart))
items = ShoppingCart.find_items(cart.json(cart))
total = 0
for item in items:
total += float(item["price"])
return render_template("shopping_cart.html", items=items, total=total)
def getVulnerabilitiesNumber(cls, report_id):
vulns = Database.find(collection="vulnerabilities",
query={'report_id': report_id})
if vulns != None:
return vulns.count()
else:
return 0
def getliked(self):
likedlist = []
liked = Database.find(collection='liked', query={'user_id': self._id})
for l in liked:
movie = Movie.Movie.get_by_id(l["movie_id"])
likedlist.append(movie)
return likedlist
def getfavourites(self):
favouritelist = []
favourite = Database.find(collection='favourites', query={'user_id': self._id})
for f in favourite:
movie = Movie.Movie.get_by_id(f["movie_id"])
favouritelist.append(movie)
return favouritelist
def getunwatched(self):
unwatchedlist = []
unwatched = Database.find(collection='unwatched', query={'user_id': self._id})
for l in unwatched:
movie = Movie.Movie.get_by_id(l["movie_id"])
unwatchedlist.append(movie)
return unwatchedlist
def getVulnerabilities(cls, report_id):
vulns = Database.find(collection="vulnerabilities",
query={'report_id': report_id})
critical = []
high = []
medium = []
low = []
info = []
if vulns != None:
for vuln in vulns:
if vuln["severity"] == "critical":
critical.append(vuln)
elif vuln["severity"] == "high":
high.append(vuln)
elif vuln["severity"] == "medium":
medium.append(vuln)
elif vuln["severity"] == "low":
low.append(vuln)
elif vuln["severity"] == "info":
info.append(vuln)
if vulns != None:
return critical + high + medium + low + info
else:
return False
def login_company(company_name, password):
company_data = Database.find_one(COLLECTION, {"company_name": company_name})
if company_data is None:
return False
if Utils.check_hashed_password(password, company_data['password']):
return True
else:
return False
def getVulnerability(cls, id):
vuln = Database.find_one(collection="vulnerabilities",
query={'_id': id})
if vuln != None:
return vuln
else:
return False
def find_by_user_id(cls, email):
cart = Database.find_one(ShoppingCartConstants.COLLECTION, {"user_email": email})
cls.user_email = cart["user_email"]
cls.time_created = cart["time_created"]
cls.temp = cart["temp"]
cls._id = cart["_id"]
cls.shopping_list = cart["items"]
return cls
def update_users(company_name, company_key, company_id):
people = TaskObjectBuilder.get_from_teamwork_scaled(CompanyConstants.people_action,
CompanyConstants.people_name,
company_name, company_key)
for person in people:
user = Database.find_one(UserConstants.COLLECTION, {"_id": int(person["id"])})
if user is None:
usr = User(person["id"], person["user-name"], "", company_id)
usr.save_to_db()
def check_pwd(account, pwd):
user_info = Database.find_one(collection='user',
query={'account': account})
if user_info is None:
return False
if pwd == user_info['pwd']:
session['user_id'] = user_info['user_id']
session['role'] = user_info['role']
return True
else:
return False
def too_cart():
if request.method == 'GET':
if "email" in session.keys():
cart = Database.find_one(ShoppingCartConstants.COLLECTION,
{"user_email": session["email"]})
items = ShoppingCart.find_items(cart)
total = 0
for item in items:
total += float(item["price"])
return render_template("shopping_cart.html",
items=items,
total=total)
return render_template("shopping_cart.html")
def login_user(email, password):
user_data = Database.find_one(UserConstants.COLLECTION,
{"email": email})
if user_data is None:
return False
if not Utils.email_is_valid(email):
return False
if Utils.check_hashed_password(password, user_data['password']):
return True
else:
return False
def pick_user():
if request.method == 'POST':
user_name = request.form.get("pick_user")
user = Database.find_one(UserConstants.COLLECTION,
{"user_name": user_name})
user_id = user["_id"]
session["user_name"] = user_name
session["user_id"] = user_id
User.get_unplaced_tasks_anyone(session["company_id"])
User.get_placed_user_tasks(session["company_id"], user_id)
User.get_unplaced_user_tasks(session["company_id"], user_id)
if user["password"] == "":
return render_template("createPassword.html")
return render_template("userLogin.html")
def enter_password():
if request.method == 'POST':
password = request.form["password"]
user_data = Database.find_one(UserConstants.COLLECTION,
{"_id": session["user_id"]})
if user_data is not None:
if Utils.check_hashed_password(password, user_data['password']):
return render_template('FullCalendar.html')
else:
return render_template(
'userLogin.html',
error_message="please enter the correct password")
else:
return render_template(
"home.html", string="something went wrong please try again")
def company_login():
if request.method == 'GET':
return render_template('login.html')
elif request.method == 'POST':
company_name = request.form['name']
company_password = request.form['password']
if Company.login_company(company_name, company_password):
company = Database.find_one(CompanyConstants.COLLECTION,
{"company_name": company_name})
# give the company_id to the session to access later on
session["company_id"] = company["_id"]
session["company_name"] = company_name
Company.update_users(company_name, company["key"],
session["company_id"])
users = Database.find(UserConstants.COLLECTION,
{"company_id": company["_id"]})
user_names = []
for user_id in users:
user_names.append(user_id["user_name"])
return render_template("userPicker.html", user_names=user_names)
else:
return render_template("home.html",
string="please use a valid login")
def create_password():
if request.method == 'POST':
password = request.form['password']
password_second = request.form['password_repeated']
if password == password_second:
hashed_password = Utils.hash_password(password)
user = Database.find_one(UserConstants.COLLECTION,
{"_id": session["user_id"]})
user["password"] = hashed_password
# update user in db
User.user_json_to_user_object(user).update_db()
return render_template("FullCalendar.html")
else:
error_message = "passwords don't match, please re-enter them"
return render_template('createPassword.html',
error_message=error_message)
def pull_from_teamwork():
List.clear_task_list()
company = Database.find_one(CompanyConstants.COLLECTION,
{"_id": session["company_id"]})
TaskObjectBuilder.build_list(
TaskObjectBuilder.get_from_teamwork_scaled(T.tasks, T.tasks_name,
session["company_name"],
company["key"]))
tsks = List.task_list
for task in tsks:
if not DatabaseChecker.does_task_exist_in_db(task):
if not DatabaseChecker.does_placed_task_exist_in_db(task):
task.save_to_db()
elif DatabaseChecker.has_task_been_updated(task):
# write an update method
task.update_in_db()
def pull_data_from_api():
pull_from_teamwork()
company = Database.find_one(CompanyConstants.COLLECTION,
{"_id": session["company_id"]})
List.clear_task_list()
TaskObjectBuilder.build_completed_list(
TaskObjectBuilder.get_from_teamwork_scaled(T.completed_tasks,
T.completed_tasks_name,
session["company_name"],
company["key"]))
ts = List.task_list
for task in ts:
if DatabaseChecker.does_task_exist_in_db(task):
task.delete_from_db()
elif DatabaseChecker.does_placed_task_exist_in_db(task):
PlacedTask.remove_placed_task(task.task_id)
return render_template("FullCalendar.html")
def register_user(email, password):
"""
this method registers a user using e-mail and password.
the password already comes hashed as sha-512.
:param email: user's e-mail (might be invalid)
:param password: sha512-hashed password
:return: True if registered successfully, or False otherwise (exeptions can be raised)
"""
user_data = Database.find_one(UserConstants.COLLECTION,
{"email": email})
if user_data is not None:
return False
if not Utils.email_is_valid(email):
return False
User(email, Utils.hash_password(password)).save_to_db()
return True
def register_company(company_name, company_password, key):
company_data = Database.find_one(COLLECTION, {"company_name": company_name, "key": key})
# needs to catch JSON decoder error and return invalid company name and key
account = TaskObjectBuilder.get_from_teamwork_scaled(CompanyConstants.account_action,
CompanyConstants.account_name,
company_name, key)
people = Company.create_user_id_list(company_name, key)
if company_data is not None:
return "already registered"
elif "companyid" in account.keys():
_id = account["companyid"]
company = Company(_id, company_name, Utils.hash_password(company_password), key, people)
company.save_to_db()
Company.create_users(company_name, company_data["key"], _id)
return "company registered"
else:
return "invalid company name or API key"
def getVulnerabilitiesSeverities(cls, report_id):
critical = high = medium = low = info = 0
vulns = Database.find(collection="vulnerabilities",
query={'report_id': report_id})
if vulns != None:
for vuln in vulns:
if vuln["severity"] == "critical":
critical = critical + 1
elif vuln["severity"] == "high":
high = high + 1
elif vuln["severity"] == "medium":
medium = medium + 1
elif vuln["severity"] == "low":
low = low + 1
elif vuln["severity"] == "info":
info = info + 1
return [critical, high, medium, low, info]
else:
return False
def fetch_suggestions():
return [suggestions for suggestions in Database.find("suggest", {})]
def fetch_reaction(brd_id):
return [react for react in Database.find("reactions", {"suggestion_id": brd_id})]
def save_to_db(self):
Database.insert_data("reactions", self.json())
def fetch_upvotes(brd_id):
return [upreact for upreact in Database.find("reactions", {"suggestion_id": brd_id, "upvote": "on"})]
def fetch_downvotes(brd_id):
return [downreact for downreact in Database.find("reactions", {"suggestion_id": brd_id, "downvote": "on"})]
def fetch_flagged_bad(brd_id):
return [flagged for flagged in Database.find("reactions", {"suggestion_id": brd_id, "flagged": "on"})]
def get_by_id(cls, id):
data = Database.find_one("users", {"_id": id})
if data is not None:
return User(data["email"], data["password"])
def get_by_email(cls, email):
data = Database.find_one("users", {"email": email})
if data is not None:
return User(data["name"], data["email"], data["password"])
def save_to_mongo(self):
Database.insert_data("users", self.json())
def save_to_db(self):
Database.insert_data("suggest", self.json())
def init_db():
Database.initialize()
def delete(brd_id):
return [sugg_ttle for sugg_ttle in Database.remove("suggest", {"board_id": brd_id})]
def find_by_author_id(cls, author_id):
blog_data = Database.find(collection='blogs',
query={'author_id': author_id})
return[cls(**blog) for blog in blogs]
def fetch_by_id(brd_id):
return [suggestion_title for suggestion_title in Database.find("suggest", {"board_id": brd_id})]
