def setUp(self,
settings_file=None,
url_converters=None,
declarative_base=None):
""" Prepare the test fixture
:param settings_file: the name of the settings file. Defaults
to `eve/tests/test_settings.py`.
This is mostly the same as in eve.tests.__init__.py, except the
creation of self.app.
"""
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings_file is None:
# Load the settings file, using a robust path
settings_file = os.path.join(self.this_directory,
'test_settings.py')
self.known_resource_count = 101
self.settings_file = settings_file
if declarative_base is not None:
SQL.driver.Model = declarative_base
else:
SQL.driver.Model = Base
self.app = eve.Eve(settings=self.settings_file,
url_converters=url_converters,
data=SQL,
validator=ValidatorSQL)
self.setupDB()
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def setUp(self):
# prepare the app
settings_file = os.path.join(SETTINGS_DIR, 'settings.py')
self.app = eve.Eve(settings=settings_file,
url_converters=None,
auth=TokenAuth,
validator=ConsentValidatorEve)
# load normalization.
with open(BSON_FILE) as fin:
mappings = list(bson.decode_iter(fin.read()))
# add normalization.
self.db = get_db()
for mapping in mappings:
self.db['normalize'].drop()
self.db['normalize'].insert(mapping)
# create the validator.
resource_def = self.app.config['DOMAIN']['trial']
schema = resource_def['schema']
#print self.app.config['SOURCES']
with self.app.app_context():
self.v = self.app.validator(schema=schema, resource='trial')
def create_app():
app_settings = {}
if os.environ.get('PROD', ''):
from .configs.production import APP_CONFIG
app_settings = APP_CONFIG
print('[x] Production config loaded.')
else:
from .configs.development import APP_CONFIG
app_settings = APP_CONFIG
print('[x] Development config loaded.')
app = eve.Eve(
__package__.split('.')[0],
settings=app_settings,
validator=db.UUIDValidator,
json_encoder=db.UUIDEncoder,
data=es.SQL,
)
app.config.update(app_settings)
# register the extensions upfront
extensions.register_extensions(app)
# scan for model definitions
utils.scan_models(app)
utils.register_resources(app)
# register blueprints
utils.scan_blueprints(app)
return app
def setUp(self):
self.app = eve.Eve(__name__, {'DOMAIN': {}})
self.app.config['SERVER_NAME'] = 'localhost'
self.app.config['DOMAIN'] = {'upload': {}}
self.app.config['MONGO_DBNAME'] = 'sptests'
self.app.data = SuperdeskDataLayer(self.app)
self.media = SuperdeskGridFSMediaStorage(self.app)
self.app.register_blueprint(bp)
def setUp(self):
settings = {'DOMAIN': DOMAIN}
settings['ELASTICSEARCH_URL'] = 'http://localhost:9200'
settings['ELASTICSEARCH_INDEX'] = INDEX
self.app = eve.Eve(settings=settings, data=Elastic)
with self.app.app_context():
for resource in self.app.config['DOMAIN']:
self.app.data.remove(resource)
def setUp(self):
settings = {'DOMAIN': DOMAIN}
settings['ELASTICSEARCH_URL'] = 'http://localhost:9200'
settings['ELASTICSEARCH_INDEX'] = INDEX
self.es = elasticsearch.Elasticsearch([settings['ELASTICSEARCH_URL']])
self.drop_index(INDEX)
self.app = eve.Eve(settings=settings, data=Elastic)
self.app.data.init_index(self.app)
def setUp(self):
self.app = eve.Eve(__name__, {"DOMAIN": {}})
self.app.config["MEDIA_PREFIX"] = "http://localhost/upload-raw"
self.app.config["DOMAIN"] = {"upload": {}}
self.app.config["MONGO_DBNAME"] = "sptests"
self.app.data = SuperdeskDataLayer(self.app)
self.media = SuperdeskGridFSMediaStorage(self.app)
self.app.register_blueprint(bp)
self.app.upload_url = upload_url
def setUp(self):
self.app = eve.Eve(__name__, {'DOMAIN': {}})
self.app.config['MEDIA_PREFIX'] = 'http://localhost/upload-raw'
self.app.config['DOMAIN'] = {'upload': {}}
self.app.config['MONGO_DBNAME'] = 'sptests'
self.app.data = SuperdeskDataLayer(self.app)
self.media = SuperdeskGridFSMediaStorage(self.app)
self.app.register_blueprint(bp)
self.app.upload_url = upload_url
def setupDB(self):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
self.settings_file = os.path.join(self.this_directory,
'test_settings.py')
self.app = eve.Eve(settings=self.settings_file, data=SQL)
self.connection = SQL.driver
self.connection.drop_all()
self.connection.create_all()
self.bulk_insert()
self.query = self.connection.session.query(Contacts)
def run_mloc():
logging.basicConfig(filename=os.path.join(LOG_DIR, 'mloc.log'),
level=LOG_LEVEL)
logging.info('Starting MLOC')
app = eve.Eve(auth=Authenticator)
setup_hooks(app)
setup_routes(app)
setup_db_hooks(app)
app.run(threaded=False, host='0.0.0.0', port=SERVER_PORT)
def setUp(self, settings=None):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings is None:
settings = os.path.join(self.this_directory, 'test_settings.py')
self.setupDB()
self.settings = settings
self.app = eve.Eve(settings=self.settings)
self.domain = self.app.config['DOMAIN']
self.hc = EveHealthCheck(self.app, self.healthcheck_uri)
def setUp(self, settings=None):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings is None:
settings = os.path.join(self.this_directory, 'test_settings.py')
self.setupDB()
self.settings = settings
self.app = eve.Eve(settings=self.settings)
eve_embedded.embedded.install(self.app)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def setUp(self, settings_file='eve/tests/test_settings.py'):
""" Prepare the test fixture
:param settings_file: the name of the settings file. Defaults
to `eve/tests/test_settings.py`.
"""
self.known_resource_count = 101
self.setupDB()
self.settings_file = settings_file
self.app = eve.Eve(settings=self.settings_file)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def setUp(self, settings_file=None):
""" Prepare the test fixture
:param settings_file: the name of the settings file. Defaults
to `eve/tests/test_settings.py`.
"""
if settings_file is None:
# Load the settings file, using a robust path
THIS_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
settings_file = os.path.join(THIS_DIRECTORY, 'test_settings.py')
self.known_resource_count = 101
self.setupDB()
self.settings_file = settings_file
self.app = eve.Eve(settings=self.settings_file)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def setUp(self, settings=None):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings is None:
settings = os.path.join(self.this_directory, "test_settings.py")
self.setupDB()
self.settings = settings
self.app = eve.Eve(settings=self.settings)
self.app.register_blueprint(eve_swagger.swagger)
self.app.config["SWAGGER_INFO"] = {
"title": "Test eve-swagger",
"version": "0.0.1",
}
self.test_client = self.app.test_client()
self.domain = self.app.config["DOMAIN"]
self.swagger_doc = self.get_swagger_doc()
def setUp(self, settings=None):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings is None:
settings = os.path.join(self.this_directory, 'test_settings.py')
self.setupDB()
self.settings = settings
self.app = eve.Eve(settings=self.settings)
self.app.register_blueprint(eve_swagger.swagger)
self.app.config['SWAGGER_INFO'] = {
'title': 'Test eve-swagger',
'version': '0.0.1',
}
self.app.config['SORTING'] = False
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
self.swagger_doc = self.get_swagger_doc()
def setUp(self, settings_file=None, url_converters=None):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
self.settings_file = os.path.join(self.this_directory,
'test_settings_neo4j.py')
self.app = eve.Eve(settings=self.settings_file,
url_converters=url_converters,
data=Neo4j,
validator=ValidatorNeo4j)
self.domain = self.app.config['DOMAIN']
self.known_resource_count = 101
self.known_resource = 'people'
self.known_resource_url = \
'/%s' % self.domain[self.known_resource]['url']
self.test_client = self.app.test_client()
self.setupDB()
self.empty_resource = 'empty'
self.empty_resource_url = '/%s' % self.empty_resource
response, _ = self.get(self.known_resource, '?max_results=2')
person = self.response_item(response)
self.item = person
self.item_id = self.item[self.app.config['ID_FIELD']]
self.item_firstname = self.item['firstname']
self.item_etag = self.item[ETAG]
self.item_id_url = (
'/%s/%s' % (self.domain[self.known_resource]['url'], self.item_id))
self.unknown_item_id = '05ced1a0-b16f-4ae8-8432-a80a84a947b2'
self.unknown_resource = 'unknown'
self.unknown_resource_url = '/%s' % self.unknown_resource
self.readonly_resource = 'payments'
self.readonly_resource_url = (
'/%s' % self.domain[self.readonly_resource]['url'])
response, _ = self.get('payments', '?max_results=1')
self.readonly_id = self.response_item(response)['_id']
self.readonly_id_url = ('%s/%s' %
(self.readonly_resource_url, self.readonly_id))
def test_get_no_hateoas_homepage_reply(self):
r = self.test_client.get("/")
resp = json.loads(r.get_data().decode())
self.assertEqual(resp, {})
self.app.config["INFO"] = "_info"
r = self.test_client.get("/")
resp = json.loads(r.get_data().decode())
self.assertEqual(resp["_info"]["server"], "Eve")
self.assertEqual(resp["_info"]["version"], eve.__version__)
settings_file = os.path.join(self.this_directory, "test_version.py")
self.app = eve.Eve(settings=settings_file)
self.app.config["INFO"] = "_info"
r = self.app.test_client().get("/v1")
resp = json.loads(r.get_data().decode())
self.assertEqual(resp["_info"]["api_version"], self.app.config["API_VERSION"])
self.assertEqual(resp["_info"]["server"], "Eve")
self.assertEqual(resp["_info"]["version"], eve.__version__)
def test_get_no_hateoas_homepage_reply(self):
r = self.test_client.get('/')
resp = json.loads(r.get_data().decode())
self.assertEqual(resp, {})
self.app.config['INFO'] = '_info'
r = self.test_client.get('/')
resp = json.loads(r.get_data().decode())
self.assertEqual(resp['_info']['server'], 'Eve')
self.assertEqual(resp['_info']['version'], eve.__version__)
settings_file = os.path.join(self.this_directory, 'test_version.py')
self.app = eve.Eve(settings=settings_file)
self.app.config['INFO'] = '_info'
r = self.app.test_client().get('/v1')
resp = json.loads(r.get_data().decode())
self.assertEqual(resp['_info']['api_version'],
self.app.config['API_VERSION'])
self.assertEqual(resp['_info']['server'], 'Eve')
self.assertEqual(resp['_info']['version'], eve.__version__)
def setUp(self):
settings = {
'DOMAIN': {
'items': {
'schema': {
'slugline': {
'type': 'string',
'mapping': {
'type': 'string',
'fields': {
'phrase': {
'type': 'string',
'index_analyzer':
'phrase_prefix_analyzer',
'search_analyzer':
'phrase_prefix_analyzer'
}
}
}
}
},
'datasource': {
'backend': 'elastic'
}
}
},
'ELASTICSEARCH_URL': 'http://localhost:9200',
'ELASTICSEARCH_INDEX': self.index_name,
'ELASTICSEARCH_SETTINGS': ELASTICSEARCH_SETTINGS
}
self.app = eve.Eve(settings=settings, data=Elastic)
self.app.data.init_index(self.app)
with self.app.app_context():
for resource in self.app.config['DOMAIN']:
self.app.data.remove(resource)
self.es = get_es(self.app.config.get('ELASTICSEARCH_URL'))
def setUp(self, settings_file=None, url_converters=None):
""" Prepare the test fixture
:param settings_file: the name of the settings file. Defaults
to `eve/tests/test_settings.py`.
"""
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings_file is None:
# Load the settings file, using a robust path
settings_file = os.path.join(self.this_directory,
'test_settings.py')
self.connection = None
self.known_resource_count = 101
self.setupDB()
self.settings_file = settings_file
self.app = eve.Eve(settings=self.settings_file,
url_converters=url_converters)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def get_app(config=None, media_storage=None):
"""App factory.
:param config: configuration that can override config from `settings.py`
:return: a new SuperdeskEve app instance
"""
if config is None:
config = {}
abs_path = os.path.abspath(os.path.dirname(__file__))
config.setdefault('APP_ABSPATH', abs_path)
for key in dir(superdesk.factory.settings):
if key.isupper():
config.setdefault(key, getattr(superdesk.factory.settings, key))
if media_storage is None:
media_storage = SuperdeskGridFSMediaStorage
config.setdefault('DOMAIN', {})
app = eve.Eve(data=SuperdeskDataLayer,
auth=TokenAuth,
media=media_storage,
settings=config,
json_encoder=MongoJSONEncoder,
validator=SuperdeskValidator)
superdesk.app = app
custom_loader = jinja2.ChoiceLoader([
app.jinja_loader,
jinja2.FileSystemLoader([abs_path + '/../templates'])
])
app.jinja_loader = custom_loader
app.mail = Mail(app)
@app.errorhandler(SuperdeskError)
def client_error_handler(error):
"""Return json error response.
:param error: an instance of :attr:`superdesk.SuperdeskError` class
"""
return send_response(None,
(error.to_dict(), None, None, error.status_code))
@app.errorhandler(500)
def server_error_handler(error):
"""Log server errors."""
app.sentry.captureException()
superdesk.logger.exception(error)
return_error = SuperdeskApiError.internalError()
return client_error_handler(return_error)
init_celery(app)
for module_name in app.config['INSTALLED_APPS']:
app_module = importlib.import_module(module_name)
try:
app_module.init_app(app)
except AttributeError:
pass
for resource in superdesk.DOMAIN:
app.register_resource(resource, superdesk.DOMAIN[resource])
for blueprint in superdesk.BLUEPRINTS:
prefix = app.api_prefix or None
app.register_blueprint(blueprint, url_prefix=prefix)
for name, jinja_filter in superdesk.JINJA_FILTERS.items():
app.jinja_env.filters[name] = jinja_filter
# we can only put mapping when all resources are registered
app.data.elastic.put_mapping(app)
app.sentry = sentry
sentry.init_app(app)
# instantiate registered provider classes (leave non-classes intact)
for key, provider in registered_feeding_services.items():
registered_feeding_services[key] = provider() if isinstance(
provider, type) else provider
return app
import os
from flask import Flask, Response, request, abort, send_file
import eve
import pandas as pd
import numpy as np
import pylab as pl
import time
import base64
from io import StringIO
# In[3]:
# from settings import BASE_DIR
app = eve.Eve()
BASE_DIR = '/Users/gautamborgohain/DEweb/REST_API_EVE_Part-1'
df = pd.read_excel(
'/Users/gautamborgohain/Google Drive/Data Extraction /actors_scores.xlsx')
###
class Radar(object):
def __init__(self, fig, titles, labels, rect=None):
if rect is None:
rect = [0.05, 0.05, 0.95, 0.95]
self.n = len(titles)
self.angles = np.arange(0, 0 + 360, 360.0 / self.n)
self.axes = [
fig.add_axes(rect, projection="polar", label="axes%d" % i)
for i in range(self.n)
def make_local_app(**kwargs):
import eve
settings = get_settings_dict()
app = eve.Eve(settings=settings, **kwargs)
return app
def app(self):
import eve
if self._app is None:
self._app = eve.Eve(settings=self.app_settings)
return self._app
def main():
app = eve.Eve()
app.run()
def get_app(config=None, media_storage=None):
"""App factory.
:param config: configuration that can override config from `settings.py`
:return: a new SuperdeskEve app instance
"""
if config is None:
config = {}
abs_path = os.path.abspath(os.path.dirname(__file__))
config.setdefault('APP_ABSPATH', abs_path)
for key in dir(koldocta.factory.settings):
if key.isupper():
config.setdefault(key, getattr(koldocta.factory.settings, key))
if media_storage is None:
media_storage = KoldoctaGridFSMediaStorage
config.setdefault('DOMAIN', {})
app = eve.Eve(
media=media_storage,
settings=config,
json_encoder=MongoJSONEncoder,
validator=KoldoctaValidator
)
configure_logging(app)
koldocta.app = app
custom_loader = jinja2.ChoiceLoader([
app.jinja_loader,
jinja2.FileSystemLoader([abs_path + '/../templates'])
])
app.jinja_loader = custom_loader
@app.errorhandler(KoldoctaError)
def client_error_handler(error):
"""Return json error response.
:param error: an instance of :attr:`koldocta.KoldoctaError` class
"""
return send_response(
None, (error.to_dict(), None, None, error.status_code))
@app.errorhandler(500)
def server_error_handler(error):
"""Log server errors."""
# app.sentry.captureException()
# app.logger.exception(error)
return_error = KoldoctaApiError.internalError()
return client_error_handler(return_error)
init_celery(app)
for module_name in app.config['INSTALLED_APPS']:
app_module = importlib.import_module(module_name)
try:
app_module.init_app(app)
except AttributeError:
app.logger.error('App %s not initialized' % (module_name))
for resource in koldocta.DOMAIN:
app.register_resource(resource, koldocta.DOMAIN[resource])
for blueprint in koldocta.BLUEPRINTS:
prefix = app.api_prefix or None
app.register_blueprint(blueprint, url_prefix=prefix)
for name, jinja_filter in koldocta.JINJA_FILTERS.items():
app.jinja_env.filters[name] = jinja_filter
# app.sentry = sentry
# sentry.init_app(app)
return app
def create_app():
setup_logging()
#app = eve.Eve()
app = eve.Eve(json_encoder=JHEDEncoder, validator=JHEDValidator)
app.on_post_GET_documents += post_documents_get_callback
@app.route("/about", methods = ["GET"])
def about():
about = {
"version": PINE_EVE_VERSION_STR,
"eve_version": eve.__version__,
"flask_version": flask_version
}
LOGGER.info(about)
return jsonify(about)
@app.route("/system/ping", methods=["GET"])
def ping():
return jsonify("pong")
@app.route("/system/export", methods = ["GET"])
def system_export():
db = app.data.driver.db
(f, filename) = tempfile.mkstemp()
os.close(f)
cmd = ["mongodump", "--host", db.client.address[0], "--port", str(db.client.address[1]),
"--gzip", "--archive={}".format(filename)]
print("RUNNING: {}".format(cmd))
try:
output = subprocess.check_output(cmd)
print(output)
return send_file(filename, as_attachment = True, attachment_filename = "dump.gz",
mimetype = "application/gzip")
finally:
os.remove(filename)
@app.route("/system/import", methods = ["PUT", "POST"])
def system_import():
db = app.data.driver.db
dump_first = request.method.upper() == "POST"
if not "file" in request.files:
raise exceptions.UnprocessableEntity("Missing 'file' parameter")
(f, filename) = tempfile.mkstemp()
os.close(f)
try:
request.files["file"].save(filename)
cmd = ["mongorestore", "--host", db.client.address[0], "--port", str(db.client.address[1]),
"--gzip", "--archive={}".format(filename)]
if dump_first:
cmd.append("--drop")
print("RUNNING: {}".format(cmd))
output = subprocess.check_output(cmd)
print(output)
return jsonify({
"success": True
})
except Exception as e:
print(e)
raise exceptions.BadRequest("Error parsing input:" + str(e))
finally:
os.remove(filename)
return app
def get_app(config=None, media_storage=None, config_object=None):
"""App factory.
:param config: configuration that can override config from `default_settings.py`
:param media_storage: media storage class to use
:param config_object: config object to load (can be module name, module or an object)
:return: a new SuperdeskEve app instance
"""
abs_path = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
app_config = flask.Config(abs_path)
app_config.from_object('superdesk.factory.default_settings')
app_config.setdefault('APP_ABSPATH', abs_path)
app_config.setdefault('DOMAIN', {})
app_config.setdefault('SOURCES', {})
if config_object:
app_config.from_object(config_object)
try:
app_config.update(config or {})
except TypeError:
app_config.from_object(config)
if not media_storage and app_config.get('AMAZON_CONTAINER_NAME'):
media_storage = AmazonMediaStorage
elif not media_storage:
media_storage = SuperdeskGridFSMediaStorage
app = eve.Eve(data=SuperdeskDataLayer,
auth=TokenAuth,
media=media_storage,
settings=app_config,
json_encoder=MongoJSONEncoder,
validator=SuperdeskValidator,
template_folder=os.path.join(abs_path, 'templates'))
superdesk.app = app
custom_loader = jinja2.ChoiceLoader([
app.jinja_loader,
jinja2.FileSystemLoader([abs_path + '/../templates'])
])
app.jinja_loader = custom_loader
app.mail = Mail(app)
app.sentry = SuperdeskSentry(app)
@app.errorhandler(SuperdeskError)
def client_error_handler(error):
"""Return json error response.
:param error: an instance of :attr:`superdesk.SuperdeskError` class
"""
return send_response(None,
(error.to_dict(), None, None, error.status_code))
@app.errorhandler(500)
def server_error_handler(error):
"""Log server errors."""
app.sentry.captureException()
superdesk.logger.exception(error)
return_error = SuperdeskApiError.internalError()
return client_error_handler(return_error)
init_celery(app)
for module_name in app.config.get('INSTALLED_APPS', []):
app_module = importlib.import_module(module_name)
try:
app_module.init_app(app)
except AttributeError:
pass
for resource in superdesk.DOMAIN:
app.register_resource(resource, superdesk.DOMAIN[resource])
for blueprint in superdesk.BLUEPRINTS:
prefix = app.api_prefix or None
app.register_blueprint(blueprint, url_prefix=prefix)
for name, jinja_filter in superdesk.JINJA_FILTERS.items():
app.jinja_env.filters[name] = jinja_filter
# we can only put mapping when all resources are registered
app.data.init_elastic(app)
# instantiate registered provider classes (leave non-classes intact)
for key, provider in registered_feeding_services.items():
registered_feeding_services[key] = provider() if isinstance(
provider, type) else provider
configure_logging(app.config['LOG_CONFIG_FILE'])
return app
def setUp(self, settings_file=None, url_converters=None):
self.connection = None
self.known_resource_count = 101
self.this_directory = os.path.dirname(os.path.realpath(__file__))
self.settings_file = os.path.join(self.this_directory,
'test_settings_sql.py')
self.app = eve.Eve(settings=self.settings_file,
url_converters=url_converters,
data=SQL,
validator=ValidatorSQL)
self.test_client = self.app.test_client()
self.app.config = copy.deepcopy(self.app.config)
self.domain = self.app.config['DOMAIN']
self.setupDB()
self.known_resource = 'people'
self.known_resource_url = \
('/%s' % self.domain[self.known_resource]['url'])
self.unknown_resource = 'unknown'
self.unknown_resource_url = '/%s' % self.unknown_resource
self.unknown_item_id = '83542635967'
self.unknown_item_name = 'unknown'
self.unknown_item_id_url = \
('/%s/%s' % (self.domain[self.known_resource]['url'],
self.unknown_item_id))
response, _ = self.get(self.known_resource, '?max_results=2')
person = self.response_item(response)
self.item = person
self.item_id = self.item[self.app.config['ID_FIELD']]
self.item_firstname = self.item['firstname']
self.item_etag = self.item[ETAG]
self.item_id_url = ('/%s/%s' %
(self.domain[self.known_resource]['url'],
self.item_id))
self.empty_resource = 'empty'
self.empty_resource_url = '/%s' % self.empty_resource
self.different_resource = 'users'
self.different_resource_url = \
('/%s' % self.domain[self.different_resource]['url'])
response, _ = self.get('users')
user = self.response_item(response)
self.user_id = user[self.app.config['ID_FIELD']]
self.user_firstname = user['firstname']
self.user_etag = user[ETAG]
self.user_id_url = ('/%s/%s' %
(self.domain[self.different_resource]['url'],
self.user_id))
self.user_firstname_url = \
('/%s/%s' % (self.domain[self.different_resource]['url'],
self.user_firstname))
response, _ = self.get('invoices')
invoice = self.response_item(response)
self.invoice_id = invoice[self.app.config['ID_FIELD']]
self.invoice_etag = invoice[ETAG]
self.invoice_id_url = ('/%s/%s' % (self.domain['invoices']['url'],
self.invoice_id))
self.readonly_resource = 'payments'
self.readonly_resource_url = (
'/%s' % self.domain[self.readonly_resource]['url'])
response, _ = self.get('payments', '?max_results=1')
self.readonly_id = self.response_item(response)['_id']
self.readonly_id_url = ('%s/%s' % (self.readonly_resource_url,
self.readonly_id))
self.epoch = date_to_str(datetime(1970, 1, 1))
