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 getVulnerability(cls, id):
vuln = Database.find_one(collection="vulnerabilities",
query={'_id': id})
if vuln != None:
return vuln
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 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 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 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 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 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 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 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 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 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 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_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 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 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 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 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 from_db(company_name):
return Database.find_one(COLLECTION, {"company_name": company_name})
def from_mongo(id):
return Database.find_one(collection='posts', query={'id': id})
def get_by_id(cls, _id):
data = Database.find_one("users", {"_id": _id})
if data is not None:
return cls(**data)
def from_db(user_name, password):
return Database.find_one(UserConstants.COLLECTION, {
"user_name": user_name,
"password": password
})
def getFromMongo(cls,id):
post_data = Database.find_one(collection='posts',query={'_id': id})
def get_task(_id):
return Database.find_one(COLLECTION, {"_id": int(_id)})
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 find_items(cls, cart_json):
item_list = []
items = cart_json["items"]
for item_id in items:
item_list.append(Database.find_one(ItemConstants.COLLECTION, {"_id": item_id}))
return item_list
def check_if_password_exists(user_id):
user = Database.find_one(UserConstants.COLLECTION, {"_id": user_id})
if user["password"] == "":
return False
else:
return True
def get_by_email(cls, email):
data = Database.find_one("users", {"email": email})
if data is not None:
return cls(**data)
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 getFromMongo(cls,id):
blog_data = Database.find_one(collection='blogs',
query={'_id': id})
return cls(**blog_data)
def get_task(_id):
return Database.find_one("placed_tasks", {"_id": int(_id)})
