added requestcounts endpoint

server/src/app.py

@@ -11,6 +11,7 @@
 from services.time_to_close import time_to_close
 from services.frequency import frequency
 from services.pinService import PinService
+from services.requestCountsService import RequestCountsService
 from services.requestDetailService import RequestDetailService
 from services.ingress_service import ingress_service
 from services.sqlIngest import DataHandler
@@ -140,6 +141,25 @@ async def pinMap(request):
     return json(return_data)
 
 
+@app.route('/requestcounts', methods=["POST"])
+@compress.compress()
+async def requestCounts(request):
+    counts_worker = RequestCountsService(app.config['Settings'])
+    postArgs = request.json
+    start = postArgs.get('startDate', None)
+    end = postArgs.get('endDate', None)
+    ncs = postArgs.get('ncList', [])
+    requests = postArgs.get('requestTypes', [])
+    countFields = postArgs.get('countFields', [])
+
+    return_data = await counts_worker.get_req_counts(startDate=start,
+                                                     endDate=end,
+                                                     ncList=ncs,
+                                                     requestTypes=requests,
+                                                     countFields=countFields)
+    return json(return_data)
+
+
 @app.route('/servicerequest/<srnumber>', methods=["GET"])
 async def requestDetails(request, srnumber):
     detail_worker = RequestDetailService(app.config['Settings'])

server/src/services/dataService.py

@@ -1,20 +1,23 @@
 import datetime
 import pandas as pd
 import sqlalchemy as db
+from sqlalchemy.orm import sessionmaker
 
 
 class DataService(object):
+    def withMeta(dataResponse):
+        # Will represent last time the ingest pipeline ran
+        lastPulledTimestamp = datetime.datetime.utcnow()
+        return {'lastPulled': lastPulledTimestamp,
+                'data': dataResponse}
+
     def includeMeta(func):
         def innerFunc(*args, **kwargs):
             dataResponse = func(*args, **kwargs)
             if 'Error' in dataResponse:
                 return dataResponse
 
-            # Will represent last time the ingest pipeline ran
-            lastPulledTimestamp = datetime.datetime.utcnow()
-            withMeta = {'lastPulled': lastPulledTimestamp,
-                        'data': dataResponse}
-            return withMeta
+            return DataService.withMeta(dataResponse)
 
         return innerFunc
 
@@ -26,6 +29,7 @@ def __init__(self, config=None, tableName="ingest_staging_table"):
         self.table = tableName
         self.data = None
         self.engine = db.create_engine(self.dbString)
+        self.session = sessionmaker(bind=self.engine)()
 
     @includeMeta
     def query(self, queryItems=None, queryfilters=[], limit=None):

server/src/services/requestCountsService.py

@@ -0,0 +1,70 @@
+from sqlalchemy import func
+from .dataService import DataService
+from .databaseOrm import Ingest as Request
+
+
+class RequestCountsService(object):
+    def __init__(self, config=None, tableName="ingest_staging_table"):
+        self.dataAccess = DataService(config, tableName)
+
+    async def get_req_counts(self,
+                             startDate=None,
+                             endDate=None,
+                             ncList=[],
+                             requestTypes=[],
+                             countFields=[]):
+        """
+        For each countField, returns the counts of each distinct value
+        in that field, given times, ncs, and request filters.
+        E.g. if countsFields is ['requesttype', 'requestsource'], returns:
+        {
+            'lastPulled': 'Timestamp',
+            'data': [
+                {
+                    'field': 'requesttype',
+                    'counts': {
+                        'Graffiti Removal': 'Int',
+                        'Bulky Items': 'Int',
+                        ...
+                    }
+                },
+                {
+                    'field': 'requestsource',
+                    'counts': {
+                        'Mobile App': 'Int',
+                        'Driver Self Report': 'Int',
+                        ...
+                    }
+                }
+            ]
+        }
+        """
+
+        # filter by date, nc, and requestType (if provided)
+        filters = [
+            Request.createddate > startDate if startDate else True,
+            Request.createddate < endDate if endDate else True,
+            Request.ncname.in_(ncList) if ncList else True,
+            Request.requesttype.in_(requestTypes) if requestTypes else True
+        ]
+
+        data = []
+        for field in countFields:
+            # make sure the field exists in the Request model
+            if not getattr(Request, field, None):
+                continue
+
+            # run count/groupby query
+            results = self.dataAccess.session \
+                .query(field, func.count()) \
+                .filter(*filters) \
+                .group_by(field) \
+                .all()
+
+            # add results to data set
+            data.append({
+                'field': field,
+                'counts': dict(results)
+            })
+
+        return DataService.withMeta(data)