Add ratings to API

app.py

@@ -1214,6 +1214,13 @@ def query_pictures():

                                
                                
                                
                            
                                
                                    
                                        
                                            1214  
                                                except APIError as e:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1215  
                                                    return flask.jsonify({"error": e.message}), e.status_code
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1216  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1217 +
                                            rating_count_subquery = db.select(db.func.count(PictureRating.id)).where(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1218 +
                                                PictureRating.resource_id == PictureResource.id).scalar_subquery()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1219 +
                                            region_count_subquery = db.select(db.func.count(PictureRegion.id)).where(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1220 +
                                                PictureRegion.resource_id == PictureResource.id).scalar_subquery()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1221 +
                                            rating_subquery = db.select(db.func.coalesce(db.func.avg(PictureRating.rating), 0)).where(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1222 +
                                                PictureRating.resource_id == PictureResource.id).scalar_subquery()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1223 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1224  
                                                match ordering:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1225  
                                                    case "date-desc":
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1226  
                                                        query = query.order_by(PictureResource.timestamp.desc())
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -1226,9 +1233,17 @@ def query_pictures():

                                
                                
                                
                            
                                
                                    
                                        
                                            1233  
                                                    case "random":
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1234  
                                                        query = query.order_by(db.func.random())
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1235  
                                                    case "number-regions-desc":
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1229 -
                                                    query = query.order_by(db.func.count(PictureResource.regions).desc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1236 +
                                                    query = query.order_by(region_count_subquery.desc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1237  
                                                    case "number-regions-asc":
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1231 -
                                                    query = query.order_by(db.func.count(PictureResource.regions).asc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1238 +
                                                    query = query.order_by(region_count_subquery.asc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1239 +
                                                case "rating-desc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1240 +
                                                    query = query.order_by(rating_subquery.desc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1241 +
                                                case "rating-asc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1242 +
                                                    query = query.order_by(rating_subquery.asc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1243 +
                                                case "number-ratings-desc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1244 +
                                                    query = query.order_by(rating_count_subquery.desc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1245 +
                                                case "number-ratings-asc":
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1246 +
                                                    query = query.order_by(rating_count_subquery.asc())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1247  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1248  
                                                query = query.offset(offset).limit(limit)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1249  
                                                resources = query.all()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -1294,6 +1309,8 @@ def api_picture(id):

                                
                                
                                
                            
                                
                                    
                                        
                                            1309  
                                                    "replaced_by": resource.replaced_by_id,
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1310  
                                                    "regions": [],
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1311  
                                                    "download": config.ROOT_URL + flask.url_for("raw_picture", id=resource.id),
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1312 +
                                                "rating_average": resource.average_rating,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1313 +
                                                "rating_count": resource.rating_totals,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1314  
                                                }
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1315  
                                                for region in resource.regions:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1316  
                                                    json_resource["regions"].append({
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -1504,3 +1521,39 @@ def api_update_picture(id):

                                
                                
                                
                            
                                
                                    
                                        
                                            1521  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1522  
                                                return flask.jsonify({"message": "Picture updated successfully"})
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            1523  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1524 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1525 +
                                        @app.route("/api/picture/<int:id>/rate", methods=["POST"])
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1526 +
                                        def api_rate_picture(id):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1527 +
                                            resource = db.session.get(PictureResource, id)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1528 +
                                            if resource is None:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1529 +
                                                flask.abort(404)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1530 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1531 +
                                            current_user = db.session.get(User, flask.session.get("username"))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1532 +
                                            if current_user is None:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1533 +
                                                flask.abort(401)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1534 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1535 +
                                            rating = int(flask.request.json.get("rating"))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1536 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1537 +
                                            if not rating:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1538 +
                                                # Delete the existing rating
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1539 +
                                                if PictureRating.query.filter_by(resource=resource, user=current_user).first():
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1540 +
                                                    db.session.delete(PictureRating.query.filter_by(resource=resource,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1541 +
                                                                                                     user=current_user).first())
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1542 +
                                                    db.session.commit()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1543 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1544 +
                                                return flask.jsonify({"message": "Existing rating removed"})
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1545 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1546 +
                                            if not 1 <= rating <= 5:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1547 +
                                                flask.flash("Invalid rating")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1548 +
                                                return flask.jsonify({"error": "Invalid rating"}), 400
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1549 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1550 +
                                            if PictureRating.query.filter_by(resource=resource, user=current_user).first():
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1551 +
                                                PictureRating.query.filter_by(resource=resource, user=current_user).first().rating = rating
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1552 +
                                            else:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1553 +
                                                # Create a new rating
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1554 +
                                                db.session.add(PictureRating(resource, current_user, rating))
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1555 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1556 +
                                            db.session.commit()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1557 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1558 +
                                            return flask.jsonify({"message": "Rating saved"})
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        1559 +