from flask import (Blueprint, request, current_app, jsonify, render_template,

                   abort)

from ennstatus.api.functions import check_json_format, update_server

from ennstatus.status.functions import (single_server, all_servers,

                                        all_servers_by_type)

api_page = Blueprint('api', __name__)

@api_page.route('/update', methods=('POST',))

def update():

    current_app.logger.info('Handling update')

    if current_app.debug:

        accepted_ips = ['127.0.0.1']

    else:

        accepted_ips = current_app.config.get('ENNSTATUS_ACCEPTED_IPS', [])

    json = request.get_json()

    if json is None:

        current_app.logger.info('No JSON data supplied!')

        return 'No JSON data supplied!\n', 400, {'Content-Type': 'text/plain'}

    try:

        check_json_format(json)

    except ValueError as e:

        current_app.logger.warning(' '.join([str(e), str(json)]))

        return str(e), 409, {'Content-Type': 'text/plain'}

    if 'ip' in json:

        ip = json['ip']

    else:

        ip = request.remote_addr

    if request.remote_addr not in accepted_ips:

                                % ip)

        return 'IP not allowed!\n', 403, {'Content-Type': 'text/plain'}

    current_app.logger.info(str(json))

    server = update_server(server=json, ip=ip)

    if server:

        current_app.logger.info('Return result')

        current_app.logger.info(str(server))

        return (jsonify(server), 201,

                {'Location': '/api/export/json/single?server_name=%s'

                 % server['server_name']})

    else:

                                 exc_info=True)

        return abort(500)

@api_page.route('/export', defaults={'server_type': 'all',

                                     'export_format': 'json'})

@api_page.route('/export/<any("json", "xml"):export_format>',

                defaults={'server_type': 'all'})

@api_page.route(('/export/<any("json", "xml"):export_format>'

                 '/<any("all", "exit", "bridge", "relay", "single")'

                 ':server_type>'))

def export(export_format, server_type):

    current_app.logger.info('Handling export')

    if server_type == 'single':

        server_name = request.args.get('server_name', None)

        if server_name is not None:

            server = single_server(server_name)

            if server:

                if export_format == 'json':

                    current_app.logger.info('Returning server as json!')

                    return jsonify(server)

                else:

                    current_app.logger.info('Returning server as xml!')

                    return (

                        render_template(

                            'api/export/xml/single_server.xml',

                            server=server),

                        200, {'Content-Type': 'text/xml'})

            else:

                current_app.logger.warning('Server not found!')

                return ('Server not found!\n',

                        404, {'Content-Type': 'text/plain'})

        else:

            current_app.logger.warning('No server_name specified!')

            return ('No server_name specified!\n',

                    400, {'Content-Type': 'text/plain'})

    else:

        if server_type == 'all':

            current_app.logger.info('Getting all servers!')

            servers = list(all_servers())

        else:

            current_app.logger.info('Getting all %s!' % server_type)

            servers = list(all_servers_by_type(server_type.capitalize()))

        if export_format == 'json':

            response = {'enn_network': servers}

            current_app.logger.info('Returning as json!')

            return jsonify(response)

        else:

            current_app.logger.info('Returning as xml!')

            return (render_template('api/export/xml/network.xml',

                                    servers=servers),

                    200, {'Content-Type': 'text/xml'})

from flask import (Blueprint, render_template, request,

                   redirect, url_for, current_app)

from ennstatus.donate.forms import DateForm

from ennstatus.donate.functions import load_csv, get_choices

donate_page = Blueprint('donate', __name__)

@donate_page.route('/')

def index():

    return render_template('donate/index.html')

@donate_page.route('/wiretransfer')

def wiretransfer():

    return render_template('donate/wiretransfer.html')

@donate_page.route('/snailmail')

def snailmail():

    return render_template('donate/snailmail.html')

@donate_page.route('/paypal')

def paypal():

    return render_template('donate/paypal.html')

@donate_page.route('/bitcoin')

def bitcoin():

    return render_template('donate/bitcoin.html')

@donate_page.route('/flattr')

def flattr():

    return render_template('donate/flattr.html')

@donate_page.route('/bpm')

def bpm():

    return render_template('donate/bpm.html')

@donate_page.route('/received',

                   methods=('GET', 'POST'))

def received():

    current_app.logger.info('Handling received')

    form = DateForm()

    current_app.logger.debug('Creating choices')

    choices = [name for name in get_choices()]

    choices.sort()

    form.date.choices = [(name, name) for name in choices]

    if not choices:

        current_app.logger.warn('No donations found!')

        return render_template('donate/received.html',

                               form=form, csv_file=None,

                               date=None)

    if request.method == 'POST':

        current_app.logger.debug('Validating form')

        if form.validate_on_submit():

            date = form.date.data

            return redirect(url_for('donate.received', date=date))

    else:

        if 'date' in request.args:

            date = request.args['date']

                current_app.logger.info('Showing date %s' % date)

                form.date.data = date

                csv_file = load_csv(date)

            else:

                current_app.logger.warn('Date %s not found' % date)

                return ('Date %s not found!' % date, 500,

                        {'Content-Type': 'text/plain'})

        else:

            current_app.logger.info('Showing last date %s' % choices[-1])

            form.date.data = choices[-1]

            csv_file = load_csv(choices[-1])

            date = choices[-1]

        current_app.logger.info('Return result')

        return render_template('donate/received.html',

                               form=form, csv_file=csv_file,

                               date=date)

import logging

import logging.handlers

logging_debug_formatter = logging.Formatter(logging_debug_string)

logging_formatter = logging.Formatter(logging_string)

def init_logging(app):

    app.logger.setLevel(logging.DEBUG)

    stream_handler = logging.StreamHandler()

    stream_handler.setLevel(logging.DEBUG)

    stream_handler.setFormatter(logging_debug_formatter)

    rotating_file_handler = logging.handlers.RotatingFileHandler(

        'log/ennstatus.log',

        maxBytes=1300000,

        backupCount=10,

        encoding='utf-8')

    rotating_file_handler.setLevel(logging.INFO)

    rotating_file_handler.setFormatter(logging_formatter)

    if app.debug:

        second_rotating_file_handler = logging.handlers.RotatingFileHandler(

            'log/ennstatus_debug.log',

            maxBytes=1300000,

            backupCount=20,

            encoding='utf-8')

        second_rotating_file_handler.setLevel(logging.DEBUG)

        second_rotating_file_handler.setFormatter(logging_debug_formatter)

        app.logger.addHandler(second_rotating_file_handler)

    smtp_handler = logging.handlers.SMTPHandler(

        app.config.get('ENNSTATUS_ADMINS', None),

    smtp_handler.setLevel(logging.ERROR)

    smtp_handler.setFormatter(logging_formatter)

    app.logger.addHandler(stream_handler)

    app.logger.addHandler(rotating_file_handler)

import os

import os.path

import json

from collections import defaultdict

from datetime import datetime

from flask import current_app

def _check_server(data):

    if data['server_status'] == 'Offline':

        return data

    date = datetime.strptime(data['last_updated'], '%d-%m-%Y %H:%M:%S')

    now = datetime.utcnow()

    delta = now - date

    if delta.seconds >= 3600:

        status = 'Offline'

    elif delta.seconds >= 1200:

        status = 'Unknown'

    else:

        status = None

    if status is not None:

                                 status))

        for key in ('server_status', 'tor_status'):

            data[key] = status

    filename = os.path.join('data', data['server_name'].lower()+'.json')

    with open(filename, mode='w', encoding='utf-8') as file_object:

        json.dump(data, file_object)

    return data

def _load_single_server(filename):

    try:

        with open(filename, encoding='utf-8') as f:

            server = json.load(f)

    except IOError:

        return False

    server = _check_server(server)

    return server

def single_server(name):

    filename = ''.join(['data/', name, '.json'])

    return _load_single_server(filename)

def _get_json_files(root, files):

    for f in files:

        if f.endswith('.json'):

            yield os.path.join(root, f)

def all_servers():

    for root, _, files in os.walk('data'):

        for f in _get_json_files(root, files):

            yield _load_single_server(f)

def all_servers_by_type(type):

    for server in all_servers():

        if server['server_type'] == type:

            yield server

def split_all_servers_to_types():

    servers = defaultdict(list)

    for server in all_servers():

        servers[server['server_type']].append(server)

    return servers

from setuptools import setup, find_packages

def _get_requirements():

    with open('requirements.in', encoding='utf-8') as f:

        lines = f.readlines()

    lines = [line[:-1] for line in lines]

    return lines

setup(name='Ennstatus',

      version='4.0.1',

      description=('Ennstatus provides the user with vital information about '

                   'the status of the organizations Tor servers.'),

      author='Frënn vun der Ënn',

      author_email='info@enn.lu',

      url='https://bitbucket.org/fvde/ennstatus',

      license="GPLv3+",

      packages=find_packages(),

      package_data={'ennstatus': ['static/css/*.css',

                                  'static/css/flags/img/png/*.png',

                                  'static/css/flags/img/gif/*.gif',

                                  'static/css/flags/*.css',

                                  'static/files/*',

                                  'static/images/*',

                                  'static/videos/*',

                                  'templates/*.html',

                                  'templates/api/extract/xml/*.xml',

                                  'templates/donate/*.html',

                                  'templates/root/*.html',

                                  'templates/status/*.html',

                                  'templates/stats/*.html'

                                  ]},

      install_requires=_get_requirements(),

                   ]

      )