├── .gitignore
├── CHANGES.md
├── LICENCE.md
├── README.md
├── bootstrap.sh
├── buildout.cfg
├── dev.cfg
├── generate-key.py
├── modwsgi.cfg
├── setup.py
└── src
    └── zeit
        ├── __init__.py
        └── api
            ├── __init__.py
            ├── access.py
            ├── application.py
            ├── blueprints.py
            ├── exception.py
            ├── metadata.py
            ├── parameters.py
            ├── queries.py
            ├── schemas
                ├── database.sql
                ├── schema.xml
                ├── schema_.xml
                ├── solrconfig.xml
                └── solrmsg.rnc
            ├── settings.py
            ├── templates
                ├── base.html
                ├── docs.html
                ├── docs
                │   ├── author.html
                │   ├── client.html
                │   ├── content.html
                │   ├── department.html
                │   ├── keyword.html
                │   ├── product.html
                │   └── series.html
                ├── error.html
                ├── explorer.html
                ├── index.html
                ├── licence.html
                ├── quickstart.html
                └── style.css
            ├── tests.py
            └── util.py


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.py[cod]
 2 | *.egg
 3 | *.egg-info
 4 | *.wsgi
 5 | .Python
 6 | dist
 7 | build
 8 | eggs
 9 | etc
10 | include
11 | lib
12 | parts
13 | bin
14 | var
15 | sdist
16 | develop-eggs
17 | .installed.cfg
18 | private.py


--------------------------------------------------------------------------------
/CHANGES.md:
--------------------------------------------------------------------------------
 1 | #Changelog
 2 | 
 3 | ## 25. Apr 2013
 4 | * [FIXED] URLs for sub-departments now working correctly
 5 | 
 6 | ## 21. Apr 2013
 7 | * [FIXED] Keyword IDs are now URL-safe
 8 | 
 9 | ##02. Jan 2013
10 | * [IMPROVED] API explorer performance
11 | 
12 | ##21. Dec 2012
13 | * [IMPROVED] General documentation expanded
14 | * [IMPROVED] Cosmetic changes at developer portal
15 | * [DEPRECATED] App Gallery removed, now only at our blog
16 | 
17 | ##20. Dec 2012
18 | * [FIXED] Server errors at /content resolved
19 | * [FIXED] UTF8 support for all parameters
20 | * [IMPROVED] Performance optimizations for /author
21 | * [ADDED] Id field for non-content searches
22 | * [ADDED] Href field for authors, if available
23 | 
24 | ##05. Dec 2012
25 | * [ADDED] Uuid field for content objects
26 | 
27 | ##04. Dec 2012
28 | * [FIXED] Response header gets proper encoding
29 | 
30 | ##30. Nov 2012
31 | * [FIXED] Related articles now have proper titles
32 | 
33 | ##23. Nov 2012
34 | * [ADDED] Initial beta release


--------------------------------------------------------------------------------
/LICENCE.md:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2013 by ZEIT ONLINE GmbH and contributors.
 2 | 
 3 | All rights reserved.
 4 | 
 5 | Redistribution and use in source and binary forms, with or without
 6 | modification, are permitted provided that the following conditions are met:
 7 | 
 8 | * Redistributions of source code must retain the above copyright notice, this
 9 | 	list of conditions and the following disclaimer.
10 | 
11 | * Redistributions in binary form must reproduce the above copyright notice,
12 | 	this list of conditions and the following disclaimer in the documentation
13 | 	and/or other materials provided with the distribution.
14 | 
15 | * Neither the name of the ZEIT ONLINE GmbH nor the names of its contributors
16 | 	may be used to endorse or promote products derived from this software
17 | 	without specific prior written permission.
18 | 
19 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
20 | ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 | DISCLAIMED. IN NO EVENT SHALL ZEIT ONLINE BE LIABLE FOR ANY DIRECT,
23 | INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
27 | OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 | ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Content-API
 2 | 
 3 | ZEIT ONLINE content API - A [flask](http://flask.pocoo.org/) –
 4 | [Solr](http://lucene.apache.org/solr/) middleware
 5 | 
 6 | 
 7 | ## Frequent questions
 8 | 
 9 | ### What is this?
10 | This is the ZEIT ONLINE content API project as available at
11 | https://developer.zeit.de. It enables you to access articles and corresponding
12 | metadata from the ZEIT newspaper archive, as well as recent articles from ZEIT
13 | and ZEIT ONLINE.
14 | 
15 | ### Is it ready?
16 | It is still in public beta. We are working on improving the quality of our data
17 | as well as the stability of our code. You are welcome to test and experiment
18 | with the API, take a look at the code, file a bug report or request a feature.
19 | 
20 | ### Where are the docs?
21 | You can find the documentation at our developer portal over at
22 | https://developer.zeit.de
23 | 
24 | ### Can I run the API locally?
25 | Yes. It is tailored to the infrastructure we have here at ZEIT ONLINE, though.
26 | So it might not be of too much use for other scenarios and will require some
27 | adaptation. See below for instructions.
28 | 
29 | ###How can I get in touch?
30 | We would love to hear your ideas and feedback. Join the discussion in the
31 | [issues section](http://github.com/ZeitOnline/content-api/issues), contact us
32 | on Twitter at [zeitonline_dev](http://twitter.com/zeitonline_dev) or send an
33 | Email to [api@zeit.de](mailto:api@zeit.de).
34 | 
35 | 
36 | ## Getting started
37 | 
38 | Check out the repository, change to the project folder and then bootstrap the
39 | project like this:
40 | ```bash
41 | $ ./bootstrap.sh  # requires python2.7 and virtualenv to be installed
42 | ```
43 | 
44 | Run the server like this:
45 | ```bash
46 | $ bin/api
47 | $ bin/doc
48 | ```
49 | 
50 | ## Local solr
51 | 
52 | Run buildout with the development configuration:
53 | ```bash
54 | $ bin/buildout -c dev.cfg
55 | ```
56 | 
57 | This will install dependencies, generate executables for the API, the developer
58 | portal and the testsuite and download a Solr package. To start the Solr
59 | locally, switch to parts/solr-server and enter:
60 | ```bash
61 | $ java -jar start.jar
62 | ```
63 | 
64 | With the search server running, you can now start the testsuite:
65 | ```bash
66 | $ bin/tests
67 | ```
68 | 


--------------------------------------------------------------------------------
/bootstrap.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | virtualenv --python=python2.7 .
4 | bin/pip install zc.buildout==2.12.0
5 | bin/buildout
6 | 


--------------------------------------------------------------------------------
/buildout.cfg:
--------------------------------------------------------------------------------
 1 | [buildout]
 2 | develop = .
 3 | parts = 
 4 | 	eggs
 5 | 	api-wsgi
 6 | 	doc-wsgi
 7 | eggs-directory = eggs
 8 | versions = versions
 9 | 
10 | [versions]
11 | lxml = 3.1.2
12 | flask = 0.9
13 | jinja2 = 2.6
14 | werkzeug = 0.8.3
15 | PasteDeploy = 1.5.0
16 | Paste = 1.7.5.1
17 | 
18 | [eggs]
19 | recipe = zc.recipe.egg
20 | eggs =
21 | 	zeit.api
22 | 	flask
23 | 	lxml
24 | 	PasteDeploy
25 | 
26 | [deployment]
27 | name = api
28 | recipe = gocept.recipe.deploymentsandbox
29 | root = ${buildout:directory}
30 | 
31 | [api-wsgi]
32 | recipe = collective.recipe.modwsgi
33 | eggs = ${eggs:eggs}
34 | target = ${buildout:directory}/api.wsgi
35 | extra-paths = ${buildout:eggs-directory}/PasteDeploy-1.5.0-py2.7.egg
36 | config-file = ${buildout:directory}/modwsgi.cfg
37 | app_name = api
38 | 
39 | [doc-wsgi]
40 | recipe = collective.recipe.modwsgi
41 | eggs = ${eggs:eggs}
42 | target = ${buildout:directory}/doc.wsgi
43 | extra-paths = ${buildout:eggs-directory}/PasteDeploy-1.5.0-py2.7.egg
44 | config-file = ${buildout:directory}/modwsgi.cfg
45 | app_name = doc


--------------------------------------------------------------------------------
/dev.cfg:
--------------------------------------------------------------------------------
 1 | [buildout]
 2 | extends = buildout.cfg
 3 | parts +=
 4 | 	solr-server 
 5 | 	solr-schema 
 6 | 	solr-conf
 7 | 	tests
 8 | 
 9 | [api-wsgi]
10 | app_name = api_dev
11 | 
12 | [doc-wsgi]
13 | app_name = doc_dev
14 | 
15 | [solr-package]
16 | recipe = gocept.download
17 | url = http://archive.apache.org/dist/lucene/solr/3.6.2/apache-solr-3.6.2.tgz
18 | md5sum = e9c51f51265b070062a9d8ed50b84647
19 | 
20 | [solr-schema]
21 | recipe = collective.recipe.rsync
22 | source = ${buildout:directory}/src/zeit/api/schemas/schema.xml
23 | target = ${buildout:directory}/parts/solr-server/solr/conf/schema.xml
24 | 
25 | [solr-conf]
26 | recipe = collective.recipe.rsync
27 | source = ${buildout:directory}/src/zeit/api/schemas/solrconfig.xml
28 | target = ${buildout:directory}/parts/solr-server/solr/conf/solrconfig.xml
29 | 
30 | [solr-server]
31 | recipe = collective.recipe.solrinstance
32 | solr-location = ${solr-package:location}
33 | index = name:uid type:string indexed:true stored:true required:true
34 | schema-template = ${buildout:directory}/src/zeit/api/schemas/schema_.xml
35 | vardir = ${deployment:root}/var/${:_buildout_section_name_}
36 | logdir = ${deployment:log-directory}
37 | script = ${deployment:rc-directory}/${:_buildout_section_name_}
38 | autoCommitMaxTime = 1000
39 | 
40 | [tests]
41 | recipe = pbp.recipe.noserunner
42 | eggs = ${eggs:eggs}
43 | defaults = -v --nocapture


--------------------------------------------------------------------------------
/generate-key.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python
 2 | 
 3 | from datetime import datetime
 4 | import os
 5 | import sqlite3
 6 | import sys
 7 | import time
 8 | 
 9 | db = sqlite3.connect('/var/lib/zon-api/data.db')
10 | 
11 | if len(sys.argv) < 3:
12 |     print('Usage: %s "Firstname Lastname" email@example.com' % sys.argv[0])
13 |     print('\nLast keys:')
14 |     query = 'SELECT * FROM client ORDER by reset DESC'
15 |     for client in db.execute(query):
16 |         reset = datetime.fromtimestamp(client[5])
17 |         print(u'{0}: "{2}" {3} ({reset})'.format(*client, reset=reset).encode('utf8'))
18 |     sys.exit(1)
19 | 
20 | api_key = str(os.urandom(26).encode('hex'))
21 | tier = 'free'
22 | name = sys.argv[1]
23 | email = sys.argv[2]
24 | requests = 0
25 | reset = int(time.time())
26 | query = 'INSERT INTO client VALUES (?, ?, ?, ?, ?, ?)'
27 | db.execute(query, (api_key, tier, name, email, requests, reset))
28 | db.commit()
29 | db.close()
30 | print api_key
31 | 


--------------------------------------------------------------------------------
/modwsgi.cfg:
--------------------------------------------------------------------------------
 1 | [app:api]
 2 | paste.app_factory = zeit.api.application:api_factory
 3 | 
 4 | [app:api_dev]
 5 | paste.app_factory = zeit.api.application:api_dev_factory
 6 | 
 7 | [app:doc]
 8 | paste.app_factory = zeit.api.application:doc_factory
 9 | 
10 | [app:doc_dev]
11 | paste.app_factory = zeit.api.application:doc_dev_factory
12 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup, find_packages
 2 | 
 3 | name = 'zeit.api'
 4 | setup(
 5 |     name = name,
 6 |     version = '0.4',
 7 |     author = 'Nicolas Drebenstedt',
 8 |     author_email = 'nicolas.drebenstedt@zeit.de',
 9 |     url = 'https://github.com/ZeitOnline/content-api',
10 |     package_dir = {'': 'src'},
11 |     packages = find_packages('src'),
12 |     namespace_packages = ['zeit',],
13 |     include_package_data = True,
14 |     install_requires = [
15 |     'setuptools',
16 |     'flask',
17 |     'lxml'
18 |     ],
19 |     zip_safe = False,
20 |     entry_points = """
21 |     [console_scripts]
22 |     api = zeit.api.application:run_local_api
23 |     doc = zeit.api.application:run_local_doc
24 |     """,
25 |     )
26 | 


--------------------------------------------------------------------------------
/src/zeit/__init__.py:
--------------------------------------------------------------------------------
1 | __import__('pkg_resources').declare_namespace(__name__)


--------------------------------------------------------------------------------
/src/zeit/api/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ZeitOnline/content-api/d277808e60b1d03b64ec7c452a200ba816fa34c5/src/zeit/api/__init__.py


--------------------------------------------------------------------------------
/src/zeit/api/access.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """
 3 |     zeit.api.access
 4 |     ~~~~~~~~~~~~~~~
 5 | 
 6 |     This module provides functionalities for regulating API access.
 7 | 
 8 |     Copyright: (c) 2013 by ZEIT ONLINE.
 9 |     License: BSD, see LICENSE.md for more details.
10 | """
11 | import time
12 | 
13 | from flask import g, current_app as current_app
14 | 
15 | from . import exception
16 | 
17 | 
18 | class Verifictaion(object):
19 |     """Context manager class for API key validation and usage tracking."""
20 | 
21 |     def __enter__(self):
22 |         """Verify key and quota. Raise exception if either fails."""
23 |         if not hasattr(g, 'api_key'):
24 |             raise exception.unauthorized()
25 | 
26 |         query = 'SELECT requests,reset,tier FROM client WHERE api_key=?;'
27 |         client = g.db.execute(query, (g.api_key,)).fetchone()
28 | 
29 |         if not client:
30 |             raise exception.unauthorized()
31 | 
32 |         requests = client[0]
33 |         reset = client[1]
34 |         quota = current_app.config['ACCESS_TIERS'][client[2]]
35 |         timeframe = current_app.config['ACCESS_TIMEFRAME']
36 | 
37 |         if (int(time.time()) - reset) / timeframe > 0:
38 |             reset += ((int(time.time()) - reset) / timeframe) * timeframe
39 |             requests = 0
40 |             query = ('UPDATE OR IGNORE client SET reset=?, requests=? '
41 |                 'WHERE api_key=?;')
42 |             g.db.execute(query, (reset, requests, g.api_key))
43 | 
44 |         if quota <= requests:
45 |             raise exception.too_many_requests()
46 | 
47 |     def __exit__(self, type, value, traceback):
48 |         """Increase request counter before closing context."""
49 |         query = ('UPDATE OR IGNORE client SET requests=requests + 1 '
50 |             'WHERE api_key=?;')
51 |         g.db.execute(query, (g.api_key,))
52 | 


--------------------------------------------------------------------------------
/src/zeit/api/application.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """
 3 |     zeit.api.application
 4 |     ~~~~~~~~~~~~~~~~~~~~
 5 | 
 6 |     This module contains factory methods, that return WSGI compatible app
 7 |     instances configured for deployment or testing, and a local run method,
 8 |     that does not require a full WSGI server.
 9 | 
10 |     Copyright: (c) 2013 by ZEIT ONLINE.
11 |     License: BSD, see LICENSE.md for more details.
12 | """
13 | 
14 | import flask
15 | 
16 | from . import settings, blueprints
17 | 
18 | 
19 | def make_app(blueprint, config):
20 |     """Configure a flask instance with a given blueprint and configuration."""
21 |     app = flask.Flask(import_name=__name__)
22 |     app.register_blueprint(blueprint)
23 |     app.url_map.strict_slashes = False
24 |     app.config.from_object(config)
25 |     return app
26 | 
27 | 
28 | def run_local_api():
29 |     """Run an api server instance on a local development server."""
30 |     cfg = settings.LocalConfig()
31 |     app = make_app(blueprints.api_server, settings.LocalConfig)
32 |     app.run(host=cfg.SERVERNAME, port=cfg.API_PORT, debug=True)
33 | 
34 | 
35 | def run_local_doc():
36 |     """Runs a developer portal instance on a local development server."""
37 |     cfg = settings.LocalConfig()
38 |     app = make_app(blueprints.developer_portal, settings.LocalConfig)
39 |     app.run(host=cfg.SERVERNAME, port=cfg.DOC_PORT, debug=True)
40 | 
41 | 
42 | def test_client_factory():
43 |     """Return a client instance for automated testing."""
44 |     app = make_app(blueprints.api_server, settings.TestingConfig)
45 |     return app.test_client()
46 | 
47 | 
48 | def api_factory(global_config, **local_conf):
49 |     """Return an api server instance configured for production."""
50 |     return make_app(blueprints.api_server, settings.ProductionConfig)
51 | 
52 | 
53 | def doc_factory(global_config, **local_conf):
54 |     """Return a developer portal instance configured for production."""
55 |     return make_app(blueprints.developer_portal, settings.ProductionConfig)
56 | 
57 | 
58 | def api_dev_factory(global_config, **local_conf):
59 |     """Return an api server instance configured for development."""
60 |     return make_app(blueprints.api_server, settings.DevelopmentConfig)
61 | 
62 | 
63 | def doc_dev_factory(global_config, **local_conf):
64 |     """Return a developer portal instance configured for development."""
65 |     return make_app(blueprints.developer_portal, settings.DevelopmentConfig)
66 | 


--------------------------------------------------------------------------------
/src/zeit/api/blueprints.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 |     zeit.api.blueprints
  4 |     ~~~~~~~~~~~~~~~~~~~
  5 | 
  6 |     This module configures two blueprint instances, one for the api server and
  7 |     one for the developer portal and documentation.
  8 | 
  9 |     Copyright: (c) 2013 by ZEIT ONLINE.
 10 |     License: BSD, see LICENSE.md for more details.
 11 | """
 12 | import contextlib
 13 | import sqlite3
 14 | 
 15 | import flask
 16 | from flask import g, jsonify, current_app as current_app
 17 | from werkzeug.datastructures import ImmutableDict
 18 | 
 19 | from . import access, metadata, exception, queries
 20 | 
 21 | 
 22 | api_server = flask.Blueprint('api_server', __name__)
 23 | developer_portal = flask.Blueprint('developer_portal', __name__)
 24 | developer_portal.jinja_options = ImmutableDict(
 25 |     {'extensions': ['jinja2.ext.loopcontrols']})
 26 | 
 27 | 
 28 | @api_server.app_errorhandler(400)
 29 | def handle_bad_request(error):
 30 |     return exception.bad_request(error)
 31 | 
 32 | 
 33 | @api_server.app_errorhandler(404)
 34 | def handle_resource_not_found(error):
 35 |     return exception.resource_not_found(error)
 36 | 
 37 | 
 38 | @api_server.app_errorhandler(405)
 39 | def handle_method_not_allowed(error):
 40 |     return exception.method_not_allowed(error)
 41 | 
 42 | 
 43 | @api_server.app_errorhandler(500)
 44 | def handle_internal_server_error(error):
 45 |     return exception.internal_server_error(error)
 46 | 
 47 | 
 48 | @api_server.before_app_first_request
 49 | def initialize_database():
 50 |     """On first startup, make sure the database is initialized."""
 51 |     g.db = sqlite3.connect(current_app.config['DATABASE'],
 52 |         isolation_level=None)
 53 |     schema = (current_app.root_path + current_app.config['SCHEMA'])
 54 |     with contextlib.closing(g.db) as db:
 55 |         with api_server.open_resource(schema) as f:
 56 |             db.cursor().executescript(f.read())
 57 |             db.commit()
 58 | 
 59 | 
 60 | @api_server.before_app_request
 61 | def before_request():
 62 |     """Intercept preflight requests, connect db and extract API key."""
 63 |     if flask.request.method == 'OPTIONS':
 64 |         return flask.Response(status=204)
 65 |     g.db = sqlite3.connect(current_app.config['DATABASE'],
 66 |         isolation_level=None)
 67 |     g.api_key = flask.request.headers.get('X-Authorization',
 68 |         flask.request.args.get('api_key', None))
 69 | 
 70 | 
 71 | @api_server.after_app_request
 72 | def after_request(response):
 73 |     """Optionally convert to JSONP, set response headers and close db."""
 74 |     callback = flask.request.args.get('callback', False)
 75 |     if callback:
 76 |         response.data = str(callback) + '(' + response.data + ');'
 77 |         response.mimetype = 'application/javascript'
 78 |     response.mimetype += ';charset=UTF-8'
 79 |     response.headers['Server'] = 'Zeit Api'
 80 |     response.headers['Cache-Control'] = 'max-age=1'
 81 |     if hasattr(g, 'db'):
 82 |         g.db.close()
 83 |     return response
 84 | 
 85 | 
 86 | @api_server.route('/')
 87 | def show_definition():
 88 |     query = queries.DefinitionQuery()
 89 |     return jsonify(query.fetch())
 90 | 
 91 | 
 92 | @api_server.route('/trigger')
 93 | def trigger_update():
 94 |     metadata.update()
 95 |     return flask.Response(status=204)
 96 | 
 97 | 
 98 | @api_server.route('/client',  methods=['POST'])
 99 | def register_client():
100 |     form = flask.request.form.copy().to_dict()
101 |     query = queries.RegisterClientQuery(**form)
102 |     return jsonify(query.push())
103 | 
104 | 
105 | @api_server.route('/<string:endpoint>')
106 | def search(endpoint):
107 |     with access.Verifictaion():
108 |         param = flask.request.args.copy().to_dict()
109 |         query = queries.QueryFactory(endpoint, **param)
110 |         return jsonify(query.fetch())
111 | 
112 | 
113 | @api_server.route('/<string:endpoint>/<string:res>')
114 | def filtered_search(endpoint, res):
115 |     with access.Verifictaion():
116 |         param = flask.request.args.copy().to_dict()
117 |         query = queries.FilteredContentSearchQuery(endpoint, res, **param)
118 |         return jsonify(query.fetch())
119 | 
120 | 
121 | @api_server.route('/content/<string:uuid>')
122 | def content_by_id(uuid):
123 |     with access.Verifictaion():
124 |         param = flask.request.args.copy().to_dict()
125 |         query = queries.ContentIdQuery(uuid, **param)
126 |         return jsonify(query.fetch())
127 | 
128 | 
129 | @developer_portal.route('/')
130 | def redirect_index():
131 |     return flask.redirect('/index/')
132 | 
133 | 
134 | @developer_portal.route('/style.css')
135 | def style_sheet():
136 |     response = flask.make_response(flask.render_template('style.css'))
137 |     response.headers['Content-Type'] = 'text/css'
138 |     return response
139 | 
140 | 
141 | @developer_portal.route('/<path:path>/')
142 | def documentation(path):
143 |     if 'documentation' in path:
144 |         return flask.redirect(path.replace('documentation', 'docs'))
145 | 
146 |     context = dict(
147 |         trunk=path if '/' not in path else path.split('/')[0],
148 |         file=path if '/' not in path else path.split('/')[-1],
149 |         recaptcha=current_app.config['RECAPTCHA_PUBLIC_KEY'],
150 |         api_url=current_app.config['API_URL'],
151 |         doc_url=current_app.config['DOC_URL']
152 |     )
153 |     try:
154 |         return flask.render_template(path + '.html', **context)
155 |     except Exception, e:
156 |         current_app.logger.error('%r: %s' % (e, e.message))
157 |         rendered = flask.render_template('error.html', **context)
158 |         return flask.make_response(rendered, 404)
159 | 
160 | 
161 | @developer_portal.after_app_request
162 | def caching(response):
163 |     response.headers['Cache-Control'] = 'max-age=7200, public'
164 |     response.headers['Server'] = 'Zeit Developer'
165 |     return response
166 | 


--------------------------------------------------------------------------------
/src/zeit/api/exception.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 |     zeit.api.exception
  4 |     ~~~~~~~~~~~~~~~~~~
  5 | 
  6 |     This module contains custom JSON exceptions. Not to be confused with the
  7 |     similarly named flask module 'exceptions'. Exceptions correspond to
  8 |     standard HTTP status codes.
  9 | 
 10 |     Copyright: (c) 2013 by ZEIT ONLINE.
 11 |     License: BSD, see LICENSE.md for more details.
 12 | """
 13 | 
 14 | from flask.exceptions import JSONHTTPException
 15 | from werkzeug.exceptions import (escape, NotFound, MethodNotAllowed,
 16 |     Unauthorized, BadRequest, InternalServerError, ServiceUnavailable)
 17 | from flask import request
 18 | 
 19 | 
 20 | class JSONTooManyRequests(JSONHTTPException):
 21 |     code = 429
 22 |     description = 'You have reached your request quota.'
 23 | 
 24 |     @property
 25 |     def name(self):
 26 |         return 'Too Many Requests'
 27 | 
 28 | 
 29 | class JSONUnauthorized(JSONHTTPException, Unauthorized):
 30 |     description = 'The provided api key seems to be invalid.'
 31 | 
 32 | 
 33 | class JSONEndpointNotFound(JSONHTTPException, NotFound):
 34 |     description = 'The requested endpoint is not defined.'
 35 | 
 36 | 
 37 | class JSONResourceNotFound(JSONHTTPException, NotFound):
 38 |     description = 'The requested resource can not be found.'
 39 | 
 40 | 
 41 | class JSONMethodNotAllowed(JSONHTTPException, MethodNotAllowed):
 42 |     def get_description(self, environ):
 43 |         m = escape(environ.get('REQUEST_METHOD', 'GET'))
 44 |         return 'The method %s is not allowed for the requested URL.' % m
 45 | 
 46 | 
 47 | class JSONBadRequest(JSONHTTPException, BadRequest):
 48 |     description = 'The request cannot be fulfilled due to bad syntax.'
 49 | 
 50 | 
 51 | class JSONInternalServerError(JSONHTTPException, InternalServerError):
 52 |     description = 'Due to an internal error the request could not be fulfilled.'
 53 | 
 54 | 
 55 | class JSONServiceUnavailable(JSONHTTPException, ServiceUnavailable):
 56 |     description = 'The service is currently unavailable.'
 57 | 
 58 | 
 59 | def too_many_requests(error=None):
 60 |     excp = JSONTooManyRequests()
 61 |     message = '%d: %s' % (excp.code, error or excp.description)
 62 |     print >> request.environ['wsgi.errors'], message
 63 |     return excp
 64 | 
 65 | 
 66 | def unauthorized(error=None):
 67 |     excp = JSONUnauthorized()
 68 |     message = '%d: %s' % (excp.code, error or excp.description)
 69 |     print >> request.environ['wsgi.errors'], message
 70 |     return excp
 71 | 
 72 | 
 73 | def endpoint_not_found(error=None):
 74 |     excp = JSONEndpointNotFound()
 75 |     message = '%d: %s' % (excp.code, error or excp.description)
 76 |     print >> request.environ['wsgi.errors'], message
 77 |     return excp
 78 | 
 79 | 
 80 | def resource_not_found(error=None):
 81 |     excp = JSONResourceNotFound()
 82 |     message = '%d: %s' % (excp.code, error or excp.description)
 83 |     print >> request.environ['wsgi.errors'], message
 84 |     return excp
 85 | 
 86 | 
 87 | def method_not_allowed(error=None):
 88 |     excp = JSONMethodNotAllowed()
 89 |     message = '%d: %s' % (excp.code, error or excp.description)
 90 |     print >> request.environ['wsgi.errors'], message
 91 |     return excp
 92 | 
 93 | 
 94 | def bad_request(error=None):
 95 |     excp = JSONBadRequest()
 96 |     message = '%d: %s' % (excp.code, error or excp.description)
 97 |     print >> request.environ['wsgi.errors'], message
 98 |     return excp
 99 | 
100 | 
101 | def internal_server_error(error=None):
102 |     excp = JSONInternalServerError()
103 |     message = '%d: %s' % (excp.code, error or excp.description)
104 |     print >> request.environ['wsgi.errors'], message
105 |     return excp
106 | 
107 | 
108 | def service_unavailable(error=None):
109 |     excp = JSONServiceUnavailable()
110 |     message = '%d: %s' % (excp.code, error or excp.description)
111 |     print >> request.environ['wsgi.errors'], message
112 |     return excp
113 | 


--------------------------------------------------------------------------------
/src/zeit/api/metadata.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 |     zeit.api.metadata
  4 |     ~~~~~~~~~~~~~~~~~
  5 | 
  6 |     This module contains methods that maintain metadata entities by parsing XML
  7 |     files and updating the API's SQLite database.
  8 | 
  9 |     Copyright: (c) 2013 by ZEIT ONLINE.
 10 |     License: BSD, see LICENSE.md for more details.
 11 | """
 12 | 
 13 | import urllib
 14 | 
 15 | from flask import g, current_app
 16 | from lxml import etree
 17 | 
 18 | from .util import iri_to_uri, save_xpath
 19 | 
 20 | 
 21 | def __update_product(product):
 22 |     """Update the given product entity."""
 23 |     product_id = save_xpath(product, './@id').lower()
 24 |     uri = '%s/product/%s' % (current_app.config['API_URL'], product_id)
 25 |     value = save_xpath(product, 'text()')
 26 |     href = save_xpath(product, './@href')
 27 |     query = 'REPLACE INTO product VALUES (?, ?, ?, ?);'
 28 |     g.db.execute(query, (href, product_id, uri, value))
 29 | 
 30 | 
 31 | def __update_series(series):
 32 |     """Update the given series entity."""
 33 |     series_id = save_xpath(series, './@url')
 34 |     uri = '%s/series/%s' % (current_app.config['API_URL'], series_id)
 35 |     value = save_xpath(series, './@title')
 36 |     name = save_xpath(series, './@serienname')
 37 |     query = 'REPLACE INTO series VALUES (?, ?, ?, ?, ?);'
 38 |     href = 'http://www.zeit.de/serie/%s' % series_id
 39 |     g.db.execute(query, (href, series_id, name, uri, value))
 40 | 
 41 | 
 42 | def __update_keyword(keyword, ranks, types):
 43 |     """Update the given keyword entity."""
 44 |     kw_id = save_xpath(keyword, './@url_value')
 45 |     uri = '%s/keyword/%s' % (current_app.config['API_URL'], kw_id)
 46 |     value = save_xpath(keyword, 'text()')
 47 |     lexical = save_xpath(keyword, './@lexical_value')
 48 |     kw_type = save_xpath(keyword, './@type')
 49 |     kw_type = 'subject' if kw_type in ['free', 'topic'] else kw_type.lower()
 50 |     score = (ranks.index(int(save_xpath(keyword, './@freq'))) + 1)
 51 |     score = int(100.0 / len(ranks) * score)
 52 |     href = 'http://www.zeit.de/schlagworte/%s/%s/index' % (types[kw_type], kw_id)
 53 |     query = 'REPLACE INTO keyword VALUES (?, ?, ?, ?, ?, ?, ?);'
 54 |     g.db.execute(query, (href, kw_id, lexical, score, kw_type, uri, value))
 55 | 
 56 | 
 57 | def __update_department(department):
 58 |     """Update the given department entity."""
 59 |     dept_id = save_xpath(department, './@label')
 60 |     if dept_id in ['startseite']:
 61 |         return
 62 |     uri = '%s/department/%s' % (current_app.config['API_URL'], dept_id)
 63 |     value = save_xpath(department, 'text()')
 64 |     href = save_xpath(department, './@href')[19:].split('/', 1)[0]
 65 |     parent = href if href != dept_id else ''
 66 |     path = parent + '/' + dept_id if parent else dept_id
 67 |     href = 'http://www.zeit.de/%s/index' % path
 68 |     query = 'REPLACE INTO department VALUES (?, ?, ?, ?, ?);'
 69 |     g.db.execute(query, (href, dept_id, parent, uri, value))
 70 | 
 71 | 
 72 | def __update_author(author):
 73 |     """Update the given author entity."""
 74 |     value = save_xpath(author, './@name')
 75 |     author_id = value.replace(' ', '-')
 76 |     uri = '%s/author/%s' % (current_app.config['API_URL'], author_id)
 77 |     initial = value.split(' ')[-1] or 'A'
 78 |     href_raw = 'http://www.zeit.de/autoren/%s/%s/index.xml'
 79 |     href = href_raw % (initial[0], value.replace(' ', '_'))
 80 |     href = href if urllib.urlopen(iri_to_uri(href)).getcode() == 200 else ''
 81 |     query = 'REPLACE INTO author VALUES (?, ?, ?, ?, ?);'
 82 |     g.db.execute(query, (href, author_id, 'author', uri, value))
 83 | 
 84 | 
 85 | def update():
 86 |     """Update metadata of all categories and write changes to database."""
 87 |     products = current_app.config['PRODUCT_ALPHABET']
 88 |     for p in etree.parse(products).xpath('//product'):
 89 |         __update_product(p)
 90 | 
 91 |     series = current_app.config['SERIES_ALPHABET']
 92 |     for s in etree.parse(series).xpath('//series'):
 93 |         print s
 94 |         __update_series(s)
 95 | 
 96 |     keywords = current_app.config['KEYWORD_ALPHABET']
 97 |     parsed_keywords = etree.parse(keywords).xpath('//tag')
 98 |     ranks = sorted(set(int(save_xpath(k, './@freq')) for k in parsed_keywords))
 99 |     types = {'location': 'orte', 'person': 'personen', 'subject': 'themen',
100 |         'organization': 'organisationen'}
101 |     for k in parsed_keywords:
102 |         print k
103 |         __update_keyword(k, ranks, types)
104 | 
105 |     depts = current_app.config['DEPARTMENT_ALPHABET']
106 |     for d in etree.parse(depts).xpath('/lists/list[@id="sitemap"]//link'):
107 |         print d
108 |         __update_department(d)
109 | 
110 |     url = '/select?q=*:*&facet=true&facet.field=author'
111 |     url += '&facet.limit=1000000&rows=0&facet.mincount=1'
112 |     authors = current_app.config['SOLR_URL'] + url
113 |     for a in etree.parse(authors).xpath('//lst[@name="author"]/int'):
114 |         print a
115 |         __update_author(a)
116 | 


--------------------------------------------------------------------------------
/src/zeit/api/parameters.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 |     zeit.api.parameters
  4 |     ~~~~~~~~~~~~~~~~~~~
  5 | 
  6 |     This module contains classes for various request parameters.
  7 |     They provide methods for validation and translation to Solr parameter
  8 |     namespace.
  9 | 
 10 |     Copyright: (c) 2013 by ZEIT ONLINE.
 11 |     License: BSD, see LICENSE.md for more details.
 12 | """
 13 | 
 14 | import re
 15 | 
 16 | from . import exception, util
 17 | 
 18 | 
 19 | class Param(object):
 20 |     """The base class for all URL parameters."""
 21 | 
 22 |     key = None
 23 |     default = None
 24 |     origin = None
 25 | 
 26 |     def __init__(self, **kwargs):
 27 |         vkeys = list(k for k in kwargs.keys())
 28 |         vargs = dict((k, v) for k, v in kwargs.iteritems() if k in vkeys)
 29 |         self.__dict__.update(vargs)
 30 |         self._value = None
 31 | 
 32 |     @property
 33 |     def value(self):
 34 |         return self._value or self.default
 35 | 
 36 |     @value.setter
 37 |     def value(self, value):
 38 |         try:
 39 |             self.valid(value)
 40 |             self._value = value
 41 |         except AssertionError:
 42 |             raise exception.JSONBadRequest()
 43 | 
 44 |     def __repr__(self):
 45 |         return str(self.value)
 46 | 
 47 |     def valid(self, value):
 48 |         pass
 49 | 
 50 | 
 51 | class StrParam(Param):
 52 |     """The base class for string parameters."""
 53 | 
 54 |     default = ''
 55 | 
 56 |     def __init__(self, **kwargs):
 57 |         super(StrParam, self).__init__(**kwargs)
 58 | 
 59 |     def valid(self, value):
 60 |         super(StrParam, self).valid(value)
 61 |         assert isinstance(value, basestring)
 62 | 
 63 | 
 64 | class SqlQParam(StrParam):
 65 |     """A parameter class enforcing SQL syntax."""
 66 | 
 67 |     default = '%'
 68 |     key = 'q'
 69 | 
 70 |     def __init__(self, **kwargs):
 71 |         super(SqlQParam, self).__init__(**kwargs)
 72 | 
 73 |     def valid(self, value):
 74 |         super(SqlQParam, self).valid(value)
 75 |         assert len(value) < 1024
 76 | 
 77 |     @property
 78 |     def value(self):
 79 |         return self._value or self.default
 80 | 
 81 |     @value.setter
 82 |     def value(self, value):
 83 |         try:
 84 |             self.valid(value)
 85 |             self._value = value.replace('*', '%')
 86 |         except AssertionError:
 87 |             raise exception.JSONBadRequest()
 88 | 
 89 | 
 90 | class FacetFieldParam(StrParam):
 91 |     """A parameter class for field facetting."""
 92 | 
 93 |     default = ''
 94 |     origin = 'facet.field'
 95 |     key = 'facet_field'
 96 | 
 97 |     def __init__(self, **kwargs):
 98 |         super(FacetFieldParam, self).__init__(**kwargs)
 99 | 
100 |     def valid(self, value):
101 |         super(FacetFieldParam, self).valid(value)
102 |         whitelist = [
103 |             'department',
104 |             'product',
105 |             'sub_department',
106 |             'keyword',
107 |             'author',
108 |             'series'
109 |         ]
110 |         assert value in whitelist
111 | 
112 | 
113 | class FacetDateParam(StrParam):
114 |     """A parameter class for date facetting."""
115 | 
116 |     default = ''
117 |     origin = 'facet.date.gap'
118 |     key = 'facet_date'
119 | 
120 |     def __init__(self, **kwargs):
121 |         super(FacetDateParam, self).__init__(**kwargs)
122 | 
123 |     def valid(self, value):
124 |         super(FacetDateParam, self).valid(value)
125 |         assert(re.match(r"^[0-9]{1,3}(day|month|year)$", value))
126 | 
127 |     @property
128 |     def value(self):
129 |         return self._value or self.default
130 | 
131 |     @value.setter
132 |     def value(self, value):
133 |         try:
134 |             self.valid(value)
135 |             self._value = util.ensure_prefix(value, '+').upper()
136 |         except AssertionError:
137 |             raise exception.JSONBadRequest()
138 | 
139 | 
140 | class IntParam(Param):
141 |     """The base class for integer parameters."""
142 | 
143 |     default = '0'
144 | 
145 |     def __init__(self, **kwargs):
146 |         super(IntParam, self).__init__(**kwargs)
147 | 
148 |     def __radd__(self, other):
149 |         result = IntParam()
150 |         result.value = str(int(self.value) + other)
151 |         return result
152 | 
153 |     def valid(self, value):
154 |         super(IntParam, self).valid(value)
155 |         assert hasattr(value, 'isdigit') and value.isdigit()
156 | 
157 | 
158 | class LimitParam(IntParam):
159 |     """A class for limit parameters."""
160 | 
161 |     default = '10'
162 |     origin = 'rows'
163 |     key = 'limit'
164 | 
165 |     def __init__(self, **kwargs):
166 |         super(LimitParam, self).__init__(**kwargs)
167 | 
168 |     def valid(self, value):
169 |         super(LimitParam, self).valid(value)
170 |         assert int(value) >= 0 and int(value) <= 1024
171 | 
172 | 
173 | class OffsetParam(IntParam):
174 |     """A class for offset parameters."""
175 | 
176 |     default = '0'
177 |     origin = 'start'
178 |     key = 'offset'
179 | 
180 |     def __init__(self, **kwargs):
181 |         super(OffsetParam, self).__init__(**kwargs)
182 | 
183 |     def valid(self, value):
184 |         super(OffsetParam, self).valid(value)
185 | 
186 | 
187 | class CsvParam(StrParam):
188 |     """The base class for comma seperated values."""
189 | 
190 |     def __init__(self, **kwargs):
191 |         super(CsvParam, self).__init__(**kwargs)
192 | 
193 |     def __iter__(self):
194 |         for item in self.value.split(','):
195 |             if item != '' and item in self.default.split(','):
196 |                 yield item
197 | 
198 |     def valid(self, value):
199 |         super(CsvParam, self).valid(value)
200 |         assert all(item in self.default.split(',') for item in self)
201 | 
202 | 
203 | class FieldsParam(CsvParam):
204 |     """A class for parial selection parameters."""
205 | 
206 |     key = 'fields'
207 |     origin = 'fl'
208 |     enforce = ''
209 | 
210 |     def __init__(self, **kwargs):
211 |         super(FieldsParam, self).__init__(**kwargs)
212 | 
213 |     def valid(self, value):
214 |         super(FieldsParam, self).valid(value)
215 | 
216 |     @property
217 |     def value(self):
218 |         if not self._value:
219 |             return self.default
220 |         if self.enforce != '' and self.enforce not in self._value.split(','):
221 |             return '%s,%s' % (self.enforce, self._value)
222 |         else:
223 |             return self._value
224 | 
225 |     @value.setter
226 |     def value(self, value):
227 |         try:
228 |             self.valid(value)
229 |             self._value = value if '*' not in value else self.default
230 |         except AssertionError:
231 |             raise exception.JSONBadRequest()
232 | 


--------------------------------------------------------------------------------
/src/zeit/api/queries.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 |     zeit.api.queries
  4 |     ~~~~~~~~~~~~~~~~
  5 | 
  6 |     This module contains classes for the different kind of queries a client
  7 |     may submit to the API. These define allowed parameters and values, methods
  8 |     to fetch a raw result set from a Solr server and transform or enrich the
  9 |     received results.
 10 | 
 11 |     Copyright: (c) 2013 by ZEIT ONLINE.
 12 |     License: BSD, see LICENSE.md for more details.
 13 | """
 14 | 
 15 | import json
 16 | import exceptions
 17 | import os
 18 | import time
 19 | import urllib
 20 | import urllib2
 21 | import warnings
 22 | 
 23 | from flask import g, current_app as current_app, request
 24 | 
 25 | from . import exception, parameters, util
 26 | 
 27 | 
 28 | class Query(object):
 29 |     """The base class for all API queries."""
 30 | 
 31 |     def __getitem__(self, key):
 32 |         if key not in self.__dict__.keys():
 33 |             raise exceptions.KeyError()
 34 |         return self.__dict__[key]
 35 | 
 36 |     def __init__(self, **kwargs):
 37 |         for kw in kwargs:
 38 |             if kw in self.__dict__.keys():
 39 |                 getattr(self, kw).value = kwargs[kw]
 40 |             elif kw == 'callback' or kw == 'api_key':
 41 |                 pass
 42 |             else:
 43 |                 warnings.warn('Unsupported parameter key %s' % kw)
 44 | 
 45 |     def __iter__(self):
 46 |         for param in self.__dict__.values():
 47 |             if isinstance(param, parameters.Param):
 48 |                 yield (param.origin or param.key, param.value)
 49 | 
 50 |     def __str__(self):
 51 |         return str(dict(self.__iter__()))
 52 | 
 53 |     def items(self):
 54 |         return list(self.__iter__())
 55 | 
 56 |     def params(self):
 57 |         for param in self.__dict__.values():
 58 |             if isinstance(param, parameters.Param) and param.key:
 59 |                 yield (param.key, param.value)
 60 | 
 61 | 
 62 | class SearchQuery(Query):
 63 |     """The base class for all SQL-based searches."""
 64 | 
 65 |     _default_field = 'value'
 66 | 
 67 |     def __init__(self, endpoint, **kwargs):
 68 |         self.q = parameters.SqlQParam()
 69 |         self.limit = parameters.LimitParam()
 70 |         self.offset = parameters.OffsetParam()
 71 |         self._endpoint = endpoint
 72 |         super(SearchQuery, self).__init__(**kwargs)
 73 | 
 74 |     def _fetch_raw(self):
 75 |         sql = 'SELECT * FROM %s WHERE %s LIKE ? LIMIT ?, ?;'
 76 |         query = sql % (self._endpoint, self._default_field)
 77 |         options = (self.q.value, self.offset.value, self.limit.value)
 78 |         result = g.db.execute(query, options).fetchall()
 79 |         return result
 80 | 
 81 |     def _fetch_count(self):
 82 |         sql = 'SELECT COUNT(*) FROM %s WHERE %s LIKE ?;'
 83 |         query = sql % (self._endpoint, self._default_field)
 84 |         result = g.db.execute(query, (self.q.value,)).fetchone()
 85 |         return result[0]
 86 | 
 87 |     def _matches(self):
 88 |         for row in self._fetch_raw():
 89 |             match = dict()
 90 |             for key in self.fields:
 91 |                 position = self.fields.default.split(',').index(key)
 92 |                 match[key] = row[position]
 93 |             yield match
 94 | 
 95 |     def fetch(self):
 96 |         return dict(
 97 |             matches=list(self._matches()),
 98 |             found=self._fetch_count(),
 99 |             limit=int(self.limit.value),
100 |             offset=int(self.offset.value)
101 |         )
102 | 
103 | 
104 | class AuthorSearchQuery(SearchQuery):
105 |     """Search query for content authors."""
106 | 
107 |     def __init__(self, **kwargs):
108 |         self.fields = parameters.FieldsParam(
109 |             default='href,id,type,uri,value'
110 |         )
111 |         super(AuthorSearchQuery, self).__init__('author', **kwargs)
112 | 
113 | 
114 | class DepartmentSearchQuery(SearchQuery):
115 |     """Search query for newspaper departments."""
116 | 
117 |     def __init__(self, **kwargs):
118 |         self.fields = parameters.FieldsParam(
119 |             default='href,id,parent,uri,value'
120 |         )
121 |         super(DepartmentSearchQuery, self).__init__('department', **kwargs)
122 | 
123 | 
124 | class KeywordSearchQuery(SearchQuery):
125 |     """Search query for available keywords."""
126 | 
127 |     def __init__(self, **kwargs):
128 |         self.fields = parameters.FieldsParam(
129 |             default='href,id,lexical,score,type,uri,value'
130 |         )
131 |         super(KeywordSearchQuery, self).__init__('keyword', **kwargs)
132 | 
133 | 
134 | class ProductSearchQuery(SearchQuery):
135 |     """Search query for publication products."""
136 | 
137 |     def __init__(self, **kwargs):
138 |         self.fields = parameters.FieldsParam(
139 |             default='href,id,uri,value'
140 |         )
141 |         super(ProductSearchQuery, self).__init__('product', **kwargs)
142 | 
143 | 
144 | class SeriesSearchQuery(SearchQuery):
145 |     """Search query for article series."""
146 | 
147 |     def __init__(self, **kwargs):
148 |         self.fields = parameters.FieldsParam(
149 |             default='href,id,name,uri,value'
150 |         )
151 |         super(SeriesSearchQuery, self).__init__('series', **kwargs)
152 | 
153 | 
154 | class ContentSearchQuery(Query):
155 |     """Unfiltered content search query."""
156 | 
157 |     _endpoint = 'content'
158 |     __action = 'search'
159 | 
160 |     def __init__(self, **kwargs):
161 |         self.q = parameters.StrParam(
162 |             key='q',
163 |             origin='q',
164 |             default='*:*'
165 |         )
166 |         self.sort = parameters.StrParam(
167 |             key='sort',
168 |             origin='sort',
169 |             default='release_date desc'
170 |         )
171 |         self.fields = parameters.FieldsParam(
172 |             default=('subtitle,uuid,title,href,release_date,'
173 |                 'uri,snippet,supertitle,teaser_title,teaser_text'),
174 |             enforce='uuid'
175 |         )
176 |         self.facet_date = parameters.FacetDateParam()
177 |         self.facet_field = parameters.FacetFieldParam()
178 |         self.limit = parameters.LimitParam()
179 |         self.offset = parameters.OffsetParam()
180 |         super(ContentSearchQuery, self).__init__(**kwargs)
181 |         if self.facet_field.value != '' or self.facet_date.value != '':
182 |             self.facet = parameters.StrParam(
183 |                 key='facet',
184 |                 origin='facet',
185 |                 default='true'
186 |             )
187 |         if self.facet_date.value != '':
188 |             self.facet_date_field = parameters.StrParam(
189 |                 origin='facet.date',
190 |                 default='release_date'
191 |             )
192 | 
193 |     def _fetch_raw(self):
194 |         query = util.url_encode(dict(self))
195 |         url = '%s/%s/%s?%s' % (current_app.config['SOLR_URL'],
196 |             self.__class__._endpoint, self.__action, query)
197 |         try:
198 |             data = urllib2.urlopen(url)
199 |             return json.load(data)
200 |         except urllib2.URLError:
201 |             raise exception.service_unavailable()
202 | 
203 |     def _make_matches(self, raw):
204 |         for match in raw['response']['docs']:
205 |             if 'uri' in self.fields:
206 |                 match['uri'] = '%s/%s/%s' % (current_app.config['API_URL'],
207 |                     self.__class__._endpoint, match['uuid'])
208 |             if 'snippet' in self.fields and self.q.value != self.q.default:
209 |                 snippet = raw['highlighting'][match['uuid']]
210 |                 if len(snippet.values()) > 0:
211 |                     match['snippet'] = snippet.values()[0][0]
212 |             if self.fields._value:
213 |                 if 'uuid' not in self.fields._value:
214 |                     del match['uuid']
215 | 
216 |     def fetch(self):
217 |         raw = self._fetch_raw()
218 |         self._make_matches(raw)
219 |         response = dict(
220 |             matches=raw['response']['docs'],
221 |             found=raw['response']['numFound'],
222 |             limit=int(self.limit.value),
223 |             offset=int(self.offset.value)
224 |         )
225 |         if  hasattr(self, 'facet'):
226 |             response['facets'] = dict()
227 |             response['facets'].update(
228 |                 raw['facet_counts']['facet_dates'])
229 |             response['facets'].update(
230 |                 raw['facet_counts']['facet_fields'])
231 |         return response
232 | 
233 | 
234 | class FilteredContentSearchQuery(ContentSearchQuery):
235 |     """Pre-filtered search query."""
236 | 
237 |     _default_field = 'id'
238 | 
239 |     def __init__(self, endpoint='', filter_id='', **kwargs):
240 | 
241 |         self.fq = parameters.StrParam(
242 |             default='%s:%s' % (endpoint, filter_id),
243 |             origin='fq'
244 |         )
245 |         super(FilteredContentSearchQuery, self).__init__(**kwargs)
246 |         self._endpoint = endpoint
247 |         self._id = filter_id
248 | 
249 |     def fetch(self):
250 |         sql = 'SELECT * FROM %s WHERE %s LIKE :q;'
251 |         query = sql % (self._endpoint, self._default_field)
252 |         result = g.db.execute(query, {'q': self._id}).fetchall()
253 |         if len(result) == 0:
254 |             raise exception.resource_not_found()
255 |         if self._endpoint == 'author':
256 |             self.fq.value = self.fq.value.replace('-', '*')
257 |         meta = dict(zip(QueryFactory(self._endpoint).fields, result[0]))
258 |         if self._endpoint == 'department':
259 |             if meta['parent'] != '':
260 |                 self.fq.value = 'sub_department:%s' % (self._id)
261 |         meta.update(super(FilteredContentSearchQuery, self).fetch())
262 |         return meta
263 | 
264 | 
265 | class DisplayClientQuery(Query):
266 |     """Display client information and API usage stats."""
267 | 
268 |     def __init__(self, **kwargs):
269 |         super(DisplayClientQuery, self).__init__(**kwargs)
270 | 
271 |     def fetch(self):
272 |         row = g.db.execute('SELECT * FROM client WHERE api_key=?',
273 |                 (g.api_key,)).fetchone()
274 |         return dict(
275 |             api_key=row[0],
276 |             tier=row[1],
277 |             name=row[2],
278 |             email=row[3],
279 |             requests=row[4],
280 |             reset=row[5],
281 |             quota=current_app.config['ACCESS_TIERS'][row[1]]
282 |         )
283 | 
284 | 
285 | class RegisterClientQuery(Query):
286 |     """Register a new API client with a POST request."""
287 | 
288 |     def __init__(self, **kwargs):
289 |         self.name = parameters.StrParam()
290 |         self.email = parameters.StrParam()
291 |         self.response = parameters.StrParam()
292 |         super(RegisterClientQuery, self).__init__(**kwargs)
293 | 
294 |     def _verify_captcha(self):
295 |         if current_app.config['TESTING']:
296 |             return True
297 |         data = urllib.urlencode(
298 |             dict(
299 |                 secret=current_app.config['RECAPTCHA_PRIVATE_KEY'],
300 |                 remoteip=request.remote_addr,
301 |                 response=self.response.value,
302 |             )
303 |         )
304 |         url = 'https://www.google.com/recaptcha/api/siteverify'
305 |         try:
306 |             response = json.load(urllib.urlopen(url, data))
307 |             return response['success']
308 |         except Exception:
309 |             return False
310 | 
311 |     def push(self):
312 |         empty = self.name.value == '' or self.email.value == ''
313 |         if empty or not self._verify_captcha():
314 |             raise exception.bad_request()
315 |         g.api_key = str(os.urandom(26).encode('hex'))
316 |         tier = 'free'
317 |         name = self.name.value
318 |         email = self.email.value
319 |         requests = 0
320 |         reset = int(time.time())
321 |         query = 'INSERT INTO client VALUES (?, ?, ?, ?, ?, ?)'
322 |         g.db.execute(query, (g.api_key, tier, name, email, requests, reset))
323 |         return DisplayClientQuery().fetch()
324 | 
325 | 
326 | class QueryFactory(object):
327 |     """A factory class for general endpoint queries."""
328 | 
329 |     def __init__(self, endpoint='', **kwargs):
330 |         if endpoint == 'author':
331 |             self.__class__ = AuthorSearchQuery
332 |         elif endpoint == 'client':
333 |             self.__class__ = DisplayClientQuery
334 |         elif endpoint == 'content':
335 |             self.__class__ = ContentSearchQuery
336 |         elif endpoint == 'department':
337 |             self.__class__ = DepartmentSearchQuery
338 |         elif endpoint == 'keyword':
339 |             self.__class__ = KeywordSearchQuery
340 |         elif endpoint == 'product':
341 |             self.__class__ = ProductSearchQuery
342 |         elif endpoint == 'series':
343 |             self.__class__ = SeriesSearchQuery
344 |         else:
345 |             raise exception.endpoint_not_found()
346 |         self.__init__(**kwargs)
347 | 
348 | 
349 | class ContentIdQuery(Query):
350 |     """Display content item with the given id."""
351 | 
352 |     _endpoint = 'content'
353 |     __action = 'id'
354 | 
355 |     def __init__(self, content_id='', **kwargs):
356 |         self.fields = parameters.CsvParam(
357 |             default=('categories,creators,href,keywords,relations,release_'
358 |                 'date,supertitle,teaser_text,teaser_title,title,uri,uuid'),
359 |             key='fields'
360 |         )
361 |         self.fq = parameters.StrParam(
362 |             default='uuid:%s' % content_id,
363 |             origin='fq'
364 |         )
365 |         self.q = parameters.StrParam(
366 |             origin='q',
367 |             default='*:*'
368 |         )
369 |         super(ContentIdQuery, self).__init__(**kwargs)
370 | 
371 |     def _fetch_raw(self):
372 |         query = util.url_encode(dict(self))
373 |         url = '%s/%s/%s?%s' % (current_app.config['SOLR_URL'],
374 |             self.__class__._endpoint, self.__action, query)
375 |         try:
376 |             data = urllib2.urlopen(url)
377 |             return json.load(data)
378 |         except urllib2.URLError:
379 |             raise exception.service_unavailable()
380 | 
381 |     def _fetch_keywords(self, keywords):
382 |         for keyword in keywords:
383 |             query = 'SELECT type, value FROM keyword WHERE id = ?;'
384 |             row = g.db.execute(query, (keyword,)).fetchone()
385 |             if row is None:
386 |                 continue
387 |             yield dict(
388 |                 rel=row[0],
389 |                 name=row[1],
390 |                 uri='%s/keyword/%s' % (current_app.config['API_URL'],
391 |                     keyword)
392 |             )
393 | 
394 |     def _fetch_relations(self, relations):
395 |         for relation in relations:
396 |             url = '%s/content/id?q=%s' % (current_app.config['SOLR_URL'],
397 |                 relation)
398 |             solr_data = urllib2.urlopen(url)
399 |             try:
400 |                 parsed = json.load(solr_data)
401 |                 title = parsed['response']['docs'][0]['title']
402 |             except:
403 |                 continue
404 |             yield dict(
405 |                 rel='related',
406 |                 name=title,
407 |                 uri='%s/content/%s' % (current_app.config['API_URL'],
408 |                     relation)
409 |             )
410 | 
411 |     def _fetch_authors(self, authors):
412 |         for author in authors:
413 |             yield dict(
414 |                 rel='author',
415 |                 name=author,
416 |                 uri='%s/author/%s' % (current_app.config['API_URL'],
417 |                     author.replace(' ', '-'))
418 |             )
419 | 
420 |     def _fetch_category(self, endpoint, cat_id, type):
421 |         query = 'SELECT value FROM %s WHERE id = "%s";' % (endpoint, cat_id)
422 |         row = g.db.execute(query).fetchone()
423 |         if row:
424 |             yield dict(
425 |                 rel=type,
426 |                 name=row[0],
427 |                 uri='%s/%s/%s' % (current_app.config['API_URL'],
428 |                     endpoint, cat_id)
429 |             )
430 | 
431 |     def fetch(self):
432 |         raw = self._fetch_raw()
433 | 
434 |         if len(raw['response']['docs']) == 0:
435 |             raise exception.resource_not_found()
436 |         else:
437 |             doc = raw['response']['docs'][0]
438 | 
439 |         categories = [('department', 'department'), ('product', 'product'),
440 |             ('sub_department', 'department'), ('series', 'series')]
441 |         whitelist = ['categories', 'creators', 'keywords', 'relations']
442 |         blacklist = ['body']
443 | 
444 |         for key in whitelist:
445 |             doc[key] = []
446 | 
447 |         for key in blacklist:
448 |             if key in doc:
449 |                 del doc[key]
450 | 
451 |         if 'uri' in self.fields:
452 |             doc['uri'] = '%s/%s/%s' % (current_app.config['API_URL'],
453 |                 self._endpoint, doc['uuid'])
454 | 
455 |         if 'keyword' in doc and 'keywords' in self.fields:
456 |             kw = self._fetch_keywords(doc['keyword'])
457 |             doc['keywords'].extend(kw)
458 |             del doc['keyword']
459 | 
460 |         if 'related' in doc and 'relations' in self.fields:
461 |             rl = self._fetch_relations(doc['related'])
462 |             doc['relations'].extend(rl)
463 |             del doc['related']
464 | 
465 |         if 'author' in doc and 'creators' in self.fields:
466 |             au = self._fetch_authors(doc['author'])
467 |             doc['creators'].extend(au)
468 |             del doc['author']
469 | 
470 |         for category, endpoint in categories:
471 |             if category in doc and 'categories' in self.fields:
472 |                 cat_id = doc[category]
473 |                 cat = self._fetch_category(endpoint, cat_id, category)
474 |                 doc['categories'].extend(cat)
475 |                 del doc[category]
476 | 
477 |         for key in doc.keys():
478 |             if key not in self.fields:
479 |                 del doc[key]
480 | 
481 |         return doc
482 | 
483 | 
484 | class DefinitionQuery(Query):
485 |     """Return API meta information for all available queries."""
486 | 
487 |     def __init__(self, **kwargs):
488 |         super(DefinitionQuery, self).__init__(**kwargs)
489 | 
490 |     def _make_def(self, endpoint, query_class):
491 |         url = '%s/%s' % (current_app.config['API_URL'], endpoint)
492 |         params = dict(p for p in query_class().params())
493 |         doc = query_class().__doc__
494 |         return endpoint, dict(url=url, params=params, doc=doc)
495 | 
496 |     def fetch(self):
497 |         endpoints = {'author': AuthorSearchQuery,
498 |             'author/{id}': FilteredContentSearchQuery,
499 |             'client': DisplayClientQuery,
500 |             'content': ContentSearchQuery,
501 |             'content/{id}': ContentIdQuery,
502 |             'department': DepartmentSearchQuery,
503 |             'department/{id}': FilteredContentSearchQuery,
504 |             'keyword': KeywordSearchQuery,
505 |             'keyword/{id}': FilteredContentSearchQuery,
506 |             'product': ProductSearchQuery,
507 |             'product/{id}': FilteredContentSearchQuery,
508 |             'series': SeriesSearchQuery,
509 |             'series/{id}': FilteredContentSearchQuery}
510 |         return dict(self._make_def(ep, endpoints[ep]) for ep in endpoints)
511 | 


--------------------------------------------------------------------------------
/src/zeit/api/schemas/database.sql:
--------------------------------------------------------------------------------
 1 | /*
 2 |     zeit.api.schemas.database
 3 |     ~~~~~~~~~~~~~
 4 | 
 5 |     These are the initialization statements for the main SQLite database.
 6 | 
 7 |     Copyright: (c) 2013 by ZEIT ONLINE.
 8 |     License: BSD, see LICENSE.md for more details.
 9 | */
10 | 
11 | CREATE TABLE IF NOT EXISTS author
12 | (
13 | 	href		CHAR(256),
14 | 	id			CHAR(256)	NOT NULL PRIMARY KEY,
15 | 	type		CHAR(32)	NOT NULL,
16 | 	uri			CHAR(288)	NOT NULL,
17 | 	value		CHAR(256)	NOT NULL
18 | );
19 | 
20 | CREATE TABLE IF NOT EXISTS client
21 | (
22 | 	api_key		CHAR(64)	NOT NULL PRIMARY KEY,
23 | 	tier		CHAR(32)	NOT NULL,
24 | 	name		CHAR(128),
25 | 	email		CHAR(128),
26 | 	requests	UNSIGNED INTEGER,
27 | 	reset		UNSIGNED INTEGER
28 | );
29 | 
30 | CREATE TABLE IF NOT EXISTS department
31 | (
32 | 	href		CHAR(128),
33 | 	id			CHAR(64)	NOT NULL PRIMARY KEY,
34 | 	parent		CHAR(64),
35 | 	uri			CHAR(96)	NOT NULL,
36 | 	value		CHAR(64)	NOT NULL,
37 | 	FOREIGN KEY(parent) REFERENCES department(id)
38 | );
39 | 
40 | CREATE TABLE IF NOT EXISTS keyword
41 | (
42 | 	href		CHAR(128),
43 | 	id			CHAR(64)	NOT NULL PRIMARY KEY,
44 | 	lexical		CHAR(64)	NOT	NULL,
45 | 	score		UNSIGNED INTEGER,
46 | 	type		CHAR(32)	NOT NULL,
47 | 	uri			CHAR(96)	NOT NULL,
48 | 	value		CHAR(64)	NOT NULL
49 | );
50 | 
51 | CREATE TABLE IF NOT EXISTS product
52 | (
53 | 	href		CHAR(128),
54 | 	id			CHAR(32)	NOT NULL PRIMARY KEY,
55 | 	uri			CHAR(64)	NOT NULL,
56 | 	value		CHAR(64)	NOT NULL
57 | );
58 | 
59 | CREATE TABLE IF NOT EXISTS series
60 | (
61 | 	href		CHAR(128),
62 | 	id			CHAR(64)	NOT NULL PRIMARY KEY,
63 | 	name		CHAR(128)	NOT NULL,
64 | 	uri			CHAR(96)	NOT NULL,
65 | 	value		CHAR(128)	NOT NULL
66 | );


--------------------------------------------------------------------------------
/src/zeit/api/schemas/schema_.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8" ?>
  2 | <!--
  3 |  Licensed to the Apache Software Foundation (ASF) under one or more
  4 |  contributor license agreements.  See the NOTICE file distributed with
  5 |  this work for additional information regarding copyright ownership.
  6 |  The ASF licenses this file to You under the Apache License, Version 2.0
  7 |  (the "License"); you may not use this file except in compliance with
  8 |  the License.  You may obtain a copy of the License at
  9 | 
 10 |      http://www.apache.org/licenses/LICENSE-2.0
 11 | 
 12 |  Unless required by applicable law or agreed to in writing, software
 13 |  distributed under the License is distributed on an "AS IS" BASIS,
 14 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 |  See the License for the specific language governing permissions and
 16 |  limitations under the License.
 17 | -->
 18 | 
 19 | <!--  
 20 |  This is the Solr schema file. This file should be named "schema.xml" and
 21 |  should be in the conf directory under the solr home
 22 |  (i.e. ./solr/conf/schema.xml by default) 
 23 |  or located where the classloader for the Solr webapp can find it.
 24 | 
 25 |  This example schema is the recommended starting point for users.
 26 |  It should be kept correct and concise, usable out-of-the-box.
 27 | 
 28 |  For more information, on how to customize this file, please see
 29 |  http://wiki.apache.org/solr/SchemaXml
 30 | -->
 31 | 
 32 | <schema name="example" version="1.1">
 33 |   <!-- attribute "name" is the name of this schema and is only used for display purposes.
 34 |        Applications should change this to reflect the nature of the search collection.
 35 |        version="1.1" is Solr's version number for the schema syntax and semantics.  It should
 36 |        not normally be changed by applications.
 37 |        1.0: multiValued attribute did not exist, all fields are multiValued by nature
 38 |        1.1: multiValued attribute introduced, false by default -->
 39 | 
 40 |   <types>
 41 |     <!-- field type definitions. The "name" attribute is
 42 |        just a label to be used by field definitions.  The "class"
 43 |        attribute and any other attributes determine the real
 44 |        behavior of the fieldType.
 45 |          Class names starting with "solr" refer to java classes in the
 46 |        org.apache.solr.analysis package.
 47 |     -->
 48 | 
 49 |     <!-- The StrField type is not analyzed, but indexed/stored verbatim.  
 50 |        - StrField and TextField support an optional compressThreshold which
 51 |        limits compression (if enabled in the derived fields) to values which
 52 |        exceed a certain size (in characters).
 53 |     -->
 54 |     <!-- A string field that has no tokenizer -->
 55 |     <fieldType name="string_nt" class="solr.StrField" omitNorms="true"/>
 56 | 
 57 |     <fieldType name="string" class="solr.StrField" sortMissingLast="true" omitNorms="true">
 58 |          <analyzer>
 59 |             <tokenizer class="solr.WhitespaceTokenizerFactory"/>
 60 |             <filter class="solr.SnowballPorterFilterFactory" language="German" />
 61 |             <filter class="solr.LowerCaseFilterFactory"/>
 62 |         </analyzer>
 63 |     </fieldType>
 64 | 
 65 |     <!-- boolean type: "true" or "false" -->
 66 |     <fieldType name="boolean" class="solr.BoolField" sortMissingLast="true" omitNorms="true"/>
 67 | 
 68 |     <!-- The optional sortMissingLast and sortMissingFirst attributes are
 69 |          currently supported on types that are sorted internally as strings.
 70 |        - If sortMissingLast="true", then a sort on this field will cause documents
 71 |          without the field to come after documents with the field,
 72 |          regardless of the requested sort order (asc or desc).
 73 |        - If sortMissingFirst="true", then a sort on this field will cause documents
 74 |          without the field to come before documents with the field,
 75 |          regardless of the requested sort order.
 76 |        - If sortMissingLast="false" and sortMissingFirst="false" (the default),
 77 |          then default lucene sorting will be used which places docs without the
 78 |          field first in an ascending sort and last in a descending sort.
 79 |     -->    
 80 | 
 81 | 
 82 |     <!-- numeric field types that store and index the text
 83 |          value verbatim (and hence don't support range queries, since the
 84 |          lexicographic ordering isn't equal to the numeric ordering) -->
 85 |     <fieldType name="integer" class="solr.IntField" omitNorms="true"/>
 86 |     <fieldType name="long" class="solr.LongField" omitNorms="true"/>
 87 |     <fieldType name="float" class="solr.FloatField" omitNorms="true"/>
 88 |     <fieldType name="double" class="solr.DoubleField" omitNorms="true"/>
 89 | 
 90 | 
 91 |     <!-- Numeric field types that manipulate the value into
 92 |          a string value that isn't human-readable in its internal form,
 93 |          but with a lexicographic ordering the same as the numeric ordering,
 94 |          so that range queries work correctly. -->
 95 |     <fieldType name="sint" class="solr.SortableIntField" sortMissingLast="true" omitNorms="true"/>
 96 |     <fieldType name="slong" class="solr.SortableLongField" sortMissingLast="true" omitNorms="true"/>
 97 |     <fieldType name="sfloat" class="solr.SortableFloatField" sortMissingLast="true" omitNorms="true"/>
 98 |     <fieldType name="sdouble" class="solr.SortableDoubleField" sortMissingLast="true" omitNorms="true"/>
 99 | 
100 | 
101 |     <!-- The format for this date field is of the form 1995-12-31T23:59:59Z, and
102 |          is a more restricted form of the canonical representation of dateTime
103 |          http://www.w3.org/TR/xmlschema-2/#dateTime    
104 |          The trailing "Z" designates UTC time and is mandatory.
105 |          Optional fractional seconds are allowed: 1995-12-31T23:59:59.999Z
106 |          All other components are mandatory.
107 | 
108 |          Expressions can also be used to denote calculations that should be
109 |          performed relative to "NOW" to determine the value, ie...
110 | 
111 |                NOW/HOUR
112 |                   ... Round to the start of the current hour
113 |                NOW-1DAY
114 |                   ... Exactly 1 day prior to now
115 |                NOW/DAY+6MONTHS+3DAYS
116 |                   ... 6 months and 3 days in the future from the start of
117 |                       the current day
118 |                       
119 |          Consult the DateField javadocs for more information.
120 |       -->
121 |     <fieldType name="date" class="solr.DateField" sortMissingLast="true" omitNorms="true"/>
122 | 
123 |     <!-- solr.TextField allows the specification of custom text analyzers
124 |          specified as a tokenizer and a list of token filters. Different
125 |          analyzers may be specified for indexing and querying.
126 | 
127 |          The optional positionIncrementGap puts space between multiple fields of
128 |          this type on the same document, with the purpose of preventing false phrase
129 |          matching across fields.
130 | 
131 |          For more info on customizing your analyzer chain, please see
132 |          http://wiki.apache.org/solr/AnalyzersTokenizersTokenFilters
133 |      -->
134 | 
135 |     <!-- One can also specify an existing Analyzer class that has a
136 |          default constructor via the class attribute on the analyzer element
137 |     <fieldType name="text_greek" class="solr.TextField">
138 |       <analyzer class="org.apache.lucene.analysis.el.GreekAnalyzer"/>
139 |     </fieldType>
140 |     -->
141 | 
142 |     <!-- A text field that only splits on whitespace for exact matching of words -->
143 |     <fieldType name="text_ws" class="solr.TextField" positionIncrementGap="100">
144 |       <analyzer>
145 |         <tokenizer class="solr.WhitespaceTokenizerFactory"/>
146 |       </analyzer>
147 |     </fieldType>
148 | 
149 |     <!-- A text field that uses WordDelimiterFilter to enable splitting and matching of
150 |         words on case-change, alpha numeric boundaries, and non-alphanumeric chars,
151 |         so that a query of "wifi" or "wi fi" could match a document containing "Wi-Fi".
152 |         Synonyms and stopwords are customized by external files, and stemming is enabled.
153 |         Duplicate tokens at the same position (which may result from Stemmed Synonyms or
154 |         WordDelim parts) are removed.
155 |         -->
156 |     <fieldType name="text" class="solr.TextField" positionIncrementGap="100">
157 |       <analyzer type="index">
158 |         <tokenizer class="solr.WhitespaceTokenizerFactory"/>
159 |         <!-- in this example, we will only use synonyms at query time
160 |         <filter class="solr.SynonymFilterFactory" synonyms="index_synonyms.txt" ignoreCase="true" expand="false"/>
161 |         -->
162 |         <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/>
163 |         <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" catenateWords="1" catenateNumbers="1" catenateAll="0"/>
164 |         <filter class="solr.LowerCaseFilterFactory"/>
165 |         <filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>
166 |         <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
167 |         <filter class="solr.SnowballPorterFilterFactory" language="German" />
168 |       </analyzer>
169 |       <analyzer type="query">
170 |         <tokenizer class="solr.WhitespaceTokenizerFactory"/>
171 |         <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/>
172 |         <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/>
173 |         <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" catenateWords="0" catenateNumbers="0" catenateAll="0"/>
174 |         <filter class="solr.LowerCaseFilterFactory"/>
175 |         <filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>
176 |         <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
177 |         <filter class="solr.SnowballPorterFilterFactory" language="German" />
178 |       </analyzer>
179 |     </fieldType>
180 | 
181 | 
182 |     <!-- Less flexible matching, but less false matches.  Probably not ideal for product names,
183 |          but may be good for SKUs.  Can insert dashes in the wrong place and still match. -->
184 |     <fieldType name="textTight" class="solr.TextField" positionIncrementGap="100" >
185 |       <analyzer>
186 |         <tokenizer class="solr.WhitespaceTokenizerFactory"/>
187 |         <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="false"/>
188 |         <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/>
189 |         <filter class="solr.WordDelimiterFilterFactory" generateWordParts="0" generateNumberParts="0" catenateWords="1" catenateNumbers="1" catenateAll="0"/>
190 |         <filter class="solr.LowerCaseFilterFactory"/>
191 |         <filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>
192 |         <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
193 |         <filter class="solr.SnowballPorterFilterFactory" language="German" />
194 | 
195 |       </analyzer>
196 |     </fieldType>
197 | 
198 |     <!-- This is an example of using the KeywordTokenizer along
199 |          With various TokenFilterFactories to produce a sortable field
200 |          that does not include some properties of the source text
201 |       -->
202 |     <fieldType name="alphaOnlySort" class="solr.TextField" sortMissingLast="true" omitNorms="true">
203 |       <analyzer>
204 |         <!-- KeywordTokenizer does no actual tokenizing, so the entire
205 |              input string is preserved as a single token
206 |           -->
207 |         <tokenizer class="solr.KeywordTokenizerFactory"/>
208 |         <!-- The LowerCase TokenFilter does what you expect, which can be
209 |              when you want your sorting to be case insensitive
210 |           -->
211 |         <filter class="solr.LowerCaseFilterFactory" />
212 |         <!-- The TrimFilter removes any leading or trailing whitespace -->
213 |         <filter class="solr.TrimFilterFactory" />
214 |         <!-- The PatternReplaceFilter gives you the flexibility to use
215 |              Java Regular expression to replace any sequence of characters
216 |              matching a pattern with an arbitrary replacement string, 
217 |              which may include back refrences to portions of the orriginal
218 |              string matched by the pattern.
219 |              
220 |              See the Java Regular Expression documentation for more
221 |              infomation on pattern and replacement string syntax.
222 |              
223 |              http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/package-summary.html
224 |           -->
225 |         <filter class="solr.PatternReplaceFilterFactory"
226 |                 pattern="([^a-z])" replacement="" replace="all"
227 |         />
228 |       </analyzer>
229 |     </fieldType>
230 | 
231 |     <!-- since fields of this type are by default not stored or indexed, any data added to 
232 |          them will be ignored outright 
233 |      --> 
234 |     <fieldtype name="ignored" stored="false" indexed="false" class="solr.StrField" /> 
235 | 
236 |  </types>
237 | 
238 | 
239 |  <fields>
240 |    <!-- Valid attributes for fields:
241 |      name: mandatory - the name for the field
242 |      type: mandatory - the name of a previously defined type from the <types> section
243 |      indexed: true if this field should be indexed (searchable or sortable)
244 |      stored: true if this field should be retrievable
245 |      compressed: [false] if this field should be stored using gzip compression
246 |        (this will only apply if the field type is compressable; among
247 |        the standard field types, only TextField and StrField are)
248 |      multiValued: true if this field may contain multiple values per document
249 |      omitNorms: (expert) set to true to omit the norms associated with
250 |        this field (this disables length normalization and index-time
251 |        boosting for the field, and saves some memory).  Only full-text
252 |        fields or fields that need an index-time boost need norms.
253 |    -->
254 | 
255 |    <field name="id" type="string" indexed="true" stored="true" required="true" /> 
256 |    <field name="sku" type="textTight" indexed="true" stored="true" omitNorms="true"/>
257 |    <field name="name" type="text" indexed="true" stored="true"/>
258 |    <field name="nameSort" type="string" indexed="true" stored="false"/>
259 |    <field name="alphaNameSort" type="alphaOnlySort" indexed="true" stored="false"/>
260 | 
261 |    <!-- catchall field, containing all other searchable text fields (implemented
262 |         via copyField further on in this schema  -->
263 |    <field name="text" type="text" indexed="true" stored="false" multiValued="true"/>
264 | 
265 |    <!-- Here, default is used to create a "timestamp" field indicating
266 |         When each document was indexed.
267 |      -->
268 |    <field name="timestamp" type="date" indexed="true" stored="true" default="NOW" multiValued="false"/>
269 | 
270 |    <!-- My fields -->
271 |    <field name="alt" type="text" indexed="true" stored="true" />
272 |    <field name="authors" type="string" indexed="true" stored="true" multiValued="true" />
273 |    <field name="authors_fulltext" type="text" indexed="true" stored="false" />
274 |    <field name="banner" type="boolean" indexed="true" stored="true" />
275 |    <field name="banner-id" type="text" indexed="true" stored="true" />
276 |    <field name="boost" type="integer" indexed="true" stored="false" />
277 |    <field name="breaking_news" type="boolean" indexed="true" stored="true" />
278 |    <field name="allow_comments" type="boolean" indexed="true" stored="true" />
279 |    <field name="byline" type="text" indexed="true" stored="true" />
280 |    <field name="caption" type="text" indexed="true" stored="true" />
281 |    <field name="corrected" type="string_nt" indexed="true" stored="true" />
282 |    <field name="countings" type="string_nt" indexed="true" stored="true" />
283 |    <field name="date-first-released" type="date" indexed="true" stored="true" />
284 |    <field name="date-last-modified" type="date" indexed="true" stored="true" />
285 |    <field name="date-last-published" type="date" indexed="true" stored="true" />
286 |    <field name="DailyNL" type="boolean" indexed="true" stored="true" />
287 |    <field name="expires" type="date" indexed="true" stored="true" />
288 |    <field name="created" type="date" indexed="true" stored="true" />
289 |    <field name="graphical-preview-url" type="string_nt" indexed="false" stored="true" />
290 |    <field name="graphical-preview-url-large" type="string_nt" indexed="false" stored="true" />
291 |    <field name="h264_url" type="string_nt" indexed="false" stored="true" />
292 |    <field name="has_recensions" type="boolean" indexed="true" stored="true" />
293 |    <field name="icon" type="string" indexed="false" stored="true" />
294 |    <field name="image-reference" type="string" indexed="true" stored="true" multiValued="true" />
295 |    <field name="indexteaser_text" type="text" indexed="true" stored="true" />
296 |    <field name="indexteaser_title" type="text" indexed="true" stored="true" />
297 |    <field name="keywords" type="text" indexed="true" stored="true" />
298 |    <field name="keywords_list" type="text" indexed="true" stored="true" multiValued="true"/>
299 |    <field name="last-semantic-change" type="date" indexed="true" stored="true" />
300 |    <field name="last_modified_by" type="string" indexed="true" stored="true" />
301 |    <field name="main_text" type="text" indexed="true" stored="true" />
302 |    <field name="master_image" type="text" indexed="true" stored="true" />
303 |    <field name="mostread" type="boolean" indexed="true" stored="true" />
304 |    <field name="page" type="integer" indexed="true" stored="true" />
305 |    <field name="product_id" type="string_nt" indexed="true" stored="true" />
306 |    <field name="product_text" type="text" indexed="true" stored="true" />
307 |    <field name="published" type="string_nt" indexed="true" stored="true" />
308 |    <field name="refined" type="string_nt" indexed="true" stored="true" />
309 |    <field name="raw-tags" type="text" indexed="true" stored="true" />
310 |    <field name="referenced" type="string_nt" indexed="true" stored="true" multiValued="true" />
311 |    <field name="ressort" type="string_nt" indexed="true" stored="true" />
312 |    <field name="serie" type="text" indexed="true" stored="true" />
313 |    <field name="sub_ressort" type="string_nt" indexed="true" stored="true" />
314 |    <field name="subtitle" type="text" indexed="true" stored="true" />
315 |    <field name="supertitle" type="text" indexed="true" stored="true" />
316 |    <field name="teaser_text" type="text" indexed="true" stored="true" />
317 |    <field name="teaser_title" type="text" indexed="true" stored="true" />
318 |    <field name="title" type="text" indexed="true" stored="true" />
319 |    <field name="type" type="string_nt" indexed="true" stored="true" />
320 |    <field name="uniqueId" type="string_nt" indexed="true" stored="true" />
321 |    <field name="urgent" type="boolean" indexed="true" stored="true" />
322 |    <field name="uuid" type="string_nt" indexed="true" stored="true" />
323 |    <field name="volume" type="integer" indexed="true" stored="true" />
324 |    <field name="year" type="integer" indexed="true" stored="true" />
325 |    <field name="range" type="integer" indexed="false" stored="true" />
326 |    <field name="range_details" type="string_nt" indexed="false" stored="true" />
327 | 
328 | 
329 |    <!-- Dynamic field definitions.  If a field name is not found, dynamicFields
330 |         will be used if the name matches any of the patterns.
331 |         RESTRICTION: the glob-like pattern in the name attribute must have
332 |         a "*" only at the start or the end.
333 |         EXAMPLE:  name="*_i" will match any field ending in _i (like myid_i, z_i)
334 |         Longer patterns will be matched first.  if equal size patterns
335 |         both match, the first appearing in the schema will be used.  -->
336 |    <dynamicField name="*_i"  type="sint"    indexed="true"  stored="true"/>
337 |    <dynamicField name="*_s"  type="string"  indexed="true"  stored="true"/>
338 |    <dynamicField name="*_l"  type="slong"   indexed="true"  stored="true"/>
339 |    <dynamicField name="*_t"  type="text"    indexed="true"  stored="true"/>
340 |    <dynamicField name="*_b"  type="boolean" indexed="true"  stored="true"/>
341 |    <dynamicField name="*_f"  type="sfloat"  indexed="true"  stored="true"/>
342 |    <dynamicField name="*_d"  type="sdouble" indexed="true"  stored="true"/>
343 |    <dynamicField name="*_dt" type="date"    indexed="true"  stored="true"/>
344 | 
345 |    <!-- uncomment the following to ignore any fields that don't already match an existing 
346 |         field name or dynamic field, rather than reporting them as an error. 
347 |         alternately, change the type="ignored" to some other type e.g. "text" if you want 
348 |         unknown fields indexed and/or stored by default --> 
349 |    <!--dynamicField name="*" type="ignored" /-->
350 |    
351 |  </fields>
352 | 
353 |  <!-- Field to use to determine and enforce document uniqueness. 
354 |       Unless this field is marked with required="false", it will be a required field
355 |    -->
356 |  <uniqueKey>id</uniqueKey>
357 | 
358 |  <!-- field for the QueryParser to use when an explicit fieldname is absent -->
359 |  <defaultSearchField>text</defaultSearchField>
360 | 
361 |  <!-- SolrQueryParser configuration: defaultOperator="AND|OR" -->
362 |  <solrQueryParser defaultOperator="AND"/>
363 | 
364 |   <!-- copyField commands copy one field to another at the time a document
365 |         is added to the index.  It's used either to index the same field differently,
366 |         or to add multiple fields to the same field for easier/faster searching.  -->
367 |    <copyField source="id" dest="sku"/>
368 |    <copyField source="name" dest="text"/>
369 |    <copyField source="name" dest="nameSort"/>
370 |    <copyField source="name" dest="alphaNameSort"/>
371 |    <copyField source="uuid" dest="id" />
372 |    <copyField source="alt" dest="text" />
373 |    <copyField source="byline" dest="text" />
374 |    <copyField source="caption" dest="text" />
375 |    <copyField source="indexteaser_title" dest="text" />
376 |    <copyField source="indexteaser_text" dest="text" />
377 |    <copyField source="keywords" dest="text" />
378 |    <copyField source="main_text" dest="text" />
379 |    <copyField source="master_image" dest="text" />
380 |    <copyField source="ressort" dest="text" />
381 |    <copyField source="serie" dest="text" />
382 |    <copyField source="sub_ressort" dest="text" />
383 |    <copyField source="subtitle" dest="text" />
384 |    <copyField source="supertitle" dest="text" />
385 |    <copyField source="teaser_title" dest="text" />
386 |    <copyField source="teaser_text" dest="text" />
387 |    <copyField source="title" dest="text" />
388 | 
389 | 
390 |  <!-- Similarity is the scoring routine for each document vs. a query.
391 |       A custom similarity may be specified here, but the default is fine
392 |       for most applications.  -->
393 |  <!-- <similarity class="org.apache.lucene.search.DefaultSimilarity"/> -->
394 | 
395 | </schema>
396 | 


--------------------------------------------------------------------------------
/src/zeit/api/schemas/solrmsg.rnc:
--------------------------------------------------------------------------------
 1 | #
 2 | #   zeit.api.schemas.solrmsg
 3 | #   ~~~~~~~~~~~~~~~~~~~~~~~~
 4 | #
 5 | #   RelaxNG schema for messages to update articles in the Solr index.
 6 | #   For more info see: http://wiki.apache.org/solr/UpdateXmlMessages
 7 | #
 8 | #   Copyright: (c) 2013 by ZEIT ONLINE.
 9 | #   License: BSD, see LICENSE.md for more details.
10 | #
11 | 
12 | 
13 | default namespace = ""
14 | 
15 | start =
16 |     element doc {
17 |         element field { attribute name { 'related' }, text }*,
18 |         element field { attribute name { 'keyword' }, text }*,
19 |         element field { attribute name { 'author' }, text }+,  
20 |         element field { attribute name { 'product' }, text }?,
21 |         element field { attribute name { 'release_date' }, text }?,
22 |         element field { attribute name { 'department' }, text }*,
23 |         element field { attribute name { 'sub_department' }, text }*,
24 |         element field { attribute name { 'self' }, text },
25 |         element field { attribute name { 'subtitle' }, text }?,
26 |         element field { attribute name { 'supertitle' }, text }?,
27 |         element field { attribute name { 'title' }, text }?,
28 |         element field { attribute name { 'body' }, text }
29 |     }


--------------------------------------------------------------------------------
/src/zeit/api/settings.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """
 3 |     zeit.api.settings
 4 |     ~~~~~~~~~~~~~~~~
 5 | 
 6 |     This module contains config classes for different build scenarios.
 7 | 
 8 |     Copyright: (c) 2013 by ZEIT ONLINE.
 9 |     License: BSD, see LICENSE.md for more details.
10 | """
11 | 
12 | 
13 | class Config(object):
14 | 
15 |     ACCESS_TIMEFRAME = 86400
16 |     ACCESS_TIERS = {'free': 10000, 'pro': 50000, 'max': 1000000}
17 | 
18 |     SCHEMA = '/schemas/database.sql'
19 |     DATABASE = '/var/lib/zon-api/data.db'
20 |     PRODUCT_ALPHABET = ''
21 |     SERIES_ALPHABET = ''
22 |     KEYWORD_ALPHABET = ''
23 |     DEPARTMENT_ALPHABET = ''
24 |     RECAPTCHA_PRIVATE_KEY = ''
25 |     RECAPTCHA_PUBLIC_KEY = ''
26 | 
27 |     try:
28 |         import private
29 |         PRODUCT_ALPHABET = private.PRODUCT_ALPHABET
30 |         SERIES_ALPHABET = private.SERIES_ALPHABET
31 |         KEYWORD_ALPHABET = private.KEYWORD_ALPHABET
32 |         DEPARTMENT_ALPHABET = private.DEPARTMENT_ALPHABET
33 |     except:
34 |         pass
35 | 
36 | 
37 | class ProductionConfig(Config):
38 | 
39 |     DOC_URL = 'https://developer.zeit.de'
40 |     API_URL = 'https://api.zeit.de'
41 |     SOLR_URL = 'http://127.0.0.1:8983/solr'
42 | 
43 |     try:
44 |         import private
45 |         RECAPTCHA_PRIVATE_KEY = private.RECAPTCHA_PRIVATE_PROD
46 |         RECAPTCHA_PUBLIC_KEY = private.RECAPTCHA_PUBLIC_PROD
47 |     except:
48 |         pass
49 | 
50 | 
51 | class DevelopmentConfig(Config):
52 | 
53 |     DOC_URL = 'http://localhost:9090'
54 |     API_URL = 'http://localhost:9091'
55 |     SOLR_URL = 'http://developer.zeit.de:8983/solr'
56 | 
57 |     try:
58 |         import private
59 |         RECAPTCHA_PRIVATE_KEY = private.RECAPTCHA_PRIVATE_DEVEL
60 |         RECAPTCHA_PUBLIC_KEY = private.RECAPTCHA_PUBLIC_DEVEL
61 |     except:
62 |         pass
63 | 
64 | 
65 | class LocalConfig(DevelopmentConfig):
66 | 
67 |     API_PORT = 5000
68 |     DOC_PORT = 5001
69 |     SERVERNAME = '127.0.0.1'
70 |     API_URL = 'http://%s:%d' % (SERVERNAME, API_PORT)
71 |     DOC_URL = 'http://%s:%d' % (SERVERNAME, DOC_PORT)
72 | 
73 | 
74 | class TestingConfig(LocalConfig):
75 | 
76 |     TESTING = True
77 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/base.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html SYSTEM "about:legacy-compat">
  2 | <html xmlns:esi="http://www.edge-delivery.org/esi/1.0" lang="de-de">
  3 | <head>
  4 | <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  5 | <script src="//cdn.optimizely.com/js/281825380.js"></script><!--start: head-->
  6 | 		<!--start: headtitle-->
  7 | 		<title>ZEIT ONLINE | Developer</title>
  8 | <!--end: headtitle-->
  9 | 		<!--start: headmeta-->
 10 | 		<meta name="apple-itunes-app" content="app-id=448633376">
 11 | 		<meta name="description" content="Developer:">
 12 | <meta name="robots" content="index,follow,noodp,noydir,noarchive">
 13 | <meta name="author" content="ZEIT ONLINE GmbH, Hamburg, Germany">
 14 | <meta name="application-name" content="ZEIT ONLINE">
 15 | <meta name="msapplication-TileImage" content="https://img.zeit.de/static/img/zo-icon-win8-144x144.png">
 16 | <meta name="msapplication-TileColor" content="#e6e6e6">
 17 | <meta property="og:site_name" content="ZEIT ONLINE">
 18 | <meta property="fb:admins" content="595098294">
 19 | <meta property="og:type" content="article">
 20 | <meta property="og:url" content="https://www.zeit.de/canvas/developer">
 21 | <meta property="og:title" content="Developer">
 22 | <!--end: headmeta-->
 23 | 		<!--  canvas stats: [version: deprecated!]  [date: 2014-04-07+02:00]  [doc_path: /canvas/developer]  -->
 24 | 		
 25 | 		<!--start: headstyles-->
 26 | 		<link href="https://static.zeit.de/static/css/base.css?0059" media="screen" type="text/css" rel="stylesheet">
 27 | <link rel="shortcut icon" href="https://static.zeit.de/static/img/favicon.ico">
 28 | <link rel="apple-touch-icon-precomposed" href="https://img.zeit.de/static/img/ZO-ipad-114x114.png">
 29 | <link rel="stylesheet" type="text/css" href="{{ doc_url }}/style.css">
 30 | <!--end: headstyles-->
 31 | 		<!--start: headscripts-->
 32 | 		<script type="text/javascript">
 33 | 			// <![CDATA[
 34 | 			window.zeitversion = "0058";
 35 | 		window.js_path = "https://static.zeit.de/static/js";
 36 | 		window.css_path = "https://static.zeit.de/static/css";
 37 | 		window.www_root = "https://www.zeit.de";
 38 | 			// ]]>
 39 | 		</script>
 40 | 		<script type="text/javascript" src="https://static.zeit.de/static/js/jquery/1.4.2/jquery-1.4.2.min.js"></script>
 41 | 		<script type="text/javascript" src="https://static.zeit.de/static/js/jquery/plugins/jquery.lazy/jquery.lazy.js?0058"></script><script type="text/javascript" src="https://static.zeit.de/static/js/base.js?0058"></script>
 42 | 		
 43 | 		<script type="text/javascript" src="https://static.zeit.de/static/js/iqd/adam.js"></script>
 44 | 		<script type="text/javascript">
 45 | 					
 46 | 					// <![CDATA[
 47 | 
 48 | 					
 49 | 						// IQD_AdProbeTag
 50 | 						var wlCus = "13004,13002,13033,13003,13005,12998";
 51 | 						var wlOrd = new Date().getTime();
 52 | 						try {
 53 | 						   document.write('<scr'+'ipt type="text/javascript" language="JavaScript" src="//req.connect.wunderloop.net/AP/1624/6625/12996/js?cus=' + wlCus + '&ord=' + wlOrd + '"><\/scr'+'ipt>');
 54 | 						} catch(err) { }
 55 | 					
 56 | 					// ]]>
 57 | 
 58 | 			</script>
 59 | 		<!--toggle: yieldlab-->
 60 | 		<script type="text/javascript" src="//ad.yieldlab.net/yp/21752,21754,21759,21987?ts=1396885470"></script>
 61 | 		<!--BEGIN Krux Control Tag for "IQ"-->
 62 | 		<!--Source: /snippet/controltag?confid=Ip52Cnbc&site=IQ&edit=1-->
 63 | 		<script class="kxct" data-id="Ip52Cnbc" data-timing="async" data-version="1.9" type="text/javascript">
 64 | 			// <![CDATA[
 65 | 			window.Krux||((Krux=function(){Krux.q.push(arguments)}).q=[]);
 66 | 			(function(){
 67 | 				var k=document.createElement('script');k.type='text/javascript';k.async=true;
 68 | 				var m,src=(m=location.href.match(/\bkxsrc=([^&]+)/))&&decodeURIComponent(m[1]);
 69 | 				k.src = /^https?:\/\/([^\/]+\.)?krxd\.net(:\d{1,5})?\//i.test(src) ? src : src === "disable" ? "" : (location.protocol==="https:"?"https:":"http:")+"//cdn.krxd.net/controltag?confid=Ip52Cnbc";
 70 | 				var s=document.getElementsByTagName('script')[0];s.parentNode.insertBefore(k,s);
 71 | 			}());
 72 | 			// ]]>
 73 | 		</script>
 74 | 		<!--END Krux Controltag-->
 75 | 		<!--BEGIN Krux IQ-->
 76 | 		<script class="kxint" type="text/javascript">
 77 | 			// <![CDATA[
 78 | 			window.Krux||((Krux=function(){Krux.q.push(arguments);}).q=[]);
 79 | 			(function(){
 80 | 				// Namespace centro
 81 | 				var Krux = this.Krux.adaudience = this.Krux.adaudience || {};
 82 | 				function retrieve(n){
 83 | 					var m, k='kxadaudience_'+n;
 84 | 					if (window.localStorage) {
 85 | 						return window.localStorage[k] || "";
 86 | 					} else if (navigator.cookieEnabled) {
 87 | 						m = document.cookie.match(k+'=([^;]*)');
 88 | 						return (m && unescape(m[1])) || "";
 89 | 					} else {
 90 | 						return '';
 91 | 					}
 92 | 				}
 93 | 				Krux.user = retrieve('user');
 94 | 				Krux.segments = retrieve('segs') ? retrieve('segs').split(',') : [];
 95 | 				// DFP Premium
 96 | 				var dfpp = [];
 97 | 				for(var i = 0; i < Krux.segments.length; i++) {
 98 | 					dfpp.push(Krux.segments[i]);
 99 | 				}
100 | 				Krux.dfppKeyValues = dfpp.length ? dfpp.join(',') + ';' : '';
101 | 				Krux.dfppKeyValues = 'ksg=' + Krux.dfppKeyValues;
102 | 			})();
103 | 			// ]]>
104 | 		</script>
105 | 		<!--end: headscripts-->
106 | 		
107 | 		
108 | 		<script type="text/javascript" src="https://script.ioam.de/iam.js"></script>
109 | 		<!--end: head-->
110 | </head>
111 | <body id="zeit-de" data-page_type="frame" class="body-administratives ipad-frame" data-ressort="administratives" data-banner_channel="administratives/centerpage" data-ad_channel="administratives" data-smk_path="/canvas/developer">
112 | <!--start: body-->
113 | 		<div id="countings" style="display:none;">
114 | <!--start: countings-->
115 | 		<!--SZM VERSION="2.0"-->
116 | 		<script type="text/javascript">
117 | 			var iam_data = {
118 | 				"st" : "zeitonl", // site/domain
119 | 				"cp" : "administratives/bild-text", // seitencode
120 | 				"sv" : "ke", // Es wird keine Befragungseinladung ausgeliefert.
121 | 				"co" : "URL: /canvas/developer" // comment
122 | 			}
123 | 			iom.c(iam_data,1); 
124 | 			</script>
125 | 		<!--/SZM VERSION="2.0"-->
126 | 		<!--SZM VERSION="1.5"-->
127 | 		<!--Dieses Online-Angebot unterliegt nicht der IVW-Kontrolle!-->
128 | 		<script type="text/javascript"><!--
129 | 					var IVW="http://zeitonl.ivwbox.de/cgi-bin/ivw/CP/rahmen/developer;";
130 | 					document.write("<img src=\""+IVW+"?r="+escape(document.referrer)+"&d="+(Math.random()*100000)+"\" alt=\"smztag\" width=\"1\" height=\"1\" />");
131 | 					// -->
132 | 				</script><noscript><img alt="szmtag" src="http://zeitonl.ivwbox.de/cgi-bin/ivw/CP/rahmen/developer;" height="1" width="1"></noscript>
133 | <!--/SZM-->
134 | 		<script type="text/javascript">
135 | 			var Z_IVW_RESSORT = 'rahmen/developer';
136 | 			var Z_WT_KENNUNG = 'redaktion.administratives...rahmen.online./canvas/developer';
137 | 		</script>
138 | 		<!--start: nuggad-->
139 | 		<script type="text/javascript">
140 | 			var ord = (Math.random()*100000);
141 | 			var n_pbt = "";
142 | 		</script><script type="text/javascript">
143 | 			nuggtg = encodeURIComponent(IVW.split("CP/")[1]);
144 | 			document.write('<scr'+'ipt type="text/javascript" src="http://gwp.nuggad.net/rc?nuggn=223088769&nuggsid=4168690&nuggtg='+nuggtg+'"><\/scr'+'ipt>');		
145 | 		</script><!--end: nuggad-->
146 | 		
147 | 		<script type="text/javascript">
148 | 			// <![CDATA[
149 | 				if( typeof yl === 'undefined') yl = {};
150 | 				if( typeof n_pbt === 'undefined' ) n_pbt = ""; // prevent javascript error if $banner_on = 'false'
151 |                 var YLP = yl.YpResult || "";
152 |                 var ylpid = [21752, 21754, 21759, 21987];
153 |                 var ylpid2 = [6069, 3039, 5641, 8504];
154 |                 var wl13004camp = wl13004camp || 0;
155 |                 var wl13002camp = wl13002camp || 0;
156 |                 var wl13033camp = wl13033camp || 0;
157 |                 var wl13001camp = wl13001camp || 0;
158 |                 var wl13003camp = wl13003camp || 0;
159 |                 var wl13034camp = wl13034camp || 0;
160 |                 var wl13005camp = wl13005camp || 0;
161 |                 var wl12998camp = wl12998camp || 0;
162 |                 var wl13170camp = wl13170camp || 0;
163 |                 try { var ylpsky = YLP.get(ylpid[0]).id; } catch(e) { ylpsky = 0; };
164 |                 try { var ylpmedrec = YLP.get(ylpid[1]).id; } catch(e) { ylpmedrec = 0; };
165 |                 try { var ylpsuba = YLP.get(ylpid[2]).id; } catch(e) { ylpsuba = 0; };
166 |                 try { var ylpdynamic = YLP.get(ylpid[3]).id; } catch(e) { ylpdynamic = 0; };
167 |                 try { var ylpwf = YLP.get(ylpid[3]).format; } catch(e) { ylpwf = 0; };
168 |                 var ylpwfid = 'y' + ylpwf;
169 |                 var iqd_wlCus = ['a13004', 'a13002', 'a13033', 'a13001', 'a13003', 'a13034', 'a13005', 'a12998', 'a13170', 'ysky', 'ymdr', 'ysba', 'ydyc', ylpwfid];
170 |                 var iqd_wlCusRec = [wl13004camp, wl13002camp, wl13033camp, wl13001camp, wl13003camp, wl13034camp, wl13005camp, wl12998camp, wl13170camp, ylpsky, ylpmedrec, ylpsuba, ylpdynamic, ylpwf];
171 |                 var iqd_wlCusRecStr = [];
172 |                 for (var i = 0; i < iqd_wlCus.length; i++) {
173 |                     iqd_wlCusRecStr[i] =  (iqd_wlCusRec[i] > 0) ? iqd_wlCus[i] + '=1' : iqd_wlCus[i] + '=0';
174 |                 }
175 |                 document.write('<scr'+'ipt>n_pbt += iqd_wlCusRecStr.join("\;");</scr'+'ipt>');
176 |                 if (window.Krux.adaudience.dfppKeyValues){
177 |                     document.write('<scr'+'ipt>n_pbt += ";" + window.Krux.adaudience.dfppKeyValues;</scr'+'ipt>');
178 |                 }
179 | 			// ]]>
180 | 			</script>
181 | 		<script>n_pbt = n_pbt.substr(0,1150);</script>
182 | 		<!--end: countings-->
183 | </div>
184 | <div id="top">
185 | <!--start: top-->
186 | 		<div class="center">
187 | <div id="p1" class="ad">
188 | <div id="place_1">
189 | 		<!--Bannerplatz "superbanner" Nr.1   Tile:1-->
190 | 		<script type="text/javascript"> 
191 | 				// <![CDATA[ 		
192 | 				if (typeof is_tablet === "undefined" || is_tablet === false) document.write('<script src="https://ad.de.doubleclick.net/adj/zeitonline/administratives/centerpage;dcopt=ist;tile=1;' + n_pbt + ';sz=728x90;kw=zeitonline;ord=' + ord + '?" type="text/javascript"><\/script>');
193 | 				// ]]>
194 | 			</script><noscript><div><a href="https://ad.de.doubleclick.net/jump/zeitonline/administratives/centerpage;tile=1;sz=728x90;kw=zeitonline;ord=123456789?" rel="nofollow"><img src="https://ad.de.doubleclick.net/ad/zeitonline/administratives/centerpage;tile=1;sz=728x90;kw=zeitonline;ord=123456789?" width="728" height="90" style="border:none;" alt=""></a></div></noscript>
195 | </div>
196 | <div id="p1_right"><div id="place_2">
197 | 		<!--Bannerplatz "skyscraper" Nr.2   Tile:2-->
198 | 		<script type="text/javascript"> 
199 | 				// <![CDATA[ 		
200 | 				if (typeof is_tablet === "undefined" || is_tablet === false) document.write('<script src="https://ad.de.doubleclick.net/adj/zeitonline/administratives/centerpage;tile=2;' + n_pbt + ';sz=120x600;kw=zeitonline;ord=' + ord + '?" type="text/javascript"><\/script>');
201 | 				// ]]>
202 | 			</script><noscript><div><a href="https://ad.de.doubleclick.net/jump/zeitonline/administratives/centerpage;tile=2;sz=120x600;kw=zeitonline;ord=123456789?" rel="nofollow"><img src="https://ad.de.doubleclick.net/ad/zeitonline/administratives/centerpage;tile=2;sz=120x600;kw=zeitonline;ord=123456789?" width="120" height="600" style="border:none;" alt=""></a></div></noscript>
203 | </div></div>
204 | </div>
205 | <div class="clr"></div>
206 | </div>
207 | <!--end: top-->
208 | </div>
209 | <div id="wrapper" class="center">
210 | <a id="wt_refpoint"></a>
211 | 		<!--start: wrapper-->
212 | 		<div id="header" role="banner">
213 | <!--start: header-->
214 | 		<ul class="nav" role="navigation">
215 | <li class="first"><ul class="nav-smallnav">
216 | <li class="first"><a href="https://www.zeitabo.de/?mcwt=2009_07_0002" id="hp.global.topnav.links.abo">Abo</a></li>
217 | <li><a href="https://shop.zeit.de?et=l6VVNm&amp;et_cid=42&amp;et_lid=175&amp;et_sub=Startseite_header" id="hp.global.topnav.links.shop">Shop</a></li>
218 | <li><a href="https://premium.zeit.de/?wt_mc=pm.intern.fix.zeitde.fix.dach.text.epaper" id="hp.global.topnav.links.epaper">E-Paper</a></li>
219 | <li><a href="https://premium.zeit.de/abo/appsios?wt_mc=pm.intern.fix.zeitde.fix.dach.text.apps" id="hp.global.topnav.links.apps">Apps</a></li>
220 | <li><a href="https://premium.zeit.de/abo/digitalpaket5?wt_mc=pm.intern.fix.zeitde.fix.dach.text.audio" id="hp.global.topnav.links.audio">Audio</a></li>
221 | <li><a href="https://www.zeit.de/archiv" id="hp.global.topnav.links.archiv">Archiv</a></li>
222 | <li class="last"><a href="https://www.zeit.de/spiele/index" id="hp.global.topnav.links.spiele">Spiele</a></li>
223 | </ul></li>
224 | <li><ul class="nav-smallnav">
225 | <li class="first"><a href="https://jobs.zeit.de/" id="hp.global.topnav.links.jobs">Jobs</a></li>
226 | <li><a href="https://www.zeit.de/angebote/partnersuche/index?pscode=01_100_20003_0001_0001_0005_empty_AF00ID_GV00ID" id="hp.global.topnav.links.partnersuche">Partnersuche</a></li>
227 | <li><a href="https://zeit.immowelt.de/" rel="nofollow" id="hp.global.topnav.links.immobilien">Immobilien</a></li>
228 | <li class="last"><a href="https://automarkt.zeit.de/" id="hp.global.topnav.links.automarkt">Automarkt</a></li>
229 | </ul></li>
230 | <li class="last"><ul class="nav-smallnav">
231 | <li class="first"><a href="https://www.zeit.de/zeit-magazin/index" id="hp.global.topnav.links.zeitmagazin">ZEITmagazin</a></li>
232 | <li><a href="https://www.zeit.de/campus/index" id="hp.global.topnav.links.zeitcampus">ZEITCampus</a></li>
233 | <li><a href="https://www.zeit.de/wissen/zeit-geschichte/index" id="hp.global.topnav.links.zeitgeschichte">ZEITGeschichte</a></li>
234 | <li class="last"><a href="https://www.zeit.de/wissen/zeit-wissen/index" id="hp.global.topnav.links.zeitwissen">ZEITWissen</a></li>
235 | </ul></li>
236 | </ul>
237 | <div class="logo">
238 | <a href="https://www.zeit.de/index" title="ZEIT ONLINE" class="zeitonline" style="background-image:url(https://static.zeit.de/static/img/zon-logo.svg?1393442189)"><!--start: title-->ZEIT ONLINE<!--end: title--></a><!--start: subtitle--><h1 class="cap"><a class="caplink" id="hp.global.topnav.Ressort.administratives" href="{{ doc_url }}">Developer</a></h1>
239 | <!--end: subtitle--><form accept-charset="utf-8" method="get" class="sitesearch" role="search" action="https://www.zeit.de/suche/index">
240 | <label for="q" class="hideme">suchen</label><input class="itext js-sitesearch-itext" id="q" name="q" size="30" type="search" placeholder="suchen" tabindex="1"><button class="sitesearch-submitbutton js-sitesearch-submitbutton" type="submit" tabindex="2">Suchen</button>
241 | </form>
242 | </div>
243 | <!--start: mainnav--><div role="navigation"><ul class="mainnav">
244 | <li class="first"><a href="https://www.zeit.de/index" id="hp.global.topnav.centerpages.start">Start</a></li>
245 | <li>
246 | <a href="https://www.zeit.de/politik/index" id="hp.global.topnav.centerpages.politik">Politik</a><ul>
247 | <li class="first"><a href="https://www.zeit.de/politik/deutschland/index">Deutschland</a></li>
248 | <li class="last"><a href="https://www.zeit.de/politik/ausland/index">Ausland</a></li>
249 | </ul>
250 | </li>
251 | <li>
252 | <a href="https://www.zeit.de/wirtschaft/index" id="hp.global.topnav.centerpages.wirtschaft">Wirtschaft</a><ul>
253 | <li class="first"><a href="https://www.zeit.de/wirtschaft/unternehmen/index">Unternehmen</a></li>
254 | <li class="last"><a href="https://www.zeit.de/wirtschaft/geldanlage/index">Geldanlage</a></li>
255 | </ul>
256 | </li>
257 | <!-- <list>
258 |       <item>
259 |         <link href="http://xml.zeit.de/meinung/index" class="groupleader" label="meinung" id="hp.global.topnav.centerpages.meinung">Meinung</link>
260 |       </item>
261 |     </list> --><li>
262 | <a href="https://www.zeit.de/gesellschaft/index" id="hp.global.topnav.centerpages.gesellschaft">Gesellschaft</a><ul>
263 | <li class="first"><a href="https://www.zeit.de/gesellschaft/zeitgeschehen/index">Zeitgeschehen</a></li>
264 | <li><a href="https://www.zeit.de/gesellschaft/familie/index">Familie</a></li>
265 | <li class="last"><a href="https://www.zeit.de/gesellschaft/schule/index">Schule</a></li>
266 | </ul>
267 | </li>
268 | <li>
269 | <a href="https://www.zeit.de/kultur/index" id="hp.global.topnav.centerpages.kultur">Kultur</a><ul>
270 | <li class="first"><a href="https://www.zeit.de/kultur/literatur/index">Literatur</a></li>
271 | <li><a href="https://www.zeit.de/kultur/film/index">Film &amp; TV</a></li>
272 | <li><a href="https://www.zeit.de/kultur/musik/index">Musik</a></li>
273 | <li class="last"><a href="https://www.zeit.de/kultur/kunst/index">Kunst</a></li>
274 | </ul>
275 | </li>
276 | <li>
277 | <a href="https://www.zeit.de/wissen/index" id="hp.global.topnav.centerpages.wissen">Wissen</a><ul>
278 | <li class="first"><a href="https://www.zeit.de/wissen/gesundheit/index">Gesundheit</a></li>
279 | <li><a href="https://www.zeit.de/wissen/umwelt/index">Umwelt</a></li>
280 | <li class="last"><a href="https://www.zeit.de/wissen/geschichte/index">Geschichte</a></li>
281 | </ul>
282 | </li>
283 | <li>
284 | <a href="https://www.zeit.de/digital/index" id="hp.global.topnav.centerpages.digital">Digital</a><ul>
285 | <li class="first"><a href="https://www.zeit.de/digital/internet/index">Internet</a></li>
286 | <li><a href="https://www.zeit.de/digital/datenschutz/index">Datenschutz</a></li>
287 | <li><a href="https://www.zeit.de/digital/mobil/index">Mobil</a></li>
288 | <li class="last"><a href="https://www.zeit.de/digital/games/index">Games</a></li>
289 | </ul>
290 | </li>
291 | <li>
292 | <a href="https://www.zeit.de/studium/index" id="hp.global.topnav.centerpages.studium">Studium</a><ul>
293 | <li class="first"><a href="https://www.zeit.de/studium/uni-leben/index">Uni-Leben</a></li>
294 | <li><a href="https://www.zeit.de/studium/hochschule/index">Hochschule</a></li>
295 | <li><a href="https://ranking.zeit.de/">Uni-Rankings</a></li>
296 | <li><a href="https://www.zeit.de/studium/studiengaenge">Studiengänge</a></li>
297 | <li class="last"><a href="https://studiengaenge.zeit.de/sit">Interessentest</a></li>
298 | </ul>
299 | </li>
300 | <li>
301 | <a href="https://www.zeit.de/karriere/index" id="hp.global.topnav.centerpages.karriere">Karriere</a><ul>
302 | <li class="first"><a href="https://www.zeit.de/karriere/bewerbung/index">Bewerbung</a></li>
303 | <li><a href="https://www.zeit.de/karriere/beruf/index">Beruf</a></li>
304 | <li class="nav-verlagsmarke">
305 | <hr>
306 | <span>Verlagsangebot</span>
307 | </li>
308 | <li class="nav-verlagsangebot js-nav-verlagsangebot  last"><a href="https://jobs.zeit.de/">Stellenmarkt</a></li>
309 | </ul>
310 | </li>
311 | <li>
312 | <a href="https://www.zeit.de/lebensart/index" id="hp.global.topnav.centerpages.lebensart">Lebensart</a><ul>
313 | <li class="first"><a href="https://www.zeit.de/lebensart/mode/index">Mode</a></li>
314 | <li><a href="https://www.zeit.de/lebensart/essen-trinken/index">Essen &amp; Trinken</a></li>
315 | <li class="last"><a href="https://www.zeit.de/lebensart/partnerschaft/index">Partnerschaft</a></li>
316 | </ul>
317 | </li>
318 | <li><a href="https://www.zeit.de/reisen/index" id="hp.global.topnav.centerpages.reisen">Reisen</a></li>
319 | <li><a href="https://www.zeit.de/mobilitaet/index" id="hp.global.topnav.centerpages.mobilitaet">Mobilität</a></li>
320 | <li><a href="https://www.zeit.de/sport/index" id="hp.global.topnav.centerpages.sport">Sport</a></li>
321 | <li class="mainnav-item-hamburg  last">
322 | <a href="https://www.zeit.de/hamburg/index" id="hp.global.topnav.centerpages.hamburg">Hamburg</a><ul>
323 | <li class="first"><a href="https://www.zeit.de/hamburg/politik-wirtschaft/index">Politik &amp; Wirtschaft</a></li>
324 | <li><a href="https://www.zeit.de/hamburg/stadtleben/index">Stadtleben</a></li>
325 | <li><a href="https://www.zeit.de/hamburg/kultur/index">Kultur</a></li>
326 | <li><a href="https://www.zeit.de/hamburg/fussball/index">Fußball</a></li>
327 | <li><a href="https://blog.zeit.de/hamburg/">Blog</a></li>
328 | <li class="last"><a href="https://blog.zeit.de/hamburg-veranstaltungen/">Veranstaltungen</a></li>
329 | </ul>
330 | </li>
331 | </ul></div>
332 | <!--end: mainnav--><div class="userlogin"></div>
333 | <div id="place_3">
334 | 		<!--Bannerplatz "sponsorbar" Nr.3   Tile:3-->
335 | 		<script type="text/javascript"> 
336 | 				// <![CDATA[ 		
337 | 				if (typeof is_tablet === "undefined" || is_tablet === false) document.write('<script src="https://ad.de.doubleclick.net/adj/zeitonline/administratives/centerpage;tile=3;' + n_pbt + ';sz=800x50;kw=zeitonline;ord=' + ord + '?" type="text/javascript"><\/script>');
338 | 				// ]]>
339 | 			</script><noscript><div><a href="https://ad.de.doubleclick.net/jump/zeitonline/administratives/centerpage;tile=3;sz=800x50;kw=zeitonline;ord=123456789?" rel="nofollow"><img src="https://ad.de.doubleclick.net/ad/zeitonline/administratives/centerpage;tile=3;sz=800x50;kw=zeitonline;ord=123456789?" width="800" height="50" style="border:none;" alt=""></a></div></noscript>
340 | </div>
341 | 		<!--end: header-->
342 | </div>
343 | <!--start: allcontent--><!--start: outerfeature--><div id="content" class="section">
344 | <!--start: feature-->
345 | <div id="main" role="main">
346 | 
347 | <h1>{% block docTitle %}{% endblock %}</h1>
348 | {% block docBody %}{% endblock %}
349 | 
350 | </div>
351 | <div id="informatives">
352 | 	<ul class="sidenav">
353 | 		<li id="sidenavHeader" class="{% if file == 'index' %}current{% endif %}">
354 | 			<a href="{{ doc_url }}">Content API</a>
355 | 		</li>
356 | 		<li class="{% if file == 'quickstart' %}current{% endif %}">
357 | 			<a href="{{ doc_url }}/quickstart">Quick Start</a>
358 | 		</li>
359 | 		<li class="{% if file == 'explorer' %}current{% endif %}">
360 | 			<a href="{{ doc_url }}/explorer">API Explorer</a>
361 | 		</li>
362 | 		<li class="{% if file == 'licence' %}current{% endif %}">
363 | 			<a href="{{ doc_url }}/licence">Licence</a>
364 | 		</li>
365 | 		<li class="{% if file == 'docs' %}current{% endif %}">
366 | 			<a href="{{ doc_url }}/docs">Documentation</a>
367 | 		</li>
368 | 		<li class="indent {% if file == 'author' %}current{% endif %}">
369 | 			<a href="{{ doc_url }}/docs/author">Author</a>
370 | 		</li>
371 | 		<li class="indent {% if file == 'client' %}current{% endif %}">
372 | 			<a href="{{ doc_url }}/docs/client">Client</a>
373 | 		</li>
374 | 		<li class="indent {% if file == 'content' %}current{% endif %}">
375 | 			<a href="{{ doc_url }}/docs/content">Content</a>
376 | 		</li>
377 | 		<li class="indent {% if file == 'department' %}current{% endif %}">
378 | 			<a href="{{ doc_url }}/docs/department">Department</a>
379 | 		</li>
380 | 		<li class="indent {% if file == 'keyword' %}current{% endif %}">
381 | 			<a href="{{ doc_url }}/docs/keyword">Keyword</a>
382 | 		</li>
383 | 		<li class="indent {% if file == 'product' %}current{% endif %}">
384 | 			<a href="{{ doc_url }}/docs/product">Product</a>
385 | 		</li>
386 | 		<li class="indent {% if file == 'series' %}current{% endif %}">
387 | 			<a href="{{ doc_url }}/docs/series">Series</a>
388 | 		</li>
389 | 	</ul>
390 | 
391 | <!--
392 | <iframe class="sidenavLink" src="https://ghbtns.com/github-btn.html?user=ZeitOnline&repo=content-api&type=follow&count=true" frameborder="0" scrolling="0" width="165" height="20"></iframe>
393 | <a class="sidenavLink sidenavBlogLink" href="https://blog.zeit.de/dev/" target="_blank">Zeit Online Developer Blog</a>
394 | <a href="https://twitter.com/zeitonline_dev" class="twitter-follow-button" data-show-count="false" data-width="180px" data-lang="en">Follow @zeitonline_dev</a>
395 | <script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="//platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs");</script>
396 | -->
397 | 
398 | </div>
399 | </div>
400 | </div>
401 | 
402 | <div id="bottom">
403 | <!--start: bottom--><div class="footer0"><a class="scroll-to-top" href="#">
404 | 				nach oben
405 | 			</a></div>
406 | <div class="footer1"><div class="center"><div class="footernav">
407 | <ul class="footernav1">
408 | <li class="first">ANGEBOTE:</li>
409 | <li><a href="https://www.zeitabo.de/?mcwt=2009_07_0002">Abo</a></li>
410 | <li><a href="https://shop.zeit.de?et=l6VVNm&amp;et_cid=42&amp;et_lid=175&amp;et_sub=Startseite_footer">Shop</a></li>
411 | <li><a href="https://www.christundwelt.de">Christ &amp; Welt</a></li>
412 | <li><a href="https://zeitreisen.zeit.de/">ZEIT Reisen</a></li>
413 | <li><a href="https://www.zeit.de/angebote/schule/index">ZEIT für die Schule</a></li>
414 | <li class="last"><a href="https://www.zeitverlag.de/veranstaltungen">ZEIT Veranstaltungen</a></li>
415 | </ul>
416 | <ul class="footernav2">
417 | <li>
418 | <li class="first">VERLAG:</li>
419 | <li><a href="https://inserieren.zeit.de/zeitads/">Inserieren</a></li>
420 | <li><a href="https://www.zeit-verlagsgruppe.de/anzeigen/">Mediadaten</a></li>
421 | <li><a href="https://www.zeitverlag.de/presse">Presse</a></li>
422 | <li><a href="https://www.zeit-verlag.de/">Unternehmen</a></li>
423 | <li class="last"><a href="https://www.zeitverlag.de/presse/rechte-und-lizenzen">Rechte &amp; Lizenzen</a></li>
424 | </ul>
425 | </div></div></div>
426 | <div class="footer2" role="contentinfo">
427 | <!--  canvas stats: [version: deprecated!]  [date: 2014-04-07+02:00]  [doc_path: /canvas/developer]  -->
428 | 		<div class="center">
429 | <ul class="navigation fix">
430 | <li class="first"><a href="https://www.zeit.de/index?mobile=true">Mobil</a></li>
431 | <li><a href="https://www.zeit.de/newsletter">Newsletter</a></li>
432 | <li><a href="https://www.zeit.de/hilfe/hilfe#rss">RSS</a></li>
433 | <li><a href="https://www.zeit.de/blogs/index">Blogs</a></li>
434 | <li><a href="https://www.zeit.de/foto/index">Foto</a></li>
435 | <li><a href="https://www.zeit.de/video">Video</a></li>
436 | <li><a href="https://www.zeit.de/leserartikel/index">Leserartikel</a></li>
437 | <li><a href="https://www.zeit.de/administratives/2010-03/netiquette">Netiquette</a></li>
438 | <li><a href="https://www.zeit.de/archiv">Print-Archiv</a></li>
439 | <li><a href="https://www.zeit.de/schlagworte/index/A/index">Schlagworte</a></li>
440 | <li><a href="#bildrechte">Bildrechte</a></li>
441 | <li><a href="https://www.zeit.de/hilfe/datenschutz">Datenschutz</a></li>
442 | <li><a href="https://www.iqm.de/Medien/Online/nutzungsbasierte_onlinewerbung.html" target="_blank">Cookies</a></li>
443 | <li><a href="https://www.zeit.de/administratives/agb-kommentare-artikel">AGB</a></li>
444 | <li><a href="https://www.zeit.de/impressum/index">Impressum</a></li>
445 | <li class="last"><a href="https://www.zeit.de/hilfe/hilfe">Hilfe / Kontakt</a></li>
446 | </ul>
447 | <div class="GvHGroup"><a href="#gvh">Weitere Angebote der Holtzbrinck-Gruppe</a></div>
448 | </div>
449 | </div>
450 | <div class="hidden"><div id="bildrechte"><ol class="bildrechte"></ol></div></div>
451 | <!--end: bottom-->
452 | </div>
453 | <!--end: body-->
454 | 		<!--start: tracker-->
455 | 		<div class="tracker">
456 | <!-- Webtrekk 3.1.1, (c) www.webtrekk.com -->
457 | 		<script type="text/javascript" src="https://static.zeit.de/static/js/webtrekk/webtrekk_v3.js"></script>
458 | 		<script type="text/javascript">
459 | 		<!--
460 | 					var webtrekk = {
461 | 						linkTrack : "standard",
462 | 						heatmap : "0",
463 | 						linkTrackAttribute: "id"
464 | 					};
465 | 					var wt = new webtrekkV3(webtrekk);
466 | 					// cookie handling
467 | 					wt.cookie = "1"; // (3|1, 1st or 3rd party cookie)
468 | 					wt.contentGroup = {
469 | 						1: "Redaktion",
470 | 						2: "Centerpage",
471 | 						3: "administratives"
472 | 						
473 | 							, 4: "Online"
474 | 						
475 | 						};
476 | 					wt.contentId = "redaktion.administratives...rahmen.online./canvas/developer"; // content id
477 | 					wt.sendinfo();
478 | 					//-->
479 | 				</script><noscript><div><img alt="" width="1" height="1" src="https://zeit01.webtrekk.net/981949533494636/wt.pl?p=311,redaktion.administratives...rahmen.online./canvas/developer,0,0,0,0,0,0,0,0&amp;cg1=Redaktion&amp;cg2=Centerpage&amp;cg3=administratives&amp;cg4=Online"></div></noscript>
480 | <!--start: google analytics tracker-->
481 | 		<div class="ga_tracker"><script type="text/javascript">
482 | 		<!--
483 | 					var _gaq = _gaq || []; 
484 | 					_gaq.push(['_setAccount', 'UA-18122964-1']); 
485 | 					_gaq.push(['_setDomainName', '.zeit.de']); 
486 | 					_gaq.push (['_gat._anonymizeIp']);
487 | 					_gaq.push(['_trackPageview']); 
488 | 					(function() { 
489 | 					var ga = document.createElement('script'); 
490 | 					ga.type = 'text/javascript'; 
491 | 					ga.async = true; 
492 | 					ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js'; 
493 | 					var s = document.getElementsByTagName('script')[0]; 
494 | 					s.parentNode.insertBefore(ga, s); })(); 
495 | 				//-->
496 | 				</script></div>
497 | <script type="text/javascript" src="https://static.zeit.de/js/rsa2.js"></script>
498 | </div>
499 | <!--end: tracker-->
500 | 		<!--start: end-scripts-->
501 | 		
502 | 		<!--end: end-scripts-->
503 | 		
504 | 		</body>
505 | </html>
506 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/docs.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | {% block docTitle %}Documentation{% endblock %}
  3 | {% block docBody %}
  4 | 
  5 | <h2>Endpoints</h2>
  6 | 
  7 | <p>
  8 | 	The API is structured into several endpoints that provide specific
  9 | 	functionalities:
 10 | </p>
 11 | 
 12 | <table>
 13 | <tr>
 14 | 	<td>
 15 | 		<code>/author</code>
 16 | 	</td>
 17 | 	<td>
 18 | 		<a href="{{ doc_url }}/docs/author#search">search all authors</a>
 19 | 	</td>
 20 | 	<td>
 21 | 		<code>/author/{id}</code>
 22 | 	</td>
 23 | 	<td>
 24 | 		<a href="{{ doc_url }}/docs/author#by-id">content by this author</a>
 25 | 	</td>
 26 | </tr>
 27 | <tr>
 28 | 	<td>
 29 | 		<code>/client</code>
 30 | 	</td>
 31 | 	<td>
 32 | 		<a href="{{ doc_url }}/docs/client#search">observe API usage</a>
 33 | 	</td>
 34 | 	<td></td>
 35 | 	<td></td>
 36 | </tr>
 37 | <tr>
 38 | 	<td>
 39 | 		<code>/content</code>
 40 | 	</td>
 41 | 	<td>
 42 | 		<a href="{{ doc_url }}/docs/content#search">search for content</a>
 43 | 	</td>
 44 | 	<td>
 45 | 		<code>/content/{id}</code>
 46 | 	</td>
 47 | 	<td>
 48 | 		<a href="{{ doc_url }}/docs/content#by-id">get content by ID</a>
 49 | 	</td>
 50 | </tr>
 51 | <tr>
 52 | 	<td>
 53 | 		<code>/department</code>
 54 | 	</td>
 55 | 	<td>
 56 | 		<a href="{{ doc_url }}/docs/department#search">search all departments</a>
 57 | 	</td>
 58 | 	<td>
 59 | 		<code>/department/{id}</code>
 60 | 	</td>
 61 | 	<td>
 62 | 		<a href="{{ doc_url }}/docs/department#by-id">content from this department</a>
 63 | 	</td>
 64 | </tr>
 65 | <tr>
 66 | 	<td>
 67 | 		<code>/keyword</code>
 68 | 	</td>
 69 | 	<td>
 70 | 		<a href="{{ doc_url }}/docs/keyword#search">search all keywords</a>
 71 | 	</td>
 72 | 	<td>
 73 | 		<code>/keyword/{id}</code>
 74 | 	</td>
 75 | 	<td>
 76 | 		<a href="{{ doc_url }}/docs/keyword#by-id">content about this keyword</a>
 77 | 	</td>
 78 | </tr>
 79 | <tr>
 80 | 	<td>
 81 | 		<code>/product</code>
 82 | 	</td>
 83 | 	<td>
 84 | 		<a href="{{ doc_url }}/docs/product#search">search all products</a>
 85 | 	</td>
 86 | 	<td>
 87 | 		<code>/product/{id}</code>
 88 | 	</td>
 89 | 	<td>
 90 | 		<a href="{{ doc_url }}/docs/product#by-id">content from this product</a>
 91 | 	</td>
 92 | </tr>
 93 | <tr>
 94 | 	<td>
 95 | 		<code>/series</code>
 96 | 	</td>
 97 | 	<td>
 98 | 		<a href="{{ doc_url }}/docs/series#search">search all series</a>
 99 | 	</td>
100 | 	<td>
101 | 		<code>/series/{id}</code>
102 | 	</td>
103 | 	<td>
104 | 		<a href="{{ doc_url }}/docs/series#by-id">content in this series</a>
105 | 	</td>
106 | </tr>
107 | </table>
108 | 
109 | <hr/>
110 | 
111 | <h2>Search Syntax</h2>
112 | 
113 | <p>
114 | 	The <code>q</code> parameter supports simple Solr query syntax for the
115 | 	<code>/content</code> endpoint and all <code>/{ep}/{id}</code> endpoints.
116 | 	Here are a few basics to get you started. For more details check out the
117 | 	<a href="http://wiki.apache.org/solr/SolrQuerySyntax" target="_blank">
118 | 	Apache Solr documentation</a>.
119 | </p>
120 | <p>
121 | 	<b>Full text search:</b> You can search the entire article text and all
122 | 	meta data simply by setting the query parameter to your search phrase.
123 | 	<code>John+Fitzgerald+Kennedy</code> will search for multiple tokens and
124 | 	<code>"John%20Fitzgerald%20Kennedy"</code> will search for the entire
125 | 	string.
126 | </p>
127 | <p>
128 | 	<b>Field queries:</b> All fields of an article can be queried individually.
129 | 	For example, to get articles that have the word "Kennedy" in their headline,
130 | 	you would search for <code>title:"Kennedy"</code>.
131 | </p>
132 | <p>
133 | 	<b>Boolean operators:</b> To form a boolean expression of multiple queries,
134 | 	connect them with<br/>an <code>AND</code> or an <code>OR</code>. So if you
135 | 	want to search the subtitle for "Kennedy" as well, you can modify the query
136 | 	to<br/><code>title:"Kennedy" AND subtitle:"Kennedy"</code>.
137 | </p>
138 | <p>
139 | 	<b>Range queries:</b> You can specify a date range for your query using
140 | 	full ISO 8601 date syntax.<br/>Getting all Kennedy related articles from
141 | 	the	60s would work like this:<br/>
142 | 	<code>"Kennedy" AND release_date:[1960-01-01T00:00:00Z TO
143 | 	1969-12-31T23:59:59.999Z]</code>.
144 | </p>
145 | <p>
146 | 	<b>Non-content search:</b> All other endpoints currently only support
147 | 	simple search phrases with asterisk wildcards. So, a search for Kennedy
148 | 	related keywords goes like this: <code>/keyword?q=*Kennedy</code>
149 | </p>
150 | 
151 | <hr/>
152 | 
153 | <h2>Pagination</h2>
154 | 
155 | <p>
156 | 	Search results are limited to 10 matches by default. You can increase this
157 | 	value with the <code>limit</code> parameter. To iterate over the resultset,
158 | 	repeat your request with the <code>offset</code> parameter set to multiples
159 | 	of the limit.
160 | </p>
161 | 
162 | <hr/>
163 | 
164 | <h2>Partial Selection</h2>
165 | 
166 | <p>
167 | 	By default, the API returns all available fields for your request. To speed
168 | 	things up, you can specify which fields the server should return using the
169 | 	<code>fields</code> paramter. If the request returns an array of matches,
170 | 	this setting only affects entries within that array. So, for example the
171 | 	field <code>found</code> cannot be deselected, as it always resides outside
172 | 	of the matches array.
173 | </p>
174 | 
175 | <hr/>
176 | 
177 | <h2>Sorting</h2>
178 | 
179 | <p>
180 | 	Search results, namely those of the <code>/content</code> endpoint, can be
181 | 	sorted using the <code>sort</code> parameter. Any of the returned fields are
182 | 	sortable. Direction keywords are <code>asc</code> and <code>desc</code> for
183 | 	an ascending or descending sort order respectively. Multiple sort orders are
184 | 	accepted as a comma-separated list, for example: <code>sort=release_date
185 | 	asc, uuid desc</code>.
186 | </p>
187 | 
188 | <hr/>
189 | 
190 | <h2>Facetting</h2>
191 | 
192 | <p>
193 | 	The content endpoint also provides a faceting interface. You can display
194 | 	facets for specific fields and for date ranges. The
195 | 	<code>facet_field</code> parameter is used to get a frequency distribution
196 | 	for the different values of a field. The <code>facet_date</code> parameter
197 | 	returns counts for the distribution over a specified date range. The
198 | 	facetting results are limited by your search query, but not by pagination
199 | 	parameters.
200 | </p>
201 | <br/>
202 | <table>
203 | <tr>
204 | 	<td><b>Parameter</b></td>
205 | 	<td><b>Possible values</b></td>
206 | </tr>
207 | <tr>
208 |     <td><code>facet_field</code></td>
209 |     <td><code>keyword, author, series, department, product</code> or any combination</td>
210 | </tr>
211 | <tr>
212 | 	<td><code>facet_date</code></td>
213 | 	<td><code>1day, 7day, 1month, 1year, 10year</code> or any numerical variation</td>
214 | </tr>
215 | </table>
216 | 
217 | {% endblock %}
218 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/docs/author.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | {% block docTitle %}Author{% endblock %}
  3 | {% block docBody %}
  4 | 
  5 | <h2 id"search">Search all authors</h2>
  6 | <p>
  7 |   This endpoint lets you search for authors by their name. The result is a list
  8 |   of possible matches with a displayable value, a URI to an article overview
  9 |   within the API and, if available, a link to all articles by this author on
 10 |   www.zeit.de.
 11 | </p>
 12 | 
 13 | <h3>Endpoint</h3>
 14 | <pre><code>{{ api_url }}/author</code></pre>
 15 | 
 16 | <h3>Parameter</h3>
 17 | <code>
 18 |   <table>
 19 |     <tr>
 20 |       <td>q<span class="default">*</span></td>
 21 |       <td>main search query with asterisk as wildcard</td>
 22 |     </tr>
 23 |     <tr>
 24 |       <td>fields<span class="default">href,id,type,uri,value</span></td>
 25 |       <td>partially select output fields</td>
 26 |     </tr>
 27 |     <tr>
 28 |       <td>limit<span class="default">10</span></td>
 29 |       <td>amount of matches to return</td>
 30 |     </tr>
 31 |     <tr>
 32 |       <td>offset<span class="default">0</span></td>
 33 |       <td>offset for the list of matches</td>
 34 |     </tr>
 35 |   </table>
 36 | </code>
 37 | 
 38 | <h2>Example</h2>
 39 | 
 40 | <h3>Request</h3>
 41 | <pre><code>GET /author?q=James*Muster*&limit=1 HTTP/1.1
 42 | Host: {{ api_url }}
 43 | X-Authorization: abcdefg1234xyz56789
 44 | </code></pre>
 45 | 
 46 | <h3>Response</h3>
 47 | <pre><code>{
 48 |   "matches": [
 49 |     {
 50 |       "href": "http://www.zeit.de/autoren/J/James_Mustermann/index.xml",
 51 |       "type": "author",
 52 |       "id": "James-Mustermann",
 53 |       "value": "James Mustermann",
 54 |       "uri": "{{ api_url }}/author/James-Mustermann"
 55 |     }
 56 |   ], 
 57 |   "found": 3, 
 58 |   "limit": 1, 
 59 |   "offset": 0
 60 | }</code></pre>
 61 | 
 62 | <hr/>
 63 | 
 64 | <h2 id="by-id">Get author by ID</h2>
 65 | 
 66 | <p>
 67 |   This endpoint provides a pre-filtered search for all articles written by a
 68 |   specific author. Deeper queries, pagination and partial field selection can
 69 |   be used to narrow down the match list.
 70 | </p>
 71 | 
 72 | <h3>Endpoint</h3>
 73 | <pre><code>{{ api_url }}/author/{id}</code></pre>
 74 | 
 75 | <h3>Parameter</h3>
 76 | <code>
 77 |   <table>
 78 |     <tr>
 79 |       <td>q<span class="default">*:*</span></td>
 80 |       <td>the main search query</td>
 81 |     </tr>
 82 |     <tr>
 83 |       <td>fields<span class="default">*</span></td>
 84 |       <td>partially select output fields</td>
 85 |     </tr>
 86 |     <tr>
 87 |       <td>limit<span class="default">10</span></td>
 88 |       <td>limit the amount of matches to return</td>
 89 |     </tr>
 90 |     <tr>
 91 |       <td>offset<span class="default">0</span></td>
 92 |       <td>offset for the list of matches</td>
 93 |     </tr>
 94 |   </table>
 95 | </code>
 96 | 
 97 | <h2>Example</h2>
 98 | 
 99 | <h3>Request</h3>
100 | <pre><code>GET /author/Jasmine-Mustermann?limit=1 HTTP/1.1
101 | Host: {{ api_url }}
102 | X-Authorization: abcdefg1234xyz56789
103 | </code></pre>
104 | 
105 | <h3>Response</h3>
106 | <pre><code>{
107 |   "value": "Jasmine Mustermann", 
108 |   "matches": [
109 |     {
110 |       "subtitle": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr,
111 |         sed diam nonumy eirmod tempor invidunt ut labore et dolore magna.", 
112 |       "title": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr.", 
113 |       "href": "http://www.zeit.de/department/sub/2012-12/Lorem-ipsum", 
114 |       "release_date": "2011-12-01T14:40:00.000Z", 
115 |       "uri": "{{ api_url }}/content/1111122299xxcc99aa", 
116 |       "supertitle": "Lorem Ipsum", 
117 |       "teaser_title": "Lorem ipsum dolor sit amet, consetetur sadipscing."
118 |     }
119 |   ], 
120 |   "uri": "{{ api_url }}/author/Jasmine-Mustermann",
121 |   "type": "author",
122 |   "limit": 1, 
123 |   "offset": 0, 
124 |   "found": 12
125 | }</code></pre>
126 | 
127 | {% endblock %}
128 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/docs/client.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% block docTitle %}Client{% endblock %}
 3 | {% block docBody %}
 4 | 
 5 | <h2 id="search">Observe your usage</h2>
 6 | 
 7 | <p>
 8 | 	The user endpoint is not a content resource per se, but lets you get
 9 | 	information about your API usage. As this is sensitive information,
10 | 	requests must be authorized. Parameters are not required.
11 | </p>
12 | 
13 | <h3>Endpoint</h3>
14 | <pre><code>{{ api_url }}/client</code></pre>
15 | 
16 | <h2>Example</h2>
17 | 
18 | <h3>Request</h3>
19 | <pre><code>GET /client HTTP/1.1
20 | Host: {{ api_url }}
21 | X-Authorization: abcdefg1234xyz56789
22 | </code></pre>
23 | 
24 | <h3>Response</h3>
25 | <pre><code>{
26 |     "reset": 1352820867,
27 |     "tier": "free",
28 |     "name": "Jane Mustermann",
29 |     "email": "jane@muster.com"
30 |     "requests": 13,
31 |     "api_key": "abcdefg1234xyz56789",
32 |     "quota": 10000
33 | }
34 | </code></pre>
35 | {% endblock %}


--------------------------------------------------------------------------------
/src/zeit/api/templates/docs/content.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | {% block docTitle %}Content{% endblock %}
  3 | {% block docBody %}
  4 | 
  5 | <h2 id="search">Search for content</h2>
  6 | 
  7 | <p>
  8 |     This endpoint exposes an unfiltered search for articles. You can set search
  9 |     queries, paginate, sort and partially select the fields, that should be
 10 |     returned. Articles, that match your query, are returned in the <code>
 11 |     matches</code> array with a reduced set of meta data. The full set of data
 12 |     is only available at <code>/content/{id}</code>.
 13 | </p>
 14 | 
 15 | <h3>Endpoint</h3>
 16 | <pre><code>{{ api_url }}/content</code></pre>
 17 | 
 18 | <h3>Parameter</h3>
 19 | <code>
 20 |     <table>
 21 |         <tr>
 22 |            <td>q<span class="default">*:*</span></td>
 23 |             <td>the main search query</td>
 24 |         </tr>
 25 |         <tr>
 26 |             <td>fields<span class="default">*</span></td>
 27 |             <td>partially select output fields</td>
 28 |         </tr>
 29 |         <tr>
 30 |             <td>limit<span class="default">10</span></td>
 31 |             <td>limit the amount of matches to return</td>
 32 |         </tr>
 33 |         <tr>
 34 |             <td>offset<span class="default">0</span></td>
 35 |             <td>offset for the list of matches</td>
 36 |         </tr>
 37 |     </table>
 38 | </code>
 39 | 
 40 | <h2>Example</h2>
 41 | 
 42 | <h3>Request</h3>
 43 | <pre><code>GET /content?q=dolore&limit=1 HTTP/1.1
 44 | Host: {{ api_url }}
 45 | X-Authorization: abcdefg1234xyz56789
 46 | </code></pre>
 47 | 
 48 | <h3>Response</h3>
 49 | <pre><code>{
 50 |   "matches": [
 51 |     {
 52 |         "subtitle": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr,
 53 |             sed diam nonumy eirmod tempor invidunt.",
 54 |         "uuid": "1111122299xxcc99aa", 
 55 |         "title": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr.",
 56 |         "href": "http://www.zeit.de/lorem/ipsum/2012-12/Lorem-ipsum-dolor-sit",
 57 |         "release_date": "2011-12-01T14:40:00.000Z", 
 58 |         "uri": "{{ api_url }}/content/1111122299xxcc99aa",
 59 |         "snippet": "tempor invidunt ut labore et <em>dolore</em> magna aliquyam
 60 |             erat, sed diam voluptua"
 61 |         "supertitle": "Lorem Ipsum", 
 62 |         "teaser_title": "Lorem ipsum dolor sit amet, consetetur sadipscing.",
 63 |         "teaser_text": "Stet clita kasd gubergren, no sea takimata sanctus est
 64 |             Lorem ipsum dolor sit amet."
 65 |     }
 66 | ],
 67 |   "found": 148,
 68 |   "limit": 1,
 69 |   "offset": 0
 70 | }</code></pre>
 71 | 
 72 | <hr/>
 73 | 
 74 | <h2 id="by-id">Get content by ID</h2>
 75 | 
 76 | <p>
 77 |     Requesting a content object by its ID will get you all available data for
 78 |     that article. Partial field selection is available, if not all fields are
 79 |     of interest.
 80 | </p>
 81 | 
 82 | <h3>Endpoint</h3>
 83 | <pre><code>{{ api_url }}/content/{id}</code></pre>
 84 | 
 85 | <h2>Example</h2>
 86 | 
 87 | <h3>Request</h3>
 88 | <pre><code>GET /content/1111122299xxcc99aa HTTP/1.1
 89 | Host: {{ api_url }}
 90 | X-Authorization: abcdefg1234xyz56789
 91 | </code></pre>
 92 | 
 93 | <h3>Response</h3>
 94 | <pre><code>{
 95 |     "title": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr.",
 96 |     "release_date": "2011-12-01T14:40:00.000Z", 
 97 |     "uri": "{{ api_url }}/content/1111122299xxcc99aa",
 98 |     "supertitle": "Lorem Ipsum", 
 99 |     "href": "http://www.zeit.de/lorem/ipsum/2012-12/Lorem-ipsum-dolor-sit-que",
100 |     "teaser_text": "Stet clita kasd gubergren, no sea takimata sanctus est
101 |         Lorem ipsum dolor sit amet."
102 |     "teaser_title": "Lorem ipsum dolor sit amet, consetetur sadipscing.",
103 |     "creators": [
104 |         {
105 |             "uri": "{{ api_url }}/author/James-Mustermann",
106 |             "rel": "author",
107 |             "name": "James Mustermann"
108 |         }
109 |     ],
110 |     "relations": [
111 |         {
112 |             "uri": "{{ api_url }}/content/55555ccc333aaawww",
113 |             "rel": "related",
114 |             "name": "Eirmod tempor invidunt ut labore"
115 |         },
116 |         {
117 |             "uri": "{{ api_url }}/content/333322ssssQQQrrrr",
118 |             "rel": "related",
119 |             "name": "No sea takimata sanctus est"
120 |         }
121 |     ],
122 |     "keywords": [
123 |         {
124 |             "uri": "{{ api_url }}/keyword/lorem",
125 |             "rel": "location",
126 |             "name": "Lorem"
127 |         },
128 |         {
129 |             "uri": "{{ api_url }}/keyword/ipsum-set",
130 |             "rel": "subject",
131 |             "name": "Ipsum Set"
132 |         }
133 |     ],
134 |     "categories": [
135 |         {
136 |             "uri": "{{ api_url }}/department/lorem",
137 |             "rel": "department",
138 |             "name": "Lorem"
139 |         },
140 |         {
141 |             "uri": "{{ api_url }}/product/dolores",
142 |             "rel": "product",
143 |             "name": "Dolores"
144 |         },
145 |         {
146 |             "uri": "{{ api_url }}/department/ipsum",
147 |             "rel": "sub_department",
148 |             "name": "Ipsum"
149 |         }
150 |     ]
151 | }</code></pre>
152 | 
153 | {% endblock %}
154 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/docs/department.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | {% block docTitle %}Department{% endblock %}
  3 | {% block docBody %}
  4 | 
  5 | <h2 id="search">Search all departments</h2>
  6 | 
  7 | <p>
  8 |   Departments correlate to the sections of our homepage and to those of the
  9 |   printed issues. There are top level departments and sub-departments. Both are
 10 |   accessible via this endpoint. Sub-departments have a link to their parent
 11 |   attached to them. The query expects an astisk for wildcards and whitespaces.
 12 | </p>
 13 | 
 14 | <h3>Endpoint</h3>
 15 | <pre><code>{{ api_url }}/department</code></pre>
 16 | 
 17 | <h3>Parameter</h3>
 18 | <code>
 19 |   <table>
 20 |     <tr>
 21 |       <td>q<span class="default">*</span></td>
 22 |       <td>the main search query</td>
 23 |     </tr>
 24 |     <tr>
 25 |       <td>fields<span class="default">uri,value,parent,href</span></td>
 26 |       <td>partially select output fields</td>
 27 |     </tr>
 28 |     <tr>
 29 |       <td>limit<span class="default">10</span></td>
 30 |       <td>limit the amount of matches to return</td>
 31 |     </tr>
 32 |     <tr>
 33 |       <td>offset<span class="default">0</span></td>
 34 |       <td>offset for the list of matches</td>
 35 |     </tr>
 36 |   </table>
 37 | </code>
 38 | 
 39 | <h2>Example</h2>
 40 | 
 41 | <h3>Request</h3>
 42 | <pre><code>GET /department?q=*lorem*&limit=1 HTTP/1.1
 43 | Host: {{ api_url }}
 44 | X-Authorization: abcdefg1234xyz56789
 45 | </code></pre>
 46 | 
 47 | <h3>Response</h3>
 48 | <pre><code>{
 49 |     "matches": [
 50 |         {
 51 |             "href": "http://www.zeit.de/dolorem/index",
 52 |             "uri": "http://127.0.0.1:5000/api/department/dolorem",
 53 |             "value": "Dolorem"
 54 |         }
 55 |     ],
 56 |     "found": 3,
 57 |     "limit": 1,
 58 |     "offset": 0
 59 | }</code></pre>
 60 | 
 61 | <hr/>
 62 | 
 63 | <h2 id="by-id">Get department by ID</h2>
 64 | 
 65 | <p>
 66 |   This endpoint provides a pre-filtered search for all articles belonging to a
 67 |   specific department. Deeper queries, pagination and partial field selection
 68 |   can be used to narrow down the match list.
 69 | </p>
 70 | 
 71 | <h3>Endpoint</h3>
 72 | <pre><code>{{ api_url }}/department/{id}</code></pre>
 73 | 
 74 | <h3>Parameter</h3>
 75 | <code>
 76 |   <table>
 77 |     <tr>
 78 |       <td>q<span class="default">*:*</span></td>
 79 |       <td>the main search query</td>
 80 |     </tr>
 81 |     <tr>
 82 |       <td>fields<span class="default">*</span></td>
 83 |       <td>partially select output fields</td>
 84 |     </tr>
 85 |     <tr>
 86 |       <td>limit<span class="default">10</span></td>
 87 |       <td>limit the amount of matches to return</td>
 88 |     </tr>
 89 |     <tr>
 90 |       <td>offset<span class="default">0</span></td>
 91 |       <td>offset for the list of matches</td>
 92 |     </tr>
 93 |   </table>
 94 | </code>
 95 | 
 96 | <h2>Example</h2>
 97 | 
 98 | <h3>Request</h3>
 99 | <pre><code>GET /department/lorem-ipsum?limit=1 HTTP/1.1
100 | Host: {{ api_url }}
101 | X-Authorization: abcdefg1234xyz56789
102 | </code></pre>
103 | 
104 | <h3>Response</h3>
105 | <pre><code>{
106 |   "matches": [
107 |     {
108 |       "subtitle": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed
109 |         diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam.", 
110 |       "title": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr.", 
111 |       "href": "http://www.zeit.de/dolorem/lorem-ipsum/2012-12/Sit-amet",
112 |       "release_date": "2011-12-01T14:40:00.000Z", 
113 |       "uri": "{{ api_url }}/content/1111122299xxcc99aa", 
114 |       "supertitle": "Lorem Ipsum", 
115 |       "teaser_title": "Lorem ipsum dolor sit amet, consetetur sadipscing."
116 |       "teaser_text": "Sicilia que es una magnifica maestrae."
117 |     }
118 |   ],
119 |   "uri": "{{ api_url }}/department/lorem-ipsum",
120 |   "parent": "{{ api_url }}/department/dolorem",
121 |   "href": "http://www.zeit.de/dolorem/lorem-ipsum/index",
122 |   "value": "Lorem Ipsum",
123 |   "limit": 1,
124 |   "offset": 0,
125 |   "found": 312
126 | }</code></pre>
127 | 
128 | {% endblock %}
129 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/docs/keyword.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | {% block docTitle %}Keyword{% endblock %}
  3 | {% block docBody %}
  4 | 
  5 | <h2 id="search">Search all keywords</h2>
  6 | 
  7 | <p>
  8 |   This endpoint lets you search for keywords that semantically summarize
  9 |   articles. An asterisk can serve as a wildcard or whitespace in your search
 10 |   query. Keywords are weighted by their overall frequency with a score from 0
 11 |   to 100. Possible keyword types are: location, person, organisation or issue.
 12 | </p>
 13 | 
 14 | <h3>Endpoint</h3>
 15 | <pre><code>{{ api_url }}/keyword</code></pre>
 16 | 
 17 | <h3>Parameter</h3>
 18 | <code>
 19 |   <table>
 20 |     <tr>
 21 |       <td>q<span class="default">*</span></td>
 22 |       <td>the main search query</td>
 23 |     </tr>
 24 |     <tr>
 25 |       <td>
 26 |         fields<span class="default">uri,value,lexical,type,score,href</span>
 27 |       </td>
 28 |       <td>partially select output fields</td>
 29 |     </tr>
 30 |     <tr>
 31 |       <td>limit<span class="default">10</span></td>
 32 |       <td>limit the amount of matches to return</td>
 33 |     </tr>
 34 |     <tr>
 35 |       <td>offset<span class="default">0</span></td>
 36 |       <td>offset for the list of matches</td>
 37 |     </tr>
 38 |   </table>
 39 | </code>
 40 | 
 41 | <h2>Example</h2>
 42 | 
 43 | <h3>Request</h3>
 44 | <pre><code>GET /keyword?q=*rom*&limit=1 HTTP/1.1
 45 | Host: {{ api_url }}
 46 | X-Authorization: abcdefg1234xyz56789
 47 | </code></pre>
 48 | 
 49 | <h3>Response</h3>
 50 | <pre><code>{
 51 |     "matches": [
 52 |         {
 53 |             "href": "http://www.zeit.de/schlagworte/orte/romanium/index",
 54 |             "score": 75,
 55 |             "type": "location",
 56 |             "uri": "{{ api_url }}/keyword/romanium",
 57 |             "value": "Romanium"
 58 |         }
 59 |     ],
 60 |     "found": 116,
 61 |     "limit": 1,
 62 |     "offset": 0
 63 | }</code></pre>
 64 | 
 65 | <hr/>
 66 | 
 67 | <h2 id="by-id">Get keyword by ID</h2>
 68 | 
 69 | <p>
 70 |   This endpoint provides a pre-filtered search for all articles tagged with a
 71 |   specific keyword. Deeper queries, pagination and partial field selection can
 72 |   be used to narrow down the match list.
 73 | </p>
 74 | 
 75 | <h3>Endpoint</h3>
 76 | <pre><code>{{ api_url }}/author/{id}</code></pre>
 77 | 
 78 | <h3>Parameter</h3>
 79 | <code>
 80 | <table>
 81 | <tr>
 82 |     <td>q<span class="default">*:*</span></td>
 83 |     <td>the main search query</td>
 84 | </tr>
 85 | <tr>
 86 |     <td>fields<span class="default">*</span></td>
 87 |     <td>partially select output fields</td>
 88 | </tr>
 89 | <tr>
 90 |     <td>limit<span class="default">10</span></td>
 91 |     <td>limit the amount of matches to return</td>
 92 | </tr>
 93 | <tr>
 94 |     <td>offset<span class="default">0</span></td>
 95 |     <td>offset for the list of matches</td>
 96 | </tr>
 97 | </table>
 98 | </code>
 99 | 
100 | <h2>Example</h2>
101 | 
102 | <h3>Request</h3>
103 | <pre><code>GET /keyword/jane-mustermann?limit=1 HTTP/1.1
104 | Host: {{ api_url }}
105 | X-Authorization: abcdefg1234xyz56789
106 | </code></pre>
107 | 
108 | <h3>Response</h3>
109 | <pre><code>{
110 |   "matches": [
111 |     {
112 |       "subtitle": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed
113 |         diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam.", 
114 |       "title": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr.", 
115 |       "href": "http://www.zeit.de/dolorem/lorem-ipsum/2012-12/Lorem-ipsum-dolor", 
116 |       "release_date": "2011-12-01T14:40:00.000Z", 
117 |       "uri": "{{ api_url }}/content/1111122299xxcc99aa", 
118 |       "supertitle": "Lorem Ipsum", 
119 |       "teaser_title": "Lorem ipsum dolor sit amet, consetetur sadipscing."
120 |       "teaser_text": "Sicilia que es una magnifica maestrae."
121 |     }
122 |   ],
123 |   "uri": "{{ api_url }}/keyword/jane-mustermann",
124 |   "href": "http://www.zeit.de/schlagworte/personen/jane-mustermann/index",
125 |   "value": "Jane Mustermann",
126 |   "lexical": "Mustermann, Jane"
127 |   "type": "person",
128 |   "score": 75,
129 |   "limit": 1,
130 |   "offset": 0,
131 |   "found": 6
132 | }</code></pre>
133 | 
134 | {% endblock %}
135 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/docs/product.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | {% block docTitle %}Product{% endblock %}
  3 | {% block docBody %}
  4 | 
  5 | <h2 id="search">Search all products</h2>
  6 | 
  7 | <p>
  8 |   This endpoint lets you search for publication products by name. The product
  9 |   field of an article provides information about where the article was first
 10 |   published. An asterisk can serve as a wildcard or whitespace in your search
 11 |   query.
 12 | </p>
 13 | 
 14 | <h3>Endpoint</h3>
 15 | <pre><code>{{ api_url }}/product</code></pre>
 16 | 
 17 | <h3>Parameter</h3>
 18 | <code>
 19 |   <table>
 20 |     <tr>
 21 |       <td>q<span class="default">*</span></td>
 22 |       <td>the main search query</td>
 23 |     </tr>
 24 |     <tr>
 25 |       <td>fields<span class="default">uri,value</span></td>
 26 |       <td>partially select output fields</td>
 27 |     </tr>
 28 |     <tr>
 29 |       <td>limit<span class="default">10</span></td>
 30 |       <td>limit the amount of matches to return</td>
 31 |     </tr>
 32 |     <tr>
 33 |       <td>offset<span class="default">0</span></td>
 34 |       <td>offset for the list of matches</td>
 35 |     </tr>
 36 |   </table>
 37 | </code>
 38 | 
 39 | <h2>Example</h2>
 40 | 
 41 | <h3>Request</h3>
 42 | <pre><code>GET /product?q=*tempor*&limit=2 HTTP/1.1
 43 | Host: {{ api_url }}
 44 | X-Authorization: abcdefg1234xyz56789
 45 | </code></pre>
 46 | 
 47 | <h3>Response</h3>
 48 | <pre><code>{
 49 |   "matches": [
 50 |    	{
 51 |       "uri": "http://127.0.0.1:5000/api/product/tpi",
 52 |       "value": "Tempores Inlinea"
 53 |    	},
 54 |    	{
 55 |       "uri": "http://127.0.0.1:5000/api/product/tem",
 56 |       "value": "TEMPORES"
 57 |   	}
 58 |   ],
 59 |   "found": 3,
 60 |   "limit": 2,
 61 |   "offset": 0
 62 | }</code></pre>
 63 | 
 64 | <hr/>
 65 | 
 66 | <h2 id="by-id">Get product by ID</h2>
 67 | 
 68 | <p>
 69 |   This endpoint provides a pre-filtered search for all articles published in a
 70 |   specific product. Deeper queries, pagination and partial field selection can
 71 |   be used to narrow down the match list.
 72 | </p>
 73 | 
 74 | <h3>Endpoint</h3>
 75 | <pre><code>{{ api_url }}/product/{id}</code></pre>
 76 | 
 77 | <h3>Parameter</h3>
 78 | <code>
 79 |   <table>
 80 |     <tr>
 81 |       <td>q<span class="default">*:*</span></td>
 82 |       <td>the main search query</td>
 83 |     </tr>
 84 |     <tr>
 85 |       <td>fields<span class="default">*</span></td>
 86 |       <td>partially select output fields</td>
 87 |     </tr>
 88 |     <tr>
 89 |       <td>limit<span class="default">10</span></td>
 90 |       <td>limit the amount of matches to return</td>
 91 |     </tr>
 92 |     <tr>
 93 |       <td>offset<span class="default">0</span></td>
 94 |       <td>offset for the list of matches</td>
 95 |     </tr>
 96 |   </table>
 97 | </code>
 98 | 
 99 | <h2>Example</h2>
100 | 
101 | <h3>Request</h3>
102 | <pre><code>GET /product/tpi?limit=1 HTTP/1.1
103 | Host: {{ api_url }}
104 | X-Authorization: abcdefg1234xyz56789
105 | </code></pre>
106 | 
107 | <h3>Response</h3>
108 | <pre><code>{
109 |   "matches": [
110 |     {
111 |       "subtitle": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed
112 |         diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam.",
113 |       "title": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr.", 
114 |       "href": "http://www.zeit.de/dolorem/lorem-ipsum/2012-12/Lorem-ipsum-que", 
115 |       "release_date": "2011-12-01T14:40:00.000Z", 
116 |       "uri": "{{ api_url }}/content/1111122299xxcc99aa", 
117 |       "supertitle": "Lorem Ipsum", 
118 |       "teaser_title": "Lorem ipsum dolor sit amet, consetetur sadipscing."
119 |       "teaser_text": "Sicilia que es una magnifica maestrae."
120 |     }
121 |   ],
122 |   "uri": "{{ api_url }}/product/tpi",
123 |   "value": "Tempores Inlinea",
124 |   "limit": 1,
125 |   "offset": 0,
126 |   "found": 9156
127 | }</code></pre>
128 | {% endblock %}
129 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/docs/series.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | {% block docTitle %}Series{% endblock %}
  3 | {% block docBody %}
  4 | 
  5 | <h2 id="search">Search all series</h2>
  6 | <p>
  7 |   This endpoint lets you search for journalistic series by name. An asterisk
  8 |   can serve as a wildcard or whitespace in your search query.
  9 | </p>
 10 | 
 11 | <h3>Endpoint</h3>
 12 | <pre><code>{{ api_url }}/series</code></pre>
 13 | 
 14 | <h3>Parameter</h3>
 15 | <code>
 16 |   <table>
 17 |     <tr>
 18 |         <td>q<span class="default">*</span></td>
 19 |         <td>the main search query</td>
 20 |     </tr>
 21 |     <tr>
 22 |         <td>fields<span class="default">uri,value,href</span></td>
 23 |         <td>partially select output fields</td>
 24 |     </tr>
 25 |     <tr>
 26 |         <td>limit<span class="default">10</span></td>
 27 |         <td>limit the amount of matches to return</td>
 28 |     </tr>
 29 | 
 30 |     <tr>
 31 |         <td>offset<span class="default">0</span></td>
 32 |         <td>offset for the list of matches</td>
 33 |     </tr>
 34 |   </table>
 35 | </code>
 36 | 
 37 | <h2>Example</h2>
 38 | 
 39 | <h3>Request</h3>
 40 | <pre><code>GET /series?q=*lorem*&limit=1 HTTP/1.1
 41 | Host: {{ api_url }}
 42 | X-Authorization: abcdefg1234xyz56789
 43 | </code></pre>
 44 | 
 45 | <h3>Response</h3>
 46 | <pre><code>{
 47 |     "matches": [
 48 |       {
 49 |       "href": "http://www.zeit.de/serie/lorem-ipsum",
 50 |       "uri": "http://127.0.0.1:5000/api/series/lorem-ipsum",
 51 |       "value": "Lorem ipsum dolor set?"
 52 |       }
 53 |     ],
 54 |     "found": 7,
 55 |     "limit": 1,
 56 |     "offset": 0
 57 | }</code></pre>
 58 | 
 59 | <hr/>
 60 | 
 61 | <h2 id="by-id">Get series by ID</h2>
 62 | 
 63 | <p>
 64 |   This endpoint provides a pre-filtered search for all articles written for a
 65 |   specific series. Deeper queries, pagination and partial field selection can
 66 |   be used to narrow down the match list.
 67 | </p>
 68 | 
 69 | <h3>Endpoint</h3>
 70 | <pre><code>{{ api_url }}/series/{id}</code></pre>
 71 | 
 72 | <h3>Parameter</h3>
 73 | <code>
 74 |   <table>
 75 |     <tr>
 76 |       <td>q<span class="default">*:*</span></td>
 77 |       <td>the main search query</td>
 78 |     </tr>
 79 |     <tr>
 80 |       <td>fields<span class="default">*</span></td>
 81 |       <td>partially select output fields</td>
 82 |     </tr>
 83 |     <tr>
 84 |       <td>limit<span class="default">10</span></td>
 85 |       <td>limit the amount of matches to return</td>
 86 |     </tr>
 87 |     <tr>
 88 |       <td>offset<span class="default">0</span></td>
 89 |       <td>offset for the list of matches</td>
 90 |     </tr>
 91 |   </table>
 92 | </code>
 93 | 
 94 | <h2>Example</h2>
 95 | 
 96 | <h3>Request</h3>
 97 | <pre><code>GET /series/lorem-ipsum?limit=1 HTTP/1.1
 98 | Host: {{ api_url }}
 99 | X-Authorization: abcdefg1234xyz56789
100 | </code></pre>
101 | 
102 | <h3>Response</h3>
103 | <pre><code>{
104 |   "matches": [
105 |     {
106 |       "subtitle": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed
107 |         diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam.",
108 |       "title": "Lorem ipsum dolor sit amet, consetetur sadipscing elitr.", 
109 |       "href": "http://www.zeit.de/dolorem/lorem-ipsum/2012-12/Lorem-ipsum-que",
110 |       "release_date": "2011-12-01T14:40:00.000Z", 
111 |       "uri": "{{ api_url }}/content/1111122299xxcc99aa", 
112 |       "supertitle": "Lorem Ipsum", 
113 |       "teaser_title": "Lorem ipsum dolor sit amet, consetetur sadipscing."
114 |       "teaser_text": "Sicilia que es una magnifica maestrae."
115 |     }
116 |   ],
117 |   "uri": "{{ api_url }}/series/lorem-ipsum",
118 |   "href": "http://www.zeit.de/series/lorem-ipsum",
119 |   "value": "Lorem ipsum dolor set?",
120 |   "limit": 1,
121 |   "offset": 0,
122 |   "found": 30
123 | }</code></pre>
124 | 
125 | {% endblock %}
126 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/error.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 | {% block docTitle %}Not Found{% endblock %}
3 | {% block docBody %}
4 | <p>The requested URL does not exist. Sorry about that.</p>
5 | <p>You might want to check your spelling or navigate using the menu.</p>
6 | <p><a href="{{ doc_url }}/index" title="Index">Start over.</a></p>
7 | {% endblock %}


--------------------------------------------------------------------------------
/src/zeit/api/templates/explorer.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | {% block docTitle %}API Explorer{% endblock %}
  3 | {% block docBody %}
  4 | 
  5 | <p>
  6 | 	You can browse the API with this interactive explorer. Select an endpoint
  7 | 	to see its available parameters and their default values. If you have
  8 | 	<a href="{{ doc_url }}/quickstart">requested an API key</a>, it is
  9 | 	inserted automatically in the form below.
 10 | </p>
 11 | 
 12 | <h3>Request</h3>
 13 | <pre class="explorerWrapper">
 14 | <code>GET <select id="explorerEndpoint"></select><span id="explorerEndpointSpan">/<input placeholder="id" id="explorerEndpointId" size="40" /></span>
 15 | <br/><div id="explorerParamWrapper"></div>Host: {{ api_url }}
 16 | X-Authorization: <input placeholder="Insert your API key here" id="explorerXAuth" size="56" />
 17 | </code></pre>
 18 | <div class="alignCenter"><span id="send">Send request</span></div>
 19 | <h3>Response</h3>
 20 | <pre class="explorerWrapper">
 21 | <code id="explorerStatus"></code><code id="explorerResponse"></code>
 22 | </pre>
 23 | 
 24 | <script type="text/javascript">
 25 | 
 26 | function readKey() {
 27 | 	var name = "api_key=";
 28 | 	var ca = document.cookie.split(';');
 29 | 	for(var i=0;i < ca.length;i++) {
 30 |         var c = ca[i];
 31 |         while (c.charAt(0)==' ') c = c.substring(1, c.length);
 32 |         if (c.indexOf(name) == 0) return c.substring(name.length,c.length);
 33 | 	}
 34 | 	return null;
 35 | }
 36 | 
 37 | function initParamFields() {
 38 | 	var endpoints;
 39 | 	var success = function(data) {
 40 | 			endpoints = data;
 41 | 		};
 42 | 
 43 | 	jQuery.ajax({
 44 | 		dataType: "json",
 45 | 		url: '{{ api_url }}',
 46 | 		async: false,
 47 | 		success: success
 48 | 	});
 49 | 
 50 | 
 51 | 	jQuery('#explorerParamWrapper').empty();
 52 | 	if (jQuery('#explorerEndpoint:empty').length == 1) {
 53 | 		initIdField(endpoints);
 54 | 	}
 55 | 	var id = (jQuery('#explorerEndpointId').val() == '') ? '' : '/{id}';
 56 | 	var params = endpoints[jQuery('#explorerEndpoint').val() + id].params;
 57 | 	for (p in params) {
 58 | 		var input = jQuery('<span>').text(p)
 59 | 			.add(jQuery('<input>').addClass(p).attr('placeholder', params[p]))
 60 | 			.add(jQuery('<br/>'));
 61 | 		jQuery('#explorerParamWrapper').append(input);
 62 | 	}
 63 | 	if (jQuery('#explorerEndpoint').val() == 'client') {
 64 | 		jQuery('#explorerEndpointSpan').hide();
 65 | 	} else {
 66 | 		jQuery('#explorerEndpointSpan').show();
 67 | 	}
 68 | }
 69 | function initIdField(endpoints) {
 70 | 	for (endpoint in endpoints) {
 71 | 		if (endpoint.search('/') > 0) { continue }
 72 | 		var option = '<option value="'+endpoint+'">/'+endpoint+'</option>';
 73 | 		jQuery('#explorerEndpoint').append(option);
 74 | 	}
 75 | }
 76 | 
 77 | function rewriteApiLinks(data) {
 78 | 	if (typeof data == 'object') {
 79 | 		jQuery.each(data, function(key, val) {
 80 | 			if (key != 'facets') {
 81 | 				rewriteApiLinks(val);
 82 | 			}
 83 | 			switch (key) {
 84 | 				case 'uri':
 85 | 					path = val.replace('{{ api_url }}', '{{ doc_url }}/explorer/#!');
 86 | 					data[key] = '<a href=' + path + ' class=explorerUriLink>'
 87 | 								+ val + '</a>';
 88 | 					break;
 89 | 				case 'href':
 90 | 					data[key] = '<a target=_blank class=explorerZonLink href='
 91 | 								+ val + '>' + val + '</a>';
 92 | 					break;
 93 | 			}
 94 | 		});
 95 | 	}
 96 | }
 97 | 
 98 | function configureEndpoint() {
 99 | 	var path = jQuery(location).attr('hash').split('/');
100 | 	switch (true) {
101 | 		case path.length > 1:
102 | 			jQuery('#explorerEndpoint').val(path[1]);
103 | 			initParamFields();
104 | 		case path.length > 2:
105 | 			jQuery('#explorerEndpointId').val(path[2]);
106 | 	}
107 | }
108 | 
109 | function sendRequest() {
110 | 	var params = {};
111 | 	jQuery(location).attr('hash', '!');
112 | 	jQuery('#explorerParamWrapper input').each(function() {
113 | 		if (jQuery(this).val()) {
114 | 			params[jQuery(this).attr('class')] = jQuery(this).val();
115 | 		}
116 | 	});
117 | 	var explorerEndpointId = '';
118 | 	if (jQuery('#explorerEndpointId').val() != '') {
119 | 		explorerEndpointId = '/' + jQuery('#explorerEndpointId').val();
120 | 	}
121 | 	jQuery.ajax({
122 | 		type: 'GET',
123 | 		url: '{{ api_url }}/' + jQuery('#explorerEndpoint').val() + explorerEndpointId,
124 | 		data: params,
125 | 		beforeSend: function (xhr) {
126 | 			xhr.setRequestHeader('X-Authorization', jQuery('#explorerXAuth').val());
127 | 			jQuery('#explorerResponse, #explorerStatus').fadeOut(50);
128 | 		},
129 | 		success: function(data) {
130 | 			rewriteApiLinks(data);
131 | 			jQuery('#explorerResponse').html(JSON.stringify(data, null, ' '));
132 | 		},
133 | 		error: function(xhr) {
134 | 			jQuery('#explorerResponse').html(xhr.responseText);
135 | 		},
136 | 		complete: function(xhr, status) {
137 | 			jQuery('#explorerStatus').html('Status Code: ' + xhr.status + ' '
138 | 				+ xhr.statusText + '<hr/>');
139 | 			jQuery('#explorerResponse, #explorerStatus').fadeIn(250);
140 | 		}
141 | 	});
142 | }
143 | 
144 | jQuery(window).bind('hashchange', function() {
145 | 	configureEndpoint();
146 | });
147 | 
148 | jQuery('#explorerEndpoint').change(function() {
149 | 	initParamFields();
150 | });
151 | 
152 | jQuery('#explorerEndpointId').change(function() {
153 | 	initParamFields();
154 | });
155 | 
156 | jQuery('document').ready(function() {
157 | 	jQuery('#explorerXAuth').attr('value', readKey());
158 | 	initParamFields();
159 | });
160 | 
161 | jQuery('#send').click(sendRequest);
162 | 
163 | </script>
164 | 
165 | {% endblock %}
166 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/index.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% block docTitle %}ZEIT ONLINE Content API{% endblock %}
 3 | {% block docBody %}
 4 | <div id="indexImg">
 5 |     <p class="indexImgCredit">Visualization by Gregor Aisch</p>
 6 | </div>
 7 | <br/>
 8 | <p>
 9 |     Willkommen zu der Beta-Version der ZEIT ONLINE Content API.
10 |     Über diese Schnittstelle kann auf Inhalte und zugehörige Metadaten aus
11 |     dem Archiv der ZEIT seit 1946 und von ZEIT ONLINE zugegriffen werden kann.
12 |     Wir laden alle an Programmierung, Datenanalyse und Visualisierung
13 |     Interessierten ein, den Index aus mehreren hunderttausenden Artikeln zu
14 |     erkunden. Die Benutzung der Schnittstelle ist für nicht-kommerzielle
15 |     Anwendungsfälle kostenlos. Bitte beachten Sie in jedem Falle die 
16 |     <a href="{{ doc_url }}/licence">Nutzungsbedingungen</a>.
17 | </p>
18 | <p>
19 |     Um gleich mit dem Erstellen von Anwendungen oder Auswertungen zu beginnen,
20 |     können Sie sich unter <a href="{{ doc_url }}/quickstart">Quickstart</a>
21 |     einen API-Key freischalten lassen. Der
22 |     <a href="{{ doc_url }}/explorer">Explorer</a> ermöglicht Ihnen die
23 |     Befragung der Schnittstelle über ein einfaches Web-Interface. Mehr über die
24 |     Funktionen und Endpunkte der API erfahren Sie in der englischen
25 |     <a href="{{ doc_url }}/docs">Dokumentation</a>.
26 | </p>
27 | <p>
28 |     Wir laden Sie ein, uns Ihre Umsetzungen, Experimente und
29 |     Erfahrungen mit der API via <a href="mailto:api@zeit.de">Email</a>
30 |     oder <a href="https://twitter.com/zeitonline_dev" target="_blank">
31 |     Twitter</a> mitzuteilen. Aktuelle Informationen und spannende Projekte mit
32 |     der API finden Sie auf dem ZEIT ONLINE <a href="http://blog.zeit.de/dev/">
33 |     Dev-Blog</a>.
34 | </p>
35 | <hr/>
36 | <p>
37 |     Welcome to the beta version of the ZEIT ONLINE content API. Via the API you
38 |     can access articles and corresponding metadata from the ZEIT archive dating
39 |     back to 1946 and from ZEIT ONLINE. We invite everybody interested in
40 |     programming, data analysis and visualization to explore the index of
41 |     hundreds of thousands articles. The API can be used for free for
42 |     non-commercial use cases. Please refer to the
43 |     <a href="{{ doc_url }}/licence"> terms of use</a> (German only at the
44 |     moment).
45 | </p>
46 | <p>
47 |     To get started building apps or analysing data, just request an API key
48 |     in our <a href="{{ doc_url }}/quickstart">quickstart guide</a>. The
49 |     <a href="{{ doc_url }}/explorer">explorer</a> will allow you to query
50 |     the API via a simple web-interface. A full <a href="{{ doc_url }}/docs">
51 |     documentation</a> of the endpoints and their capabilites is also available.
52 | </p>
53 | <p>
54 |     We invite you to share your apps, experiments and experiences with the API
55 |     with us via <a href="mailto:api@zeit.de">email</a> and
56 |     <a href="https://twitter.com/zeitonline_dev" target="_blank">Twitter</a>.
57 |     More news and a roundup of projects using our API can be found at the
58 |     ZEIT ONLINE <a href="http://blog.zeit.de/dev/">Dev-Blog</a>.
59 | </p>
60 | 
61 | {% endblock %}
62 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/licence.html:
--------------------------------------------------------------------------------
 1 | {% extends "base.html" %}
 2 | {% block docTitle %}Licence{% endblock %}
 3 | {% block docBody %}
 4 | 
 5 | <p>
 6 | 	ZEIT ONLINE stellt die API (Application Programming Interface) als
 7 | 	öffentliche BETA-Version zur Verfügung. Die API umfasst die Inhalte des
 8 | 	ZEIT Archivs seit 1946 sowie Inhalte von ZEIT ONLINE in maschinenlesbarer
 9 | 	Form. Mit der API sollen nicht-kommerzielle Erforschung, Analyse und
10 | 	Visualisierung der Inhalte erleichtert werden. Umsetzungen auf Basis der
11 | 	API möchten wir sehr gerne auf diesen Seiten vorstellen, bitte informieren
12 | 	Sie uns unter <a href="mailto:api@zeit.de">api@zeit.de</a>.
13 | </p>
14 | <p>
15 | 	Die Speicherung und Ausgabe des Volltexts von Artikeln ist zum derzeitigen
16 | 	Stand nicht möglich. Bitte beachten Sie, dass die Beiträge unserer Autoren
17 | 	dem Schutz des Urheberrechts unterliegen. Falls Sie ein Projekt auf
18 | 	Grundlage von Volltextübernahmen planen, möchten wir Sie bitten, mit uns
19 | 	Kontakt aufzunehmen. Es gelten die
20 | 	<a href="https://www.zeit.de/administratives/agb-kommentare-artikel#agb">
21 | 	Allgemeinen Nutzungsbedingungen</a> von ZEIT ONLINE. Für Rückfragen stehen
22 | 	wir gern zur Verfügung.
23 | </p>
24 | <p>
25 | 	Wir wünschen einen fruchtbaren Dialog mit allen an der API Interessierten.
26 | 	<br/>Für Vorschläge, technische Fragen oder Anregungen erreichen Sie uns unter
27 | 	<a href="mailto:api@zeit.de">api@zeit.de</a> oder
28 | 	<a href="https://twitter.com/zeitonline_dev" target="_blank">
29 | 	@zeitonline_dev</a>, bei Fragen zur kommerziellen Verwendung und Lizenzierung
30 | 	unter <a href="mailto:to online-syndication@zeit.de">online-syndication@zeit.de</a>. 
31 | </p>
32 | 
33 | {% endblock %}
34 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/quickstart.html:
--------------------------------------------------------------------------------
  1 | {% extends "base.html" %}
  2 | {% block docTitle %}Quick Start Guide{% endblock %}
  3 | {% block docBody %}
  4 | 
  5 | <h2>Request an API key</h2>
  6 | 
  7 | <p>Accessing our content requires an API key. To request one, simply
  8 |   sign up with your full name and a valid Email address. A key will be
  9 |   generated for you right here on this page. At the moment we offer free
 10 |   API-Access with a limit of 10,000 requests per day.</p>
 11 | 
 12 | <h3>Sign up</h3>
 13 | 
 14 | <script type="text/javascript"
 15 | 	src="https://www.google.com/recaptcha/api.js"></script>
 16 | 
 17 | <div id="signUpWrapper">
 18 | 	<table id="signUpForm">
 19 | 		<tr>
 20 | 			<td>
 21 | 				<div class="g-recaptcha" data-sitekey="{{ recaptcha }}"
 22 |              data-callback="captchaSuccess"></div>
 23 | 			</td>
 24 | 			<td>
 25 | 				<input type="text" name="name" placeholder="Your name">
 26 | 				<input type="email" name="email" placeholder="Email address">
 27 | 			</td>
 28 | 		</tr>
 29 | 		<tr>
 30 | 			<td></td>
 31 | 			<td>
 32 | 				<input type="checkbox" name="agreement" required>
 33 | 				<div id="signUpAgreement">
 34 | 					I have read and accept the <a href="{{ doc_url }}/licence">
 35 | 					licence agreement</a>.
 36 | 				</div>
 37 | 				<span id="send">Request API key</span>
 38 | 			</td>
 39 | 		</tr>
 40 | 	</table>
 41 | 	<div id="signUpError">
 42 | 	</div>
 43 | </div>
 44 | 
 45 | <script>
 46 | function readKey() {
 47 | 	var name = "api_key=";
 48 | 	var ca = document.cookie.split(';');
 49 | 	for(var i=0;i < ca.length;i++) {
 50 |         var c = ca[i];
 51 |         while (c.charAt(0)==' ') c = c.substring(1, c.length);
 52 |         if (c.indexOf(name) == 0) return c.substring(name.length,c.length);
 53 | 	}
 54 | 	return null;
 55 | }
 56 | 
 57 | function setKey(data) {
 58 | 	jQuery('#signUpWrapper').html('<code>api_key: ' + data['api_key'] + '</code>');
 59 | 	var date = new Date();
 60 |     date.setTime(date.getTime()+(7*24*60*60*1000));
 61 | 	document.cookie = "api_key=" + data['api_key'] + "; expires="
 62 | 		+date.toGMTString() + "; path=/";
 63 | }
 64 | 
 65 | function flashError(errorMessage) {
 66 | 	jQuery('#signUpError').html('<code>' + errorMessage + '</code>');
 67 | 	jQuery('#signUpForm, #signUpError').toggle(100).delay(2000).toggle(100);
 68 | }
 69 | 
 70 | function captchaSuccess(response) {
 71 |   jQuery('#signUpForm').data('captcha', response);
 72 | }
 73 | 
 74 | function getKey() {
 75 | 	jQuery.ajax({
 76 | 		type: 'POST',
 77 | 		url: '{{ api_url }}/client',
 78 | 		data: {
 79 |             'name': jQuery('input[name="name"]').val(),
 80 |             'email': jQuery('input[name="email"]').val(),
 81 |             'response': jQuery('#signUpForm').data('captcha')
 82 |         },
 83 | 		timeout: 1000,
 84 | 		success: function(data) {
 85 | 			jQuery('#signUpWrapper').fadeOut('fast', function() {
 86 | 				setKey(data);
 87 | 				jQuery('#signUpWrapper').fadeIn('fast');
 88 | 			});
 89 | 		},
 90 | 		error: function(error) {
 91 | 			flashError('Sorry, something went wrong.');
 92 | 		}
 93 | 	});
 94 | }
 95 | 
 96 | jQuery('document').ready(function() {
 97 | 	var key = readKey();
 98 | 	if (key) {
 99 | 		setKey({'api_key': key});
100 | 	}
101 | });
102 | 
103 | jQuery('#send').click(function() {
104 | 	switch(true) {
105 | 		case jQuery('input[name="name"]').val().length == 0:
106 |   			flashError('Please fill in your full name.');
107 |   			break;
108 | 		case jQuery('input[name="email"]').val().length == 0:
109 | 			flashError('Please fill in a valid email address.');
110 | 			break;
111 | 		case !jQuery('#signUpForm').data('captcha'):
112 | 			flashError('Please enter the captcha.');
113 | 			break;
114 | 		/*case !jQuery('input[name="agreement"]').attr('checked'):
115 | 			flashError('Please accept our licence agreement.');
116 | 			break;*/
117 | 		default:
118 | 			getKey();
119 | 	}
120 | });
121 | </script>
122 | 
123 | <hr/>
124 | <h2>Authorize requests</h2>
125 | 
126 | <p>
127 | 	All requests to our API must be authorized, so we know who plays with our
128 | 	data. To keep URLs simple and clean, the key should be sent as an
129 | 	X-Authorization header attached to your HTTP request.
130 | </p>
131 | 
132 | <h3>Example</h3>
133 | <pre><code>GET /{endpoint} HTTP/1.1
134 | Host: {{ api_url }}
135 | X-Authorization: {api_key}
136 | </code></pre>
137 | 
138 | <p>
139 | 	The key may also be sent as a query parameter, but a header is preferred.
140 | </p>
141 | 
142 | <h3>Example</h3>
143 | <pre><code>GET /{endpoint}?api_key={api_key} HTTP/1.1
144 | Host: {{ api_url }}
145 | </code></pre>
146 | 
147 | <hr/>
148 | <h2>Available formats</h2>
149 | <p>
150 | 	The supported content types for now are <a href="https://www.json.org/"
151 | 	target="_blank">JSON</a> and <a href="https://json-p.org/" target="_blank">
152 | 	JSONP</a>, simple as that. The default is JSON.<br/>To get JSONP, a
153 | 	callback parameter specifying the function's name is required.
154 | </p>
155 | 
156 | <h3>Example</h3>
157 | <pre><code>GET /{endpoint}?callback=myCallbackName HTTP/1.1
158 | Response: myCallbackName({"result":"data"});</code></pre>
159 | 
160 | <hr/>
161 | <h2>Error handling</h2>
162 | <p>If there was something wrong with your request or, if for some reason, we
163 | 	dropped the ball, you will receive an appropriate HTTP status code. The
164 | 	body will contain a JSON-encoded description of what might have been the
165 | 	problem.
166 | </p>
167 | 
168 | <h3>Example</h3>
169 | <pre><code>HTTP/1.0 401 UNAUTHORIZED
170 | Content: {"description": "The provided API key seems to be invalid."}
171 | </code></pre>
172 | 
173 | <hr/>
174 | 
175 | <h2>Start exploring</h2>
176 | <p>
177 | 	Now, that you have learned the basics, head over to our <a
178 | 	href="{{ doc_url }}/explorer">API Explorer</a> or digg into the
179 | 	<a href="{{ doc_url }}/docs">documentation</a>.
180 | </p>
181 | 
182 | {% endblock %}
183 | 


--------------------------------------------------------------------------------
/src/zeit/api/templates/style.css:
--------------------------------------------------------------------------------
  1 | #header h1.cap:after {
  2 | 	content: 'beta';
  3 | 	vertical-align: top;
  4 | 	font-size: 50%;
  5 | 	padding-left: 3px;
  6 | }
  7 | 
  8 | #main {
  9 | 	width: 750px;
 10 | }
 11 | 
 12 | #main p {
 13 | 	font-family: Georgia, Palatino, Palatino Linotype, FreeSerif, serif;
 14 | 	line-height: 1.3em;
 15 | }
 16 | 
 17 | #informatives {
 18 | 	padding: 0 1em;
 19 | 	width: 160px;
 20 | }
 21 | 
 22 | #informatives ul {
 23 | 	width: auto;
 24 | 	margin: .75em 0 1.5em;
 25 | }
 26 | 
 27 | #informatives .sidenav {
 28 | 	list-style-type: none;
 29 | }
 30 | 
 31 | #informatives .sidenav .indent {
 32 | 	list-style-type: square;
 33 | 	list-style-position:inside;
 34 | }
 35 | 
 36 | #informatives .sidenav.current a,
 37 | #informatives ul .current a {
 38 | 	color: #444;
 39 | 	text-decoration: underline;
 40 | }
 41 | 
 42 | #informatives ul.sidenav a {
 43 | 	font-weight: 600;
 44 | 	text-transform: uppercase;
 45 | }
 46 | 
 47 | #informatives ul.sidenav a:hover {
 48 | 	color: #444;
 49 | }
 50 | 
 51 | #informatives #sidenavHeader {
 52 | 	font-size: 17px;
 53 | 	font-weight: 600;
 54 | 	margin-bottom: 10px;
 55 | }
 56 | 
 57 | #informatives .sidenavLink {
 58 | 	margin: 0 0 5px -10px;
 59 | }
 60 | 
 61 | #informatives a.sidenavBlogLink {
 62 | 	border: 1px solid #ccc;
 63 | 	padding: 3px 6px 3px 38px;
 64 | 	border-radius: 3px;
 65 | 	font-size: 10px;
 66 | 	font-weight: 600;
 67 | 	color: #444;
 68 | 	background: #fafafa url(http://wordpress.org/favicon.ico) no-repeat 2px 0;
 69 | }
 70 | 
 71 | #informatives .twitter-follow-button {
 72 | 	margin: 11px 0 0 -10px;
 73 | }
 74 | 
 75 | #informatives a.sidenavBlogLink:hover {
 76 | 	background-color: #efefef;
 77 | }
 78 | 
 79 | #content.section {
 80 | 	padding: 0 10px 10px;
 81 | 	margin-bottom: 10px;
 82 | 	min-height: 350px;
 83 | 	background: transparent url(https://static.zeit.de/static/img/bg_content_eee.gif) repeat-y 782px 0px;
 84 | }
 85 | 
 86 | #main h1 {
 87 | 	font-size: 1.6em;
 88 | 	margin: 10px 0 20px;
 89 | }
 90 | 
 91 | #main h2 {
 92 | 	font-size: 1.2em;
 93 | }
 94 | 
 95 | #main h3 {
 96 | 	color: #900;
 97 | 	font-size: 0.6em;
 98 | 	text-transform: uppercase;
 99 | 	margin: 14px 0 10px;
100 | }
101 | 
102 | #main h2, #main p, #main code{
103 | 	margin: 10px 0;
104 | }
105 | 
106 | #signUpWrapper input, #send, select {
107 | 	border: 1px solid #ccc;
108 | 	padding: 3px 6px;
109 | 	border-radius: 3px;
110 | }
111 | 
112 | #main .alignCenter {
113 | 	text-align: center;
114 | }
115 | 
116 | #main input:focus:invalid {
117 | 	border-color: #900;
118 | }
119 | 
120 | #main input:required:valid {
121 | 	border-color: #3CB371;
122 | }
123 | 
124 | #main #send {
125 | 	cursor: pointer;
126 | 	font-size: 0.8em;
127 | }
128 | 
129 | #main select {
130 | 	cursor: pointer;
131 | }
132 | 
133 | #main #signUpWrapper {
134 | 	position: relative;
135 | }
136 | 
137 | #main #signUpWrapper table, #main #signUpWrapper td {
138 | 	border: none;
139 | }
140 | 
141 | #main #signUpWrapper td {
142 | 	width: 50%;
143 | 	text-align: center;
144 | }
145 | 
146 | #main #signUpWrapper #signUpForm input[name="name"],
147 | #main #signUpWrapper #signUpForm input[name="email"] {
148 | 	width: 288px;
149 | }
150 | 
151 | #main #signUpWrapper #signUpForm input[name="email"] {
152 | 	margin-top: 5px;
153 | }
154 | 
155 | #main #signUpWrapper #signUpError {
156 | 	position: absolute;
157 | 	display: none;
158 | 	top: 10px;
159 | }
160 | 
161 | #main #signUpWrapper #signUpForm #send:hover {
162 | 	border-color: #bbb;
163 | 	background-color: #e9e9e9;
164 | }
165 | 
166 | #main #signUpWrapper #signUpAgreement {
167 | 	font-size: 11px;
168 | 	width: 120px;
169 | 	display: inline-block;
170 | 	vertical-align: -5px;
171 | }
172 | 
173 | .explorerWrapper {
174 | 	min-height: 70px;
175 | 	margin-bottom: 20px;
176 | }
177 | 
178 | #main pre, #signUpWrapper {
179 | 	border: 1px solid #ccc;
180 | 	background-color: #fafafa;
181 | 	overflow: auto;
182 | 	padding: 5px 10px;
183 | 	border-radius: 3px;
184 | }
185 | 
186 | #main hr {
187 | 	border: none;
188 | 	border-top: 1px solid #eaeaea;
189 | 	margin: 24px 0;
190 | }
191 | 
192 | .explorerWrapper hr {
193 | 	margin: 12px 0;
194 | }
195 | 
196 | #main code, #explorerXAuth, #explorerEndpoint,
197 | #explorerParamWrapper input, #explorerEndpointId {
198 | 	font-family: Consolas, 'Liberation Mono', Courier, monospace;
199 | 	font-size: 1em;
200 | 	line-height: 1.125em;
201 | }
202 | 
203 | #main p code {
204 | 	background-color: #fafafa;
205 | 	outline: 1px solid #ccc;
206 | }
207 | 
208 | #explorerStatus hr {
209 | 	margin: 10px 0;
210 | }
211 | 
212 | #explorerEndpoint {
213 | 	width: 100px;
214 | }
215 | 
216 | .explorerZonLink {
217 | 	color: #004c99 !important;
218 | }
219 | 
220 | #explorerParamWrapper {
221 | 	position: relative;
222 | 	margin: -18px 0px 6px;
223 | 	min-height: 1.2em;
224 | 	width: 595px;
225 | 	left: 140px;
226 | }
227 | 
228 | #explorerParamWrapper span:first-child:before {
229 | 	content: '?';
230 | }
231 | 
232 | #explorerParamWrapper span:before {
233 | 	content: '&';
234 | }
235 | 
236 | #explorerParamWrapper span:after {
237 | 	content: '=';
238 | }
239 | 
240 | #explorerParamWrapper input {
241 | 	width: 400px;
242 | }
243 | 
244 | #explorerEndpoint, #explorerXAuth,
245 | #explorerParamWrapper input,
246 | #explorerEndpointId {
247 | 	margin: 0px;
248 | 	padding: 0px;
249 | 	border: none;
250 | 	border-width: 0px;
251 | 	background: #fafafa;
252 | 	color: #222;
253 | 	appearance: textfield;
254 | 	-moz-appearance: textfield;
255 | 	-webkit-appearance: textfield;
256 | }
257 | 
258 | #explorerParamWrapper input {
259 | 	color: #777;;
260 | }
261 | 
262 | #explorerEndpointSpan {
263 | 	margin-left: 4px;
264 | }
265 | 
266 | #main table {
267 | 	background-color: #fafafa;
268 | 	border-spacing: 0px;
269 | 	width: 100%;
270 | }
271 | 
272 | #main table td {
273 | 	border: 1px solid #ccc;
274 | 	padding: 5px 10px;
275 | 	border-right-width: 0px;
276 |     border-bottom-width: 0px;
277 | }
278 | 
279 | #main table tr:last-child td:first-child {
280 |     -moz-border-radius-bottomleft: 3px;
281 |     -webkit-border-bottom-left-radius: 3px;
282 |     border-bottom-left-radius: 3px;
283 | }
284 | 
285 | #main table tr:last-child td:last-child {
286 |     -moz-border-radius-bottomright: 3px;
287 |     -webkit-border-bottom-right-radius: 3px;
288 |     border-bottom-right-radius: 3px;
289 | }
290 | 
291 | #main table tr:first-child td:first-child {
292 |     -moz-border-radius-topleft: 3px;
293 |     -webkit-border-top-left-radius: 3px;
294 |     border-top-left-radius: 3px;
295 | }
296 | 
297 | #main table tr:first-child td:last-child {
298 |     -moz-border-radius-topright: 3px;
299 |     -webkit-border-top-right-radius: 3px;
300 |     border-top-right-radius: 3px;
301 | }
302 | 
303 | #main table tr td:last-child {
304 |     border-right-width: 1px;
305 | }
306 | 
307 | #main table tr:last-child td {
308 |     border-bottom-width: 1px;
309 | }
310 | 
311 | #main table td span.default {
312 | 	color: #aaa;
313 | 	-moz-user-select: -moz-none;
314 | 	-khtml-user-select: none;
315 | 	-webkit-user-select: none;
316 | 	-ms-user-select: none;
317 | 	user-select: none;
318 | }
319 | 
320 | #main table td span.default:before {
321 | 	content: '=';
322 | 	padding-left: 3px;
323 | }
324 | 
325 | #main .floatColumn {
326 | 	float: left;
327 | 	width: 360px;
328 | 	text-align: justify;;
329 | }
330 | 
331 | #main .floatColumn.leftColumn {
332 | 	padding-right: 20px;
333 | }
334 | 
335 | #main #indexImg {
336 | 	background-image: url(https://img.zeit.de/administratives/header.jpg);
337 | 	background-size: cover;
338 | 	width: 740px;
339 | 	height: 250px;
340 | }
341 | 
342 | #main .indexImgCredit {
343 | 	color: #555;
344 | 	font-size: 0.8em;
345 | 	float: right;
346 | 	margin: 228px 0 0 0;
347 | 	background: #fff;
348 | 	padding: 3px;
349 | }
350 | 


--------------------------------------------------------------------------------
/src/zeit/api/tests.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | """
  3 |     zeit.api.tests
  4 |     ~~~~~~~~~~~~~~~~
  5 | 
  6 |     This module contains automated testing functionalities.
  7 | 
  8 |     Copyright: (c) 2013 by ZEIT ONLINE.
  9 |     License: BSD, see LICENSE.md for more details.
 10 | """
 11 | import json
 12 | import random
 13 | import unittest
 14 | import werkzeug
 15 | 
 16 | from . import application
 17 | 
 18 | 
 19 | class ClientTestCase(unittest.TestCase):
 20 | 
 21 |     def setUp(self):
 22 |         self.client = application.test_client_factory()
 23 |         data = dict(
 24 |             name='Any Name',
 25 |             email='mail@provider.tld',
 26 |             challenge='0123456789',
 27 |             response='abcdefghij'
 28 |         )
 29 |         resp = self.client.post('/client', data=data)
 30 |         self.parsed = json.loads(resp.data)
 31 | 
 32 |     def test_signup(self):
 33 |         """Client signup successful."""
 34 |         self.assertTrue('api_key' in self.parsed)
 35 | 
 36 |     def test_unauthorized(self):
 37 |         """Unauthorized access blocked."""
 38 |         resp = self.client.get('/client')
 39 |         self.assertEqual(resp.status_code, 401)
 40 | 
 41 |     def test_api_key_parameter(self):
 42 |         """Authorization via URL parameter."""
 43 |         query_string = dict(api_key=self.parsed['api_key'])
 44 |         resp = self.client.get('/client', query_string=query_string)
 45 |         self.assertEqual(resp.status_code, 200)
 46 | 
 47 |     def test_x_authorization_header(self):
 48 |         """Authorization via HTTP header."""
 49 |         headers = werkzeug.datastructures.Headers()
 50 |         headers.add('X-Authorization', self.parsed['api_key'])
 51 |         resp = self.client.get('/client', headers=headers)
 52 |         self.assertEqual(resp.status_code, 200)
 53 | 
 54 | 
 55 | class QueryTestCase(unittest.TestCase):
 56 | 
 57 |     def setUp(self):
 58 |         self.client = application.test_client_factory()
 59 |         data = dict(name='Some Name', email='mail@provider.tld')
 60 |         resp = self.client.post('/client', data=data)
 61 |         self.headers = werkzeug.datastructures.Headers()
 62 |         self.headers.add('X-Authorization', json.loads(resp.data)['api_key'])
 63 | 
 64 |     def __get_json(self, url, data={}):
 65 |         print 'Checking ' + url + ' with ' + str(data)
 66 |         resp = self.client.get(url, headers=self.headers)
 67 |         self.assertEqual(resp.status_code, 200)
 68 |         return json.loads(resp.data)
 69 | 
 70 |     def test_endpoint_availability(self):
 71 |         """All endpoints up and running."""
 72 |         endpoints = self.__get_json('/')
 73 |         for path in endpoints:
 74 |             if '{id}' in path:
 75 |                 continue
 76 |             endpoint = self.__get_json('/' + path)
 77 |             if 'matches' in endpoint:
 78 |                 for match in endpoint['matches']:
 79 |                     ids = (match[i] for i in ['id', 'uuid'] if i in match)
 80 |                     for i in list(ids):
 81 |                         self.__get_json('/' + path + '/' + i)
 82 | 
 83 |     def test_parameter_defaults(self):
 84 |         """Parameters accepting their default values."""
 85 |         for endpoint, definition in self.__get_json('/').items():
 86 |             if '{id}' in endpoint:
 87 |                 continue
 88 |             for param, val in definition['params'].items():
 89 |                 self.__get_json('/' + endpoint, {param: val})
 90 | 
 91 | 
 92 | class ParameterTestCase(unittest.TestCase):
 93 | 
 94 |     def setUp(self):
 95 |         self.client = application.test_client_factory()
 96 |         data = dict(name='Some Name', email='mail@provider.tld')
 97 |         resp = self.client.post('/client', data=data)
 98 |         self.headers = werkzeug.datastructures.Headers()
 99 |         self.headers.add('X-Authorization', json.loads(resp.data)['api_key'])
100 |         resp = self.client.get('/', headers=self.headers)
101 |         self.endpoints = json.loads(resp.data)
102 | 
103 |     def test_callback_parameter(self):
104 |         """Callback parameter results in JSONP output."""
105 |         for ep in self.endpoints:
106 |             if '{id}' in ep or 'client' in ep:
107 |                 continue
108 |             rnd = ''.join(random.choice('abcdefghij') for x in range(5))
109 |             json_resp = self.client.get(
110 |                 '/' + ep,
111 |                 query_string=dict(limit=1),
112 |                 headers=self.headers
113 |             )
114 |             jsonp_resp = self.client.get(
115 |                 '/' + ep,
116 |                 query_string=dict(callback=rnd, limit=1),
117 |                 headers=self.headers
118 |             )
119 |             expected = rnd + '(' + json_resp.data + ');'
120 |             self.assertEqual(expected, jsonp_resp.data)
121 | 
122 |     def test_limit_parameter(self):
123 |         """Limit parameter behaves as expected."""
124 |         for ep in self.endpoints:
125 |             if '{id}' in ep or 'limit' not in self.endpoints[ep]['params']:
126 |                 continue
127 |             for entry, result in [(-1, 0), (0, 0), (1, 1), (1025, 0)]:
128 |                 resp = self.client.get(
129 |                     '/' + ep,
130 |                     query_string=dict(limit=entry),
131 |                     headers=self.headers
132 |                 )
133 |                 matches = json.loads(resp.data).get('matches', [])
134 |                 self.assertEqual(len(matches), result)
135 | 
136 |     def test_offset_parameter(self):
137 |         """Offset parameter behaves as expected."""
138 |         for ep in self.endpoints:
139 |             if '{id}' in ep or 'offset' not in self.endpoints[ep]['params']:
140 |                 continue
141 |             resp = self.client.get(
142 |                 '/' + ep,
143 |                 query_string=dict(limit=0),
144 |                 headers=self.headers
145 |             )
146 |             maximum = json.loads(resp.data)['found']
147 | 
148 |             for entry, code in [(-1, 400), (0, 200), (maximum, 200)]:
149 |                 resp = self.client.get(
150 |                     '/' + ep,
151 |                     query_string=dict(offset=entry),
152 |                     headers=self.headers
153 |                 )
154 |                 self.assertEqual(resp.status_code, code)
155 | 
156 |     def test_fields_parameter(self):
157 |         """Fields parameter behaves as expected."""
158 |         for ep in self.endpoints:
159 |             if '{id}' in ep or 'fields' not in self.endpoints[ep]['params']:
160 |                 continue
161 |             fields = self.endpoints[ep]['params']['fields'].split(',')
162 | 
163 |             for n in range(1, len(fields)):
164 |                 for perm_fields in [fields[:n]]:
165 |                     query_string = dict(
166 |                         fields=','.join(perm_fields),
167 |                         limit=1
168 |                     )
169 |                     resp = self.client.get(
170 |                         '/' + ep,
171 |                         query_string=query_string,
172 |                         headers=self.headers
173 |                     )
174 |                     print 'Checking /' + ep + ' with ' + str(query_string)
175 |                     parsed_fields = json.loads(resp.data)['matches'][0].keys()
176 |                     sd = set(perm_fields).symmetric_difference(set(parsed_fields))
177 |                     self.assertTrue(sd.issubset(['snippet']))
178 | 
179 | 
180 | if __name__ == '__main__':
181 |     unittest.main()
182 | 


--------------------------------------------------------------------------------
/src/zeit/api/util.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | """
 3 |     zeit.api.util
 4 |     ~~~~~~~~~~~~~
 5 | 
 6 |     This module provides helper functions used throughout the application.
 7 | 
 8 |     Copyright: (c) 2013 by ZEIT ONLINE.
 9 |     License: BSD, see LICENSE.md for more details.
10 | """
11 | 
12 | import re
13 | import urllib
14 | import urlparse
15 | 
16 | 
17 | def append_to_csv(csv, new):
18 |     """Add a new value to a string formatted, comma separted value list."""
19 | 
20 |     if csv == '':
21 |         return new
22 |     arr = csv.split(',')
23 |     arr.append(new)
24 |     return ','.join(arr)
25 | 
26 | 
27 | def csv_to_list(csv):
28 |     """Convert a csv string to an array, while ommitting empty entries."""
29 | 
30 |     for val in csv.split(','):
31 |         if val != '':
32 |             yield val
33 | 
34 | 
35 | def dict_by_list(dic, arr):
36 |     """Filter a dictionary by a list of valid keys."""
37 | 
38 |     for key in dic:
39 |         if key in arr:
40 |             yield key, dic[key]
41 | 
42 | 
43 | def ensure_prefix(string, prefix):
44 |     """Ensure, that a string is prefixed by another string."""
45 | 
46 |     if string[:len(prefix)] == prefix:
47 |         return string
48 |     return prefix + string
49 | 
50 | 
51 | def iri_to_uri(iri):
52 |     """Convert an Internationalized Resource Identifier to a URI."""
53 | 
54 |     parts = urlparse.urlparse(iri)
55 |     return urlparse.urlunparse(
56 |         part.encode('idna') if parti == 1 else
57 |             url_encode_non_ascii(part.encode('utf-8'))
58 |         for parti, part in enumerate(parts)
59 |     )
60 | 
61 | 
62 | def save_xpath(element, xpath, fallback=''):
63 |     """Safely return the first result of an xpath expression."""
64 | 
65 |     try:
66 |         return element.xpath(xpath)[0]
67 |     except IndexError:
68 |         return fallback
69 | 
70 | 
71 | def url_encode(data):
72 |     """Safely encode a dictionary to a URL compatible string."""
73 | 
74 |     param = dict()
75 |     for key, val in data.iteritems():
76 |         if key == 'facet.field':
77 |             param[key] = list(csv_to_list(val))
78 |         elif isinstance(val, int):
79 |             param[key] = '%d' % val
80 |         else:
81 |             param[key] = val
82 |     return urllib.urlencode(param, True)
83 | 
84 | 
85 | def url_encode_non_ascii(href):
86 |     """URL-encode non ascii characters."""
87 | 
88 |     function = lambda c: '%%%02x' % ord(c.group(0))
89 |     return re.sub('[\x80-\xFF]', function, href)
90 | 


--------------------------------------------------------------------------------