Gitlab username little improvements

@click.option('-p', '--password', help='Users password', prompt=True, hide_input=True,

              confirmation_prompt=True)

@click.option('-s', '--secret', help="User's secret")

def cli_users_create(name, password, secret):

@click.option('-G', '--gitlab', help="Gitlab username")

def cli_users_create(name, password, secret, gitlab):

    log.info(f"[CMD] Create User: {name}")

    manager.create_admin_user(name, password, secret)

    manager.create_admin_user(name, password, secret, gitlab)

@users_cli.command('set-password', help='Sets password for the user')

ADMIN_USER="${ADMIN_USER:-admin}"

ADMIN_PASSWORD="${ADMIN_PASSWORD:-789789}"

ADMIN_SECRET="${ADMIN_SECRET:-devel-admin-secret}"

ADMIN_GITLAB="${ADMIN_GITLAB}"

# INIT

echo "[INIT] Initializing the database"

echo "[INIT] Initializing data for env: $ENVIRONMENT"

flask data init ${ENVIRONMENT}

echo "[INIT] Initializing admin user: ${ADMIN_USER}"

flask users create ${ADMIN_USER} --password ${ADMIN_PASSWORD} --secret ${ADMIN_SECRET}

flask users create ${ADMIN_USER} --password ${ADMIN_PASSWORD} --secret ${ADMIN_SECRET} --gitlab ${ADMIN_GITLAB}

if [ "$DATASETS" != "" ]; then

    echo "[INIT] Additional datasets: $DATASETS"

from management.data.data_prod import init_prod_data

from management.data.data_test import init_test_data

from portal import logger

from portal.database.models import Course, Role, Secret, Submission, User

from portal.database import SubmissionState

from portal.database.models import Course, Role, Secret, Submission, User

from portal.service.find import FindService

from portal.service.users import UserService

from portal.tools import time

            log.debug(f"[DATA] User's password updated: {user.log_name}")

            return user

    def create_admin_user(self, name: str, password: str, secret: str = None) -> User:

    def create_admin_user(self, name: str, password: str, secret: str = None, gitlab: str = None) \

            -> User:

        """Creates new admin user with username

        Args:

            name(str): Username of the user

                username=name,

                name=name,

                admin=True,

                gitlab_username=gitlab,

                password=password)

            if secret:

                user.secrets.append(Secret(name='admin-secret', value=secret))

        return self._db.session

    def create_user(self, username: str, uco=0, name=None, password=None,

                    email=None, admin=False) -> User:

                    email=None, admin=False, gitlab_username: str = None) -> User:

        email = email or f"{username}@example.com"

        password = password or "123456"

        user = self.__create_entity(

            User, uco=uco, username=username, is_admin=admin, email=email)

            User, uco=uco, username=username, is_admin=admin, email=email,

            gitlab_username=gitlab_username)

        user.name = name or f"{username.capitalize()} User"

        user.set_password(password=password)

        return user

    value = db.Column(db.String(120))

    expires_at = db.Column(db.TIMESTAMP, nullable=True)

    client_id = db.Column(db.String(36), db.ForeignKey(

        'client.id', ondelete='cascade'), nullable=False)

    client = db.relationship(

        "Client", back_populates="secrets", uselist=False)

    client_id = db.Column(db.String(36),

                          db.ForeignKey('client.id', ondelete='cascade'), nullable=False)

    client = db.relationship("Client", back_populates="secrets", uselist=False)

    def __init__(self, name: str, value: str = None, expires_at=None):

        # TODO: check date/timestamp

    """

    UPDATABLE = ['name', 'email', 'uco', 'gitlab_username', 'managed']

    BASE_PARAMS = ['username', 'codename', 'is_admin', *UPDATABLE, 'managed', 'id']

    LISTABLE = ['username', 'gitlab_username']

    __tablename__ = 'user'

    id = db.Column(db.String(length=36), db.ForeignKey('client.id'),

                   default=lambda: str(uuid.uuid4()), primary_key=True)

    # optional - after password change

    password_hash = db.Column(db.String(120), default=None)

    gitlab_username = db.Column(db.String(50), nullable=True)

    _gitlab_username = db.Column('gitlab_username', db.String(50), nullable=True)

    managed = db.Column(db.Boolean, default=False)

    submissions = db.relationship("Submission", back_populates="user", cascade="all, delete-orphan",

                                  passive_deletes=True)

    }

    @hybrid_property

    def username(self):

    def username(self) -> str:

        return self.codename

    @hybrid_property

    def gitlab_username(self) -> str:

        return self._gitlab_username or self.username

    @gitlab_username.setter

    def gitlab_username(self, value: str):

        self._gitlab_username = value

    @username.setter

    def username(self, value):

    def username(self, value: str):

        self.codename = value

    def is_self(self, eid):

        return self.query_projects_by_course(course=course).all()

    def __init__(self, uco: int = None, email: str = None, username: str = None,

                 is_admin: bool = False, **kwargs) -> None:

                 is_admin: bool = False, gitlab_username: str = None, **kwargs) -> None:

        """Creates user instance

        Args:

            uco(int): User's UCO (school identifier)

        self.email = email

        self.username = username

        self.is_admin = is_admin

        self.gitlab_username = gitlab_username

        super().__init__(ClientType.USER, **kwargs)

    def __eq__(self, other):