def test_switch_user_message_handler(self):
        user_id = 1
        handler_code1 = "handler1"
        handler_code2 = "handler2"
        self.server.set_message_handler(self.message_handler,
                                        handler_code1,
                                        default=True)

        # handler is not setted
        self.assertRaises(MessageHandlerNotSettedException,
                          self.server.switch_user_message_handler, user_id,
                          handler_code2)

        # set special handler for user
        self.server.set_message_handler(self.message_handler, handler_code2)
        self.server.switch_user_message_handler(user_id, handler_code2)
        self.assertEqual(
            User.objects(user_id=str(user_id)).first().next_handler,
            handler_code2)

        # set default handler for user
        self.server.switch_user_message_handler(user_id, None)
        self.assertEqual(
            User.objects(user_id=str(user_id)).first().next_handler,
            handler_code1)
Exemple #2
0
 def saveUser(self, _param):
     """
     保存用户信息
     @param _param: 
     @return: 
     """
     flag_add = True
     user = User.objects.filter(
         pk=_param['id']).first() if _param.get('id', None) else None
     if user:
         flag_add = False
     if user and User.objects.exclude(pk=_param['id']).filter(
             username=_param['username']).count():
         raise ex(u'该用户名已经存在!')
     if not user:
         if _param.get('username', None) and User.objects.filter(
                 username=_param['username']):
             raise ex(u'该用户名已经存在!')
         user = User()
     dic2obj(user, [
         'username', 'truename', 'name', 'email', 'phone', 'department_id',
         'role_id'
     ], _param)
     if _param.get('password', ''):
         user.password = _param['password']
     user.save()
     self.logAtion(ActionLog.ACTION_MODIFY, User, user.id)
Exemple #3
0
def signup():
    user = User()
    form = UserForm()
    if form.validate_on_submit():
        form.populate_obj(user)
        user.save(force_insert=True)
        flash('Your account have been created')
        return redirect(url_for('index'))
    return render_template('index.html', form=form)
Exemple #4
0
 def setUp(self):
     self.client = Client()
     self.user1 = User(username="******",
                       first_name="Fa",
                       password="******")
     self.user1.save()
     self.user2 = User(username="******",
                       first_name="Fa",
                       password="******")
     self.user2.save()
Exemple #5
0
def submit(request):
    try:
        email = request.POST.get('email')
        locale_id = request.POST.get('locale_id')
        user = User(email=email.lower(), locale_id_id=locale_id, active=True)
        user.save()
        return HttpResponseRedirect(reverse('subscription:submitted'))
    except IntegrityError as err:
        log_error(err)
    return HttpResponseRedirect(reverse('subscription:nosubmit'))
Exemple #6
0
def init_data():
    """Fish data for project"""
    if prompt_bool('Do you want to kill your db?'):
        db.drop_all()
    try:
       db.create_all()
    except:
        pass

    user = User.query.filter(User.email=='*****@*****.**').first()
    if user is None:
       user = User(username='******', email='*****@*****.**', password='******')
    user.save()
Exemple #7
0
def home():
    print "config.AUTHENTICATE {}".format(config.AUTHENTICATE)
    if config.AUTHENTICATE:
        return render_template('index.html',
                               login_form=LoginForm(),
                               create_form=CreateAccountForm())
    else:
        email = 'default'
        password = '******'
        access_key_id = config.AWS_ID
        secret_access_key = config.AWS_KEY
        aws_bucket_name = config.AWS_BUCKET_NAME
        next_backend_global_host = config.NEXT_BACKEND_GLOBAL_HOST
        if not User.objects(email=email):
            user = User(email=email,
                        access_key_id=access_key_id,
                        secret_access_key=secret_access_key,
                        aws_bucket_name=aws_bucket_name,
                        next_backend_global_host=next_backend_global_host)
            user.set_password(password)
            user.save()
        else:
            user = User.objects(email=email).first()
        login_user(user, remember=True)
        return redirect(url_for('dashboard._dashboard'))
Exemple #8
0
    def test_delete_user(self):
        self.user3 = User(username="******",
                          first_name="Ryan",
                          password="******")
        self.user3.save()
        user_detail = self.client.get('/users/%s/' % self.user3.pk)
        u_json_string = json.loads(user_detail.content.decode('utf-8'))
        self.assertEqual(user_detail.status_code, 200)

        user_delete = self.client.delete('/users/%s/' % self.user3.pk)
        self.assertEqual(user_delete.status_code, 204)

        user_detail = self.client.get('/users/%s/' % self.user3.pk)
        u_json_string = json.loads(user_detail.content.decode('utf-8'))
        self.assertEqual(user_detail.status_code, 404)
Exemple #9
0
 def changePassword(self, password, newpassword):
     '''
     修改用户密码
     @param password: 
     @param newpassword: 
     @return: 
     '''
     if not newpassword:
         raise ex(u'新密码不能为空')
     user = self.get_me()
     if user and user.password == User.pwdhash(password, user.salt):
         user.password = User.pwdhash(newpassword, user.salt)
         user.save()
     else:
         raise ex(u'原密码不正确!')
Exemple #10
0
    def post(self):
        """
        Handles the HTTP POST requests (overriding :meth:`MethodView.post`) .

        If the form was correctly filled and the user password validates
        (through :meth:`~base.models.User.check_password`),
        calls :func:`flask.ext.login.login_user`,
        emits a flash message of success and redirects the request to
        the `next` parameter or the home page if not specified.

        Otherwise, emits errors as flash messages and renders the login page again.

        :return: On error, renders the login page, but redirects to value of `next` or home page on success.
        """
        form = LoginForm()
        if not form.validate_on_submit():
            flash(self._messages['invalid_data'])
            return render_template('login.html', form=form)

        user = User.get_by_email(form.email.data)
        if user and user.check_password(form.password.data):
            login_user(user)
            flash(self._messages['success'])
        else:
            flash(self._messages['invalid_auth'])
            return redirect(url_for('base.login'))

        return redirect(request.args.get('next') or url_for('base.front_page'))
Exemple #11
0
 def POST(cls):
     name = request.form.get("login")
     password = request.form.get("password")
     context = cls.get_context()
     if not User.try_login(name, password):
         flash("Invalid password or username!", "error")
     return render_template(cls.template, **context), cls.status
Exemple #12
0
    def post(self):
        """
        Handles the HTTP POST requests (overriding :meth:`MethodView.post`) .

        If the form was correctly filled and the user password validates
        (through :meth:`~base.models.User.check_password`),
        calls :func:`flask.ext.login.login_user`,
        emits a flash message of success and redirects the request to
        the `next` parameter or the home page if not specified.

        Otherwise, emits errors as flash messages and renders the login page again.

        :return: On error, renders the login page, but redirects to value of `next` or home page on success.
        """
        form = LoginForm()
        if not form.validate_on_submit():
            flash(self._messages['invalid_data'])
            return render_template('login.html', form=form)

        user = User.get_by_email(form.email.data)
        if user and user.check_password(form.password.data):
            login_user(user)
            flash(self._messages['success'])
        else:
            flash(self._messages['invalid_auth'])
            return redirect(url_for('base.login'))

        return redirect(request.args.get('next') or url_for('base.front_page'))
Exemple #13
0
def signup():
    vals = dict(request.form)
    for key, val in vals.items():
        vals[key] = val[0]

    email = vals.get('email')
    username = vals.get('username')

    user_db = User.query.filter_by(username=username).first()
    email_db = User.query.filter_by(email=email).first()

    if not user_db and not email_db:
        user = User(email=email,
                    username=username,
                    password=generate_password_hash(vals.get('password')))
        db.session.add(user)
        db.session.commit()
        return json.dumps({
            'status': 'success',
            'msg': 'Sign up successful! Please login now.'
        })
    else:
        response = {'status': 'failed', 'msg': ''}
        if user_db:
            response['msg'] += 'This username already exists. '
        if email_db:
            response['msg'] += 'This email already exists. '
        return json.dumps(response)
Exemple #14
0
def add_user():
    username = request.form["username"]
    if User.query.filter_by(username=username).count() > 0:
        return jsonify(Msg(False, gettext("User exists.")))
    password = request.form["password"]
    user = User(username, password)
    db.session.add(user)
    db.session.commit()
    return jsonify(Msg(True, gettext("User added Successfully.")))
 def login(self, request):
     username = request.data.get("username", None)
     password = request.data.get("password", None)
     try:
         ca = User.login(username, password)
         serializer = UserAuthSerializer(ca)
         cache_for_admin_login(serializer)
         return Response(serializer.data)
     except ObjectDoesNotExist:
         raise BusinessValidationError(error_const.BUSINESS_ERROR.ADMIN_LOGIN_FAIL)
Exemple #16
0
 def get_object(self, queryset=None):
     obj = super().get_object(queryset=queryset)
     if obj.is_deleted:
         raise User.DoesNotExist("未查询到用户: %s" %
                                 self.model._meta.object_name)
     # opt_log
     self.opt_logger.info(User.objects.get(pk=self.kwargs.get('user_id')),
                          content='更新用户',
                          action='更新用户')
     return obj
Exemple #17
0
    def get(self):
        user = User('Test Name', '*****@*****.**')
        db.session.add(user)

        try:
            db.session.commit()
        except Exception as e:
            db.session.rollback()
            app.logger.debug(e)

        return TODOS
Exemple #18
0
    def POST(cls, *args, **kwargs):
        new_user = User()
        form = request.form
        new_user.nickname = form.get('nickname')
        new_user.password_hash = generate_password_hash(form.get('password'))
        new_user.image_url = form.get('image_url')
        new_user.about = form.get('about')
        new_user.footer_text = form.get('footer')
        new_user.email = form.get('email')

        db.session.add(new_user)
        db.session.commit()
        return cls.GET(*args, **kwargs)
Exemple #19
0
def login():
    login_form = LoginForm(request.form)
    if login_form.validate_on_submit():
        user = User.objects(email=login_form.email.data).first()
        if user and user.check_password(login_form.password.data):
            login_user(user)
            return redirect(request.args.get("next") or url_for('dashboard._dashboard'))
        else:
            flash("Login failed.", "login_error")
            # login is not valid
            return redirect('#create')
    return render_template('index.html', login_form=login_form, create_form=CreateAccountForm())
Exemple #20
0
    def setUp(self):
        self.db = base.db
        self.db.create_all()
        self.client = self.app.test_client()

        u = User(username='******', email='*****@*****.**', password='******')
        bm = Bookmark(user=u, url="http://www.example.com", tags="one,two,three")
        self.db.session.add(u)
        self.db.session.add(bm)
        self.db.session.commit()

        self.client.post(url_for('auth.login'), data=dict(username='******', password='******'))
Exemple #21
0
    def __init__(self):
        global _player
        if _player is not None:
            raise "Player was initialized!"

        random.seed(time.clock())

        print("Starting player...")
        self.vlcInstance = vlc.Instance(
            "--live-caching=0 --network-caching=0 --norm-buff-size=8")
        self.vlcPlayer = self.vlcInstance.media_player_new()
        self.vlcEvents = self.vlcPlayer.event_manager()
        self.vlcEvents.event_attach(vlc.EventType.MediaPlayerEndReached,
                                    self.songFinished)
        self.vlcEvents.event_attach(vlc.EventType.MediaPlayerEncounteredError,
                                    self.songCorrupted)
        self.vlcEvents.event_attach(vlc.EventType.MediaStateChanged,
                                    self.mediaStateChanged)

        # Import old DJPajton playlist
        if Song.objects.count() == 0 and os.path.isfile('music4you.playlist'):
            with open("music4you.playlist", "r") as f:
                playlist = json.loads(f.read())
                for item in playlist:
                    print("Item: {}".format(item))

                    song = Song()
                    song.id = int(item['id'])
                    song.date = item['addedDate']
                    song.active = (bool(item['deleted']) == False)
                    song.url = item['url']
                    song.title = item['title']

                    try:
                        user = User.objects.get(login=item['addedLogin'])
                    except:
                        user = User()
                        user.active = False
                        user.type = USER_TYPE_SKYPE
                        user.login = item['addedLogin']
                        user.displayName = user.login
                        user.save()

                    song.user = user
                    song.save()

        #self.vlcPlayer.audio_set_volume(100)

        if Song.objects.count() == 0:
            return
Exemple #22
0
class KitTestCase(TestCase):

    def create_app(self):
        return AppFactory(TestingConfig).get_app(__name__)

    def setUp(self):
        db.create_all()
        self.user = User(username='******', email='*****@*****.**', password='******')
        self.user.save()

    def tearDown(self):
        db.session.remove()
        db.drop_all()

    def assertContains(self, response, text, count=None,
                       status_code=200, msg_prefix=''):
        """
        Asserts that a response indicates that some content was retrieved
        successfully, (i.e., the HTTP status code was as expected), and that
        ``text`` occurs ``count`` times in the content of the response.
        If ``count`` is None, the count doesn't matter - the assertion is true
        if the text occurs at least once in the response.
        """

        if msg_prefix:
            msg_prefix += ": "

        self.assertEqual(response.status_code, status_code,
            msg_prefix + "Couldn't retrieve content: Response code was %d"
                         " (expected %d)" % (response.status_code, status_code))

        real_count = response.data.count(text)
        if count is not None:
            self.assertEqual(real_count, count,
                msg_prefix + "Found %d instances of '%s' in response"
                             " (expected %d)" % (real_count, text, count))
        else:
            self.assertTrue(real_count != 0,
                msg_prefix + "Couldn't find '%s' in response" % text)
Exemple #23
0
def app_add_user():
    try:
        app_add_user = User(**request.form)
        db.session.merge(app_add_user)
        db.session.commit()
        return json.dumps({'success': True}), 200, {
            'ContentType': 'application/json'
        }
    except Exception as e:
        print(e)
        return json.dumps({'success': False}), 400, {
            'ContentType': 'application/json'
        }
Exemple #24
0
def login():
    login_form = LoginForm(request.form)
    if login_form.validate_on_submit():
        user = User.objects(email=login_form.email.data).first()
        if user and user.check_password(login_form.password.data):
            login_user(user)
            return redirect(request.args.get("next") or url_for('dashboard._dashboard'))
        else:
            flash("Login failed.", "login_error")
            # login is not valid
            return redirect('#create')
    return render_template('index.html',
                           login_form=login_form,
                           create_form=CreateAccountForm())
Exemple #25
0
def load_user(user_id):
    """
    We need to provide a :meth:`~flask.ext.login.LoginManager.user_loader` callback to the login manager.
    This callback is used to reload the user object from the user ID stored in the session.

    It should return `None` (**not raise an exception**) if the ID is not valid.
    (In that case, the ID will manually be removed from the session and processing
    will continue.)

    This is done by calling :meth:`~base.models.User.get_by_id`)
    ,
    :param user_id: the unicode ID of a user
    :return:the corresponding user object
    """
    return User.get_by_id(user_id)
Exemple #26
0
    def post(self):
        form = LoginForm()
        if not form.validate_on_submit():
            flash(self._messages['invalid_form'])
            return render_template('login.html', form=form)

        user = User.get_by_email(form.email.data)
        if user and user.check_password(form.password.data):
            login_user(user)
            flash(self._messages['success'])
        else:
            flash(self._messages['invalid_auth'])
            return redirect(url_for('base.login'))

        return redirect(request.args.get('next') or url_for('base.front_page'))
Exemple #27
0
def load_user(user_id):
    """
    We need to provide a :meth:`~flask.ext.login.LoginManager.user_loader` callback to the login manager.
    This callback is used to reload the user object from the user ID stored in the session.

    It should return `None` (**not raise an exception**) if the ID is not valid.
    (In that case, the ID will manually be removed from the session and processing
    will continue.)

    This is done by calling :meth:`~base.models.User.get_by_id`)
    ,
    :param user_id: the unicode ID of a user
    :return:the corresponding user object
    """
    return User.get_by_id(user_id)
Exemple #28
0
    def post(self):
        form = LoginForm()
        if not form.validate_on_submit():
            flash(self._messages['invalid_form'])
            return render_template('login.html', form=form)

        user = User.get_by_email(form.email.data)
        if user and user.check_password(form.password.data):
            login_user(user)
            flash(self._messages['success'])
        else:
            flash(self._messages['invalid_auth'])
            return redirect(url_for('base.login'))

        return redirect(request.args.get('next') or url_for('base.front_page'))
    def test_handle_postback(self, mock_obj):
        handler_code = "handler"
        sender_id = 1
        postback = {"payload": handler_code}

        # message handler not setted up
        self.assertRaises(PostbackHandlerUndefinedException,
                          self.server.handle_postback, postback, sender_id)

        # handle message
        self.server.set_postback_handler(self.message_handler, handler_code)
        self.server.handle_postback(postback, sender_id)
        self.assertEqual(
            User.objects(user_id=str(sender_id)).first().next_handler,
            "special_handler")
Exemple #30
0
def login():
    form = LoginForm()
    if form.validate_on_submit():
        try:
            user = User.get(User.user_username == form.username.data)
            if user.user_password == form.password.data:
                #user.is_authenticated = True
                login_user(user)
                session['username'] = request.form['username']
                flash("You're now logged in!")
                return redirect(url_for('index'))
            else:
                flash("Error on password or username")
        except:
            flash("Error !!,You should start again")
    return render_template('login.html', form=form)
Exemple #31
0
    def form_valid(self, form):
        # Create a user, but remember to set inactive!
        user = User()
        user.username = form.cleaned_data['email']
        user.email = form.cleaned_data['email']
        user.is_active = False
        try:
            user.save()
        except IntegrityError:
            form.add_error('email',
                           gettext('Shop with this email already exists.'))
            return super(ShopRegisterView, self).form_invalid(form)

        self.object = form.save(commit=False)
        self.object.postcode = Postcode.objects.get(
            postcode=form.cleaned_data['postcode_special'])
        self.object.user = user
        self.object.save()

        current_site = get_current_site(self.request)
        context = {
            'shopname': self.object.name,
            'user': user,
            'domain': current_site.domain,
            'uid': urlsafe_base64_encode(force_bytes(user.pk)),
            'token': account_activation_token.make_token(user),
        }

        html_message = render_to_string('emails/account_activation.html',
                                        context)
        txt_message = render_to_string('emails/account_activation.txt',
                                       context)

        email = EmailMultiAlternatives(gettext('FOODBEE - Confirm email'),
                                       txt_message)
        email.from_email = settings.DEFAULT_FROM_EMAIL
        email.to = [self.object.email]
        email.attach_alternative(html_message, "text/html")
        email.content_subtype = 'html'
        email.mixed_subtype = 'related'

        with open('base/static/base/img/fb_logo.png', mode='rb') as f:
            image = MIMEImage(f.read())
            image.add_header('Content-ID', "<Foodbee_logo_long.png>")
            email.attach(image)

        email.send()

        return super().form_valid(form)
    def test_handle_message(self, mock_obj):
        message = {'text': "test"}
        sender_id = 1
        handler_code = "handler"

        # message handler not setted up
        self.assertRaises(MessageHandlerNotSettedException,
                          self.server.handle_message, message, sender_id)

        # handle message
        self.server.set_message_handler(self.message_handler,
                                        handler_code,
                                        default=True)
        self.server.handle_message(message, sender_id)
        self.assertEqual(
            User.objects(user_id=str(sender_id)).first().next_handler,
            "special_handler")
Exemple #33
0
 def login(self, username, password):
     """
     用户登录
     @param username: 
     @param password: 
     @return: 
     """
     user = User.objects.filter(username=username).first()
     if user and user.password == User.pwdhash(password, user.salt):
         if user.status == User.STATUS_CANCELED:
             raise ex(u'该用户已被锁定无法登陆')
         self.session_set('me', user.get_json())
         self.logAtion(ActionLog.ACTION_LOGIN)
         logingoto = self.session_get_once('logingoto')
         return obj2dic(user, ['id', 'username', 'token'],
                        {'goto': logingoto or '/xadmin/'})
     else:
         raise ex(u'用户名或密码错误')
Exemple #34
0
def create():
    create_form = CreateAccountForm(request.form)
    if create_form.validate_on_submit():
        print "form data",create_form.new_email.data
        new_email = create_form.new_email.data
        new_password = create_form.new_password.data
        confirm_password = create_form.confirm_password.data
        print User.objects()
        if User.objects(email=new_email).count() == 0:
            if new_password == confirm_password:
                # Set the hashed password on the user.
                user = User(email=new_email)
                user.set_password(new_password)
                user.save()
                login_user(user, remember=True)
                return redirect(url_for('dashboard._dashboard'))
            else:
                flash("Passwords don't match!", "create_error")
                return redirect('#create')    
        else:
            flash("Username exists!", "create_error")
            return redirect('#create')
    # login form is not valid
    return render_template('index.html', login_form=LoginForm(), create_form=create_form)
Exemple #35
0
    def force_lookup(self):
        "Lookup users who were not included in the original crawl."
        for user in User.get_all():
            if (    user.lookup_done or
                    user.protected or
                    user._id not in self.scores or
                    user.local_prob==1
               ):
                continue

            state, rfs, ats = self.scores.split(user._id)
            reasons = [
                user.utc_offset == settings.utc_offset,
                log_score(rfs,ats) >= settings.non_local_cutoff,
                user.local_prob == .5,
            ]
            if sum(reasons)>=2:
                logging.info("force %s - %d for %r", user.screen_name, user._id, reasons)
                self._send_job(user._id,rfs,ats,True)
Exemple #36
0
    def run(self):
        while True:
            jobs = []
            for x in xrange(100):
                try:
                    # reserve blocks to wait when x is 0, but returns None for 1-99
                    j = self.stalk.reserve(0 if x else None)
                except beanstalkc.DeadlineSoon:
                    break
                if j is None:
                    break
                jobs.append(j)

            bodies = [LookupJobBody.from_job(j) for j in jobs]
            try:
                users =self.twitter.user_lookup([b._id for b in bodies])
            except ResourceNotFound:
                logging.info("no profile for %r",[b._id for b in bodies])
                continue

            logging.info("looking at %r"%[getattr(u,'screen_name','') for u in users])
            for job,body,user in zip(jobs,bodies,users):
                if user is None:
                    logging.info("no profile for %d",body._id)
                    job.delete()
                    continue
                try:
                    self.twitter.sleep_if_needed()
                    logging.info("look at %s",user.screen_name)
                    if (not body.force) and User.in_db(user._id):
                        job.delete()
                        continue
                    self.crawl_user(user,body.force)
                    user.save()
                    job.delete()
                except:
                    logging.exception("exception for job %s"%job.body)
                    job.bury()
            logging.info("api calls remaining: %d",self.twitter.remaining)
Exemple #37
0
def create():
    create_form = CreateAccountForm(request.form)
    if create_form.validate_on_submit():
        print "form data",create_form.new_email.data
        new_email = create_form.new_email.data
        new_password = create_form.new_password.data
        confirm_password = create_form.confirm_password.data
        print User.objects()
        if User.objects(email=new_email).count() == 0:
            if new_password == confirm_password:
                # Set the hashed password on the user.
                user = User(email=new_email)
                user.set_password(new_password)
                user.save()
                login_user(user, remember=True)
                return redirect(url_for('dashboard._dashboard'))
            else:
                flash("Passwords don't match!", "create_error")
                return redirect('#create')    
        else:
            flash("Username exists!", "create_error")
            return redirect('#create')
    # login form is not valid
    return render_template('index.html', login_form=LoginForm(), create_form=create_form)
def login(request):
    try:
        body = json.loads(request.body)

        user = User.by_login(body['login'])
        if user.auth.password == hex_hash(body['password']):
            # 200
            r = HttpResponse()
            r.set_cookie("user_id",
                         user.id,
                         24 * 60 * 60,
                         domain=settings.SESSION_COOKIE_DOMAIN)
            r.set_cookie("login",
                         user.auth.login,
                         24 * 60 * 60,
                         domain=settings.SESSION_COOKIE_DOMAIN)
            return r

        # 403
        return HttpResponseForbidden()
    except ObjectDoesNotExist:
        # 404
        return HttpResponseNotFound()
Exemple #39
0
def init_user():
    if User.query.count() == 0:
        db.session.add(User('admin', 'admin'))
        db.session.commit()
Exemple #40
0
 def setUp(self):
     db.create_all()
     self.user = User(username='******', email='*****@*****.**', password='******')
     self.user.save()
Exemple #41
0
def load_user(user_id):
    return User.get_by_id(user_id)
Exemple #42
0
 def produce(self):
     Model.database = MongoDB(name=self.db_name, host=settings.db_host)
     endtime = datetime.utcnow()
     return User.find(User.next_crawl_date < endtime, sort=User.next_crawl_date, timeout=False)
Exemple #43
0
def load_user(userid):
    users = User.objects(email=userid)
    if len(users) >0:
        return users[0]
    return None