Flask API, jakie podejście jest lepsze

Witam, pytanie jakie podejście do budowy API jest lepsze.

1. flask_restful

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


class RemoveProducts(Resource):
    def post(self):
        try:
            pass
        except Exception as e:
            pass

api.add_resource(RemoveProducts,'/api/products/remove')

2. flask

app = Flask(__name__)

@app.route("/api2/products/remove", methods=['POST'])
def remove():
    try:
            pass
    except Exception as e:
            pass 

Z tego co testowałem oba sposoby mają z podstaw te same możliwości. Ale jakby ktoś bardziej doświadczony potrafił wymienić kluczowe różnice, oraz inne możliwości był bym wdzięczny.

Wydaje mi się, że pierwsze podejście warto stosować kiedy budujesz REST API, możesz zamknąć wszystkie metody w jednej klasie, przykład:

 
class UsersResource(Resource):
 def get():
  pass

 def post():
  pass

 def put():
  pass
 
 def delete():
  pass

Hej tak też mi się zdaje 2 podejście fajniejsze, tylko jak pod odwołanie

api.add_resource podpiąć @app.errorhandler(InvalidUsage) z tym mam problem ;(
pod @app.route działa mi prawidłowo.

Jak to u mnie wygląda pod app.route

Mam classe odpowiedzialną za budowę exception, przebudowałem ją i wrzucam sobie tutaj wszystko.

class InvalidUsage(Exception):
    status_code = 400

    def __init__(self, message, status_code=None, payload=None):
        Exception.__init__(self)
        self.message = message
        if status_code is not None:
            self.status_code = status_code
        self.payload = payload

    def to_dict(self):
        rv = dict()
        rv['status'] = "Error"
        rv['errorCode'] = self.status_code
        rv['message'] = self.message
        if self.payload is not None:
            rv['dateContent'] = self.payload
        return rv
 

następnie

w apce wbijam to

@app.errorhandler(InvalidUsage)
def handle_invalid_usage(error):
    response = jsonify(error.to_dict())
    response.status_code = error.status_code
    return response
 

i przykładowe wywołanie kodu

 
except Exception as e:
        myrequest = content
        raise InvalidUsage(e.message,400,myrequest)

Gdzie content to są dane wysłane od klienta.

I coś podobnego właśnie chciał bym zbudować w dla api.add_resource

Zbudowałem sobie też klasę odpowiedzialną za zwracanie informacji w określonym formacie ;) żeby zawsze było tak samo

class ApiResponse(object):

    @staticmethod
    def standard(status,dateContent,message=None):

        response = dict()
        response['status'] = 'Success' if status else 'Error'
        response['message'] = message 
        response['dateContent'] = dateContent

        return jsonify(response)

i taki przykład jak u mnie to wygląda

 
# pobieranie
@app.route("/api/reports/<int:report_id>", methods=['GET'])
def getreport(report_id):
     
    try:
        reports = mongo.db.reports
        exist_rep = reports.find_one({'report_id' : int(report_id)})

        if exist_rep is not None:

            resp = {}
            if '_id' in exist_rep:
                del exist_rep['_id']
                
            resp['report_id'] = report_id
            resp['report_name'] = exist_rep['report_name']
            resp['report'] = exist_rep['report_content']
            resp['report_object'] = exist_rep 

            return ApiResponse.standard(True,resp,"Success Find")

        else:
            resp = {}
            resp['report_id'] = report_id
            return ApiResponse.standard(False,resp,"Don't finds reports")
               
    except Exception as e:
        raise InvalidUsage("Dont find raport name: %s" % e.message) 

być może to jest też rozwiązanie dla zwracania informacji, tylko jak mi się coś wysypie gdzieś głebiej to też chciał bym mieć powiedzmy możliwość wyrzucania exceptiona

Jeśli korzystasz z Flask-RESTFul to czy rozwiązaniem problemu nie będzie skorzystanie z: http://flask-restful-cn.readthedocs.io/en/0.3.4/extending.html#custom-error-handlers