Beispiel #1
0
 def run(self, req):
     """on get request
     return Welcome message
     """
     jdata = jsend.error('ERROR')
     if 'id' in req.params:
         data = self.process(req.params['id'])
         if isinstance(data, list):
             jdata = jsend.success({'locations': self.etl(data)})
         elif isinstance(data, str):
             jdata = jsend.error(data)
         elif isinstance(data, dict):
             jdata = jsend.fail(data)
     return jdata
    def on_get(self, req, resp):
        """ on get request """
        try:
            if req.params['token'] != os.environ.get('EXPORT_TOKEN') and req.params['token'] != os.environ.get('ACCESS_KEY'):
                raise ValueError(ERROR_ACCESS_401)

            timezone = pytz.timezone('America/Los_Angeles')
            current_time = datetime.datetime.now(timezone)
            file_name = 'DBI_permits_' + str(current_time.year) + str(current_time.month) + str(current_time.day)
            #DBI_permits_YYYYMMDDHHMI_response.csv  where HH = 24 hour clock Mi  = minutes
            #file_name = 'PTS_Export_09_26.csv'
            current_time = datetime.datetime.now(timezone)
            hours_added = datetime.timedelta(hours=-1) # rewind 1 hour to get the correct uploaded file name
            file_time = current_time + hours_added
            file_name = 'DBI_permits_' + str(file_time.year) + str(file_time.month) + str(file_time.day) + str(file_time.hour) + str(file_time.minute) + '_response.csv'
            result = self.get_result_file(file_name)

            if result == file_name:
                # dowloaded the result file
                self.process_file(self.data_file_path + file_name)

                resp.body = json.dumps(jsend.success({'message': file_name, 'responses':len(file_name)}))
                resp.status = falcon.HTTP_200
        #pylint: disable=broad-except
        except Exception as exception:
            logging.exception('ProcessResultFile.on_get Exception')
            resp.status = falcon.HTTP_500

            msg_error = ERROR_GENERIC
            if exception.__class__.__name__ == 'ValueError':
                msg_error = "{0}".format(exception)

            resp.body = json.dumps(jsend.error(msg_error))
Beispiel #3
0
 def resp_error(msg, resp):
     """ Sets response error """
     with sentry_sdk.configure_scope() as scope:
         scope.set_extra('message', msg)
         sentry_sdk.capture_message('sftp.resp_error', 'error')
     resp.body = json.dumps(jsend.error(msg))
     resp.status = falcon.HTTP_400
Beispiel #4
0
    def on_post(self, _req, resp):
        #pylint: disable=no-self-use
        """
            append a new row
        """
        try:
            request_body = _req.bounded_stream.read()
            request_params_json = json.loads(request_body)
            validate_post_params(request_params_json)

            gc = gspread.service_account(filename=CREDENTIALS_FILE) # pylint: disable=invalid-name
            worksheet = gc.open_by_key(
                request_params_json['spreadsheet_key']
            ).worksheet(
                request_params_json['worksheet_title']
            )
            row = request_params_json['row_values']
            worksheet.append_rows(row)

            resp.body = json.dumps(jsend.success({
                'row': row
            }))

        except Exception as err:    # pylint: disable=broad-except
            err_msg = "{0}".format(err)
            resp.body = json.dumps(jsend.error(err_msg))
            resp.status = falcon.HTTP_500
Beispiel #5
0
    def on_get(self, _req, resp, permit_type):
        """on GET request
        return list of permits
        """
        msg = False
        if permit_type in ('retail', 'retail_legacy'):
            permit_list = self.get_permit_list(permit_type)
            permit_list.sort(key=lambda v: ((v.get('dba_name') if v.get(
                'dba_name') else v.get('business_name', '')) + ' ' + v.get(
                    'application_id', '')).upper())
            if isinstance(permit_list, list):
                if permit_type == 'retail_legacy':
                    data = self.get_legacy_list_transform(permit_list)
                else:
                    data = {'list': permit_list}
                data_json = jsend.success(data)
                msg = 'success (' + str(len(permit_list)) + ')'
        else:
            pass

        if msg is not False:
            sentry_sdk.capture_message(msg, 'info')
            resp.body = json.dumps(data_json)
            resp.status = falcon.HTTP_200
        else:
            msg = 'ERROR'
            sentry_sdk.capture_message(msg, 'error')
            resp.body = json.dumps(jsend.error(msg))
            resp.status = falcon.HTTP_400
def default_error(_req, resp):
    """Handle default error"""
    resp.status = falcon.HTTP_404
    msg_error = jsend.error('404 - Not Found')

    sentry_sdk.capture_message(msg_error)
    resp.body = json.dumps(msg_error)
Beispiel #7
0
    def on_patch(self, _req, resp, row_id):
        #pylint: disable=no-self-use
        """
            update an existing row
        """
        try:
            request_body = _req.bounded_stream.read()
            request_params_json = json.loads(request_body)
            validate_patch_params(request_params_json)

            gc = gspread.service_account(filename=CREDENTIALS_FILE) # pylint: disable=invalid-name
            worksheet = gc.open_by_key(
                request_params_json['spreadsheet_key']
            ).worksheet(
                request_params_json['worksheet_title']
            )
            column_idx = gspread.utils.a1_to_rowcol(request_params_json['id_column_label'] + '1')[1]
            row_to_edit_idx = worksheet.find(row_id, in_column=column_idx).row
            updates = []
            for column_label, column_value in request_params_json['label_value_map'].items():
                updates.append({
                    'range': column_label + str(row_to_edit_idx),
                    'values': [[column_value]]
                })
            worksheet.batch_update(updates)

            resp.body = json.dumps(jsend.success({
                'updates': updates
            }))
            resp.status = falcon.HTTP_200
        except Exception as err:   # pylint: disable=broad-except
            err_msg = "{0}".format(err)
            resp.body = json.dumps(jsend.error(err_msg))
            resp.status = falcon.HTTP_500
Beispiel #8
0
def handle_set_converter_state(state: str):
    try:
        message = jsend.success({"converter_state":converter.set_converter_state(state)})
    except ConverterError as e:
        message = jsend.error(e.message)

    return jsonify(message)
Beispiel #9
0
    def on_post(self, req, resp):
        """Handle Submission POST requests"""
        submission = None
        try:
            json_params = req.media
            validate(json_params)
            # log submission to database
            submission = create_submission(self.session, json_params)  # pylint: disable=no-member
            # schedule dispatch to external systems
            jobs_scheduled = tasks.schedule(submission_obj=submission,\
                systems_dict=MAP)

            # return adu dispatcher id
            resp.body = json.dumps(
                jsend.success({
                    'submission_id': submission.id,
                    'job_ids': [job.id for job in jobs_scheduled],
                    'params': json.dumps(req.media)
                }))
            resp.status = falcon.HTTP_200
        except Exception as err:  # pylint: disable=broad-except
            if (submission is not None and hasattr(submission, 'id')
                    and isinstance(submission.id, int)):
                self.session.delete(submission)  # pylint: disable=no-member
                self.session.commit()  # pylint: disable=no-member
            # print("caught error in submission on_post")
            # print("traceback:")
            # traceback.print_exc(file=sys.stdout)
            print("error:")
            print("{0}".format(err))
            resp.body = json.dumps(jsend.error("{0}".format(err)))
            resp.status = falcon.HTTP_500
Beispiel #10
0
 def default_error(self, _req, resp):
     """Handle default error"""
     msg = falcon.HTTP_404
     status = falcon.HTTP_404
     resp.status = status
     msg_error = jsend.error(msg)
     resp.body = json.dumps(msg_error)
Beispiel #11
0
 def default_error(self, _req, resp):
     # pylint: disable=no-self-use
     """Handle default error"""
     msg = falcon.HTTP_404
     status = falcon.HTTP_404
     resp.status = status
     msg_error = jsend.error(msg)
     resp.body = json.dumps(msg_error)
def test_default_error(client, mock_env_access_key):
    """Test default error response"""
    response = client.simulate_get('/some_page_that_does_not_exist')

    assert response.status_code == 404

    expected_msg_error = jsend.error('404 - Not Found')
    assert json.loads(response.content) == expected_msg_error
Beispiel #13
0
 def on_get(self, req, resp):
     """handle the get request"""
     response = FireRequest.get()
     if response.status_code == 200:
         resp.body = json.dumps(jsend.success(response.json()))
     else:
         resp.body = json.dumps(jsend.error(Records.ERROR_MSG))
         resp.status = str(
             response.status_code) + " " + responses[response.status_code]
Beispiel #14
0
 def create(self, request, *args, **kwargs):
     serializer = self.serializer_class(data=request.data)
     if serializer.is_valid(raise_exception=True):
         self.perform_create(serializer)
         return Response(jsend.success({"invoice": serializer.data}),
                         status=status.HTTP_201_CREATED)
     else:
         return Response(jsend.error("INVALID REQUEST"),
                         status=status.HTTP_400_BAD_REQUEST)
Beispiel #15
0
def handle_get(status: str):
    try:
        response, text = converter.read_status(status)
        message = jsend.success(
            {"response":response, "response_text":text})
    except ConverterError as e:
        message = jsend.error(e.message)

    return jsonify(message)
Beispiel #16
0
def decode():
    if strtobool(os.environ.get('ENABLE_AUTH_HEADER', 'false')):
        key = os.environ['AUTH_TOKEN_KEY']
        value = os.environ['AUTH_TOKEN']
        if value != request.headers.get(key):
            abort(403)

    data = request.get_json(True)
    if 'src' not in data:
        return jsonify(jsend.error('params/src'))

    try:
        src = str(data['src'])
        b = bytearray()
        b.extend(src.encode())
        ret = base64.decodebytes(b).decode('ascii')
        return jsonify(jsend.success({'result': ret}))
    except:
        return jsonify(jsend.error('app/decoding'))
Beispiel #17
0
    def on_get(self, _req, resp, version):
        #pylint: disable=no-self-use,no-member
        """
            on get request
            determine which service and get the file
        """
        try:
            if set(['name']).issubset(_req.params.keys()):
                object_name = _req.params['name']
                temp_file_path = os.path.join(self.TEMP_FILE_DIR, object_name.replace('/', '-'))

                # download the file from provider
                client = self.determine_client(version)
                client.download_file(object_name, temp_file_path)
                # determine content type
                mime = magic.Magic(mime=True)
                resp.content_type = mime.from_file(temp_file_path)

                # build response
                resp.status = falcon.HTTP_200
                with open(temp_file_path, 'rb') as f: # pylint: disable=invalid-name
                    resp.body = f.read()

                # cleanup
                os.remove(temp_file_path)
            else:
                raise Exception('The name parameter is required')

        except botocore.exceptions.ClientError as err:
            if err.response['Error']['Code'] == "404":
                resp.status = falcon.HTTP_404
                resp.body = json.dumps(jsend.error("The object does not exist"))
            else:
                resp.status = falcon.HTTP_500
                resp.body = json.dumps(jsend.error(err.response['Error']['Message']))
        except azure.core.exceptions.ResourceNotFoundError as err:
            resp.status = falcon.HTTP_404
            resp.body = json.dumps(jsend.error("The object does not exist"))
        except Exception as err: # pylint: disable=broad-except
            print("FileHandler.on_get Err:{}".format(err))
            print("Err type:{}".format(type(err).__name__))
            resp.status = falcon.HTTP_500
            resp.body = json.dumps(jsend.error("{0}".format(err)))
Beispiel #18
0
    def _create_error(self, status_code):
        """
        Construct an error message in jsend format.

        :param int status_code: The status code to translate into an error message
        :return: A dictionary in jsend format with the error and the code
        :rtype: dict
        """

        return jsend.error(message=ComodoCA.status_code[status_code],
                           code=status_code)
Beispiel #19
0
    def update_record(self, req, resp, custom_type=None):
        """ example update_record """
        record_id = None
        if 'id' in req.params:
            record_id = req.params['id']

        if not record_id:
            resp.status = falcon.HTTP_400
            msg = "The ID of the record to fetch is missing"
            resp.body = json.dumps(jsend.error(msg))
            return

        if req.content_length:
            params = req.params
            del params['id']

            data = req.stream.read(sys.maxsize)
            if custom_type == 'tables':
                response = self.accela.records.update_record_custom_tables(
                    record_id, data, params)
            elif custom_type == 'forms':
                response = self.accela.records.update_record_custom_forms(
                    record_id, data, params)
            else:
                response = self.accela.records.update_record(
                    record_id, data, params)

            # default
            resp.status = falcon.HTTP_400
            resp.body = json.dumps(jsend.error(response.text))

            # if successful
            if response.status_code == 200:
                resp.status = falcon.HTTP_200
                resp.body = json.dumps(response.json())

        else:
            resp.status = falcon.HTTP_400
            msg = "Request body is required."
            resp.body = json.dumps(jsend.error(msg))
            return
Beispiel #20
0
    def create_record(self, req, resp):
        """ example create_record """
        if req.content_length:
            params = {'fields':'customId,id'}
            record = req.stream.read(sys.maxsize)
            response = self.accela.records.create_record(record, params)

            # default
            resp.status = falcon.HTTP_400
            resp.body = json.dumps(jsend.error(response.text))

            # if successful
            if response.status_code == 200:
                resp.status = falcon.HTTP_200
                resp.body = json.dumps(response.json())

        else:
            resp.status = falcon.HTTP_400
            msg = "The create record information is missing"
            resp.body = json.dumps(jsend.error(msg))
            return
 def to_dict(self):
     ''' Transforms this exception to a dict '''
     if self.status_code >= 400 and self.status_code < 500:
         result = dict(
             jsend.fail({
                 'message': self.message,
                 'payload': self.payload
             }))
     elif self.status_code >= 500:
         result = dict(
             jsend.error(self.message, self.status_code, self.payload))
     return result
def users(request):
    usersResourceUrl = os.environ.get('PREREQS_SERVICE_URL') + '/users'
    if request.method == 'GET':
        response = requests.get(usersResourceUrl)
    elif request.method == 'POST':
        postParams = json.loads(request.body)
        response = requests.post(usersResourceUrl, json=postParams)

    if response.status_code >= 300:
        return JsonResponse(jsend.error(response.text))

    return JsonResponse(json.loads(response.text), safe=False)
Beispiel #23
0
 def update_invoice(self, request, pk=None):
     if self.queryset.filter(id=pk).exists():
         self.queryset.filter(id=pk).update(**request.data)
         inv = self.queryset.get(id=pk)
         serializer = self.serializer_class(inv)
         return Response(
             jsend.success({"invoice": serializer.data}),
             status=status.HTTP_200_OK,
         )
     else:
         return Response((jsend.error("Invoice not found")),
                         status=status.HTTP_404_NOT_FOUND)
Beispiel #24
0
    def get_records(self, req, resp):
        """ example get_records response """
        if 'ids' in req.params:
            record_id = req.params['ids']
            params = req.params
            del params['ids']

            response = self.accela.records.get_records(record_id, params, 'AccessToken')

            # default
            resp.status = falcon.HTTP_400
            resp.body = json.dumps(jsend.error(response.text))

            # if successful
            if response.status_code == 200:
                resp.status = falcon.HTTP_200
                resp.body = json.dumps(response.json())

        else:
            resp.status = falcon.HTTP_400
            msg = "Parameter ids is required"
            resp.body = json.dumps(jsend.error(msg))
            return
Beispiel #25
0
    def parcels(self, req, resp):
        """ get parcels """

        missing_env = self.has_missing_env(['PLN_ARCGIS_PARCEL'])
        if missing_env:
            resp.status = falcon.HTTP_404
            msg_error = jsend.error(
                'Missing or invalid environment variable(s): ' +
                ", ".join(missing_env))
            resp.body = json.dumps(msg_error)
            return

        response = {'message': 'parcels'}
        if 'address' in req.params:
            address = req.params['address']
            options = {
                'returnGeometry': False,
                'returnSuggestions': False,
                'outFields': 'blklot,block_num,lot_num,ADDRESS'
            }
            if 'returnSuggestions' in req.params and req.params[
                    'returnSuggestions'] == 'true':
                options['returnSuggestions'] = True
            if 'returnGeometry' in req.params:
                options['returnGeometry'] = req.params['returnGeometry']
            if 'outFields' in req.params:
                options['outFields'] = req.params['outFields']

            sfarcgis = SfArcgis()
            sfarcgis.set_layer('parcel', os.environ.get('PLN_ARCGIS_PARCEL'))
            parcels = sfarcgis.get_fields_by_address(address, options)
            response = {'parcels': parcels}

            with sentry_sdk.configure_scope() as scope:
                scope.set_extra('arcgis.parcels', {
                    'address': address,
                    'options': options,
                    'response': parcels
                })

            blank_response_msg = ""
            if not parcels:
                blank_response_msg = "(blank)"

            sentry_sdk.capture_message(
                ('parcel response ' + blank_response_msg).strip(), 'info')

        resp.body = json.dumps(jsend.success(response))
        resp.status = falcon.HTTP_200
Beispiel #26
0
    def on_get(self, req, resp, name):
        """on get request
        return Welcome message
        """
        msg = jsend.error('Service Call failed.')

        if name == 'config.js':
            return self.config_js(req, resp)

        if name.isalnum() and os.path.isfile(
                os.path.join(self.svcs_path, name + '.py')):
            svc_module = importlib.import_module('service.svcs.' + name)
            svc_class = getattr(svc_module, name.capitalize())
            svc = svc_class()
            msg = svc.run(req)
        resp.body = json.dumps(msg)
        resp.status = falcon.HTTP_200
Beispiel #27
0
    def submit(self, cert_type_name, csr, term, subject_alt_names=''):
        """
        Submit a certificate request to Comodo.

        :param string cert_type_name: The full cert type name (Example: 'PlatinumSSL Certificate') the supported
                                      certificate types for your account can be obtained with the
                                      get_cert_types() method.
        :param string csr: The Certificate Signing Request (CSR)
        :param int term: The length, in days, for the certificate to be issued
        :param string subject_alt_names: Subject Alternative Names separated by a ",".
        :return: The certificate_id and the normal status messages for errors.
        :rtype: dict
        """
        cert_types = self.get_cert_types()

        # If collection of cert types fails we simply pass the error back.
        if cert_types['status'] == 'fail':
            return cert_types

        # Find the certificate type ID
        for cert_type in cert_types['data']['types']:
            if cert_type['name'] == cert_type_name:
                cert_type_id = cert_type['id']

        url = self._create_url('enroll')
        data = {
            'orgId': self.org_id,
            'csr': csr,
            'subjAltNames': subject_alt_names,
            'certType': cert_type_id,
            'numberServers': 1,
            'serverType': -1,
            'term': term,
            'comments': 'Requested with comodo_proxy',
            'externalRequester': ''
        }
        result = self.session.post(url, json=data)

        if result.status_code == 200:
            return jsend.success({'certificate_id': result.json()['sslId']})
        # Anything else is an error
        else:
            return jsend.error(result.json()['description'])
Beispiel #28
0
    def revoke(self, cert_id, reason=''):
        """
        Revoke a certificate.

        :param int cert_id: The certificate ID
        :param str reason: Reason for revocation (up to 512 characters), can be blank: '', but must exist.
        :return: The result of the operation, 'Successful' on success
        :rtype: dict
        """
        url = self._create_url('revoke/{}'.format(cert_id))
        data = {'reason': reason}
        result = self.session.post(
            url,
            json=data,
        )

        if result.status_code == 204:
            return jsend.success()
        else:
            return jsend.error(result.json()['description'])
Beispiel #29
0
    def on_post(self, _req, resp):
        #pylint: disable=no-self-use
        """
            Record post into the database
        """
        try:
            request_body = _req.bounded_stream.read()
            json_params = json.loads(request_body)
            submission = create_submission(self.session, json_params)  # pylint: disable=no-member

            resp.status = falcon.HTTP_200
            resp.body = json.dumps(
                jsend.success({
                    'submission_id':
                    submission.id,
                    'date_received':
                    submission.date_received.astimezone(LOCAL_TZ).strftime(
                        "%Y/%m/%d, %H:%M:%S")
                }))
        except Exception as err:  # pylint: disable=broad-except
            print("error:")
            print("{0}".format(err))
            resp.status = falcon.HTTP_500
            resp.body = json.dumps(jsend.error("{0}".format(err)))
    def on_get(self, _req, resp):
        #pylint: disable=no-self-use
        """ returns status of the export """
        try:
            if 'export_id' in _req.params:
                export_id = _req.params['export_id']

                if not is_valid_uuid(export_id):
                    raise Exception("Invalid export_id")

                exports = self.session.query(ExportStatusModel).filter(  # pylint: disable=no-member
                    ExportStatusModel.guid == export_id)
                if exports.count() == 1:
                    export_status = exports.first()
                    resp.status = falcon.HTTP_200

                    if export_status.result is None:
                        export_status.result = {'success': [], 'failure': []}
                    resp.body = json.dumps(
                        jsend.success({
                            'is_finished':
                            export_status.date_finished is not None,
                            'success':
                            export_status.result['success'],
                            'failure':
                            export_status.result['failure']
                        }))
                else:
                    raise Exception("Invalid export_id")
            else:
                raise Exception("export_id is required")
        except Exception as err:  # pylint: disable=broad-except
            err_msg = "{0}".format(err)
            print(err_msg)
            resp.status = falcon.HTTP_500
            resp.body = json.dumps(jsend.error(err_msg))
Beispiel #31
0
 def test_error(self):
     jsend_obj = jsend.error(message='error message')
     self.assertTrue(jsend_obj.is_error)
     self.assertEqual(jsend_obj.message, 'error message')
Beispiel #32
0
 def test_error_message_must_be_str(self):
     try:
         jsend.error(message=1)
     except ValueError:
         return
     self.fail()
Beispiel #33
0
 def test_error_code_must_be_number(self):
     try:
         jsend.error(code='1')
     except ValueError:
         return
     self.fail()
Beispiel #34
0
 def test_error_data_must_be_dict(self):
     try:
         jsend.error(data=1)
     except ValueError:
         return
     self.fail()