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


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'))
    #
    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('/rules/')
def rules():
    # 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 = {
        'total': models.Containers.select().count(),
        'items': models.Containers.select()
    }
    return render_template('administrator/rules/index.html', rules=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 models.DataCenters.select().where(models.DataCenters.id == dc_id).count() == 0:
        return redirect(url_for('administrator.datacenters'))

    if request.method == "POST":
        # 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_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"))

    servers_items = {
        'total': models.Servers.select().count(),
        'items': models.Servers.select()
    }

    return render_template('administrator/servers/index.html', servers=servers_items)


@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
        server_id = uuid4()
        server_secret = uuid4()
        server_name = request.form['hostname']
        server_dcid = request.form['datacenter_id']
        server_ip = request.form['ip']
        server_status = request.form['status']

        models.Servers.create(
            id=server_id,
            hostname=server_name,
            ip=server_ip,
            datacenter=server_dcid,
            secret=server_secret,
            status=server_status
        )
    dcs = {
        'total': models.DataCenters.select().count(),
        'items': models.DataCenters.select()
    }

    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')