def validate_days(self, days):
"""Medhod for validating the """
if not isinstance(days, int):
raise AccessManagementException("days invalid")
if (self._attr_value != self.ACCESS_TYPE_RESIDENT or days !=
RESIDENT_DAYS) and (self._attr_value != self.ACCESS_TYPE_GUEST
or days < MIN_DAYS_GUEST or days > 15):
raise AccessManagementException("days invalid")
return days
def _parse_json_file(self):
"""read the file in json format format"""
try:
with open(self._file, "r", encoding="utf-8", newline="") as json_file:
data = json.load(json_file)
except FileNotFoundError as ex:
raise AccessManagementException(err.WRONG_PATH_OR_FILE) from ex
except json.JSONDecodeError as ex:
raise AccessManagementException(self.m_error) from ex
return data
def add_item(self, item):
"""Implementing the restrictions related to avoid duplicated keys"""
# pylint: disable=import-outside-toplevel,cyclic-import
from secure_all.data.access_key import AccessKey
if not isinstance(item, AccessKey):
raise AccessManagementException(err.KEY_INVALID_ITEM)
if not self.find_item(item.key) is None:
raise AccessManagementException(err.KEY_ALREADY_STORED)
return super().add_item(item)
def add_item(self, item):
"""Implementing the restrictions related to avoid duplicated access_codes in the list
import of AccessRequest must be placed here instead of at the top of the file
to avoid circular references"""
# pylint: disable=import-outside-toplevel,cyclic-import
from secure_all.data.access_request import AccessRequest
if not isinstance(item, AccessRequest):
raise AccessManagementException(err.REQUEST_INVALID_ITEM)
if not self.find_item(item.access_code) is None:
raise AccessManagementException(
err.REQUEST_ACCESS_CODE_DOCUMENT_ALREADY_STORED)
super().add_item(item)
def _validate(self, attr_value):
"""Calls the superclass method for validating the syntax and then
validate the char according to the algorithm"""
dni = super()._validate(attr_value)
valid_dni_chars = {
"0": "T",
"1": "R",
"2": "W",
"3": "A",
"4": "G",
"5": "M",
"6": "Y",
"7": "F",
"8": "P",
"9": "D",
"10": "X",
"11": "B",
"12": "N",
"13": "J",
"14": "Z",
"15": "S",
"16": "Q",
"17": "V",
"18": "H",
"19": "L",
"20": "C",
"21": "K",
"22": "E"
}
dni_number = int(dni[0:8])
dni_remainder = str(dni_number % 23)
if not dni[8] == valid_dni_chars[dni_remainder]:
raise AccessManagementException("DNI is not valid")
return dni
def is_not_expired(self):
"""Return true if the key is not expired"""
# time = datetime.timestamp(datetime.utcnow())
# fix self.__issued_at only for testing 2018-01-09 15:12:09
time = 1515507129.580297
if self.__expiration_date != 0 and self.__expiration_date < time:
raise AccessManagementException(err.KEY_EXPIRED)
return True
def _validate(self, attr_value):
"""overrides the validate method for managing the input as a list of emails"""
email_list = []
for email in attr_value:
email_list.append(Email(email).value)
if len(email_list) < 1 or len(email_list) > 5:
raise AccessManagementException(self._error_message)
return email_list
def create_request_from_code(cls, access_code, dni):
"""Load from the store an AccessRequest from the access_code
and the dni"""
request_store = RequestJsonStore()
request_stored = request_store.find_item(access_code)
if request_stored is None:
raise AccessManagementException(err.REQUEST_NOT_FOUND_IN_THE_STORE)
request_stored_object = cls(
request_stored[request_store.DNI_FIELD],
request_stored[request_store.REQUEST__NAME],
request_stored[request_store.REQUEST__VISITOR_TYPE],
request_stored[request_store.REQUEST__EMAIL_ADDRESS],
request_stored[request_store.ACCESS_REQUEST__VALIDITY])
if not request_stored_object.id_document == dni:
raise AccessManagementException(
err.REQUEST_NOT_CORRECT_FOR_THIS_DNI)
return request_stored_object
def create_key_from_id(cls, key):
"""Class method from creating an instance of AccessKey
retrieving the information from the keys store"""
keys_store = KeysJsonStore()
key_object = keys_store.find_item(Key(key).value)
if key_object is None:
raise AccessManagementException(err.KEY_NOT_EXITS)
return cls(key_object[keys_store.DNI],
key_object[keys_store.ACCESS_CODE],
key_object[keys_store.MAIL_LIST],
key_object[keys_store.ISSUED_AT])
def _validate_json(self):
"""validate the json keys"""
for key in self._key_list:
if not key in self._json_content.keys():
raise AccessManagementException(err.WRONG_JSON_LABEL)
def check_previous_revoke(self, item):
"""Check if a key has been already revoked"""
if not self.find_item(item.key) is None:
raise AccessManagementException(err.KEY_ALREADY_REVOKED)
return True
def _validate(self, attr_value):
if not isinstance(attr_value, str):
raise AccessManagementException(self._error_message)
if not re.fullmatch(self._validation_pattern, attr_value):
raise AccessManagementException(self._error_message)
return attr_value
def del_item(self, item):
data = self.find_item(item.key)
if data is None:
raise AccessManagementException(err.KEY_DOESNT_EXIST)
return super().del_item(data)