UsersManager

Complexity

Total Complexity

13

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	17	1
D	make_question()	0	36	8
B	register()	0	29	3
A	valid_attribute()	0	11	1

"""Module used to handle Users in Napps Server."""
import logging
import re
from getpass import getpass

from kytos.utils.client import UsersClient
from kytos.utils.config import KytosConfig

log = logging.getLogger(__name__)

NAME_PATTERN = ("\t- insert only letters", r'[a-zA-Z][a-zA-Z]{2,}$')
USERNAME_PATTERN = ("\t- start with letter\n"
                    "\t- insert only numbers and letters",
                    r'[a-zA-Z][a-zA-Z0-9_]{2,}$')
PASSWORD_PATTERN = ("\t- insert only the caracters:"
                    " [letters, numbers, _, %, &, -, $]",
                    r'[a-zA-Z0-9_%\-&$]{2,}$')
EMAIL_PATTERN = ("\t- follow the format: <login>@<domain>\n"
                 "\t\te.g. john@test.com", r'[^@]+@[^@]+\.[^@]+')
PHONE_PATTERN = ("\t- insert only numbers", r'\d*$')


class UsersManager:
    """Class used to handle users stored by Napps server."""

    attributes = {
        "username": {"question": "Please insert your Username(Required): ",
                     "pattern": USERNAME_PATTERN},
        "first_name": {"question": "Please insert your First Name(Required): ",
                       "pattern": NAME_PATTERN},
        "last_name": {"question": "Please insert your Last Name: ",
                      "pattern": NAME_PATTERN},
        "password": {"question": "Please insert your Password(Required): ",
                     "pattern": PASSWORD_PATTERN},
        "email": {"question": "Please insert a Email(Required): ",
                  "pattern": EMAIL_PATTERN},
        "phone": {"question": "Please insert your Phone: ",
                  "pattern": PHONE_PATTERN},
        "city": {"question": "Please insert your City: ",
                 "pattern": NAME_PATTERN},
        "state": {"question": "Please insert your State: ",
                  "pattern": NAME_PATTERN},
        "country": {"question": "Please insert your Country: ",
                    "pattern": NAME_PATTERN}
    }

    required = ["username", "first_name", "password", "email"]

    def __init__(self, controller=None):
        """If controller is not informed, the necessary paths must be.

        If ``controller`` is available, NApps will be (un)loaded at runtime and
        you don't need to inform the paths. Otherwise, you should inform the
        required paths for the methods called.

        Args:
            controller (kytos.Controller): Controller to (un)load NApps.
            install_path (str): Folder where NApps should be installed. If
                None, use the controller's configuration.
            enabled_path (str): Folder where enabled NApps are stored. If None,
                use the controller's configuration.
        """
        self._controller = controller
        self._config = KytosConfig().config
        self._users_client = UsersClient()

    def register(self):
        """Method used to register a new user.

        This method will as for user attributes and create that in
        Napps server, when All required fields is filled.

        Returns:
            result(string): Response of user registration process.
        """
        user = {}

        print('--------------------------------------------------------------')
        print('Welcome to the user registration process.')
        print('--------------------------------------------------------------')
        print("To continue you must fill the follow fields.")
        for attribute, value in self.attributes.items():

            is_required = attribute in self.required
            question = value['question']
            pattern = value['pattern']

            if attribute != 'password':
                user[attribute] = self.make_question(question, pattern,
                                                     is_required)
            else:
                user[attribute] = self.make_question(question, pattern,
                                                     password=True)

        return self._users_client.register(user)

    def make_question(self, question, pattern=NAME_PATTERN, required=False,
                      password=False):
        """Method used to make a question and get the input values.

        This method will validade the input values.
        Args:
            question(string): Question used to ask for input value.
            pattern(string): Pattern to validate the input value.
            required(bool): Boolean value if the input value is required.
            password(bool): Boolean value to get input password with mask.
        Returns:
            input_value(string): Input value validated.
        """
        input_value = ""

        while not input_value:
            input_value = getpass(question) if password else input(question)

            if not input_value:
                if not required:
                    break
                else:
                    continue

            if password:
                confirm_password = getpass('Confirm your password: ')
                if confirm_password != input_value:
                    print("Password don't match.")
                    input_value = ""

            if not self.valid_attribute(input_value, pattern[1]):
                error_message = "Invalid field, you should:\n{}"
                print(error_message.format(pattern[0]))
                input_value = ""

        return input_value

    @classmethod
    def valid_attribute(cls, attribute, pattern):
        """Check the validity of the given 'attribute' using the pattern given.

        Args:
            attribute(string): String with the value of an attribute
            pattern(string): Pattern used to validate the attribute value.
        Returns:
            pattern_found(bool): Return True if the pattern match.
        """
        return attribute and re.match(pattern, attribute)