console/app/cloud/views/administrator/__init__.py

# coding: utf-8

from uuid import uuid4
from flask import Blueprint
from flask import request
from flask import session
from flask import redirect
from flask import render_template
from flask import url_for
from flask import g
from app import models
from app.cloud.controllers.common import special_match
from app.cloud.controllers.common import ControllerMessagesEmail
from app.cloud.controllers.administrators import ControllerAdministrators
from app.cloud.controllers.users.manage import ControllerManageUsers
from app.cloud.controllers.users.manage import ControllerManageUsersDetails
from app.cloud.controllers.users.manage import ControllerManageUsersBalance
from app.cloud.controllers.datacenters.manage import ControllerManageDatacenters
from app.cloud.controllers.servers.manage import ControllerManageServer
from app.cloud.controllers.billing import ControllerBilling
from app.cloud.controllers.containers.manage import ControllerManageContainers
from app.cloud.controllers.ips.manage import ControllerManageIPs

viewAdministrator = Blueprint('administrator', __name__, url_prefix='/administrator')


@viewAdministrator.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        admin_email = request.form['email'].encode('utf-8')
        admin_password = request.form['password'].encode('utf-8')

        # validation entered data
        if not special_match(admin_email, r"^[A-Za-z0-9\.\+_-]+@[A-Za-z0-9\._-]+\.[a-zA-Z]*$")\
                or len(admin_password) < 5:
            g.errors['items'].append('Invalid registration data.')
            g.errors['total'] += 1
        # если ошибок нет, то продолжаем обработку
        if g.errors['total'] == 0:
            # try auth only active users (with status code 1)
            if ControllerAdministrators().auth(admin_email, admin_password, 1):
                # get user_id
                user_id = ControllerAdministrators().get_id_by_email(admin_email)

                # save user data to session
                session['admin_id'] = str(user_id)
                session['admin_email'] = admin_email
                session['admin_password'] = admin_password

                # redirect to rules list
                return redirect(url_for('administrator.dashboard'))
            else:
                g.errors['items'].append('Invalid login. Please try again.')
                g.errors['total'] += 1
    return render_template('administrator/login.html')


@viewAdministrator.route('/logout')
def logout():
    session.pop('admin_id', None)
    session.pop('admin_email', None)
    session.pop('admin_password', None)
    return redirect(url_for('administrator.login'))


@viewAdministrator.route('/dashboard')
def dashboard():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    #
    stats = {
        'users': models.Users.select().count(),
        # 'rules': models.Rules.select().count(),
        # 'traffic': models.RulesTraffic.select().count(),
        'payments': models.UsersBalanceTransactions.select().count(),
    }
    #
    return render_template('administrator/dashboard.html', stats=stats)


@viewAdministrator.route('/users/')
def users():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    #
    return render_template(
        'administrator/users/index.html',
        users=ControllerManageUsers().items_get()
    )


@viewAdministrator.route('/users/details/<uuid:user_id>')
def user_details(user_id):
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    # check exists user by uuid
    if not ControllerManageUsers().exists_by_id(user_id):
        return redirect(url_for('administrator.users'))
    #
    if not ControllerBilling().exists(user_id):
        ControllerBilling().create(user_id, g.settings['bonus'])
    return render_template(
        'administrator/users/details.html',
        user_account=ControllerManageUsers().item_get(user_id),
        user_details=ControllerManageUsersDetails().item_get(user_id),
        user_balance=ControllerManageUsersBalance().item_get(user_id),
    )


@viewAdministrator.route('/containers/')
def containers():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    # формируем список правил
    rules_items = ControllerManageContainers().get_all_items()
    return render_template(
        'administrator/containers/index.html',
        containers=rules_items
    )


@viewAdministrator.route('/payments')
def payments():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    payments_items = {
        'total': models.UsersBalanceTransactions.select().count(),
        'items': models.UsersBalanceTransactions.select()
    }
    return render_template('administrator/payments.html', payments=payments_items)


@viewAdministrator.route('/datacenters')
def datacenters():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    #
    return render_template(
        'administrator/datacenters/index.html',
        datacenters=ControllerManageDatacenters().items_get()
    )


@viewAdministrator.route('/datacenters/create', methods=['GET', 'POST'])
def datacenters_create():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))

    if request.method == "POST":
        # TODO: validate
        dc_name = request.form['name']
        dc_status = request.form['status']

        # check exists datacenter
        if models.DataCenters.select().where(models.DataCenters.name == dc_name).count() == 1:
            return redirect(url_for('administrator.datacenters_create'))

        models.DataCenters.create(id=uuid4(), name=dc_name, status=dc_status)
        return redirect(url_for('administrator.datacenters'))
        # todo: ... update record for datacenter
        # return url_for('administrator.datacenters_edit', dc_id=dc_id)
    # datacenter = models.DataCenters.select().where(models.DataCenters.id == dc_id).limit(1)[0]

    return render_template('administrator/datacenters/create.html')


@viewAdministrator.route('/datacenters/edit/<uuid:dc_id>', methods=['GET', 'POST'])
def datacenters_edit(dc_id):
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    # check exists datacenter
    if not ControllerManageDatacenters().check_exists(dc_id):
        return redirect(url_for('administrator.datacenters'))
    # POST
    if request.method == "POST":
        # todo: ... update record for datacenter
        return url_for('administrator.datacenters_edit', dc_id=dc_id)

    datacenter = ControllerManageDatacenters().item_get(dc_id)

    return render_template(
        'administrator/datacenters_edit.html',
        datacenter=datacenter
    )


@viewAdministrator.route('/servers/')
def servers_index():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    #
    return render_template(
        'administrator/servers/index.html',
        servers=ControllerManageServer().items_get()
    )


@viewAdministrator.route('/ips/')
def ips_index():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    #
    return render_template(
        'administrator/ips/index.html',
        ips=ControllerManageIPs().items_get()
    )


@viewAdministrator.route('/servers/create', methods=['GET', 'POST'])
def servers_create():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))

    if request.method == "POST":
        print request.form
        params = {
            'datacenter_id': request.form['datacenter_id'],
            'server_id': uuid4(),
            'secret': uuid4(),
            'hostname': request.form['hostname'],
            'ipv4': request.form['ip'],
            'status': request.form['status']
        }

        ControllerManageServer().item_create(
            params['datacenter_id'],
            params['server_id'],
            params['secret'],
            params['hostname'],
            params['ipv4'],
            None,
            params['status']
        )

    dcs = ControllerManageDatacenters().items_get()

    return render_template(
        'administrator/servers/create.html',
        datacenters=dcs
    )


@viewAdministrator.route('/servers/edit/<uuid:server_id>', methods=['GET', 'POST'])
def servers_edit(server_id):
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    # check exists server
    if models.Servers.select().where(models.Servers.id == server_id).count() == 0:
        return redirect(url_for('administrator.servers'))

    server_details = models.Servers.select().where(models.Servers.id == server_id).limit(1)[0]

    return render_template('administrator/servers/edit.html', server=server_details)


@viewAdministrator.route('/settings/')
def settings_index():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))

    settings_list = {
        'total': models.Settings.select().count(),
        'items': models.Settings.select()
    }

    return render_template('administrator/settings/index.html', settings=settings_list)


@viewAdministrator.route('/settings/create', methods=['GET', 'POST'])
def settings_create():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    # auth user
    if not ControllerAdministrators().auth(session['admin_email'], session['admin_password']):
        return redirect(url_for("administrator.logout"))
    # Обрабатываем POST-запрос
    if request.method == 'POST':
        # check exists `key`
        if models.Settings.select().where(models.Settings.key == request.form['key']).count() == 0:
            # Если указанного ключа нет в таблице, то добавляем его
            models.Settings.create(key=request.form['key'], val=request.form['val'])
            # После добавления записи делаем редирект на страницу со списком параметров
            return redirect(url_for('administrator.settings_index'))
        # Если предыдущее условие (проверка отсутствия ключа) не сработало,
        # то выдаём сообщение об уже существующем ключе
        g.errors['total'] += 1
        g.errors['items'].append(u"Параметр уже существует")
    return render_template('administrator/settings/create.html')


@viewAdministrator.route('/settings/delete', methods=['GET', 'POST'])
def settings_delete():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))
    #
    if models.Settings.select().where(models.Settings.id == request.args['id']).count() == 0:
        return redirect(url_for('administrator.settings_index'))
    #
    if request.method == 'POST':
        delete_set = models.Settings.delete().where(models.Settings.id == request.form['id'])
        delete_set.execute()
        return redirect(url_for('administrator.settings_index'))
    #
    setting = models.Settings.select().where(models.Settings.id == request.args['id']).limit(1)[0]
    #
    return render_template('administrator/settings/delete.html', setting=setting)


@viewAdministrator.route('/settings/update', methods=['GET', 'POST'])
def settings_update():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))

    if models.Settings.select().where(models.Settings.id == request.args['id']).count() == 0:
        return redirect(url_for('administrator.settings_index'))
    #
    if request.method == 'POST':
        uq = models.Settings.update(val=request.form['val']).where(models.Settings.id == request.form['id'])
        uq.execute()
        return redirect(url_for('administrator.settings_index'))
    # get setting parameter by ID
    setting = models.Settings.select().where(models.Settings.id == request.args['id']).limit(1)[0]
    return render_template('administrator/settings/update.html', setting=setting)


@viewAdministrator.route('/settings/messages/email_test.html', methods=['GET', 'POST'])
def settings_messages_email_test():
    # check session
    if not ControllerAdministrators().check_session():
        return redirect(url_for("administrator.logout"))

    email = ControllerMessagesEmail()
    email.send(title='test', to='vanzhiganov@ya.ru', lead='qwdqwd', message='qwdqwd', callout='qwdqwd')
    # if request.method == 'POST':
    #     uq = models.Settings.update(val=request.form['val']).where(models.Settings.id == request.form['id'])
    #     uq.execute()
    #     return redirect(url_for('administrator.settings_index'))
    # get setting parameter by ID
    setting = models.Settings.select().where(models.Settings.id == request.args['id']).limit(1)[0]
    return render_template('administrator/settings/messages/email.html')