Beispiel #1
0
class DealList(Resource):
    sender = Sender(broker, addr_deals)
    sender.init()

    def get(self):
        parser = reqparse.RequestParser()
        parser.add_argument('bond_key_listed_market')
        args = parser.parse_args()
        bond_key_listed_market = args['bond_key_listed_market']
        print 'bond_key_listed_market:', bond_key_listed_market
        t = time.clock()
        response = self.sender.sync_send(Message(
            content={'bond_key_listed_market': bond_key_listed_market},
            correlation_id='deals_list'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch deal list failed.")
Beispiel #2
0
class MoneyOrderList(Resource):
    sender = Sender(broker, addr_money_order)
    sender.init()

    def get(self):
        t = time.clock()
        response = self.sender.sync_send(Message(correlation_id='order_list'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch money order list failed.")

    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument('order_list', type=list, location='json')
        args = parser.parse_args()
        print args
        order_list = args['order_list']
        self.sender.send(
            Message(content=json.dumps(order_list),
                    correlation_id='money_order_add'))
        # response = sender.sync_send(Message(content=json.dumps(task_list), correlation_id='task_add'), timeout=3)
        # update_list = json.loads(response.content)
        return '', 202
Beispiel #3
0
class ResearchTask(Resource):
    sender = Sender(broker, addr_research_task)
    sender.init()

    def get(self, task_id):
        t = time.clock()
        response = self.sender.sync_send(Message(content={'task_id': task_id},
                                                 correlation_id='task'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch research task failed.")

    def put(self, task_id):
        parser = reqparse.RequestParser()
        parser.add_argument('task', type=dict, location='json')
        args = parser.parse_args()
        print args
        task = args['task']
        task['task_id'] = task_id
        task_list = [task]

        self.sender.send(
            Message(content=json.dumps(task_list),
                    correlation_id='task_update'))
        # response = sender.sync_send(Message(content=json.dumps(task_list), correlation_id='task_add'), timeout=3)
        # update_list = json.loads(response.content)
        return '', 202
        # return update_list
        # task_list = json.loads(args['task_list'])
        # print task_list

    def delete(self, task_id):
        task_list = [task_id]
        self.sender.send(
            Message(content=json.dumps(task_list),
                    correlation_id='task_delete'))
        # response = sender.sync_send(Message(content=json.dumps(task_list), correlation_id='task_delete'), timeout=3)
        # update_list = json.loads(response.content)
        return '', 202
Beispiel #4
0
class BondList(Resource):
    sender = Sender(broker, addr_bonds)
    sender.init()

    def get(self):
        t = time.clock()
        response = self.sender.sync_send(Message(correlation_id='bond_list'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch bond list failed.")
Beispiel #5
0
class CDCData(Resource):
    sender = Sender(broker, addr_cdc_data)
    sender.init()

    def get(self, bond_key_listed_market):
        t = time.clock()
        response = self.sender.sync_send(Message(
            content={'bond_key_listed_market': bond_key_listed_market},
            correlation_id='cdc_single'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch cdc data failed.")
Beispiel #6
0
class PrimaryMarketBond(Resource):
    sender = Sender(broker, addr_primary_market)
    sender.init()

    def get(self, bond_key_listed_market):
        t = time.clock()
        response = self.sender.sync_send(Message(
            content={'bond_key_listed_market': bond_key_listed_market},
            correlation_id='pmbond'),
                                         timeout=5)
        print '[pmbond] get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch primary bond failed.")
Beispiel #7
0
class InvestableBond(Resource):
    sender = Sender(broker, addr_investment_pool)
    sender.init()

    def get(self, bond_key_listed_market):
        t = time.clock()
        response = self.sender.sync_send(Message(
            content={'bond_key_listed_market': bond_key_listed_market},
            correlation_id='investable_bond'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch investable bond failed.")

    def put(self, bond_key_listed_market):
        parser = reqparse.RequestParser()
        parser.add_argument('investable_bond', type=list, location='json')
        args = parser.parse_args()
        print args
        investable_bond = args['investable_bond']
        investable_bond['bond_key_listed_market'] = bond_key_listed_market
        investable_bond_list = [investable_bond]

        self.sender.send(
            Message(content=json.dumps(investable_bond_list),
                    correlation_id='investment_pool_update'))
        return '', 202

    def delete(self, bond_key_listed_market):
        investable_bond_list = [bond_key_listed_market]
        self.sender.send(
            Message(content=json.dumps(investable_bond_list),
                    correlation_id='investment_pool_delete'))
        return '', 202
Beispiel #8
0
class ResearchTaskList(Resource):
    sender = Sender(broker, addr_research_task)
    sender.init()

    def get(self):
        parser = reqparse.RequestParser()
        parser.add_argument('task_type')
        parser.add_argument('confirmed')
        args = parser.parse_args()
        task_type = args['task_type']
        confirmed = args['confirmed']
        print 'task_type:', task_type, 'confirmed:', confirmed
        t = time.clock()
        response = self.sender.sync_send(Message(content={
            'task_type': task_type,
            'confirmed': confirmed,
        },
                                                 correlation_id='task_list'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch research task list failed.")

    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument('task_list', type=list, location='json')
        args = parser.parse_args()
        print args
        task_list = args['task_list']
        self.sender.send(
            Message(content=json.dumps(task_list), correlation_id='task_add'))
        # response = sender.sync_send(Message(content=json.dumps(task_list), correlation_id='task_add'), timeout=3)
        # update_list = json.loads(response.content)
        return '', 202
Beispiel #9
0
class MoneyOrder(Resource):
    sender = Sender(broker, addr_money_order)
    sender.init()

    def get(self, order_id):
        t = time.clock()
        response = self.sender.sync_send(Message(
            content={'order_id': order_id}, correlation_id='single_order'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch secondary order failed.")

    def put(self, order_id):
        parser = reqparse.RequestParser()
        parser.add_argument('order', type=list, location='json')
        args = parser.parse_args()
        print args
        order = args['order']
        order['order_id'] = order_id
        order_list = [order]

        self.sender.send(
            Message(content=json.dumps(order_list),
                    correlation_id='money_order_update'))
        return '', 202

    def delete(self, order_id):
        order_list = [order_id]
        self.sender.send(
            Message(content=json.dumps(order_list),
                    correlation_id='money_order_delete'))
        return '', 202
Beispiel #10
0
class AccountCashImport(Resource):
    sender = Sender(broker, addr_cash)
    sender.init()

    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument('filter_params', type=dict, location='json')
        args = parser.parse_args()
        filter_params = args['filter_params']
        t = time.clock()
        response = self.sender.sync_send(Message(
            content=json.dumps(filter_params), correlation_id='import'),
                                         timeout=30)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch account cash failed.")
Beispiel #11
0
class InvestableBondList(Resource):
    sender = Sender(broker, addr_investment_pool)
    sender.init()

    def get(self):
        parser = reqparse.RequestParser()
        parser.add_argument('investable')
        args = parser.parse_args()
        investable = args['investable']
        print 'investable:', investable
        t = time.clock()
        response = self.sender.sync_send(Message(
            content={'investable': investable},
            correlation_id='investment_pool'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp
            except:
                pass

        abort(404, message="fetch investable bond list failed.")

    def post(self):
        parser = reqparse.RequestParser()
        parser.add_argument('investable_bond_list', type=list, location='json')
        args = parser.parse_args()
        print args
        investable_bond_list = args['investable_bond_list']
        self.sender.send(
            Message(content=json.dumps(investable_bond_list),
                    correlation_id='investment_pool_add'))
        return '', 202
Beispiel #12
0
from eventlet.wsgi import server
from flask import Flask, make_response
from flask_restful import Api, Resource, reqparse, abort
from flask_cors import CORS

from qpid_helper import Sender, Message

app = Flask(__name__)
api = Api(app)
CORS(app)

broker = '127.0.0.1'

addr_demo = 'demo.service'

sender = Sender(broker, addr_demo)
sender.init()


class Demo1(Resource):
    def get(self, key):
        t = time.clock()
        response = self.sender.sync_send(Message(content={'key': key},
                                                 correlation_id='demo1'),
                                         timeout=3)
        print 'get cost time: {}'.format(time.clock() - t)
        if response:
            try:
                resp = make_response(zlib.decompress(response.content))
                resp.headers['content-type'] = 'text/plain'
                return resp