API error handling

app.py

@@ -10,6 +10,7 @@ from flask_httpauth import HTTPBasicAuth

                                
                                
                                
                            
                                
                                    
                                        
                                            10  
                                            from markupsafe import escape, Markup
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            11  
                                            from flask_migrate import Migrate, current
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            12  
                                            from jinja2_fragments.flask import render_block
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        13 +
                                        from sqlalchemy import false
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            14  
                                            from sqlalchemy.orm import backref
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            15  
                                            import sqlalchemy.dialects.postgresql
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            16  
                                            from os import path
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -1010,6 +1011,12 @@ def gallery_remove_user(id):

                                
                                
                                
                            
                                
                                    
                                        
                                            1011  
                                                return flask.redirect("/gallery/" + str(gallery.id) + "/users")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1012  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1013  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1014 +
                                        class APIError(Exception):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1015 +
                                            def __init__(self, status_code, message):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1016 +
                                                self.status_code = status_code
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1017 +
                                                self.message = message
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1018 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1019 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1020  
                                            def get_picture_query(query_data):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1021  
                                                query = db.session.query(PictureResource)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1022  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -1038,16 +1045,24 @@ def get_picture_query(query_data):

                                
                                
                                
                            
                                
                                    
                                        
                                            1045  
                                                }
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1046  
                                                if "want" in query_data:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1047  
                                                    for i in query_data["want"]:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1048 +
                                                    if len(i) != 1:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1049 +
                                                        raise APIError(400, "Each requirement must have exactly one key")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1050  
                                                        requirement, value = list(i.items())[0]
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1042 -
                                                    condition = requirement_conditions.get(requirement)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1043 -
                                                    if condition:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1044 -
                                                        query = query.filter(condition(value))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1051 +
                                                    if requirement not in requirement_conditions:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1052 +
                                                        raise APIError(400, f"Unknown requirement type: {requirement}")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1053 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1054 +
                                                    condition = requirement_conditions[requirement]
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1055 +
                                                    query = query.filter(condition(value))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1056  
                                                if "exclude" in query_data:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1057  
                                                    for i in query_data["exclude"]:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1058 +
                                                    if len(i) != 1:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1059 +
                                                        raise APIError(400, "Each exclusion must have exactly one key")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1060  
                                                        requirement, value = list(i.items())[0]
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1048 -
                                                    condition = requirement_conditions.get(requirement)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1049 -
                                                    if condition:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1050 -
                                                        query = query.filter(~condition(value))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1061 +
                                                    if requirement not in requirement_conditions:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1062 +
                                                        raise APIError(400, f"Unknown requirement type: {requirement}")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1063 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1064 +
                                                    condition = requirement_conditions[requirement]
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1065 +
                                                    query = query.filter(~condition(value))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1066  
                                                if not query_data.get("include_obsolete", False):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1067  
                                                    query = query.filter(PictureResource.replaced_by_id.is_(None))
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1068  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -1064,7 +1079,10 @@ def graphical_query_pictures_results():

                                
                                
                                
                            
                                
                                    
                                        
                                            1079  
                                                query_yaml = flask.request.args.get("query", "")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1080  
                                                yaml_parser = yaml.YAML()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1081  
                                                query_data = yaml_parser.load(query_yaml) or {}
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1067 -
                                            query = get_picture_query(query_data)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1082 +
                                            try:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1083 +
                                                query = get_picture_query(query_data)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1084 +
                                            except APIError as e:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1085 +
                                                flask.abort(e.status_code)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1086  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1087  
                                                page = int(flask.request.args.get("page", 1))
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1088  
                                                per_page = int(flask.request.args.get("per_page", 16))
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -1110,7 +1128,10 @@ def query_pictures():

                                
                                
                                
                            
                                
                                    
                                        
                                            1128  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1129  
                                                yaml_parser = yaml.YAML()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1130  
                                                query_data = yaml_parser.load(flask.request.data) or {}
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1113 -
                                            query = get_picture_query(query_data)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1131 +
                                            try:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1132 +
                                                query = get_picture_query(query_data)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1133 +
                                            except APIError as e:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1134 +
                                                return flask.jsonify({"error": e.message}), e.status_code
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1135  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1136  
                                                match ordering:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1137  
                                                    case "date-desc":