def qq_weibo_get_code():
    code = request.args['code']
    openid = request.args['openid']
    openkey = request.args['openkey']

    qqbot = db.session.query(Bot).filter(Bot.type == 1).one()
    bot = qqbot.build_bot()
    resp = bot.request_access_token(code)
    resp.openid = openid
    resp.openkey = openkey
    logger.debug(resp)

    u = db.session.query(User).filter(User.openid == openid)
    if u.count():
        u = u.one()
        u.assign(resp)
    else:
        u = User()
        u.assign(resp)
        db.session.add(u)
        logger.info('Created new user <%s %s>' % (u.name, u.openid))
    db.session.commit()

    if not u.token:
        u.generate_token()

    return 'your arm server token: %s' % (u.token)

    def post(self):
        data = request.form
        print data
        if len(set(['name', 'cost', 'payer', 'buyins']) &
               set([x for x in data])) == 4:

            # Validate that users involved have accounts

                # Extract payer id
            payer = User.objects(username=data['payer'])
            payer_id = payer[0].id

                # Extract ids of those who buy in
            buyins = User.objects(username__in=data['buyins'])
            buyin_ids = map(lambda x: x.id, buyins)

            purchase = Purchase(name=data['name'],
                                cost=data['cost'],
                                payer=payer_id,
                                buyins=buyin_ids,
                                time=datetime.datetime.now())
            purchase.save()

            debt_up_to_date = self.updateDebt(purchase)

            return jsonify({'res': True,
                            'messsage': 'Purchase added',
                            'debts': debt_up_to_date})
        return jsonify({'res': False,
                        'message': 'default'})

    def test_user_password(self, testapp):
        """ Test password hashing and checking """

        admin = User('admin', 'supersafepassword')

        assert admin.username == 'admin'
        assert admin.check_password('supersafepassword')

  def setUp(self):
    t = Tool(id=1, name='test_tool', status=1, status_message='working ok')
    t.save()

    u = User(id=1, name='Test user', subscribed=True)
    u.card_set.add(Card(card_id='12345678'))
    u.save()

def staff_group_add(cid, email, aid):
    assign = Assignment.query.filter_by(id=aid, course_id=cid).one_or_none()
    if not assign or not Assignment.can(assign, current_user, 'grade'):
        flash('Cannot access assignment', 'error')
        return abort(404)

    form = forms.StaffAddGroupFrom()
    result_page = url_for('.student_assignment_detail', cid=cid,
                          email=email, aid=aid)

    student = User.lookup(email)
    if not student:
        return abort(404)

    if form.validate_on_submit():
        target = User.lookup(form.email.data)
        if not target or not target.is_enrolled(cid):
            flash("This user is not enrolled", 'warning')
            return redirect(result_page)
        try:
            Group.force_add(current_user, student, target, assign)
        except BadRequest as e:
            flash("Error: {}".format(str(e.description)), 'error')
            return redirect(result_page)

    return redirect(result_page)

    def test_is_staff(self):
        self.setup_course()
        random_user = User(name=self.studentA['name'], email=self.studentA['email'])
        db.session.add(random_user)
        db.session.commit()

        self.assertTrue(self.staff1.is_staff())
        self.assertTrue(self.admin.is_staff())
        self.assertFalse(self.user1.is_staff())
        self.assertFalse(random_user.is_staff())

 def post(self):
     try:
         username = generate_username()
         user = User(username=username)
         user.save()
         self.write(json.dumps(user.to_representation()))
     except Chat.DoesNotExist:
         self.clear()
         self.set_status(404)
         self.finish({'error': 'not found'})

    def test_lookup(self):
        email = '[email protected]'

        user = User.lookup(email)
        assert user is None

        db.session.add(User(email=email))
        db.session.commit()

        user = User.lookup(email)
        assert user.email == email

 def post(self):
     if self.registration_form.validate_on_submit():
         try:
             user = User(self.registration_form.login.data, self.registration_form.password.data)
             user.email = self.registration_form.email.data
             db.session.add(user)
             db.session.commit()
             session['userId'] = user.id
             flash('Willkommen Benutzer "%s".' % user.login, 'info')
             return redirect(url_for('vote.home.inactive'))
         except IntegrityError:
             self.registration_form.login.errors.append("Eine Benutzer mit diesem Login existiert bereits")
             return self.render()
     return self.render()

def me(user: User):
    """
    User object representation ready for JSON serialization.

    :param user: User object
    :return: Dictionary with User representation fields
    """
    return {
        'id':         user.id,
        'nickname':   user.nickname,
        'university': University.query.get(user.university).name,
        'gender':     user.get_gender(),
        'boards':     [board(b) for b in user.get_boards()],
        'profilepic': user.profilepic
    }

    def test_enroll_from_form(self):
        self.setup_course()

        Enrollment.enroll_from_form(self.course.id, make_enrollment_form(self.studentB))

        user = User.lookup(self.studentB['email'])
        self.studentB['id'] = user.id

        self.enrollment_matches_info(user, self.studentB)

        Enrollment.enroll_from_form(self.course.id, make_enrollment_form(self.lab_assistantA))
        lab_assistant = User.lookup(self.lab_assistantA['email'])
        self.lab_assistantA['id'] = lab_assistant.id

        self.enrollment_matches_info(lab_assistant, self.lab_assistantA)

    def test_basic(self):
        i = User(username='alice', email='[email protected]')
        j = User(username='bob', email='[email protected]')
        db.session.add(i)
        db.session.add(j)
        db.session.commit()

        t = i.create_task(title='I want to test', abstract='a test', content='I want to test the test part.') 
#        db.session.add(t)
#        db.session.commit()
        assert len(i.watched_tasks) == 1
        assert len(t.watcher.all()) == 1
        j.watch_task(t)
        assert len(i.watched_tasks) == 1
        assert len(t.watcher.all()) == 2
        assert j in t.watcher.all()

    def test_score_staff(self):
        self._test_backup(True)

        user = User.lookup(self.user1.email)
        self.login(self.staff1.email)

        response = self.client.post('/api/v3/score/')
        self.assert_400(response)
        assert response.json['code'] == 400
        backup = Backup.query.filter(Backup.submitter_id == user.id).first()

        data = {'bid': encode_id(backup.id), 'kind': 'Total',
                'score': 128.2, 'message': 'wow'}
        response = self.client.post('/api/v3/score/', data=data)
        self.assert_200(response)
        assert response.json['code'] == 200

        self.logout()
        self.login(self.admin.email)

        data = {'bid': encode_id(backup.id), 'kind': 'Total',
                'score': 128.2, 'message': 'wow'}
        response = self.client.post('/api/v3/score/', data=data)
        self.assert_200(response)
        assert response.json['code'] == 200

    def test_export_final(self):
        self._test_backup(True)
        student = User.lookup(self.user1.email)

        backup = Backup.query.filter(Backup.submitter_id == student.id).first()
        endpoint = '/api/v3/assignment/{0}/submissions/'.format(self.assignment.name)

        response = self.client.get(endpoint)
        self.assert_403(response)

        self.login(self.staff1.email)
        response = self.client.get(endpoint)
        self.assert_200(response)
        backups = response.json['data']['backups']
        self.assertEqual(len(backups), 1)
        self.assertEqual(backups[0]['is_late'], False)
        self.assertEqual(len(backups[0]['group']), 1)
        self.assertEqual(backups[0]['group'][0]['email'], self.user1.email)
        self.assertEqual(len(backups[0]['messages']), 1)

        self.assertEqual(response.json['data']['count'], 1)
        self.assertEqual(response.json['data']['has_more'], False)
        self.assertEqual(response.json['data']['offset'], 0)

        response = self.client.get(endpoint + '?offset=1')
        self.assert_200(response)
        backups = response.json['data']['backups']
        self.assertEqual(len(backups), 0)
        self.assertEqual(response.json['data']['count'], 1)
        self.assertEqual(response.json['data']['has_more'], False)
        self.assertEqual(response.json['data']['offset'], 1)

    def test_export_user(self):
        self._test_backup(True)
        student = User.lookup(self.user1.email)
        self.login(self.staff1.email)

        backup = Backup.query.filter(Backup.submitter_id == student.id).first()

        endpoint = '/api/v3/assignment/{0}/export/{1}'.format(self.assignment.name,
                                                          student.email)
        response = self.client.get(endpoint)
        self.assert_200(response)
        backups = response.json['data']['backups']
        self.assertEqual(len(backups), 1)
        self.assertTrue('submission_time' in backups[0])
        self.assertEqual(backups[0]['submission_time'], backups[0]['created'])
        self.assertEqual(response.json['data']['count'], 1)
        self.assertEqual(response.json['data']['limit'], 150)
        self.assertEqual(response.json['data']['offset'], 0)
        self.assertEqual(response.json['data']['has_more'], False)

        response = self.client.get(endpoint + "?offset=20&limit=2")
        self.assert_200(response)
        backups = response.json['data']['backups']
        self.assertEqual(len(backups), 0)
        self.assertEqual(response.json['data']['count'], 1)
        self.assertEqual(response.json['data']['limit'], 2)
        self.assertEqual(response.json['data']['offset'], 20)
        self.assertEqual(response.json['data']['has_more'], False)

    def test_enroll_from_csv(self):
        self.setup_course()

        template = "{email},{name},{sid},{class_account},{section}"
        form = BatchEnrollmentForm()
        form.csv.data = template.format(**self.studentA) + "\n" + template.format(**self.studentB)

        Enrollment.enroll_from_csv(self.course.id, form)

        user_a = User.lookup(self.studentA['email'])
        self.studentA['id'] = user_a.id
        self.enrollment_matches_info(user_a, self.studentA)

        user_b = User.lookup(self.studentB['email'])
        self.studentB['id'] = user_b.id
        self.enrollment_matches_info(user_b, self.studentB)

        def routine(user: User, board: Board):
            """
            Create new Thread linked to specified board, from POST JSON data.

            :param user:  Requesting User object
            :param board: Board object
            :return: New thread inside specified board
            """
            try:
                # Check thread JSON arguments
                self.check_args()
                self.validate_args()

                # Process anon, image and construct new entity
                anon   = str_to_bool(self.args['anon'])
                image  = self.media_processing()
                thread = Thread(anon, self.args['title'], self.args['text'], image, board.id, user.id)

                # Add new Thread table to database
                uchan.add_to_db(thread)

                # Add new ThreadUser link
                thread = user.get_last_thread()
                uchan.add_to_db(ThreadUser(thread.id, user.id))

                return responses.successful(201, JSONRepresentation.thread(thread, user))
            except ValueError as msg:
                return responses.client_error(400, '{}'.format(msg))
            except KeyError as key:
                return responses.client_error(400, 'Invalid parameter: {}'.format(key))

    def test_assignment_api(self):
        self._test_backup(True)
        student = User.lookup(self.user1.email)
        endpoint = '/api/v3/assignment/{0}'.format(self.assignment.name)
        # View a public assignment
        response = self.client.get(endpoint)
        self.assert_200(response)
        # Change assignment to be hidden
        self.assignment.visible = False
        db.session.commit()
        response = self.client.get(endpoint)
        self.assert_403(response)

        self.assignment.visible = True
        db.session.commit()

        self.login(self.staff1.email)
        response = self.client.get(endpoint)
        self.assert_200(response)
        self.assertEqual(response.json['data']['name'], self.assignment.name)

        # Hidden assignment, but should be visible to staff
        self.assignment.visible = False
        db.session.commit()
        response = self.client.get(endpoint)
        self.assert_200(response)

        self.login(self.user1.email)
        self.assignment.visible = False
        db.session.commit()
        response = self.client.get(endpoint)
        self.assert_403(response)

def staff_flag_backup(cid, email, aid):
    assign = Assignment.query.filter_by(id=aid, course_id=cid).one_or_none()
    if not assign or not Assignment.can(assign, current_user, 'grade'):
        return abort(404)
    result_page = url_for('.student_assignment_detail', cid=cid,
                          email=email, aid=aid)

    student = User.lookup(email)
    if not student:
        abort(404)
    user_ids = assign.active_user_ids(student.id)

    bid = request.form.get('bid')

    form = forms.CSRFForm()
    if form.validate_on_submit():
        backup = Backup.query.filter_by(id=utils.decode_id(bid),
                                        assignment=assign).one_or_none()
        if not backup:
            flash('{} does not exist'.format(bid, 'error'))
            return redirect(result_page)

        if not backup.flagged:
            result = assign.flag(backup.id, user_ids)
            flash('Flagged backup {} for grading'.format(bid), 'success')
        else:
            result = assign.unflag(backup.id, user_ids)
            flash('Removed grading flag on {}'.format(bid), 'success')

    return redirect(result_page)

def board_routine(user: User, func, id: int, *args, **kwargs):
    """
    Basic board routine.
    Serves as a layer of abstraction to treat priority errors in board method resource routines.

    This fuction needs to be passed (and called) by session_oriented_request() (inherited from AuthEntity),
    with subroutine function (that has to be called from within this routine) and an ID (serves as Board ID).

    Function passed to this routine needs this signature:
        >>> def func(user: User, board: Board, *args, **kwargs)

    N.B. *args and **kwargs can be omitted.

    :param user:   User Object (got from session_oriented_request())
    :param func:   Subroutine function (needs to be called from within this routine)
    :param id:     Board ID
    :param args:   Name arguments
    :param kwargs: Positional arguments
    :return:
    """
    # Requesting board object
    board = BoardAPI.get_board(id)

    if board is None:
        # Board does not exists
        return responses.client_error(404, 'Board does not exist')
    elif not user.board_subscribed(id):
        # User not subscribed to this board
        return responses.client_error(401, 'User is not authorized to see this board')

    # Return the result got from closure function passed as argument
    return func(user, board, *args, **kwargs)