Merge pull request #6811 from fossasia/development

chore: Release v1.12.0

Author: iamareebjamal

.flake8.ini .flake8.flake8.ini renamed to .flake8

@@ -1,5 +1,5 @@
 [flake8]
-max-line-length = 120
+max-line-length = 90
 exclude =
     .git,
     __pycache__,

.hound.yml

@@ -1,3 +1,3 @@
 python:
   enabled: true
-  config_file: .flake8.ini
+  config_file: .flake8

.pre-commit-config.yaml

@@ -0,0 +1,6 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: stable
+    hooks:
+    - id: black
+      language_version: python3.7

CHANGELOG.md

@@ -1,5 +1,11 @@
 ## Changelog
 
+#### v1.12.0 (2020-02-02):
+
+- Add check if donation ticket has payment method enabled
+- Fix general event statistics type
+- Internal refactoring and code cleanup
+
 #### v1.11.2 (2020-01-25):
 
 - Fix celery task status endpoint

app/__init__.py

@@ -4,24 +4,28 @@
 
 from app.api.bootstrap import api
 from app.api.helpers.db import safe_query
-from app.api.helpers.exceptions import ForbiddenException, ConflictException
-from app.api.helpers.exceptions import UnprocessableEntity
+from app.api.helpers.exceptions import (
+    ConflictException,
+    ForbiddenException,
+    UnprocessableEntity,
+)
 from app.api.helpers.permission_manager import has_access
 from app.api.helpers.permissions import jwt_required
 from app.api.helpers.query import event_query
 from app.api.helpers.utilities import require_relationship
 from app.api.schema.access_codes import AccessCodeSchema
 from app.models import db
 from app.models.access_code import AccessCode
+from app.models.event import Event
 from app.models.ticket import Ticket
 from app.models.user import User
-from app.models.event import Event
 
 
 class AccessCodeListPost(ResourceList):
     """
     Create AccessCodes
     """
+
     def before_post(self, args, kwargs, data):
         """
         before post method to check for required relationships and permissions
@@ -45,28 +49,39 @@ def before_create_object(self, data, view_kwargs):
             for ticket in data['tickets']:
                 # Ensuring that the ticket exists and is hidden.
                 try:
-                    ticket_object = self.session.query(Ticket).filter_by(id=int(ticket),
-                                                                         deleted_at=None).one()
+                    ticket_object = (
+                        self.session.query(Ticket)
+                        .filter_by(id=int(ticket), deleted_at=None)
+                        .one()
+                    )
                     if not ticket_object.is_hidden:
-                        raise ConflictException({'pointer': '/data/relationships/tickets'},
-                                                "Ticket with id {} is public.".format(ticket) +
-                                                " Access code cannot be applied to public tickets")
+                        raise ConflictException(
+                            {'pointer': '/data/relationships/tickets'},
+                            "Ticket with id {} is public.".format(ticket)
+                            + " Access code cannot be applied to public tickets",
+                        )
                 except NoResultFound:
-                    raise ConflictException({'pointer': '/data/relationships/tickets'},
-                                            "Ticket with id {} does not exists".format(str(ticket)))
+                    raise ConflictException(
+                        {'pointer': '/data/relationships/tickets'},
+                        "Ticket with id {} does not exists".format(str(ticket)),
+                    )
 
     schema = AccessCodeSchema
-    methods = ['POST', ]
-    data_layer = {'session': db.session,
-                  'model': AccessCode,
-                  'methods': {'before_create_object': before_create_object
-                              }}
+    methods = [
+        'POST',
+    ]
+    data_layer = {
+        'session': db.session,
+        'model': AccessCode,
+        'methods': {'before_create_object': before_create_object},
+    }
 
 
 class AccessCodeList(ResourceList):
     """
     List AccessCodes
     """
+
     def query(self, view_kwargs):
         """
         Method to get access codes list based on different view_kwargs
@@ -90,19 +105,22 @@ def query(self, view_kwargs):
         return query_
 
     view_kwargs = True
-    methods = ['GET', ]
+    methods = [
+        'GET',
+    ]
     schema = AccessCodeSchema
-    data_layer = {'session': db.session,
-                  'model': AccessCode,
-                  'methods': {
-                      'query': query,
-                  }}
+    data_layer = {
+        'session': db.session,
+        'model': AccessCode,
+        'methods': {'query': query,},
+    }
 
 
 class AccessCodeDetail(ResourceDetail):
     """
     AccessCode detail by id or code
     """
+
     def before_get(self, args, kwargs):
         """
         before get method of access code details.
@@ -115,12 +133,21 @@ def before_get(self, args, kwargs):
 
         if kwargs.get('access_event_identifier'):
             event = safe_query(
-                db, Event, 'identifier', kwargs['access_event_identifier'],
-                'event_identifier')
+                db,
+                Event,
+                'identifier',
+                kwargs['access_event_identifier'],
+                'event_identifier',
+            )
             kwargs['access_event_id'] = event.id
         if kwargs.get('code') and kwargs.get('access_event_id'):
-            access = db.session.query(AccessCode).filter_by(code=kwargs.get('code'),
-                                                            event_id=kwargs.get('access_event_id')).first()
+            access = (
+                db.session.query(AccessCode)
+                .filter_by(
+                    code=kwargs.get('code'), event_id=kwargs.get('access_event_id')
+                )
+                .first()
+            )
             if access:
                 kwargs['id'] = access.id
             else:
@@ -134,35 +161,44 @@ def before_get(self, args, kwargs):
                 raise ObjectNotFound({'parameter': '{id}'}, "Access Code:  not found")
 
             if not has_access('is_coorganizer', event_id=access.event_id):
-                raise UnprocessableEntity({'source': ''},
-                                          "Please verify your permission")
-
-    decorators = (api.has_permission('is_coorganizer', fetch='event_id',
-                  fetch_as="event_id", model=AccessCode, methods="PATCH"),
-                  api.has_permission('is_coorganizer_but_not_admin', fetch='event_id',
-                  fetch_as="event_id", model=AccessCode, methods="DELETE"),)
+                raise UnprocessableEntity({'source': ''}, "Please verify your permission")
+
+    decorators = (
+        api.has_permission(
+            'is_coorganizer',
+            fetch='event_id',
+            fetch_as="event_id",
+            model=AccessCode,
+            methods="PATCH",
+        ),
+        api.has_permission(
+            'is_coorganizer_but_not_admin',
+            fetch='event_id',
+            fetch_as="event_id",
+            model=AccessCode,
+            methods="DELETE",
+        ),
+    )
     schema = AccessCodeSchema
-    data_layer = {'session': db.session,
-                  'model': AccessCode
-                  }
+    data_layer = {'session': db.session, 'model': AccessCode}
 
 
 class AccessCodeRelationshipRequired(ResourceRelationship):
     """
     AccessCode Relationship Required
     """
+
     decorators = (jwt_required,)
     methods = ['GET', 'PATCH']
     schema = AccessCodeSchema
-    data_layer = {'session': db.session,
-                  'model': AccessCode}
+    data_layer = {'session': db.session, 'model': AccessCode}
 
 
 class AccessCodeRelationshipOptional(ResourceRelationship):
     """
     AccessCode Relationship Optional
     """
+
     decorators = (jwt_required,)
     schema = AccessCodeSchema
-    data_layer = {'session': db.session,
-                  'model': AccessCode}
+    data_layer = {'session': db.session, 'model': AccessCode}

app/api/access_codes.py

@@ -10,19 +10,23 @@ class ActivityList(ResourceList):
     """
     List and create activity
     """
+
     schema = ActivitySchema
-    methods = ['GET', ]
-    decorators = (api.has_permission('is_admin', ),)
-    data_layer = {'session': db.session,
-                  'model': Activity}
+    methods = [
+        'GET',
+    ]
+    decorators = (api.has_permission('is_admin',),)
+    data_layer = {'session': db.session, 'model': Activity}
 
 
 class ActivityDetail(ResourceDetail):
     """
     Activity detail by id
     """
+
     schema = ActivitySchema
-    methods = ['GET', ]
-    decorators = (api.has_permission('is_admin', ),)
-    data_layer = {'session': db.session,
-                  'model': Activity}
+    methods = [
+        'GET',
+    ]
+    decorators = (api.has_permission('is_admin',),)
+    data_layer = {'session': db.session, 'model': Activity}

app/api/activities.py

@@ -1,10 +1,10 @@
-from sqlalchemy import func
 from flask_rest_jsonapi import ResourceList
 from marshmallow_jsonapi import fields
 from marshmallow_jsonapi.flask import Schema
+from sqlalchemy import func
 
-from app.api.helpers.utilities import dasherize
 from app.api.bootstrap import api
+from app.api.helpers.utilities import dasherize
 from app.models import db
 from app.models.discount_code import DiscountCode
 from app.models.event import Event
@@ -13,20 +13,24 @@
 
 
 def sales_per_marketer_and_discount_by_status(status):
-    return db.session.query(Event.id.label('event_id'),
-                            DiscountCode.id.label('discount_code_id'),
-                            User.id.label('marketer_id'),
-                            func.sum(Order.amount).label(status + '_sales'),
-                            func.sum(OrderTicket.quantity).label(status + '_tickets')) \
-                     .filter(Event.id == Order.event_id) \
-                     .filter(Order.marketer_id == User.id) \
-                     .filter(Order.discount_code_id == DiscountCode.id) \
-                     .filter(Order.status == status) \
-                     .group_by(Event) \
-                     .group_by(DiscountCode) \
-                     .group_by(User) \
-                     .group_by(Order.status) \
-                     .cte()
+    return (
+        db.session.query(
+            Event.id.label('event_id'),
+            DiscountCode.id.label('discount_code_id'),
+            User.id.label('marketer_id'),
+            func.sum(Order.amount).label(status + '_sales'),
+            func.sum(OrderTicket.quantity).label(status + '_tickets'),
+        )
+        .filter(Event.id == Order.event_id)
+        .filter(Order.marketer_id == User.id)
+        .filter(Order.discount_code_id == DiscountCode.id)
+        .filter(Order.status == status)
+        .group_by(Event)
+        .group_by(DiscountCode)
+        .group_by(User)
+        .group_by(Order.status)
+        .cte()
+    )
 
 
 class AdminSalesDiscountedSchema(Schema):
@@ -80,38 +84,44 @@ def query(self, _):
         completed = sales_per_marketer_and_discount_by_status('completed')
         placed = sales_per_marketer_and_discount_by_status('placed')
 
-        discounts = self.session.query(Event.id.label('event_id'),
-                                       Event.name.label('event_name'),
-                                       DiscountCode.id.label('discount_code_id'),
-                                       DiscountCode.code.label('code'),
-                                       User.id.label('marketer_id'),
-                                       User.email.label('email')) \
-                                .filter(Event.id == Order.event_id) \
-                                .filter(Order.marketer_id == User.id) \
-                                .filter(Order.discount_code_id == DiscountCode.id) \
-                                .cte()
-
-        return self.session.query(discounts, pending, completed, placed) \
-                           .outerjoin(pending,
-                                      (pending.c.event_id == discounts.c.event_id) &
-                                      (pending.c.discount_code_id == discounts.c.discount_code_id) &
-                                      (pending.c.marketer_id == discounts.c.marketer_id)) \
-                           .outerjoin(completed,
-                                      (completed.c.event_id == discounts.c.event_id) &
-                                      (completed.c.discount_code_id == discounts.c.discount_code_id) &
-                                      (completed.c.marketer_id == discounts.c.marketer_id)) \
-                           .outerjoin(placed,
-                                      (placed.c.event_id == discounts.c.event_id) &
-                                      (placed.c.discount_code_id == discounts.c.discount_code_id) &
-                                      (placed.c.marketer_id == discounts.c.marketer_id))
+        discounts = (
+            self.session.query(
+                Event.id.label('event_id'),
+                Event.name.label('event_name'),
+                DiscountCode.id.label('discount_code_id'),
+                DiscountCode.code.label('code'),
+                User.id.label('marketer_id'),
+                User.email.label('email'),
+            )
+            .filter(Event.id == Order.event_id)
+            .filter(Order.marketer_id == User.id)
+            .filter(Order.discount_code_id == DiscountCode.id)
+            .cte()
+        )
+
+        return (
+            self.session.query(discounts, pending, completed, placed)
+            .outerjoin(
+                pending,
+                (pending.c.event_id == discounts.c.event_id)
+                & (pending.c.discount_code_id == discounts.c.discount_code_id)
+                & (pending.c.marketer_id == discounts.c.marketer_id),
+            )
+            .outerjoin(
+                completed,
+                (completed.c.event_id == discounts.c.event_id)
+                & (completed.c.discount_code_id == discounts.c.discount_code_id)
+                & (completed.c.marketer_id == discounts.c.marketer_id),
+            )
+            .outerjoin(
+                placed,
+                (placed.c.event_id == discounts.c.event_id)
+                & (placed.c.discount_code_id == discounts.c.discount_code_id)
+                & (placed.c.marketer_id == discounts.c.marketer_id),
+            )
+        )
 
     methods = ['GET']
-    decorators = (api.has_permission('is_admin'), )
+    decorators = (api.has_permission('is_admin'),)
     schema = AdminSalesDiscountedSchema
-    data_layer = {
-        'model': Event,
-        'session': db.session,
-        'methods': {
-            'query': query
-        }
-    }
+    data_layer = {'model': Event, 'session': db.session, 'methods': {'query': query}}