from settings import config
from flask import g, url_for, request, session, make_response, flash
from paramecio2.libraries.generate_admin_class import GenerateAdminClass
from paramecio2.libraries.i18n import I18n, PGetText
from paramecio2.modules.admin import admin_app, t as admin_t
from paramecio2.libraries.db.coreforms import SelectForm, SelectModelForm, HiddenForm
from paramecio2.libraries.mtemplates import PTemplate, env_theme
from paramecio2.libraries import datetime
from paramecio2.libraries.urls import make_media_url, make_url
#from modules.monit.models.monit import Server, ServerData, Alerts
from modules.pastafari2.libraries.scandir import scandir
from paramecio2.libraries.db.webmodel import WebModel
from paramecio2.libraries.lists import AjaxList
from paramecio2.libraries.db.extraforms.fileform import FileForm
from paramecio2.libraries.formsutils import show_form, check_form
from modules.pastafari2.libraries.task import Task as SSHTask
from modules.pastafari2.models.tasks import Task, LogTask
from modules.pastafari2.libraries.configtask import config_task
from modules.pastafari2.libraries.check_task import check_task_status
from modules.pastafari2.models.pastafari2 import ServerGroup, ServerDbTask, UpdateServerScripts, SystemUser
from paramecio2.libraries.config_admin import config_admin
#from modules.pastafari2.settings.config_admin import pastafari_admin_i18n, pastafari_admin_i18n, pastafari_settings_i18n, pastafari_servers_i18n, pastafari_groups_i18n, pastafari_tasks_log_i18n, num_element_admin

from pathlib import Path
import paramiko
import socket
import os
import configparser
from collections import OrderedDict
from importlib import import_module, reload
from modules.pastafari2.libraries.progress import load_progress
from modules.pastafari2.libraries.load_task import load_db_in_task
from subprocess import call
from settings import config

try:
    import ujson as json
except:
    import json

pgettext=PGetText(__file__+'/../')

_=pgettext.gettext

env=env_theme(__file__)

t=PTemplate(env)

t.env.directories=admin_t.env.directories

t.env.directories.insert(1, os.path.dirname(__file__).replace('/admin', '')+'/templates/admin')

#system_path=config_task.ssh_directory+'/'

#if hasattr(config, 'pastafari_system_path'):
#    system_path=config.pastafari_system_path

base_path='modules/pastafari2/tasks'

if hasattr(config, 'pastafari_base_path'):
    base_path=config.pastafari_base_path

pastafari_paths=[]

#if hasattr(config, 'pastafari_paths'):
#    pastafari_paths=config.pastafari_paths

pastafari_paths=config_task.pastafari_paths

@admin_app.route('/pastafari2/dashboard/')
def pastafari2_dashboard():
    
    db=g.connection
    
    config_parser=configparser.ConfigParser()
                
    (select_task, select_hash)=scandir(base_path, config_parser, OrderedDict(), {},  'tasks')
    
    for module in pastafari_paths:

        (select_task, select_hash)=scandir(module, config_parser, select_task, select_hash,  'tasks')
    
    title_task=''
    
    description_task=''
    
    links=''
    
    path_module='admin_app.pastafari2_dashboard'
    
    task_path=request.args.get('task_path', '')
    
    module=os.getcwd()+'/'+task_path
    
    details_task=[]
    
    #import the module for load links in general dashboard
    
    if os.path.isfile(module) and task_path in select_hash:
        final_path=task_path.replace('.py', '').replace('/','.')
        #print(final_path)
        ptask=import_module(final_path)
        
        if config.reloader:
            reload(ptask)
    
        task_first=ptask.ServerTask('', db, remote_user='root', remote_password='', private_key=config_task.ssh_private_key, password_key='', remote_path='pastafari2', task_id=0, data=dict(request.args))
        
        links=task_first.links
        
        path_module=task_first.path_module
        
        title_task=' - '+task_first.name_task
        
        description_task=task_first.description_task
        
        details_task=select_hash[task_path]
        
    else:
        task_path=''
        #print(task_first.links)
        
    #print(module)
    
    return t.load_template('dash_pastafari.phtml', title=_('Servers Dashboard')+title_task, path_module=path_module, select_task=select_task, task_path=task_path, links=links, description_task=description_task, details_task=details_task)

@admin_app.route('/pastafari2/settings/')
def pastafari2_settings():
    
    txt_error=''
    txt_generate_key='<p>You have created your ssh keys</p>'
    txt_generate_key_button='Regenerate SSH keys'
    regenerate=True
    
    if not os.path.isdir(config_task.ssh_directory):
            
        try:
            Path(config_task.ssh_directory).mkdir(mode=511)
            
        except:
            
            txt_error='<p><strong>You need create ssh directory for save ssh keys</strong></p>'
    
    #Get ssh key
        
    if not os.path.isfile(config_task.ssh_private_key):
        
        txt_generate_key='<p>You need generate a global private ssh key, because doesn\'t exists</p>'
        txt_generate_key_button='Generate SSH keys'
        regenerate=False
        pass
    
    return t.load_template('settings.phtml', title=_('Settings'), path_module='admin_app.pastafari2_settings', txt_error=txt_error, txt_generate_key=txt_generate_key, txt_generate_key_button=txt_generate_key_button, regenerate=regenerate)

@admin_app.route('/pastafari2/edit_global_ssh_keys/', methods=['POST'])
def pastafari2_edit_global_ssh_keys():
    
    form={}
    
    error=1
    
    if not os.path.isfile(config_task.ssh_private_key):
    
        # -C "your_email@example.com" -f $HOME/.ssh/id_rsa
        
        arr_type={'rsa': 'ssh-keygen -t rsa -b 4096', 'dsa': 'ssh-keygen -t dsa', 'ecdsa': 'ssh-keygen -t ecdsa -b 521', 'ed25519': 'ssh-keygen -t ed25519'}
        
        ssh_key_type=request.args.get('ssh_key_type')
        
        if ssh_key_type in arr_type:
            
            file_ssh_path='-f {}id_rsa -q -N ""'.format(config_task.ssh_directory)
        
            if not os.path.isfile(config_task.ssh_private_key):
                
                if call(arr_type[ssh_key_type]+' '+file_ssh_path, shell=True) > 0:
                    
                    error=1
                else:
                    """
                    config_admin.insert(num_element_admin-1, [pastafari_servers_i18n(), 'modules.pastafari2.admin.dashboard', 'admin_app.pastafari2_dashboard', 'fa-linux'])
                    config_admin.insert(num_element_admin, [pastafari_groups_i18n(), 'modules.pastafari2.admin.groups', 'admin_app.pastafari2_groups', 'fa-object-group'])
                    config_admin.insert(num_element_admin+1, [pastafari_tasks_log_i18n(), 'modules.pastafari2.admin.tasks', 'admin_app.pastafari2_tasks', 'fa-file-text-o'])
                    
                    import_module('modules.pastafari2.admin.dashboard')
                    import_module('modules.pastafari2.admin.groups')
                    import_module('modules.pastafari2.admin.tasks')
                    
                    print(config_admin)
                    """
                    
                    error=0
    
    return {'error': error}
    
@admin_app.route('/pastafari2/add_server/')
def pastafari2_add_server():
    
    db=g.connection
    
    group_form=SelectModelForm('group_id', '', ServerGroup(db), 'group', 'id', field_parent=None)
    
    return t.load_template('add_server.phtml', title=_('Add server'), path_module='admin_app.pastafari2_dashboard', group_form=group_form)
    

@admin_app.route('/pastafari2/add_server_task/', methods=['POST'])
def pastafari2_add_server_task():
    
    db=g.connection
    
    error_form={}
    
    server_host=request.form.get('server_host', '')
    server_username=request.form.get('server_username', '')
    server_password=request.form.get('server_password', '')
    repeat_server_password=request.form.get('repeat_server_password', '')
    group_id=request.form.get('group_id', '')
    private_key=config_task.ssh_private_key
    public_key=config_task.ssh_public_key
    remote_path='pastafari2'
    task_id=0
    ip=''
    error=0
    data={}
    ssh_user=config_task.remote_user
    ssh_port=config_task.port
    
    try:
    
        tmp_port=int(request.form.get('ssh_port', '22'))
        
        ssh_port=tmp_port
        
    except:
        pass
        ssh_port='22'
    
    
    #make ping to server
    
    if server_host=='':
        error=1
        error_form['#server_host_error']=_('Error: you need enter a valid hostname')
        
    if server_username=='':
        error=1
        error_form['#server_username_error']=_('Error: you need enter a valid username for the server')
    
    txt_error=''
    
    try:
        
        ip=socket.gethostbyname(server_host)
        pass
    except socket.error as err_msg:
        error=1
        error_form['#server_host_error']=_('Error: ')+err_msg.__str__()
    
    if not error:
        
        group_name=''
        
        if group_id!='':
            server_group=ServerGroup(db)
            arr_group=server_group.set_conditions('WHERE id=%s', [group_id]).select_a_row_where()
            group_name=arr_group['code_group']
        
        
        data={'ssh_user': ssh_user, 'pub_key': public_key, 'hostname': server_host, 'ip': ip, 'group_id': group_id, 'group_name': group_name}
    
        with SSHTask(server_host, db, remote_user=server_username, remote_password=server_password, private_key=private_key, remote_path=remote_path, task_id=task_id, data=data, port=ssh_port) as ssh_task:
            if not ssh_task.prepare_connection():
                error=1
                txt_error=ssh_task.txt_error #_('Error: cannot connect to server')
                error_form['#server_host_error']=txt_error #_('Error: cannot connect to server')
            else:
                # Prepare task for install monit 
        
                task=Task(db)
                
                task_id=0
                
                path_task='modules.pastafari2.tasks.system.task'
                
                if not task.run_task(ip, path_task, 'Add new server', 'add_new_server', 'Task for add a new server', user=server_username, password=server_password, where_sql_server='', url='', data=data, send_task=True, ssh_port=ssh_port):
                        
                    error=1
                    error_form['#server_host_error']=_('Error: cannot execute the task ')+task.txt_error
                    txt_error=_('Error: cannot execute the task ')+task.txt_error
                
                task_id=task.task_id
    
    return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id}

# Maybe translate to api

@admin_app.route('/pastafari2/progress/')
def pastafari2_progress():
    
    db=g.connection

    return load_progress(db, t)
    

@admin_app.route('/pastafari2/getprogress/', methods=['POST'])
def pastafari2_getprogress():
    
    s=session
    
    db=g.connection
    
    if request.args.get('task_id', '0')=='0':
        
        s['get_progress']=s.get('get_progress', 0)
    
    try:
    
        task_id=int(request.args.get('task_id', '0'))
    except:
        task_id=0
        
    try:
        position=int(request.args.get('position', '0'))
    except:
        position=0
    
    task=Task(db)
    logtask=LogTask(db)
    
    arr_task=task.select_a_row(task_id)
    
    arr_rows={'wait': 1}
    
    if arr_task:
        
        c_list=logtask.set_conditions('WHERE task_id=%s', [task_id]).select_count()
        
        final_pos=c_list-position
        
        logtask.set_limit([position, final_pos])
            
        logtask.set_order({'id': 0})
        
        logtask.conditions=['WHERE task_id=%s', [task_id]]
        
        server=request.args.get('server', '')
        
        if server!='':
            logtask.conditions=['WHERE task_id=%s', [task_id]]
        
        logtask.yes_reset_conditions=False
        
        c=0
            
        arr_rows=[]
        
        with logtask.select([], True) as cursor:            
            for arr_row in cursor:
                arr_rows.append(arr_row)
                c+=1
        
        if c==0:
            arr_rows=[]
            
            c_error=logtask.set_conditions('WHERE task_id=%s and logtask.error=%s and logtask.status=%s', [task_id, 1, 1]).select_count()
            
            if c_error==0:
                
                arr_rows={'wait': 1}
            else:
                logtask.limit=''
                
                with logtask.set_conditions('WHERE task_id=%s and logtask.error=%s and logtask.status=%s', [task_id, 1, 1]).select([], True) as cursor:            
                    for arr_row in cursor:
                        arr_rows.append(arr_row)
                
    else:
        
        arr_rows=[{'task_id': task_id, 'progress': 100, 'message': 'Error: no exists task', 'error': 1, 'status': 1}]
        
    db.close()
    
    resp=make_response(json.dumps(arr_rows))
    
    resp.headers['Content-Type']='application/json'
    
    return resp

@admin_app.route('/pastafari2/get_servers/', methods=['POST'])
def get_servers_task():

    db=g.connection
    
    group_sql=''
    
    count_data=[]
    sql_data=[]
    
    group_id=request.form.get('group_id', '')
    
    group_sql_count=''
    group_sql=''
    
    if group_id!='':
        group_sql_count=' WHERE `group_id`=%s'
        count_data=[group_id]
        sql_data=[group_id]
        group_sql=' WHERE `group_id`=%s'
    
    fields=[[_('Hostname'), True], ['IP', True], [_('Selected'), False], [_('Options'), False]]
    arr_order_fields=['hostname', 'ip']    
    
    count_query=['select count(serverdbtask.id) as num_elements from serverdbtask'+group_sql_count, count_data]
    
    str_query=['select serverdbtask.hostname, serverdbtask.ip, serverdbtask.id as select_id, serverdbtask.id from serverdbtask'+group_sql, sql_data]
    
    ajax=AjaxList(db, fields, arr_order_fields, count_query, str_query)
    
    ajax.func_fields['select_id']=options_selected
    ajax.func_fields['id']=options_options
    ajax.limit=0
    
    return ajax.show()

def options_selected(row_id, row):
    
    return '<input type="checkbox" name="server_id_{}" class="server_id" value="{}"/>'.format(row_id, row_id)

def options_options(row_id, row):
    
    arr_options=['<a href="{}">{}</a>'.format(url_for('admin_app.pastafari2_edit_server', id=row_id, op_admin=1), _('Edit'))]
    
    arr_options.append('<a href="{}">{}</a>'.format(url_for('admin_app.pastafari2_edit_users', server_id=row_id), _('Users')))
    
    arr_options.append('<a href="{}">{}</a>'.format(url_for('admin_app.pastafari2_delete_server', server_id=row_id), _('Delete')))
    
    arr_options.append('<a href="{}">{}</a>'.format(url_for('admin_app.pastafari2_edit_update', server_id=row_id), _('Edit update task')))
    
    return '<br />'.join(arr_options)


@admin_app.route('/pastafari2/get_groups/', methods=['GET'])
def get_groups_task():
    
    db=g.connection
    
    arr_groups=[]
    
    with db.query('select * from servergroup', []) as cursor:
        for data in cursor:
            arr_groups.append(data)
    
    return json.dumps(arr_groups)
    

@admin_app.route('/pastafari2/update_task/', methods=['POST'])
def pastafari2_update_task():

    db=g.connection

    ids=json.loads(request.form.get('ids', '[]'))
    arr_ids=[]
    
    error=0
    txt_error=''
    error_form={}

    #print(ids)
    for v in ids:
        arr_ids.append(str(int(v)))
    
    where_sql='WHERE id IN ('+",".join(arr_ids)+') order by hostname ASC'
    
    task=Task(db)
    
    task_id=0
    
    path_task='modules.pastafari2.tasks.system.updates'
    
    data={}
    
    server_host=''
    
    user=config_task.remote_user
    
    ssh_key_priv=config_task.ssh_private_key
    
    if not task.run_task(server_host, path_task, 'Update server', 'update_server', 'Task for update servers', user=user, password='', where_sql_server=where_sql, ssh_key_priv=ssh_key_priv, url='', data=data, send_task=True):
            
        error=1
        error_form['#server_host_error']=_('Error: cannot execute the task')
    
    task_id=task.task_id
    
    return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id}

@admin_app.route('/pastafari2/make_task/', methods=['POST'])
def pastafari2_make_task():

    db=g.connection

    ids=json.loads(request.form.get('ids', '[]'))
    
    json_ids=json.dumps(ids)
    
    arr_ids=[]

    task_path=request.form.get('task', '')
    
    task_file=task_path.replace('/', '.')
            
    task_file=task_file.replace('.py', '')
        
    task_execute=import_module(task_file)   
    
    if config.reloader:
        reload(task_execute)
    
    task_first=task_execute.ServerTask('', db, remote_user='root', remote_password='', private_key=config_task.ssh_private_key, password_key='', remote_path='pastafari2', task_id=0, data=dict(request.args))
    
    send_task=request.args.get('send_task', '')
    
    error=0
    txt_error=''
    error_form={}
    
    task=Task(db)
    
    task_id=0
    
    data={}
    
    #if not os.path.isfile(task) 
    
    if send_task=='':
        
        #Check if form
        
        if hasattr(task_first, 'form'):
            
            url_exec=url_for('.pastafari2_make_task', send_task=1, **request.args)
            
            links='<a href="'+url_for('admin_app.pastafari2_dashboard')+'">'+_('Servers')+'</a>'
            
            path_module='admin_app.pastafari2_dashboard'
            
            if hasattr(task_first, 'links'):
                links=task_first.links
                
            if hasattr(task_first, 'path_module'):
                path_module=task_first.path_module
            
            return t.load_template('maketask.phtml', title=_('Make task'), form=task_first.form(t, yes_error=False, pass_values=False), url_exec=url_exec, ids=json_ids, task_file=task_path, links=links, path_module=path_module)
    
    elif send_task!='':
        
        if hasattr(task_first, 'form'):
            
            #Check form
            
            if not task_first.check_form(request.form):
                
                error=1
                txt_error=_('Errors: fields required')
                
                for k,v in task_first.arr_form.items():
                    if task_first.arr_form[k].error:
                        error_form['#'+k+'_error']=task_first.arr_form[k].txt_error
                
                return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id}
            
            for k, v in  task_first.data.items():
                data[k]=v
            
            pass

    for v in ids:
        arr_ids.append(str(int(v)))
    
    where_sql='WHERE id IN ('+",".join(arr_ids)+') order by hostname ASC'

    path_task=task_file
    
    #Load task, check if have question
    
    server_host=''
    
    user=config_task.remote_user
    
    ssh_key_priv=config_task.ssh_private_key
    
    if not task.run_task(server_host, path_task, task_first.name_task, task_first.codename_task, task_first.description_task, user=user, password='', where_sql_server=where_sql, ssh_key_priv=ssh_key_priv, url=task_first.url_return, data=data, send_task=True):
            
        error=1
        error_form['#server_host_error']=_('Error: cannot execute the task')
        txt_error=task.txt_error
    
    task_id=task.task_id
    
    return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id}

@admin_app.route('/pastafari2/multiprogress/')
def pastafari2_multiprogress():

    db=g.connection
    
    task_id=request.args.get('task_id', '')

    task=Task(db)

    arr_task=task.select_a_row(task_id)
    
    num_servers=task.set_conditions('WHERE parent_id=%s', [task_id]).select_count()
    
    links=''
    path_module='admin_app.pastafari2_dashboard'
    
    
    task_process=load_db_in_task(task_id, db)
    
    if task_process:
        links=task_process.links
        path_module=task_process.path_module
    
    if arr_task:

        return t.load_template('multiprogress.phtml', title=_('Task progress'), path_module=path_module, name_task=arr_task['name_task'], description_task=arr_task['description_task'], task_id=task_id, server=arr_task['server'], num_servers=num_servers, links=links)
        
    else:
        
        return ""
        
@admin_app.route('/pastafari2/get_servers_task/')
def pastafari2_get_servers_task():

    db=g.connection
    
    task_id=request.args.get('task_id', '')

    task=Task(db)

    arr_ids=task.set_conditions('WHERE parent_id=%s', [task_id]).select_to_array(['id', 'hostname', 'server'])

    resp=make_response(json.dumps(arr_ids))
    
    resp.headers['Content-Type']='application/json'
    
    return resp

@admin_app.route('/pastafari2/get_multiprogress/')
def pastafari2_get_multiprogress():
    
    s=session
    
    db=g.connection

    ids=request.args.get('ids', '[]')
    
    try:
        position=int(request.args.get('position', '0'))
    except:
        position=0
    
    final_ids=[str(i) for i in json.loads(ids)]
    
    final_str=",".join(['%s']*len(final_ids))

    task=Task(db)
    
    logtask=LogTask(db)
    
    arr_log=logtask.set_limit([position, 20]).set_conditions('WHERE task_id IN ({})'.format(final_str), final_ids).select_to_array([], True)
    
    resp=make_response(json.dumps(arr_log))
    
    resp.headers['Content-Type']='application/json'
    
    return resp
    
@admin_app.route('/pastafari2/delete_server/')
def pastafari2_delete_server():
    
    db=g.connection
    
    server=ServerDbTask(db)
    
    server_id=request.args.get('server_id', '0')
    
    arr_server=server.select_a_row(server_id)
    
    if arr_server:
    
        return t.load_template('delete_server.phtml', title=_('Delete server'), path_module='admin_app.pastafari2_dashboard', server_id=server_id, server=arr_server)
        
    else:
        
        return ""

@admin_app.route('/pastafari2/delete_server_db/', methods=['POST'])
def pastafari2_delete_server_db():

    db=g.connection

    error=0
    
    server=ServerDbTask(db)
    
    server_id=request.form.get('server_id', '0')
    
    server.set_conditions('WHERE id=%s', [server_id]).delete()
    
    return {'error': error}
    

@admin_app.route('/pastafari2/edit_server/', methods=['POST', 'GET'])
def pastafari2_edit_server():

    db=g.connection

    error=0
    
    server=ServerDbTask(db)
    
    url=url_for('.pastafari2_edit_server')
    
    admin=GenerateAdminClass(server, url, t)
    
    admin.arr_fields_edit=['hostname', 'ip', 'ssh_port']
    
    admin.url_redirect=url_for('.pastafari2_dashboard')
    
    admin.pre_update=pre_update_server
    
    form_admin=admin.show()
    
    if type(form_admin).__name__=='str':
    
        return t.load_template('edit_server.phtml', title=_('Edit server'), path_module='admin_app.pastafari2_dashboard', edit_server=form_admin)
        
    else:
        return form_admin

def pre_update_server(admin):
    
    db=g.connection
    
    ssh_user=config_task.remote_user
    ssh_port=request.form.get('ssh_port', 22)
    server_host=request.form.get('ip', '')
    private_key=config_task.ssh_private_key
    public_key=config_task.ssh_public_key
    remote_path='pastafari2'
    data={}
    task_id=0
    
    with SSHTask(server_host, db, remote_user=ssh_user, remote_password='', private_key=private_key, remote_path=remote_path, task_id=task_id, data=data, port=ssh_port) as ssh_task:
        if not ssh_task.prepare_connection():
            
            admin.model.fields['ssh_port'].txt_error=ssh_task.txt_error
            admin.model.fields['ssh_port'].error=True
            
            return False
            
    
    return True

@admin_app.route('/pastafari2/edit_update/', methods=['POST', 'GET'])
def pastafari2_edit_update():
    """Simple function for edit and add extra scripts for update function"""

    db=g.connection
    
    server_id=request.args.get('server_id', '0')
    
    update_server=UpdateServerScripts(db)
    
    update_server.fields['server_id'].name_form=HiddenForm

    update_server.fields['server_id'].extra_parameters=[]
    
    update_server.fields['server_id'].default_value=server_id
    
    update_server.enctype=True
    
    update_server.fields['file'].yes_prefix=False
    
    server=ServerDbTask(db)
    
    url=url_for('.pastafari2_edit_update', server_id=server_id)
    
    arr_server=server.select_a_row(server_id)
    
    update_server.set_conditions('WHERE server_id=%s', [server_id])
    
    admin=GenerateAdminClass(update_server, url, t)
    
    admin.list.fields_showed=['name', 'file', 'position']
    
    admin.list.yes_search=False
    
    #admin.list.table_div=True
    
    admin.list.order_field='position'
    
    form_admin=admin.show()
    
    if type(form_admin).__name__=='str':
    
        return t.load_template('edit_update.phtml', title=_('Edit update'), path_module='admin_app.pastafari2_edit_update', server_data=arr_server, edit_update=form_admin)
        
    else:
        return form_admin

@admin_app.route('/pastafari2/change_order_scripts/', methods=['POST', 'GET'])
def pastafari2_change_order_scripts():
    
    db=g.connection
    
    server_id=request.args.get('server_id', '0')
    
    update_server=UpdateServerScripts(db)
    
    server=ServerDbTask(db)
    
    arr_server=server.select_a_row(server_id)
    
    update_server.set_conditions('WHERE server_id=%s', [server_id]).set_order({'position': 0})
    
    arr_update_server=update_server.select_to_array()
    
    return t.load_template('change_order_scripts.phtml', title=_('Edit update'), path_module='admin_app.pastafari2_change_order_scripts', server_data=arr_server, scripts=arr_update_server)

@admin_app.route('/pastafari2/save_positions' , methods=['POST'])
def pastafari2_save_positions():
    
    db=g.connection
    
    error=0
    
    error_form={}
    
    txt_error=''
    
    text=''
    
    server_id=request.args.get('server_id', '0').strip()
    
    server=ServerDbTask(db)
    
    update_server=UpdateServerScripts(db)
    
    update_server.create_forms()
    
    update_server.safe_query()
    
    arr_server=server.set_conditions('WHERE id=%s', [server_id]).select_a_row_where([], True)
    
    if arr_server:
        
        order_id=json.loads(request.form.get('order_id', '{}'))
        
        #print(order_id)
        position=0
        
        for item_id in order_id:
            
            update_server.set_conditions('WHERE server_id=%s AND id=%s', [server_id, item_id]).update({'position': position})
            position+=1
        
        pass
    
    return {'error': error, 'form': error_form, 'txt_error': txt_error}

@admin_app.route('/pastafari2/edit_users/<int:server_id>')
def pastafari2_edit_users(server_id):
    
    db=g.connection
    
    server=ServerDbTask(db)
    
    arr_server=server.select_a_row(server_id)
    
    return t.load_template('edit_users.phtml', title=_('Edit server users'), path_module='admin_app.pastafari2_dashboard', server_id=server_id, server_data=arr_server)

@admin_app.route('/pastafari2/get_server_users/<int:server_id>', methods=['POST'])
def pastafari2_get_server_users(server_id):

    db=g.connection

    fields=[['Username', True], ['Options', False]]
    
    #rows=[{'username': 'developer', 'options': ''}]
    rows=[]
    
    with db.query('select * from systemuser WHERE server_id=%s', [server_id]) as cursor:
        for user in cursor:
            rows.append({'username': '<a href="#" class="change_password">'+user['username']+'</a>', 'options': '<a href="'+url_for('admin_app.pastafari2_delete_user', server_id=server_id, username=user['username'])+'">'+_('Delete')+'</a>'})
            
    
    arr_return={'fields': fields, 'rows': rows, 'html_pages': ''}
    
    #print(json.dumps(arr_return))
    
    return json.dumps(arr_return)
    

@admin_app.route('/pastafari2/add_user/<int:server_id>')
def pastafari2_add_user(server_id):

    db=g.connection

    server=ServerDbTask(db)
    
    system_user=SystemUser(db)
    
    system_user.fields['server_id'].name_form=HiddenForm
    system_user.fields['server_id'].extra_parameters=[]
    
    system_user.create_forms()
    
    arr_server=server.select_a_row(server_id)
    
    if arr_server:
        
        #system_user.forms['server_id'].default_value=arr_server['id']
        #print(system_user.forms['server_id'].default_value)
    
        form=show_form({'server_id': arr_server['id']}, system_user.forms, t, yes_error=False, pass_values=True, modelform_tpl='forms/modelform.phtml') 
        
        #system_user.forms['server_id'].parameters=[]
        
        return t.load_template('add_user.phtml', title=_('Add server user'), path_module='admin_app.pastafari2_dashboard', server_id=server_id, hostname=arr_server['hostname'], form=form)

    return ""

@admin_app.route('/pastafari2/add_user_task/', methods=['POST'])
def pastafari2_add_user_task():
    
    db=g.connection
    
    error_form={}
    
    arr_log={}
    
    error=True
    
    txt_error=''
    
    task_id=0
    
    server_id=request.form.get('server_id', '0')
    
    system_user=SystemUser(db)
    
    system_user.create_forms()
    
    #(error, fields, values, post)=system_user.check_all_fields(dict(request.form), external_agent=True)
    
    (error, error_form, post, arr_form)=check_form(dict(request.form), system_user.forms)
    
    if not error:
        
        with db.query('select count(*) as num_user from systemuser WHERE username=%s AND server_id=%s', [post['username'], server_id]) as cursor:
            num_user=cursor.fetchone()['num_user']
        
        if num_user==0:
    
            with db.query('select * from serverdbtask WHERE id=%s', [server_id]) as cursor:
                arr_server=cursor.fetchone()
            
            if arr_server:
                
                sshtask=Task(db)
                
                if not sshtask.run_task(arr_server['ip'], 'modules.pastafari2.tasks.system.add_user', 'Create user in server', 'Create_user', 'Task for create and user in the server', {'username': post['username'], 'home': '/home/{}'.format(post['username'])}, config_task.remote_user, '', '', url_for('admin_app.pastafari2_dashboard'), ssh_key_priv=config_task.ssh_private_key, ssh_key_password=config_task.ssh_private_key_password, send_task=True, ssh_port=arr_server['ssh_port']):
                    
                    error=1
                
                else:
                    error=0
                
                task_id=sshtask.task_id
                
                if task_id:
    
                    check_task=True
                    
                    while check_task:
                            
                        with db.query('select * from logtask where task_id=%s order by id DESC limit 1', [task_id]) as cursor:
                            
                            arr_log=cursor.fetchone()
                            
                            if arr_log:
                                
                                if arr_log['status']==1:

                                    error=arr_log['error']
                                    
                                    error_form['#username_error']=arr_log['message']
                                    check_task=False
                                    
                                    if not error:
                                        flash(_('The user was added successfully'))
            
        else:
            
            error=1
            error_form['#username_error']=_('User exists')
            
    else:
        error=1
        error_form['#username_error']='Username invalid'
    
    
    return {'error': error, 'txt_error': txt_error, 'error_form': error_form, 'task_id': task_id, 'log': arr_log}


@admin_app.route('/pastafari2/change_user_password/<int:server_id>', methods=['POST'])
def pastafari2_change_user_password(server_id):
    
    #server_id=request.args.get('webserver_id', '0')
    
    error=0
    
    error_form={}
    
    task_id=0
    
    db=g.connection
    
    serverdb=ServerDbTask(db)

    arr_server=serverdb.select_a_row(server_id, [], True)
    
    if arr_server:

        ssh_pub_key=request.form.get('ssh_pub_key', '')
        
        user=request.form.get('user', '')
        
        if user=='':
            error_form['#user_error']=_('Error: you need an user')
            error=1
        
        if ssh_pub_key=='':
            error_form['#ssh_pub_key_error']=_('Error: you need a ssh public key')
            error=1
                    
        sshtask=Task(db)
    
        ssh_key_priv=config_task.ssh_private_key
        
        if not sshtask.run_task(arr_server['ip'], 'modules.pastafari2.tasks.system.change_password_user', 'Change user password', 'Change user password', 'Task for change unix user password', {'user': user, 'ssh_pub_key': ssh_pub_key}, config_task.remote_user, '', '', url_for('admin_app.pastafari2_dashboard', server_id=server_id), ssh_key_priv=ssh_key_priv, ssh_key_password='', send_task=True, ssh_port=arr_server['ssh_port']):
            
            error=1
        
        task_id=sshtask.task_id
        
        if task_id:
        
            log=check_task_status(_('SSH key changed'), db, task_id)
            
            error=log['error']
            
            error_form['#ssh_pub_key_error']=log['message']

    else:
        error=1
    
    return {'error': error, 'error_form': error_form, 'task_id': task_id}


@admin_app.route('/pastafari2/delete_user/')
def pastafari2_delete_user():
    
    db=g.connection
    
    server=ServerDbTask(db)
    
    server_id=request.args.get('server_id', '0')
    
    user=SystemUser(db)
    
    arr_server=server.select_a_row(server_id)
    
    username=request.args.get('username')
    
    arr_user=user.set_conditions('WHERE username=%s AND server_id=%s', [username, server_id]).select_a_row_where()
    
    if arr_server and arr_user:
    
        return t.load_template('delete_user.phtml', title=_('Delete user'), path_module='admin_app.pastafari2_dashboard', server_id=server_id, server=arr_server, username=username, user_id=arr_user['id'])
        
    else:
        
        return ""

@admin_app.route('/pastafari2/delete_user_db/<int:server_id>', methods=['POST'])
def pastafari2_delete_user_db(server_id):

    db=g.connection

    error=0
    
    server=ServerDbTask(db)
    
    user=SystemUser(db)
    
    arr_server=server.set_conditions('WHERE id=%s', [server_id]).select_a_row_where([], True)
    
    user_id=request.form.get('user_id', '0')
    
    arr_user=user.set_conditions('WHERE id=%s AND server_id=%s', [user_id, server_id]).select_a_row_where([], True)
    
    error_form={}
    
    #server.set_conditions('WHERE id=%s', [server_id]).delete()
    
    if arr_server and arr_user:
        #user.set_conditions('WHERE id=%s',[arr_user['id']]).delete()
        sshtask=Task(db)
    
        ssh_key_priv=config_task.ssh_private_key
        
        if not sshtask.run_task(arr_server['ip'], 'modules.pastafari2.tasks.system.delete_user', 'Delete user', 'Delete', 'Task for delete a unix user', {'user_id': user_id, 'username': arr_user['username']}, config_task.remote_user, '', '', url_for('admin_app.pastafari2_dashboard', server_id=server_id), ssh_key_priv=ssh_key_priv, ssh_key_password='', send_task=True, ssh_port=arr_server['ssh_port']):
            
            error=1
        
        task_id=sshtask.task_id
        
        if task_id:
        
            log=check_task_status(_('User deleted'), db, task_id)
            
            error=log['error']
            
            error_form['#user_delete_error']=log['message']
    
    return {'error': error, 'error_form': error_form, 'task_id': task_id}