Python Session.query方法代码示例

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
    def email_change_POST(self):
        '''
            Processes POST requests to generate change email hash
        '''
        if self.check_csrf:
            token = self.request.session.get_csrf_token()
        else:
            token = ''
        if self.check_csrf and token != self.request.POST.get('token'):
            return {'status': False,
                    'msg': self.request._('csrf-mismatch',
                                          default='CSRF token did not match.',
                                          domain='pyramid_fullauth'),
                    'token': token}
        try:
            Session.query(User).filter(User.email == self.request.POST.get('email', '')).one()
            return {'status': False,
                    'msg': self.request._('User with this email exists',
                                          domain='pyramid_fullauth'),
                    'token': token}
        except NoResultFound:
            pass

        user = self.request.user
        try:
            result = self.request.registry.notify(BeforeEmailChange(self.request, user))
        except AttributeError as e:
            return {'status': False, 'msg': e.message, 'token': token}

        try:
            user.set_new_email(self.request.POST.get('email', ''))
        except EmptyError:
            return {'status': False,
                    'msg': self.request._(
                        'E-mail is empty',
                        domain='pyramid_fullauth'),
                    'token': token}
        except EmailValidationError:
            return {'status': False,
                    'msg': self.request._(
                        'Incorrect e-mail format',
                        domain='pyramid_fullauth'),
                    'token': token}

        response_values = {'status': True,
                           'msg': self.request._('We sent you email to activate your new email address',
                                                 domain='pyramid_fullauth')}
        try:
            self.request.registry.notify(AfterEmailChange(self.request, user))
        except HTTPFound as redirect:
            if self.request.is_xhr:
                response_values['url'] = redirect.location
                return response_values
            else:
                return redirect
        else:
            if self.request.is_xhr:
                return response_values
            else:
                return HTTPFound(location='/')

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
    def reset_continue(self):
        '''
            Method that serves password reset page
        '''
        user = self.request.matchdict.get('user')
        if self.check_csrf:
            token = self.request.session.get_csrf_token()
        else:
            token = ''

        if self.request.method == 'POST':
            # if turned on, check for csrf token
            if self.check_csrf and token != self.request.POST.get('token'):
                return {'status': False,
                        'msg': self.request._('csrf-mismatch',
                                              default='CSRF token did not match.',
                                              domain='pyramid_fullauth'),
                        'token': token}

            password = self.request.POST.get('password', None)
            password_confirm = self.request.POST.get('confirm_password', None)
            if password == password_confirm:

                try:
                    self.request.registry.notify(BeforeReset(self.request, user))
                    validate_passsword(self.request, password, user)

                    user.reset_key = None
                    try:
                        Session.query(AuthenticationProvider).filter(
                            AuthenticationProvider.user_id == user.id,
                            AuthenticationProvider.provider == u'email').one()
                    except NoResultFound:
                        user.providers.append(
                            AuthenticationProvider(provider=u'email',
                                                   provider_id=user.id))

                    Session.flush()
                except (ValidateError, AttributeError) as e:
                    return {'status': False, 'msg': str(e), 'token': token}

                try:
                    self.request.registry.notify(AfterReset(self.request, user))
                except HTTPFound as redirect:
                    return redirect
            else:
                return {'status': False,
                        'msg': self.request._('password-mismatch',
                                              default='Password doesn\'t match',
                                              domain='pyramid_fullauth'),
                        'token': token}

        return {'status': True, 'token': token}

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
 def rank(self):
     """Rank by the number of promote and cover offers."""
     
     logger.warn('XXX how do we retire offers?')
     
     # Start with a rank of zero and ignore everything that's over a week old.
     n = 0
     now = datetime.datetime.utcnow()
     one_week_ago = get_one_week_ago()
     
     # For each promote offer.
     query = Session.query(PromoteOffer.created)
     query = query.filter(PromoteOffer.assignment==self)
     query = query.filter(PromoteOffer.created>one_week_ago)
     results = query.all()
     self.promote_offer_count = len(results)
     for item in results:
         created_date = item[0]
         delta = now - created_date
         # Make sure the diff is at least one second (n.b.:
         # ``timedelta.total_seconds`` requires Python>=2.7)
         if hasattr(delta, 'total_seconds'):
             tot_seconds = delta.total_seconds()
         else:
             secs = delta.seconds + delta.days * 24.0 * 3600.0
             tot_seconds = (delta.microseconds + secs * 10.0**6) / 10.0**6
         seconds = max(tot_seconds, 1)
         # Half life of 1 day.
         score = 1440 / seconds
         n += score
     
     # For each cover offer.
     query = Session.query(CoverOffer.created)
     query = query.filter(CoverOffer.assignment==self)
     query = query.filter(CoverOffer.created>one_week_ago)
     results = query.all()
     self.cover_offer_count = len(results)
     for item in results:
         created_date = item[0]
         delta = now - created_date
         if hasattr(delta, 'total_seconds'):
             tot_seconds = delta.total_seconds()
         else:
             secs = delta.seconds + delta.days * 24.0 * 3600.0
             tot_seconds = (delta.microseconds + secs * 10.0**6) / 10.0**6
         seconds = max(tot_seconds, 1)
         # Three times as important as promote offers.
         score = 3 * 1440 / seconds
         n += score
     
     return n

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
def includeme(config):
    registry = config.registry
    settings = registry.settings

    config.include('pyramid_basemodel')
    config.include('pyramid_tm')

    models = [
        (IActivationClass, Activation),
        (IUserClass, User),
        (IUIStrings, UIStringsBase),
        (IConsumerClass, Consumer),
        (IDBSession, Session)
    ]

    for iface, imp in models:
        if not registry.queryUtility(iface):
            registry.registerUtility(imp, iface)

    if asbool(settings.get('basemodel.should_create_all', True)):
        key = settings['api.key']
        secret = settings.get('api.secret')
        ttl = settings.get('api.ttl', auth.DEFAULT_TTL)

        session = Session()
        consumer = session.query(Consumer).filter(Consumer.key == key).first()
        if not consumer:
            with transaction.manager:
                consumer = Consumer(key=key, secret=secret, ttl=ttl)
                session.add(consumer)
                session.flush()

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
    def reset_POST(self):
        '''
            Processes POST requests to generate reset password hashes
        '''
        if self.check_csrf:
            token = self.request.session.get_csrf_token()
        else:
            token = ''

        if self.check_csrf and token != self.request.POST.get('token'):
            return {'status': False,
                    'msg': self.request._('csrf-mismatch',
                                          default='CSRF token did not match.',
                                          domain='pyramid_fullauth'),
                    'token': token}
        try:
            user = Session.query(User).filter(
                User.email == self.request.POST.get('email', '')).one()
        except NoResultFound:
            return {'status': False,
                    'msg': self.request._('user-not-exists',
                                          default='User does not exists',
                                          domain='pyramid_fullauth'),
                    'token': token}

        user.set_reset()
        try:
            self.request.registry.notify(AfterResetRequest(self.request, user))
        except HTTPFound as redirect:
            return redirect

        return HTTPFound(location='/')

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
    def create_api_consumer(target, connection, **kwargs):
        key = settings['api.key']
        secret = settings.get('api.secret')
        ttl = settings.get('api.ttl', auth.DEFAULT_TTL)

        session = Session()
        consumer = session.query(Consumer).filter(Consumer.key == key).first()
        if not consumer:
            with transaction.manager:
                consumer = Consumer(key=key, secret=secret, ttl=ttl)
                session.add(consumer)
                session.flush()

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
def database_locales(request):
    '''
        Returns list of all database locales available

        :returns: dictionary of Language objects language_code: Language
        :rtype: dict
    '''
    locales = {}
    for language in Session.query(Language).all():
        locales[language.language_code] = language

    return locales

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
def user(request):
    '''
        When called for the first time, it queries for user, which is later available as a pure property
        overriding this method

        :returns: logged in user object, or None
        :rtype: pyramid_fullauth.models.User
    '''
    userid = unauthenticated_userid(request)
    if userid:
        try:
            user = Session.query(User).filter(User.id == userid).one()
            return user
        except NoResultFound:  # pragma: no cover
            pass

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
def activate_hash(info, request):
    '''
        Checks whether activate hash is correct

        :param dict info: pyramid info dict with path fragments and info
        :param pyramid.request.Request request: request object
    '''

    activate_hash = info['match'].get('hash', None)
    if activate_hash:
        try:
            info['match']['user'] = Session.query(User).filter(User.activate_key == activate_hash).one()
            return True
        except NoResultFound:
            pass
    return False

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
        def set_provider(user, provider_name, user_provider_id):
            '''
                Method sets the provider authentication method for user.
            '''
            if user.id:
                try:
                    provider_auth = Session.query(
                        AuthenticationProvider).filter(AuthenticationProvider.user_id == user.id,
                                                       AuthenticationProvider.provider == provider_name).one()
                    if provider_auth.provider_id != user_provider_id:
                        return False
                    return True
                except NoResultFound:
                    pass

            provider_auth = AuthenticationProvider()
            provider_auth.provider = provider_name
            provider_auth.provider_id = user_provider_id
            user.providers.append(provider_auth)
            return True

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
    def activate(self):
        '''
            Process account activation
        '''

        activate_hash = self.request.matchdict.get('hash')
        user = None
        response = {}
        response['status'] = True
        if activate_hash:
            try:
                user = Session.query(User).filter(User.activate_key == activate_hash).one()
                if not user.is_active:
                    user.is_active = True
            except NoResultFound:
                response['status'] = False
        try:
            self.request.registry.notify(AfterActivate(self.request, user))
        except HTTPFound as e:
            # it's a redirect, let's follow it!
            return e

        return response

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
    def login(self):
        """
            Login action
        """

        after = self.request.params.get("after") or self.request.referer
        return_dict = {
            "status": False,
            "msg": self.request._("Login error", domain="pyramid_fullauth"),
            "after": after,
            "csrf_token": self.request.session.get_csrf_token(),
        }

        if authenticated_userid(self.request):
            try:
                self.request.registry.notify(AlreadyLoggedIn(self.request))
            except HTTPFound as redirect:
                if self.request.is_xhr:
                    return_dict["status"] = True
                    del return_dict["msg"]
                    return_dict["after"] = redirect.location
                    return return_dict
                else:
                    return redirect

        # Code copied from alternative. Not yes implemented
        if self.request.method == "POST":

            email = self.request.POST.get("email", "")
            password = self.request.POST.get("password", "")
            try:
                user = Session.query(User).filter(User.email == email).one()
                try:
                    self.request.registry.notify(BeforeLogIn(self.request, user))
                except AttributeError as e:
                    return_dict["msg"] = str(e)
                    return return_dict

                if user.check_password(password):
                    try:
                        # if remember in POST set cookie timeout to one month
                        remember_me = self.request.POST.get("remember")
                        self.request.registry.notify(AfterLogIn(self.request, user))
                    except HTTPFound as redirect:
                        redirect_return = self.request.login_perform(
                            user, location=redirect.location, remember_me=remember_me
                        )
                        if self.request.is_xhr:
                            return_dict["status"] = True
                            del return_dict["msg"]
                            return_dict["after"] = redirect_return.location
                            return return_dict
                        else:
                            return redirect_return
                    except AttributeError as e:
                        return_dict["msg"] = str(e)
                        return return_dict
                    else:
                        redirect = self.request.login_perform(user, remember_me=remember_me)
                        if self.request.is_xhr:
                            return_dict["status"] = True
                            del return_dict["msg"]
                            return_dict["after"] = redirect.location
                            return return_dict
                        else:
                            return redirect
                else:
                    return_dict["msg"] = self.request._("Wrong e-mail or password.", domain="pyramid_fullauth")
                    return return_dict
            except NoResultFound:
                self.request.registry.notify(BeforeLogIn(self.request, None))

                return_dict["msg"] = self.request._("Wrong e-mail or password.", domain="pyramid_fullauth")
                return return_dict
        else:
            self.request.registry.notify(BeforeLogIn(self.request, None))

        return_dict["status"] = True
        del return_dict["msg"]
        return return_dict

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
    def register_POST(self):
        '''
            Process POST register request
        '''

        invalid_fields = {}
        response_values = {
            'status': False,
            'msg': self.request._('You have an error in your registration form',
                                  domain='pyramid_fullauth'),
            'csrf_token': self.request.session.get_csrf_token()}
        response_values['errors'] = invalid_fields

        email = self.request.POST.get('email', u'')
        # here if e-mail is already in database
        try:
            Session.query(User).filter(User.email == email).one()
            invalid_fields['email'] = self.request._('User with given e-mail already exists!',
                                                     domain='pyramid_fullauth')
        except NoResultFound:
            pass

        try:
            user = User()
            try:
                user.email = email
            except ValidateError as e:
                # do not overwrite existing error
                if not 'email' in invalid_fields:
                    invalid_fields['email'] = str(e)

            user.address_ip = self.request.remote_addr

            if self.request.config.fullauth.register.password.require:
                try:
                    tools.validate_passsword(self.request,
                                             self.request.POST.get('password', u''),
                                             user)
                except ValidateError as e:
                    invalid_fields['password'] = e.message
            else:
                user.password = tools.password_generator(
                    self.request.config.fullauth.register.password.length_min)

            self.request.registry.notify(BeforeRegister(self.request, user, invalid_fields))
            if not invalid_fields:
                Session.add(user)
                Session.flush()
                # lets add AuthenticationProvider as email!
                user.providers.append(
                    AuthenticationProvider(provider=u'email', provider_id=user.id))
            else:
                return response_values
        except AttributeError as e:
            invalid_fields['msg'] = str(e)
            return response_values

        response_values['status'] = True
        response_values['msg'] = self.request._('You have successfully registered',
                                                domain='pyramid_fullauth')

        try:
            self.request.registry.notify(AfterRegister(self.request, user, response_values))
        except HTTPFound as redirect:
            return redirect

        return response_values

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
    def register_social(self):
        '''
            Action provides social authorization functionality. When authorization with facebook or twitter is done successfully
            action tries to find existing user in database, if it exists - login this user, otherwise creates new user.
        '''

        def set_provider(user, provider_name, user_provider_id):
            '''
                Method sets the provider authentication method for user.
            '''
            if user.id:
                try:
                    provider_auth = Session.query(
                        AuthenticationProvider).filter(AuthenticationProvider.user_id == user.id,
                                                       AuthenticationProvider.provider == provider_name).one()
                    if provider_auth.provider_id != user_provider_id:
                        return False
                    return True
                except NoResultFound:
                    pass

            provider_auth = AuthenticationProvider()
            provider_auth.provider = provider_name
            provider_auth.provider_id = user_provider_id
            user.providers.append(provider_auth)
            return True

        context = self.request.context
        response_values = {'status': False, 'csrf_token': self.request.session.get_csrf_token()}
        user = self.request.user

        if user:
            # when user is logged in already, just connect social account to
            # this app account
            try:
                if set_provider(user, context.provider_name, context.profile['accounts'][0]['userid']):
                    Session.flush()
                else:
                    response_values['msg'] = 'Your account is already connected to other {provider} account.'.format(
                        provider=context.provider_name)
                    return response_values
            except IntegrityError:
                response_values['msg'] = 'This {provider} account is already connected with other account.'.format(
                    provider=context.provider_name)
                try:
                    self.request.registry.notify(SocialAccountAlreadyConnected(
                        self.request, user, context.profile, response_values))
                except HTTPFound as redirect:
                    # it's a redirect, let's follow it!
                    return redirect
                return response_values
        else:
            # getting verified email from provider
            if 'verifiedEmail' in context.profile:
                email = context.profile['verifiedEmail']
            # getting first of the emails provided by social login provider
            elif 'emails' in context.profile and context.profile['emails'] and 'value' in context.profile['emails'][0]:
                email = context.profile['emails'][0]['value']
            # generating some random email address based on social userid and provider domain
            else:
                email = u'{0}@{1}'.format(context.profile['accounts'][
                                          0]['userid'], context.profile['accounts'][0]['domain'])

            try:
                user = Session.query(
                    User).join(AuthenticationProvider).filter(AuthenticationProvider.provider == context.provider_name,
                                                              AuthenticationProvider.provider_id == context.profile['accounts'][0]['userid']).one()
            except NoResultFound:
                user = None

            # If the user for the provider was not found then check if in the DB exists user with the same email
            if not user:
                try:
                    user = Session.query(User).filter(User.email == email).one()
                    # If we are here that means that in the DB exists user with the same email but without the provider
                    # then we connect social account to this user
                    set_provider(user, context.provider_name, context.profile['accounts'][0]['userid'])
                    Session.flush()
                except NoResultFound:
                    length_min = self.request.config.fullauth.register.password.length_min
                    user = User(email=email,
                                password=tools.password_generator(length_min),
                                address_ip=self.request.remote_addr)
                    self.request.registry.notify(BeforeSocialRegister(self.request, user, context.profile))
                    set_provider(user, context.provider_name, context.profile['accounts'][0]['userid'])
                    Session.add(user)
                    Session.flush()
                    user.is_active = True

                    try:
                        self.request.registry.notify(AfterSocialRegister(
                            self.request, user, context.profile, response_values))
                    except HTTPFound as redirect:
                        # it's a redirect, let's follow it!
                        return redirect

        # if we're here, user exists
        try:
            self.request.registry.notify(AfterSocialLogIn(self.request, user, context.profile))
        except HTTPFound as redirect:
#.........这里部分代码省略.........

# 需要导入模块: from pyramid_basemodel import Session [as 别名]
# 或者: from pyramid_basemodel.Session import query [as 别名]
 def read_user(self, email):
     '''
         Reads user
     '''
     return Session.query(User).filter(User.email == email).first()