コード例 #1
0
def setup_tasks_endpoint():
    endpoint = api.namespace(
        name='tasks', description='Endpoint to handle tasks CRUD operations.')

    @endpoint.route('/')
    @endpoint.doc(security='apiKey')
    class ListTasks(TokenRequiredMixin, Resource):
        @endpoint.marshal_list_with(TaskSerializer)
        @endpoint.param(
            'chunk',
            f'dividing tasks into chunks of {LIMIT_PER_CHUNK}, default is 1.')
        def get(self):
            ''' Get list of tasks. '''
            chunk = request.args.get('chunk', 1, type=int)

            return Task.query.paginate(chunk,
                                       per_page=LIMIT_PER_CHUNK,
                                       error_out=False).items, HTTPStatus.OK
コード例 #2
0
ファイル: customers.py プロジェクト: rg3915/crm-flask
        'total_pages': fields.Integer(
            description='Total number of pages of results'
        ),
        'total_items': fields.Integer(description='Total number of results'),
        'next_page': fields.String(),
        'prev_page': fields.String()
    }
)

customers_list = api.inherit(
    'Page of customers',
    pagination,
    {'customers': fields.List(fields.Nested(customer_model))}
)

ns_customers = api.namespace('customers', description='Customers')

parser = reqparse.RequestParser()
parser.add_argument('page', 1, type=int, location='args', required=False)
parser.add_argument('per_page', 10, choices=[5, 10, 25, 50, 100], type=int,
                    location='args', required=False)


@ns_customers.route('/<int:id>')
class CustomerService(Resource):

    @api.marshal_with(customer_model)
    def get(self, id):
        return Customer.query.get_or_404(id).to_dict()

    @api.expect(customer_model)
コード例 #3
0
# -*- coding: utf-8 -*-

from flask import json, g
from flask_httpauth import HTTPTokenAuth
from flask_restplus import Resource
from app.elastic import get_user_from_id
from app.models import User
from app.api import api

ns = api.namespace('postman', description='Postman export.')

# ================================================================================================
# AUTH
# ================================================================================================
#
#   Auth verification
#
# ================================================================================================

auth = HTTPTokenAuth(scheme='Token')


@auth.verify_token
def verify_token(token):
    """
    Verify auth token

    :param token: User token
    :type token: str

    :return: True if valid token, else False
コード例 #4
0
def setup_tickets_endpoint():
    endpoint = api.namespace(
        name='tickets',
        description='Endpoint to handle tickets CRUD operations.')

    @endpoint.route('/')
    @endpoint.doc(security='apiKey')
    class ListDeleteAndCreateTickets(TokenRequiredMixin, Resource):
        @endpoint.marshal_list_with(TicketSerializer)
        @endpoint.param('processed',
                        'get only processed tickets, by default False.')
        @endpoint.param(
            'chunk',
            f'dividing tickets into chunks of {LIMIT_PER_CHUNK}, default is 1.'
        )
        def get(self):
            ''' Get list of tickets. '''
            chunk = request.args.get('chunk', 1, type=int)
            processed = request.args.get('processed', False, type=bool)
            tickets = Serial.all_clean()

            if processed:
                tickets = tickets.filter_by(p=True)

            return tickets.paginate(chunk,
                                    per_page=LIMIT_PER_CHUNK,
                                    error_out=False).items, HTTPStatus.OK

        @endpoint.marshal_with(TicketSerializer)
        @endpoint.expect(TicketSerializer)
        def post(self):
            ''' Generate a new ticket. '''
            registered = api.payload.get('n', False)
            name_or_number = api.payload.get('name', None)
            task = Task.get(api.payload.get('task_id', None))
            office = Office.get(api.payload.get('office_id', None))

            if not task:
                abort(message='Task not found', code=HTTPStatus.NOT_FOUND)

            if registered and not name_or_number:
                abort(message='Name must be entered for registered tickets.',
                      code=HTTPStatus.NOT_FOUND)

            ticket, exception = Serial.create_new_ticket(
                task, office, name_or_number)

            if exception:
                abort(message=str(exception))

            return ticket, HTTPStatus.OK

        def delete(self):
            ''' Delete all tickets. '''
            Serial.all_clean().delete()
            db.session.commit()
            return '', HTTPStatus.NO_CONTENT

    @endpoint.route('/<int:ticket_id>')
    @endpoint.doc(security='apiKey')
    class GetAndUpdateTicket(TokenRequiredMixin, GetOrRejectMixin, Resource):
        module = Serial
        kwarg = 'ticket_id'

        @endpoint.marshal_with(TicketSerializer)
        def get(self, ticket_id):
            ''' Get a specific ticket. '''
            return self.ticket, HTTPStatus.OK

        @endpoint.marshal_with(TicketSerializer)
        @endpoint.expect(TicketSerializer)
        def put(self, ticket_id):
            ''' Update a specific ticket. '''
            api.payload.pop('id', '')
            self.ticket.query.update(api.payload)
            db.session.commit()
            return self.ticket, HTTPStatus.OK

        def delete(self, ticket_id):
            ''' Delete a specific ticket. '''
            db.session.delete(self.ticket)
            db.session.commit()
            return '', HTTPStatus.NO_CONTENT

    @endpoint.route('/pull')
    @endpoint.doc(security='apiKey')
    class PullTicket(TokenRequiredMixin, Resource):
        @endpoint.marshal_with(TicketSerializer)
        @endpoint.param('ticket_id',
                        'to pull a specific ticket with, by default None.')
        @endpoint.param('office_id',
                        'to pull a specific ticket from, by default None.')
        def get(self):
            ''' Pull a ticket from the waiting list. '''
            ticket_id = request.args.get('ticket_id', None, type=int)
            office_id = request.args.get('office_id', None, type=int)
            ticket = Serial.get(ticket_id)

            if ticket_id and not ticket:
                abort(message='Ticket not found', code=HTTPStatus.NOT_FOUND)

            next_ticket = ticket or Serial.get_next_ticket()

            if not next_ticket:
                abort(message='No tickets left to pull',
                      code=HTTPStatus.NOT_FOUND)

            next_ticket.pull(office_id, self.auth_token and self.auth_token.id)
            return next_ticket, HTTPStatus.OK
コード例 #5
0
from flask_restplus import abort

from app import models
from app.api import api
from app.api.endpoints import TaskList, Task


ns = api.namespace('text_tasks')


@ns.route('/')
class TextTaskList(TaskList):
    @property
    def model(self):
        return models.TextTask

    @property
    def celery_task(self):
        from app import celery_tasks
        return celery_tasks.execute_text_task


@ns.route('/<string:tid>')
class TextTask(Task):
    @property
    def model(self):
        return models.TextTask


@ns.route('/<string:tid>/text')
class TextTaskText(TextTask):
コード例 #6
0
from Queue import Empty

from flask import current_app
from flask_restplus import Resource, fields

from app.api import api
from app.queue import L1_DATASOURCES
from app.queue import L2_DATASOURCES

ns = api.namespace('line',
                   description='Operations to get lines displayed on the clock')


@ns.route('/<int(min=0, max=1):lineno>')
@api.response(404, 'Line not found.')
class LineEP(Resource):
    """
    Endpoint to get the lines to be displayed on the clock.
    """

    def get(self, lineno):
        """
        Get the messages queued for a line.
        """
        lineno = int(lineno)
        plugin = None
        ret = {'text': '', 'icon': '', 'seconds': 0}
        plugin_queue = None

        if lineno == 0:
            plugin_queue = L1_DATASOURCES
コード例 #7
0
from bson.errors import InvalidId
from flask_restplus import abort
from mongoengine import ValidationError
from werkzeug.utils import redirect

from app import models
from app.api import api
from app.api.endpoints import Task, TaskList
from app.models import StatusEnum

ns = api.namespace('images_tasks')


@ns.route('/')
class ImagesTaskList(TaskList):
    @property
    def model(self):
        return models.ImageTask

    @property
    def queryset(self):
        return super().queryset.exclude('images')

    @property
    def celery_task(self):
        from app import celery_tasks
        return celery_tasks.execute_images_task


@ns.route('/<string:tid>')
class ImagesTask(Task):
コード例 #8
0
# Importing Flask and dependencies
from flask import Blueprint, jsonify, request, make_response
from flask_restx import Resource, abort
from app.api import api
import os

# Import model and db
from app import db
from app.api.developer.model import Developer, DeveloperSchema, DeveloperRestSchema, DeveloperReturnSchema

# Defining namespace
developer_namespace = api.namespace(os.path.basename(
    os.path.dirname(os.path.realpath(__file__))),
                                    description='Manage developers.')


## Defining reoutes
@developer_namespace.route('/<int:id>')
class DeveloperApiOne(Resource):
    def get(self, id):
        if id is None:
            abort(400)
        developer_data = Developer.query.get(id)
        developer_schema = DeveloperSchema()
        retval = developer_schema.dump(developer_data)

        if not retval:
            abort(404, 'The requested data with id: %d does not exist.' % (id))

        return jsonify(retval)
コード例 #9
0
from flask import request
from flask_restplus import Resource, fields

from app.message import Message
from app.queue import L2_DATASOURCES
from app.api import api

ns = api.namespace(
    'message',
    description='Operations to add messages to be displayed on the clock')

message = api.model(
    'Message', {
        'text':
        fields.String(description='The text of the messae'),
        'icon':
        fields.String(description='Optional URL to an icon to include'),
        'repeat':
        fields.Integer(description='Number times to display the message'),
        'interval_sec':
        fields.Integer(
            description='Minimum number of seconds between message repeats'),
        'display_sec':
        fields.Integer(
            description='Minimum number of seconds the messaage is visible')
    })


@ns.route('/')
@api.expect(message)
@api.response(404, 'Message was not added.')
コード例 #10
0
from http import HTTPStatus

from flask_restplus import Resource
from flask import jsonify, request, abort, make_response
from app.api import api
from app.validators import UserValidator
from app.models import User
from app.extensions import db

user_namespace = api.namespace('users/', description='User management API')
api.add_namespace(user_namespace)


@user_namespace.route('/user/')
class UsersResource(Resource):
    """ Describes HTTP methods of users endpoint
    """
    @api.expect(UserValidator.fields)
    def post(self):
        """ User Sign Up
        """
        data = request.json
        errors = UserValidator.RequestValidator().validate(data)
        if errors:
            abort(HTTPStatus.UNPROCESSABLE_ENTITY, str(errors))

        User.create(data)

        return make_response(jsonify({"message": "User has created"}))

    @api.expect(UserValidator.fields)