X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=utils%2Ftest%2Ftestapi%2Fopnfv_testapi%2Fresources%2Fresult_handlers.py;h=9389d266deeda72b0052706aef9d5ae30908a382;hb=69151dce8f4f9bb59c4998fa9e903618265ac0d5;hp=44b9f8c0761dabf02e78525d3e4d407fffe543db;hpb=d5dfeab7f851e407d6bb72ad0329897d4668fff2;p=releng.git

diff --git a/utils/test/testapi/opnfv_testapi/resources/result_handlers.py b/utils/test/testapi/opnfv_testapi/resources/result_handlers.py
index 44b9f8c07..9389d266d 100644
--- a/utils/test/testapi/opnfv_testapi/resources/result_handlers.py
+++ b/utils/test/testapi/opnfv_testapi/resources/result_handlers.py
@@ -6,16 +6,20 @@
 # which accompanies this distribution, and is available at
 # http://www.apache.org/licenses/LICENSE-2.0
 ##############################################################################
+import logging
 from datetime import datetime
 from datetime import timedelta
-import httplib
+import json
 
 from bson import objectid
-from tornado import web
 
+from opnfv_testapi.common.config import CONF
+from opnfv_testapi.common import message
+from opnfv_testapi.common import raises
 from opnfv_testapi.resources import handlers
 from opnfv_testapi.resources import result_models
 from opnfv_testapi.tornado_swagger import swagger
+from opnfv_testapi.ui.auth import constants as auth_const
 
 
 class GenericResultHandler(handlers.GenericApiHandler):
@@ -30,12 +34,14 @@ class GenericResultHandler(handlers.GenericApiHandler):
         try:
             value = int(value)
         except:
-            raise web.HTTPError(httplib.BAD_REQUEST,
-                                '{} must be int'.format(key))
+            raises.BadRequest(message.must_int(key))
         return value
 
     def set_query(self):
         query = dict()
+        date_range = dict()
+
+        query['public'] = {'$not': {'$eq': 'false'}}
         for k in self.request.query_arguments.keys():
             v = self.get_query_argument(k)
             if k == 'project' or k == 'pod' or k == 'case':
@@ -48,8 +54,28 @@ class GenericResultHandler(handlers.GenericApiHandler):
                     query['start_date'] = obj
             elif k == 'trust_indicator':
                 query[k + '.current'] = float(v)
-            elif k != 'last':
+            elif k == 'from':
+                date_range.update({'$gte': str(v)})
+            elif k == 'to':
+                date_range.update({'$lt': str(v)})
+            elif k == 'signed':
+                openid = self.get_secure_cookie(auth_const.OPENID)
+                role = self.get_secure_cookie(auth_const.ROLE)
+                logging.info('role:%s', role)
+                if role:
+                    del query['public']
+                    if role != "reviewer":
+                        query['user'] = openid
+            elif k not in ['last', 'page', 'descend']:
                 query[k] = v
+            if date_range:
+                query['start_date'] = date_range
+
+            # if $lt is not provided,
+            # empty/None/null/'' start_date will also be returned
+            if 'start_date' in query and '$lt' not in query['start_date']:
+                query['start_date'].update({'$lt': str(datetime.now())})
+
         return query
 
 
@@ -65,16 +91,19 @@ class ResultsCLHandler(GenericResultHandler):
                  - case : case name
                  - pod : pod name
                  - version : platform version (Arno-R1, ...)
-                 - installer (fuel, ...)
+                 - installer : fuel/apex/compass/joid/daisy
                  - build_tag : Jenkins build tag name
-                 - period : x (x last days)
+                 - period : x last days, incompatible with from/to
+                 - from : starting time in 2016-01-01 or 2016-01-01 00:01:23
+                 - to : ending time in 2016-01-01 or 2016-01-01 00:01:23
                  - scenario : the test scenario (previously version)
                  - criteria : the global criteria status passed or failed
                  - trust_indicator : evaluate the stability of the test case
                    to avoid running systematically long and stable test case
+                 - signed : get logined user result
 
                 GET /results/project=functest&case=vPing&version=Arno-R1 \
-                &pod=pod_name&period=15
+                &pod=pod_name&period=15&signed
             @return 200: all test results consist with query,
                          empty list if no result is found
             @rtype: L{TestResults}
@@ -114,20 +143,53 @@ class ResultsCLHandler(GenericResultHandler):
             @type period: L{string}
             @in period: query
             @required period: False
+            @param from: i.e. 2016-01-01 or 2016-01-01 00:01:23
+            @type from: L{string}
+            @in from: query
+            @required from: False
+            @param to: i.e. 2016-01-01 or 2016-01-01 00:01:23
+            @type to: L{string}
+            @in to: query
+            @required to: False
             @param last: last records stored until now
             @type last: L{string}
             @in last: query
             @required last: False
+            @param page: which page to list, default to 1
+            @type page: L{int}
+            @in page: query
+            @required page: False
             @param trust_indicator: must be float
             @type trust_indicator: L{float}
             @in trust_indicator: query
             @required trust_indicator: False
+            @param signed: user results or all results
+            @type signed: L{string}
+            @in signed: query
+            @required signed: False
+            @param descend: true, newest2oldest; false, oldest2newest
+            @type descend: L{string}
+            @in descend: query
+            @required descend: False
         """
-        last = self.get_query_argument('last', 0)
-        if last is not None:
-            last = self.get_int('last', last)
+        def descend_limit():
+            descend = self.get_query_argument('descend', 'true')
+            return -1 if descend.lower() == 'true' else 1
+
+        def last_limit():
+            return self.get_int('last', self.get_query_argument('last', 0))
+
+        def page_limit():
+            return self.get_int('page', self.get_query_argument('page', 1))
 
-        self._list(self.set_query(), sort=[('start_date', -1)], last=last)
+        limitations = {
+            'sort': {'_id': descend_limit()},
+            'last': last_limit(),
+            'page': page_limit(),
+            'per_page': CONF.api_results_per_page
+        }
+
+        self._list(query=self.set_query(), **limitations)
 
     @swagger.operation(nickname="createTestResult")
     def post(self):
@@ -141,33 +203,54 @@ class ResultsCLHandler(GenericResultHandler):
             @raise 404: pod/project/testcase not exist
             @raise 400: body/pod_name/project_name/case_name not provided
         """
-        def pod_query(data):
-            return {'name': data.pod_name}
+        self._post()
+
+    def _post(self):
+        def pod_query():
+            return {'name': self.json_args.get('pod_name')}
+
+        def project_query():
+            return {'name': self.json_args.get('project_name')}
 
-        def pod_error(data):
-            message = 'Could not find pod [{}]'.format(data.pod_name)
-            return httplib.NOT_FOUND, message
+        def testcase_query():
+            return {'project_name': self.json_args.get('project_name'),
+                    'name': self.json_args.get('case_name')}
 
-        def project_query(data):
-            return {'name': data.project_name}
+        miss_fields = ['pod_name', 'project_name', 'case_name']
+        carriers = [('pods', pod_query),
+                    ('projects', project_query),
+                    ('testcases', testcase_query)]
 
-        def project_error(data):
-            message = 'Could not find project [{}]'.format(data.project_name)
-            return httplib.NOT_FOUND, message
+        self._create(miss_fields=miss_fields, carriers=carriers)
 
-        def testcase_query(data):
-            return {'project_name': data.project_name, 'name': data.case_name}
 
-        def testcase_error(data):
-            message = 'Could not find testcase [{}] in project [{}]'\
-                .format(data.case_name, data.project_name)
-            return httplib.NOT_FOUND, message
+class ResultsUploadHandler(ResultsCLHandler):
+    @swagger.operation(nickname="uploadTestResult")
+    def post(self):
+        """
+            @description: upload and create a test result
+            @param body: result to be created
+            @type body: L{ResultCreateRequest}
+            @in body: body
+            @rtype: L{CreateResponse}
+            @return 200: result is created.
+            @raise 404: pod/project/testcase not exist
+            @raise 400: body/pod_name/project_name/case_name not provided
+        """
+        logging.info('file upload')
+        fileinfo = self.request.files['file'][0]
+        is_public = self.get_body_argument('public')
+        logging.warning('public:%s', is_public)
+        logging.info('results is :%s', fileinfo['filename'])
+        logging.info('results is :%s', fileinfo['body'])
+        self.json_args = json.loads(fileinfo['body']).copy()
+        self.json_args['public'] = is_public
+
+        openid = self.get_secure_cookie(auth_const.OPENID)
+        if openid:
+            self.json_args['user'] = openid
 
-        miss_checks = ['pod_name', 'project_name', 'case_name']
-        db_checks = [('pods', True, pod_query, pod_error),
-                     ('projects', True, project_query, project_error),
-                     ('testcases', True, testcase_query, testcase_error)]
-        self._create(miss_checks, db_checks)
+        super(ResultsUploadHandler, self)._post()
 
 
 class ResultsGURHandler(GenericResultHandler):
@@ -181,7 +264,7 @@ class ResultsGURHandler(GenericResultHandler):
         """
         query = dict()
         query["_id"] = objectid.ObjectId(result_id)
-        self._get_one(query)
+        self._get_one(query=query)
 
     @swagger.operation(nickname="updateTestResultById")
     def put(self, result_id):
@@ -197,4 +280,4 @@ class ResultsGURHandler(GenericResultHandler):
         """
         query = {'_id': objectid.ObjectId(result_id)}
         db_keys = []
-        self._update(query, db_keys)
+        self._update(query=query, db_keys=db_keys)