# -*- coding: utf-8 -*-
# (c) 2019 The PatZilla Developers
import logging
from cornice.service import Service
from patzilla.access.epo.publicationserver.client import fetch_pdf
log = logging.getLogger(__name__)
publicationserver_pdf_service = Service(
name='publicationserver-pdf',
path='/api/publicationserver/{patent}',
description="EPO publication server pdf interface")
@publicationserver_pdf_service.get(renderer='pdf')
def publicationserver_pdf_handler(request):
"""request pdf from EPO publication server"""
# https://data.epo.org/publication-server/pdf-document?cc=EP&pn=nnnnnn&ki=nn
patent = request.matchdict['patent']
pdf_payload = fetch_pdf(patent)
# http://tools.ietf.org/html/rfc6266#section-4.2
request.response.headers['Content-Disposition'] = 'inline; filename={0}.pdf'.format(patent)
request.response.headers['X-Pdf-Source'] = 'epo-publication-server'
return pdf_payload
def test_cors_policy_can_be_overwritten(self):
policy = {'origins': ('foo', 'bar', 'baz')}
foo = Service(name='foo', path='/foo', cors_origins=(),
cors_policy=policy)
self.assertEqual(len(foo.cors_supported_origins), 0)
# -*- coding: utf-8 -*-
from logging import getLogger
from cornice.service import Service
from openprocurement.api.utils import (
save_tender,
apply_patch,
add_next_award,
error_handler,
)
from openprocurement.api.validation import (
validate_tender_auction_data, )
LOGGER = getLogger(__name__)
auction = Service(name='Tender Auction',
path='/tenders/{tender_id}/auction',
renderer='json',
error_handler=error_handler)
@auction.get(renderer='json', permission='auction')
def get_auction(request):
"""Get auction info.
Get tender auction info
-----------------------
Example request to get tender auction information:
.. sourcecode:: http
GET /tenders/4879d3f8ee2443169b5fbbc9f89fa607/auction HTTP/1.1
def test_method_takes_precendence_for_credential_support(self):
foo = Service(name='foo', path='/foo', cors_credentials=True)
foo.add_view('GET', _stub, cors_credentials=False)
self.assertFalse(foo.cors_support_credentials_for('GET'))
def test_max_age_can_be_defined(self):
foo = Service(name='foo', path='/foo', cors_max_age=42)
foo.add_view('POST', _stub)
self.assertEqual(foo.cors_max_age_for(), 42)
def test_cors_headers_for_view_definition(self):
# defining headers in the view should work.
service = Service('coconuts', '/migrate')
service.add_view('POST', _stub, cors_headers=('X-Header-Foobar'))
self.assertIn('X-Header-Foobar', service.cors_supported_headers_for())
def test_credential_support_is_disabled_by_default(self):
foo = Service(name='foo', path='/foo')
foo.add_view('POST', _stub)
self.assertFalse(foo.cors_support_credentials_for())
# -*- coding: utf-8 -*-
from cornice.service import Service, get_services
from openregistry.api.constants import VERSION
spore = Service(name='spore', path='/spore', renderer='json')
#####
# from cornice.ext.spore import generate_spore_description
import re
URL_PLACEHOLDER = re.compile(r'\{([a-zA-Z0-9_-]*)\}')
def generate_spore_description(services, name, base_url, version, **kwargs):
"""Utility to turn cornice web services into a SPORE-readable file.
See https://github.com/SPORE/specifications for more information on SPORE.
"""
URL_PLACEHOLDER = re.compile(r'\{([a-zA-Z0-9_-]*)\}')
spore_doc = dict(
base_url=base_url,
name=name,
version=version,
expected_status=[200, ],
methods={},
**kwargs
)
for service in services:
# -*- coding: utf-8 -*-
# (c) 2013-2015 Andreas Motl, Elmyra UG
import logging
import arrow
from cornice.service import Service
from pyramid.httpexceptions import HTTPNotFound
from pyramid.response import Response
from patzilla.access.epo.ops.api import ops_service_usage
from patzilla.util.date import week_range, month_range, year_range
from patzilla.util.web.identity.store import User
log = logging.getLogger(__name__)
admin_users_emails_service = Service(
name='admin-users-email-service',
path='/api/admin/users/emails',
description="Responds with email addresses of all customers")
@admin_users_emails_service.get()
def admin_users_emails_handler(request):
tag = request.params.get('tag')
users = User.objects()
user_emails = []
for user in users:
if '@' not in user.username:
continue
if 'email:invalid' in user.tags or 'newsletter:opt-out' in user.tags:
continue
if tag and tag not in user.tags:
continue
def test_max_age_can_be_defined(self):
foo = Service(name='foo', path='/foo', cors_max_age=42)
self.assertEqual(foo.cors_max_age_for(), 42)
# -*- coding: utf-8 -*-
# (c) 2013-2015 Andreas Motl, Elmyra UG
import logging
from beaker.cache import cache_region
from cornice.service import Service
from patzilla.access.google.search import GooglePatentsAccess
log = logging.getLogger(__name__)
google_published_data_search_service = Service(
name='google-published-data-search',
path='/api/google/published-data/search',
description="Google Patents search interface")
@cache_region('search')
def google_published_data_search(query, offset, limit):
google = GooglePatentsAccess()
try:
return google.search(query, offset, limit)
except SyntaxError as ex:
log.warn('Invalid query for Google Patents: %s' % ex.msg)
raise
@google_published_data_search_service.get(accept="application/json")
def google_published_data_search_handler(request):
"""Search for published-data at Google Patents"""
# CQL query string
query = request.params.get('query', '')
def test_credential_support_is_disabled_by_default(self):
foo = Service(name='foo', path='/foo')
self.assertFalse(foo.cors_support_credentials())
def test_credential_support_can_be_enabled(self):
foo = Service(name='foo', path='/foo', cors_credentials=True)
self.assertTrue(foo.cors_support_credentials())
from pyramid.httpexceptions import HTTPBadGateway, HTTPBadRequest, HTTPNotFound
from json.decoder import JSONDecodeError
from cornice.validators import colander_body_validator
from .. import supervisor
from ..config import path
from ..device_discovery import PhilipsHueBridgeApiClient, UnauthenticatedDeviceError, UpstreamError
from ..lockfile import open_locked
from .api_descriptions import descriptions as desc
logger = logging.getLogger(__name__)
list_service = Service(
name='devices_list',
path=path('setup/devices'),
description=desc.get('list_service'),
renderer='json',
)
@list_service.get()
def devices_list_view(request):
"""
Returns list of discovered devices/bridges.
"""
return read_json(request.registry.settings['devices_path'], [])
discover_service = Service(
name='devices_discover',
# TODO: log/send full stacktrace
log.error(exception_traceback())
except JwtVerifyError as ex:
log.error('Error while decoding opaque parameter token: %s',
ex.message)
request.opaque_meta.update({'status': 'error', 'errors': [ex.message]})
# TODO: log/send full stacktrace
log.error(exception_traceback())
# ------------------------------------------
# services
# ------------------------------------------
opaquelinks_token_service = Service(name='opaquelinks-token',
path='/api/opaquelinks/token',
description="opaquelinks token generator")
opaquelinks_verify_service = Service(name='opaquelinks-verify',
path='/api/opaquelinks/token/verify',
description="opaquelinks token verifier")
# ------------------------------------------
# service handlers
# ------------------------------------------
@opaquelinks_token_service.post(accept="application/json")
def opaquelinks_token_handler(request):
"""Generate an opaquelinks token"""
payload = request_payload(request)
signer = request.registry.getUtility(ISigner)
from .setup_devices import get_device
from .api_descriptions import descriptions as desc
from .nuimos import is_device_responsive
import yaml
import requests
import json
import time
import soco
logger = getLogger(__name__)
nuimo_components_service = Service(
name='nuimo_components',
path=service_path('nuimos/{mac_address:[a-z0-9\-]+}/components'),
description=desc.get('nuimo_components_service'),
renderer='json',
accept='application/json',
)
nuimo_component_service = Service(
name='nuimo_component',
path=service_path(
'nuimos/{mac_address:[a-z0-9\-]+}/components/{component_id:[a-z0-9\-]+}'
),
description=desc.get('nuimo_component_service'),
renderer='json',
accept='application/json',
)
nuimo_device_test_service = Service(
from cornice.service import Service
from pkg_resources import get_distribution
from ..config import path, get_logger
log = get_logger(__name__)
app_info = Service(
name='appinfo',
path=path(''),
renderer='json',
accept='application/json')
@app_info.get()
def get_app_info(request):
result = dict(
version=get_distribution('senic.nuimo_hub').version,
bin_path=request.registry.settings['bin_path']
)
return result
from pymongo.errors import OperationFailure
from pyramid.httpexceptions import HTTPNotFound, HTTPBadRequest
from patzilla.access.depatech import get_depatech_client
from patzilla.access.depatech.client import depatech_search, LoginException, depatech_crawl
from patzilla.access.depatech.expression import DepaTechParser, should_be_quoted
from patzilla.navigator.services import handle_generic_exception
from patzilla.util.expression.keywords import keywords_to_response
from patzilla.navigator.services.util import request_to_options
from patzilla.access.generic.exceptions import NoResultsException, SearchException
from patzilla.util.data.container import SmartBunch
from patzilla.util.python import _exception_traceback
log = logging.getLogger(__name__)
depatech_published_data_search_service = Service(
name='depatech-published-data-search',
path='/api/depatech/published-data/search',
description="MTC depa.tech search interface")
depatech_published_data_crawl_service = Service(
name='depatech-published-data-crawl',
path='/api/depatech/published-data/crawl{dummy1:\/?}{constituents:.*?}',
description="MTC depa.tech crawler interface")
status_upstream_depatech = Service(
name='status_depatech',
path='/api/status/upstream/mtc/depatech',
description="Checks MTC depa-tech upstream for valid response")
@status_upstream_depatech.get()
def status_upstream_depatech_handler(request):
client = get_depatech_client()
def test_credential_support_can_be_enabled(self):
foo = Service(name='foo', path='/foo', cors_credentials=True)
foo.add_view('POST', _stub)
self.assertTrue(foo.cors_support_credentials_for())
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.
from pyramid import testing
from pyramid.exceptions import NotFound
from pyramid.response import Response
from webtest import TestApp
from cornice.service import Service
from cornice.tests.support import TestCase, CatchErrors
squirel = Service(path='/squirel', name='squirel', cors_origins=('foobar', ))
spam = Service(path='/spam', name='spam', cors_origins=('*', ))
eggs = Service(path='/eggs',
name='egg',
cors_origins=('*', ),
cors_expose_all_headers=False)
bacon = Service(path='/bacon/{type}', name='bacon', cors_origins=('*', ))
class Klass(object):
"""
Class implementation of a service
"""
def __init__(self, request):
self.request = request
def post(self):
return "moar squirels (take care)"
def test_per_method_credential_support(self):
foo = Service(name='foo', path='/foo')
foo.add_view('GET', _stub, cors_credentials=True)
foo.add_view('POST', _stub)
self.assertTrue(foo.cors_support_credentials_for('GET'))
self.assertFalse(foo.cors_support_credentials_for('POST'))
from pyramid.threadlocal import get_current_request
from pyramid.httpexceptions import HTTPServerError, HTTPBadRequest
from patzilla.navigator.export import Dossier, DossierXlsx
from patzilla.util.config import read_list
from patzilla.util.cql.util import pair_to_cql
from patzilla.util.data.container import SmartBunch
from patzilla.util.expression.keywords import keywords_from_boolean_expression
from patzilla.util.numbers.numberlists import parse_numberlist, normalize_numbers
from patzilla.util.python import exception_traceback
from patzilla.util.xml.format import pretty_print
from patzilla.util.web.email.submit import email_issue_report
log = logging.getLogger(__name__)
query_expression_util_service = Service(
name='query-expression-utility-service',
path='/api/util/query-expression',
description="Query expression utility service")
numberlist_util_service = Service(
name='numberlist-utility-service',
path='/api/util/numberlist',
description="Numberlist utility service")
export_util_service = Service(
name='export-utility-service',
path='/api/util/export/{kind}.{format}',
description="Export utility service")
issue_reporter_service = Service(
name='issue-reporter-service',
path='/api/util/issue/report',
def test_max_age_is_none_if_undefined(self):
foo = Service(name='foo', path='/foo')
foo.add_view('POST', _stub)
self.assertIsNone(foo.cors_max_age_for('POST'))
from pyramid.httpexceptions import HTTPNotFound, HTTPBadRequest
from patzilla.navigator.services import handle_generic_exception
from patzilla.util.expression.keywords import keywords_to_response
from patzilla.navigator.services.util import request_to_options
from patzilla.access.generic.exceptions import NoResultsException, SearchException
from patzilla.access.ificlaims.api import ificlaims_download, ificlaims_download_multi
from patzilla.access.ificlaims.client import IFIClaimsException, IFIClaimsFormatException, LoginException, ificlaims_search, ificlaims_crawl, ificlaims_client
from patzilla.access.ificlaims.expression import should_be_quoted, IFIClaimsParser
from patzilla.util.data.container import SmartBunch
from patzilla.util.data.zip import zip_multi
from patzilla.util.python import _exception_traceback
log = logging.getLogger(__name__)
ificlaims_published_data_search_service = Service(
name='ificlaims-published-data-search',
path='/api/ificlaims/published-data/search',
description="IFI CLAIMS search interface")
ificlaims_published_data_crawl_service = Service(
name='ificlaims-published-data-crawl',
path='/api/ificlaims/published-data/crawl{dummy1:\/?}{constituents:.*?}',
description="IFI CLAIMS crawler interface")
ificlaims_download_service = Service(
name='ificlaims-download',
path='/api/ificlaims/download/{resource}.{format}',
description="IFI CLAIMS download interface")
ificlaims_deliver_service = Service(name='ificlaims-deliver',
path='/api/ificlaims/deliver/{kind}',
description="IFI CLAIMS deliver interface")
status_upstream_ificlaims = Service(
def test_cors_policy(self):
policy = {'origins': ('foo', 'bar', 'baz')}
foo = Service(name='foo', path='/foo', cors_policy=policy)
self.assertTrue('foo' in foo.cors_supported_origins)
self.assertTrue('bar' in foo.cors_supported_origins)
self.assertTrue('baz' in foo.cors_supported_origins)
from cornice.service import Service
from ..config import path
from .api_descriptions import descriptions as desc
from .. import hub_metadata
app_info = Service(
name='appinfo',
path=path(''),
description=desc.get('app_info'),
renderer='json',
accept='application/json')
@app_info.get()
def get_app_info(request):
return dict(
wifi=hub_metadata.HubMetaData.wifi(),
os_version=hub_metadata.HubMetaData.os_version(),
hardware_identifier=hub_metadata.HubMetaData.hardware_identifier(),
)
class SchemaFromQuerystring(MappingSchema):
yeah = SchemaNode(String(), location="querystring", type='str')
class ModelField(MappingSchema):
name = SchemaNode(String())
description = SchemaNode(String())
class ModelFields(SequenceSchema):
field = ModelField()
class ModelDefinition(MappingSchema):
title = SchemaNode(String(), location="body")
fields = ModelFields(validator=Length(min=1), location="body")
nested_service = Service(name='nested', path='/nested')
@nested_service.post(schema=ModelDefinition)
def get_nested(request):
return "yay"
foobar = Service(name="foobar", path="/foobar")
@foobar.post(schema=FooBarSchema)
def foobar_post(request):
return {"test": "succeeded", 'baz': request.validated['baz']}
@foobar.get(schema=SchemaFromQuerystring)
def foobar_get(request):
return {"test": "succeeded"}
from cornice.service import Service
from restbase import path
import psycopg2
import math
search = Service(name='others', path=path('others'), renderer='json')
def distance(p0, p1):
return math.sqrt((float(p0[0]) - float(p1[0]))**2 +
(float(p0[1]) - float(p1[1]))**2)
@search.get(accept='application/json')
def query(request):
if "lat" in request.GET:
lat = request.GET["lat"]
else:
lat = "50.5"
if "lng" in request.GET:
lng = request.GET["lng"]
else:
lng = "10.5"
if "dist" in request.GET:
dist = request.GET["dist"]
else:
dist = "0.1"
con = psycopg2.connect(database='appartmapp', user='******')
cur = con.cursor()
cur.execute('SELECT * from items')
rows = cur.fetchall()
result = [(row) for row in rows
from colander import MappingSchema, String, SchemaNode, Length
import mmap
import os
import struct
import soco
import requests
from nuimo import Controller, ControllerManager
logger = getLogger(__name__)
connected_nuimos = Service(
name='connected_nuimos',
path=service_path('nuimos'),
description=desc.get('connected_nuimos'),
renderer='json',
accept='application/json')
configured_nuimos = Service(
name='configured_nuimos',
path=service_path('confnuimos'),
description=desc.get('configured_nuimos'),
renderer='json',
accept='application/json')
nuimo_service = Service(
name='nuimo_services',
path=service_path('nuimos/{mac_address:[a-z0-9\-]+}'),
return True
else:
raise Invalid(node, _(node.title + u' already exists'))
class Schema(MappingSchema):
""" Signup schema for new users. """
firstname = SchemaNode(String(), missing=null)
lastname = SchemaNode(String(), missing=null)
email = SchemaNode(String(),
title=u'Email',
validator=All(Email(), email_not_registered))
password = SchemaNode(String())
service = Service(name='signup', path=path('signup'))
@service.post(schema=Schema, accept='application/json')
def signup(request):
signup_user(request, **request.validated)
return dict(status='success')
def signup_user(request, **data):
user = principals.Principal(active=False, **data)
send_confirmation_mail(user, request)
return user
def make_token(user):
