Notification, RepoGroup, UserGroupRepoGroupToPerm, \

    UserEmailMap, UserIpMap, UserGroupUserGroupToPerm, UserGroup

from rhodecode.lib.exceptions import DefaultUserException, \

    UserOwnsReposException

from rhodecode.model.meta import Session

log = logging.getLogger(__name__)

PERM_WEIGHTS = Permission.PERM_WEIGHTS

class UserModel(BaseModel):

    cls = User

    def get(self, user_id, cache=False):

        user = self.sa.query(User)

        if cache:

            user = user.options(FromCache("sql_cache_short",

                                          "get_user_%s" % user_id))

        return user.get(user_id)

    def get_user(self, user):

        return self._get_user(user)

    def get_by_username(self, username, cache=False, case_insensitive=False):

        if case_insensitive:

            user = self.sa.query(User).filter(User.username.ilike(username))

        else:

            user = self.sa.query(User).filter(User.username == username)

        if cache:

            user = user.options(FromCache("sql_cache_short",

                                          "get_user_%s" % username))

        return user.scalar()

    def get_by_email(self, email, cache=False, case_insensitive=False):

        return User.get_by_email(email, case_insensitive, cache)

    def get_by_api_key(self, api_key, cache=False):

        return User.get_by_api_key(api_key, cache)

    def create(self, form_data, cur_user=None):

        if not cur_user:

            cur_user = getattr(get_current_rhodecode_user(), 'username', None)

        from rhodecode.lib.hooks import log_create_user, check_allowed_create_user

        _fd = form_data

            'username': _fd['username'], 'password': _fd['password'],

            'email': _fd['email'], 'firstname': _fd['firstname'], 'lastname': _fd['lastname'],

            'active': _fd['active'], 'admin': False

        }

        # raises UserCreationError if it's not allowed

        from rhodecode.lib.auth import get_crypt_password

        try:

            new_user = User()

            for k, v in form_data.items():

                if k == 'password':

                    v = get_crypt_password(v)

                if k == 'firstname':

                    k = 'name'

                setattr(new_user, k, v)

            new_user.api_key = generate_api_key(form_data['username'])

            self.sa.add(new_user)

            log_create_user(new_user.get_dict(), cur_user)

            return new_user

        except Exception:

            log.error(traceback.format_exc())

            raise

    def create_or_update(self, username, password, email, firstname='',

                         lastname='', active=True, admin=False, ldap_dn=None,

                         cur_user=None):

        """

        Creates a new instance if not found, or updates current one

        :param username:

        :param password:

        :param email:

        :param active:

        :param firstname:

        :param lastname:

        :param active:

        :param admin:

        :param ldap_dn:

        :param cur_user:

        """

        if not cur_user:

            cur_user = getattr(get_current_rhodecode_user(), 'username', None)

        from rhodecode.lib.auth import get_crypt_password

        from rhodecode.lib.hooks import log_create_user, check_allowed_create_user

            'username': username, 'password': password,

            'email': email, 'firstname': firstname, 'lastname': lastname,

            'active': active, 'admin': admin

        }

        # raises UserCreationError if it's not allowed

        log.debug('Checking for %s account in RhodeCode database' % username)

        user = User.get_by_username(username, case_insensitive=True)

        if user is None:

            log.debug('creating new user %s' % username)

            new_user = User()

            edit = False

        else:

            log.debug('updating user %s' % username)

            new_user = user

            edit = True

        try:

            new_user.username = username

            new_user.admin = admin

            # set password only if creating an user or password is changed

            if not edit or user.password != password:

                new_user.password = get_crypt_password(password) if password else None

                new_user.api_key = generate_api_key(username)

            new_user.email = email

            new_user.active = active

            new_user.ldap_dn = safe_unicode(ldap_dn) if ldap_dn else None

            new_user.name = firstname

            new_user.lastname = lastname

            self.sa.add(new_user)

            if not edit:

                log_create_user(new_user.get_dict(), cur_user)

            return new_user

        except (DatabaseError,):

            log.error(traceback.format_exc())

            raise

    def create_for_container_auth(self, username, attrs, cur_user=None):

        """

        Creates the given user if it's not already in the database

        :param username:

        :param attrs:

        :param cur_user:

        """

        if not cur_user:

            cur_user = getattr(get_current_rhodecode_user(), 'username', None)

        if self.get_by_username(username, case_insensitive=True) is None:

            # autogenerate email for container account without one

            generate_email = lambda usr: '%s@container_auth.account' % usr

            firstname = attrs['name']

            lastname = attrs['lastname']

            active = attrs.get('active', True)

            email = attrs['email'] or generate_email(username)

            from rhodecode.lib.hooks import log_create_user, check_allowed_create_user

                'username': username, 'password': None,

                'email': email, 'firstname': firstname, 'lastname': lastname,

                'active': attrs.get('active', True), 'admin': False

            }

            # raises UserCreationError if it's not allowed

            try:

                new_user = User()

                new_user.username = username

                new_user.password = None

                new_user.api_key = generate_api_key(username)

                new_user.email = email

                new_user.active = active

                new_user.name = firstname

                new_user.lastname = lastname

                self.sa.add(new_user)

                log_create_user(new_user.get_dict(), cur_user)

                return new_user

            except (DatabaseError,):

                log.error(traceback.format_exc())

                self.sa.rollback()

                raise

        log.debug('User %s already exists. Skipping creation of account'

                  ' for container auth.', username)

        return None

    def create_ldap(self, username, password, user_dn, attrs, cur_user=None):

        """

        Checks if user is in database, if not creates this user marked

        as ldap user

        :param username:

        :param password:

        :param user_dn:

        :param attrs:

        :param cur_user:

        """

        if not cur_user:

            cur_user = getattr(get_current_rhodecode_user(), 'username', None)

        from rhodecode.lib.auth import get_crypt_password

        log.debug('Checking for such ldap account in RhodeCode database')

        if self.get_by_username(username, case_insensitive=True) is None:

            # autogenerate email for container account without one

            generate_email = lambda usr: '%s@ldap.account' % usr

            password = get_crypt_password(password)

            firstname = attrs['name']

            lastname = attrs['lastname']

            active = attrs.get('active', True)

            email = attrs['email'] or generate_email(username)

            from rhodecode.lib.hooks import log_create_user, check_allowed_create_user

                'username': username, 'password': password,

                'email': email, 'firstname': firstname, 'lastname': lastname,

                'active': attrs.get('active', True), 'admin': False

            }

            # raises UserCreationError if it's not allowed

            try:

                new_user = User()

                username = username.lower()

                # add ldap account always lowercase

                new_user.username = username

                new_user.password = password

                new_user.api_key = generate_api_key(username)

                new_user.email = email

                new_user.active = active

                new_user.ldap_dn = safe_unicode(user_dn)

                new_user.name = firstname

                new_user.lastname = lastname

                self.sa.add(new_user)

                log_create_user(new_user.get_dict(), cur_user)

                return new_user

            except (DatabaseError,):

                log.error(traceback.format_exc())

                self.sa.rollback()

                raise

        log.debug('this %s user exists skipping creation of ldap account',

                  username)

        return None

    def create_registration(self, form_data):

        from rhodecode.model.notification import NotificationModel

        try:

            form_data['admin'] = False

            new_user = self.create(form_data)

            self.sa.add(new_user)

            self.sa.flush()

            # notification to admins

            subject = _('New user registration')

            body = ('New user registration\n'

                    '---------------------\n'

                    '- Username: %s\n'

                    '- Full Name: %s\n'

                    '- Email: %s\n')

            body = body % (new_user.username, new_user.full_name, new_user.email)

            edit_url = url('edit_user', id=new_user.user_id, qualified=True)

            kw = {'registered_user_url': edit_url}

            NotificationModel().create(created_by=new_user, subject=subject,

                                       body=body, recipients=None,

                                       type_=Notification.TYPE_REGISTRATION,

                    _(u"You can't remove this user since it's"

                      " crucial for entire application")

                )

            if user.repositories:

                repos = [x.repo_name for x in user.repositories]

                raise UserOwnsReposException(

                    _(u'user "%s" still owns %s repositories and cannot be '

                      'removed. Switch owners or remove those repositories. %s')

                    % (user.username, len(repos), ', '.join(repos))

                )

            self.sa.delete(user)

            from rhodecode.lib.hooks import log_delete_user

            log_delete_user(user.get_dict(), cur_user)

        except Exception:

            log.error(traceback.format_exc())

            raise

    def reset_password_link(self, data):

        from rhodecode.lib.celerylib import tasks, run_task

        from rhodecode.model.notification import EmailNotificationModel

        user_email = data['email']

        try:

            user = User.get_by_email(user_email)

            if user:

                log.debug('password reset user found %s' % user)

                link = url('reset_password_confirmation', key=user.api_key,

                           qualified=True)

                reg_type = EmailNotificationModel.TYPE_PASSWORD_RESET

                body = EmailNotificationModel().get_email_tmpl(reg_type,

                                                    **{'user': user.short_contact,

                                                       'reset_url': link})

                log.debug('sending email')

                run_task(tasks.send_email, user_email,

                         _("Password reset link"), body, body)

                log.info('send new password mail to %s' % user_email)

            else:

                log.debug("password reset email %s not found" % user_email)

        except Exception:

            log.error(traceback.format_exc())

            return False

        return True

    def reset_password(self, data):

        from rhodecode.lib.celerylib import tasks, run_task

        from rhodecode.lib import auth

        user_email = data['email']

        try:

            run_task(tasks.send_email, user_email,

                     _('Your new password'),

                     _('Your new RhodeCode password:%s') % (new_passwd,))

            log.info('send new password mail to %s' % user_email)

        except Exception:

            log.error('Failed to update user password')

            log.error(traceback.format_exc())

        return True

    def fill_data(self, auth_user, user_id=None, api_key=None):

        """

        Fetches auth_user by user_id,or api_key if present.

        Fills auth_user attributes with those taken from database.

        Additionally set's is_authenitated if lookup fails

        present in database

        :param auth_user: instance of user to set attributes

        :param user_id: user id to fetch by

        :param api_key: api key to fetch by

        """

        if user_id is None and api_key is None:

            raise Exception('You need to pass user_id or api_key')

        try:

            if api_key:

                dbuser = self.get_by_api_key(api_key)

            else:

                dbuser = self.get(user_id)

            if dbuser is not None and dbuser.active:

                log.debug('filling %s data' % dbuser)

                for k, v in dbuser.get_dict().items():

                    setattr(auth_user, k, v)

            else:

                return False

        except Exception:

            log.error(traceback.format_exc())

            auth_user.is_authenticated = False

            return False

        return True

    def fill_perms(self, user, explicit=True, algo='higherwin'):

        """

        Fills user permission attribute with permissions taken from database

        works for permissions given for repositories, and for permissions that

        are granted to groups

        :param user: user instance to fill his perms

        :param explicit: In case there are permissions both for user and a group

            that user is part of, explicit flag will defiine if user will

            explicitly override permissions from group, if it's False it will

            make decision based on the algo