def get_user_id_from_token(self, token: str) -> int: # Recover user_id from token try: s = Serializer(self.secret_key) payload = s.loads(token) return payload except SignatureExpired: logger.info(GenericErrorMessages.EXPIRED_TOKEN_ERROR) raise AppException(msg=GenericErrorMessages.EXPIRED_TOKEN_ERROR) except BadSignature: logger.warning(GenericErrorMessages.BAD_SIGNATURE_TOKEN_ERROR) raise AppException( msg=GenericErrorMessages.BAD_SIGNATURE_TOKEN_ERROR)
def get_all_users(self): """ This method retrieves all users from DB :return: {User} """ try: alchemy_users_list = self.session.query(AlchemyUser).all() user_list = list() for u in alchemy_users_list: role_list = list() for r in u.roles: permission_list = list() for p in r.permissions: new_permission = Permission(p.id, p.name, p.description) permission_list.append(new_permission) role = Role(r.id, r.name, r.description, permission_list) role_list.append(role) new_user = User(u.id, u.username, u.password, u.first_name, u.family_name, u.email, role_list) user_list.append(new_user) return user_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_all_evidences(self): """ This method retrieves all evidences from DB :return: {Evidence} """ try: alchemy_evidences_list = self.session.query(AlchemyEvidence).all() evidence_list = list() for e in alchemy_evidences_list: roles_list = list() for r in e.owner.roles: permission_list = list() for p in r.permissions: new_permission = Permission(p.id, p.name, p.description) permission_list.append(new_permission) new_role = Role(r.id, r.name, r.description, permission_list) roles_list.append(new_role) new_user = User(e.owner.id, e.owner.username, e.owner.password, e.owner.first_name, e.owner.family_name, e.owner.email, roles_list) new_evidence = Evidence(e.id, e.alias, e.size, new_user) evidence_list.append(new_evidence) return evidence_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_all_uploads(self, evidence_id): """ This method retrieves all uploads from DB that belongs to evidence_id :return: {Upload} """ try: alchemy_upload_list = self.session.query(AlchemyUpload).filter_by(evidence_id=evidence_id).all() upload_list = list() for u in alchemy_upload_list: roles_list = list() for r in u.evidence.owner.roles: permission_list = list() for p in r.permissions: new_permission = Permission(p.id, p.name, p.description) permission_list.append(new_permission) new_role = Role(r.id, r.name, r.description, permission_list) roles_list.append(new_role) new_user = User(u.evidence.owner.id, u.evidence.owner.username, u.evidence.owner.password, u.evidence.owner.first_name, u.evidence.owner.family_name, u.evidence.owner.email, roles_list) new_evidence = Evidence(u.evidence.id, u.evidence.alias, u.evidence.size, new_user) new_upload = Upload(u.id, u.path, u.size, u.type, new_evidence) upload_list.append(new_upload) return upload_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_upload(self, upload_id): """ This method retrieves uploads with given id from DB :return: Upload """ try: alchemy_upload = self.session.query(AlchemyUpload).filter_by(id=upload_id).first() if alchemy_upload is None: new_upload = None else: roles_list = list() for r in alchemy_upload.evidence.owner.roles: permissions_list = list() for p in r.permissions: new_permission = Permission(p.id, p.name, p.description) permissions_list.append(new_permission) new_role = Role(r.id, r.name, r.description, permissions_list) roles_list.append(new_role) new_user = User(alchemy_upload.evidence.owner.id, alchemy_upload.evidence.owner.username, alchemy_upload.evidence.owner.password, alchemy_upload.evidence.owner.first_name, alchemy_upload.evidence.owner.family_name, alchemy_upload.evidence.owner.email, roles_list) new_evidence = Evidence(alchemy_upload.evidence.id, alchemy_upload.evidence.alias, alchemy_upload.evidence.size, new_user) new_upload = Upload(alchemy_upload.id, alchemy_upload.path, alchemy_upload.size, alchemy_upload.type, new_evidence) return new_upload except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_all_files(self, upload_id): """ This method retrieves all files from DB that belongs to upload_id :return: {File} """ try: alchemy_file_list = self.session.query(AlchemyFile).filter_by(upload_id=upload_id).all() file_list = list() for f in alchemy_file_list: roles_list = list() for r in f.upload.evidence.owner.roles: permission_list = list() for p in r.permissions: new_permission = Permission(p.id, p.name, p.description) permission_list.append(new_permission) new_role = Role(r.id, r.name, r.description, permission_list) roles_list.append(new_role) new_owner = User(f.upload.evidence.owner.id, f.upload.evidence.owner.username, f.upload.evidence.owner.password, f.upload.evidence.owner.first_name, f.upload.evidence.owner.family_name, f.upload.evidence.owner.email, roles_list) new_evidence = Evidence(f.upload.evidence.id, f.upload.evidence.alias, f.upload.evidence.size, new_owner) new_upload = Upload(f.upload.id, f.upload.path, f.upload.size, f.upload.type, new_evidence) new_file = File(f.id, f.path, f.size, f.name, f.hash_md5, f.hash_sha256, new_upload) file_list.append(new_file) return file_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_user(self, user_id): """ This method retrieves users with given id from DB :return: User """ try: alchemy_user = self.session.query(AlchemyUser).filter_by(id=user_id).first() if alchemy_user is None: new_user = None else: role_list = list() for r in alchemy_user.roles: permissions_list = list() for p in r.permissions: new_permission = Permission(p.id, p.name, p.description) permissions_list.append(new_permission) new_role = Role(r.id, r.name, r.description, permissions_list) role_list.append(new_role) new_user = User(alchemy_user.id, alchemy_user.username, alchemy_user.password, alchemy_user.first_name, alchemy_user.family_name, alchemy_user.email, role_list) return new_user except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def check_token(self, token: str) -> bool: # Check if token is ok and it is in tokens dictionary self.get_user_id_from_token(token) if token in self.tokens: return True else: raise AppException( msg=GenericErrorMessages.TOKEN_DOES_NOT_EXIST_ERROR)
def get_module(module_name: str) -> Module: """ Get module by name :param module_name: str :return: module """ if module_name not in modules_manager.keys(): raise AppException(msg=GenericErrorMessages.MODULE_NOT_FOUND) return modules_manager[module_name]
def alchemy_get_case_status(self, status_id): """ This method retrieves case status with given id from DB :return: AlchemyCaseStatus """ try: alchemy_case_status = self.session.query(AlchemyCaseStatus).filter_by(id=status_id).first() return alchemy_case_status except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def alchemy_get_permission(self, permission_id): """ This method retrieves an alchemy permission with given id from DB Not included in views (not published) :return: {AlchemyPermission} """ try: alchemy_permission = self.session.query(AlchemyPermission).filter_by(id=permission_id).first() return alchemy_permission except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def alchemy_get_role(self, role_id): """ This method retrieves an alchemy role with given id from DB Not included in views (not published) :return: {AlchemyRole} """ try: alchemy_role = self.session.query(AlchemyRole).filter_by(id=role_id).first() return alchemy_role except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def alchemy_get_entity(self, entity_id): """ This method retrieves an alchemy entity with given id from DB Not included in views (not published) :return: {AlchemyEntity} """ try: alchemy_entity = self.session.query(AlchemyEntity).filter_by(id=entity_id).first() return alchemy_entity except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def alchemy_get_upload(self, upload_id): """ This method retrieves an alchemy upload with given id from DB Not included in views (not published) :return: {AlchemyUpload} """ try: alchemy_upload = self.session.query(AlchemyUpload).filter_by(id=upload_id).first() return alchemy_upload except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_user_id(self, name, password): """ This method retrieves user with given name and password (None if it doesn't exist) :return: Int """ try: alchemy_user = self.session.query(AlchemyUser).filter_by(username=name, password=password).first() if alchemy_user: return alchemy_user.id else: return None except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def logout(self, token: str): """ This method do logout """ # Recover payload (user_id) from token logger.debug('Recover user_id from token') user_id = self.get_user_id_from_token(token) # Remove token from dictionary. If raise exception then token does not exist try: self.tokens.pop(token) except KeyError: # Something went wrong because token does not exist logger.error('{} user_id: {}'.format( GenericErrorMessages.TOKEN_DOES_NOT_EXIST_ERROR, user_id)) raise AppException( msg=GenericErrorMessages.TOKEN_DOES_NOT_EXIST_ERROR)
def create_input(self, cls_input_data, cls_input_data_schema) -> object: """ This method create an object from POST request Has no sense using this method in GET/PUT/DELETE requests :param self: :param cls_input_data: class that represents object :param cls_input_data_schema: schema of the object :return: object filled with data from request """ validate_input = cls_input_data_schema().load(request.json) if len(validate_input.errors) > 0: raise AppException(msg=GenericErrorMessages.VALIDATION_ERROR) return cls_input_data(**request.json)
def get_case_type(self, type_id): """ This method retrieves case type with given id from DB :return: CaseType """ try: alchemy_case_type = self.session.query(AlchemyCaseType).filter_by(id=type_id).first() if alchemy_case_type is None: new_case_type = None else: new_case_type = CaseType(alchemy_case_type.id, alchemy_case_type.name, alchemy_case_type.description) return new_case_type except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_all_case_types(self): """ This method retrieves all case types from DB :return: {CaseType} """ try: alchemy_case_types_list = self.session.query(AlchemyCaseType).all() case_types_list = list() for t in alchemy_case_types_list: new_type = CaseType(t.id, t.name, t.description) case_types_list.append(new_type) return case_types_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_entity(self, entity_id): """ This method retrieves entity with given id from DB :return: Entity """ try: alchemy_entity = self.session.query(AlchemyEntity).filter_by(id=entity_id).first() if alchemy_entity is None: new_entity = None else: new_entity = Entity(alchemy_entity.id, alchemy_entity.name, alchemy_entity.description) return new_entity except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_instance(self, instance_id): """ This method retrieves instances with given id from DB :return: Instance """ try: alchemy_instance = self.session.query(AlchemyInstance).filter_by(id=instance_id).first() if alchemy_instance is None: new_instance = None else: new_entity = Entity(alchemy_instance.entity.id, alchemy_instance.entity.name, alchemy_instance.entity.description) new_instance = Instance(alchemy_instance.id, alchemy_instance.name, new_entity) return new_instance except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_all_entities(self): """ This method retrieves all entities from DB :return: {Entity} """ try: alchemy_entities_list = self.session.query(AlchemyEntity).all() entities_list = list() for ent in alchemy_entities_list: new_entity = Entity(ent.id, ent.name, ent.description) entities_list.append(new_entity) return entities_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_permission(self, permission_id): """ This method retrieves permission with given id from DB :return: {Permission} """ try: alchemy_permission = self.session.query(AlchemyPermission).filter_by(id=permission_id).first() if alchemy_permission is None: new_permission = None else: new_permission = Permission(alchemy_permission.id, alchemy_permission.name, alchemy_permission.description) return new_permission except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_all_case_status(self): """ This method retrieves all case status from DB :return: {CaseStatus} """ try: alchemy_case_status_list = self.session.query(AlchemyCaseStatus).all() case_status_list = list() for s in alchemy_case_status_list: new_status = CaseStatus(s.id, s.name, s.description) case_status_list.append(new_status) return case_status_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_case_status(self, status_id): """ This method retrieves case status with given id from DB :return: CaseStatus """ try: alchemy_case_status = self.session.query(AlchemyCaseStatus).filter_by(id=status_id).first() if alchemy_case_status is None: new_case_status = None else: new_case_status = CaseStatus(alchemy_case_status.id, alchemy_case_status.name, alchemy_case_status.description) return new_case_status except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_all_instances(self, entity_id): """ This method retrieves all instances from DB that belongs to entity_id :return: {Instance} """ try: alchemy_instance_list = self.session.query(AlchemyInstance).filter_by(entity_id=entity_id).all() instance_list = list() for ins in alchemy_instance_list: new_entity = Entity(ins.entity.id, ins.entity.name, ins.entity.description) new_instance = Instance(ins.id, ins.name, new_entity) instance_list.append(new_instance) return instance_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_all_properties(self, entity_id): """ This method retrieves all properties from DB that belongs to entity_id :return: {Property} """ try: alchemy_property_list = self.session.query(AlchemyProperty).filter_by(entity_id=entity_id).all() property_list = list() for prop in alchemy_property_list: new_entity = Entity(prop.entity.id, prop.entity.name, prop.entity.description) new_property = Property(prop.id, prop.name, prop.description, new_entity) property_list.append(new_property) return property_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def login(self, username: str, password: str) -> str: """ This methods do login and return token """ # Check if username and password are in database #user_id = self.ds.get_user_id(username, password) user_id = 1 # If user exists, generate token, store token and return it. Else raise exception if user_id: token = self.generate_token(user_id) self.tokens[token] = user_id logger.info('{} username: {} user_id: {}'.format( GenericErrorMessages.USER_LOGIN, username, user_id)) return token else: raise AppException(logger=logger, msg='{} username: {}'.format( GenericErrorMessages.USER_NOT_FOUND, username))
def get_all_permissions(self): """ This method retrieves all permissions from DB :return: {Permission} """ try: alchemy_permission_list = self.session.query(AlchemyPermission).all() permission_list = list() for perm in alchemy_permission_list: new_permission = Permission(perm.id, perm.name, perm.description) permission_list.append(new_permission) return permission_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))
def get_all_cases(self): """ This method retrieves all cases from DB :return: {Case} """ try: alchemy_cases_list = self.session.query(AlchemyCase).all() case_list = list() for c in alchemy_cases_list: case_type = CaseType(c.type.id, c.type.name, c.type.description) case_status = CaseStatus(c.status.id, c.status.name, c.status.description) new_case = Case(c.id, c.formal_name, c.friend_name, c.creation_datetime, c.num_win, c.num_lin, c.num_ios, c.num_mal, c.num_pac, c.num_log, case_type, case_status) case_list.append(new_case) return case_list except Exception as e: raise AppException(GenericErrorMessages.DATABASE_ERROR + ': ' + str(e))