whmcsDNSManager/modules/addons/DNSManager2/controllers/addon/admin/tools.php

<?php

namespace MGModule\DNSManager2\controllers\addon\admin;

use MGModule\DNSManager2 as main;
use MGModule\DNSManager2\helpers\WHMCS\Domain;
use MGModule\DNSManager2\helpers\WHMCS\Service;
use MGModule\DNSManager2\mgLibs\custom;
use MGModule\DNSManager2\mgLibs\custom\AjaxResponse;
use MGModule\DNSManager2\mgLibs\custom\dns;
use MGModule\DNSManager2\mgLibs\custom\helpers;
use MGModule\DNSManager2\mgLibs\MySQL as mysql;
use MGModule\DNSManager2\models\custom\clientfiles;
use MGModule\DNSManager2\models\custom\globalsetting;
use MGModule\DNSManager2\models\custom\server;
use MGModule\DNSManager2\models\custom\task;

class tools extends main\mgLibs\process\abstractController{

    function indexHTML($input, $vars = array()) {
        $cron_last_run = globalsetting\GlobalSetting::byKey(globalsetting\GlobalSettingEnum::CRON_LAST_RUN)->value;

        $vars['cron_path'] = main\addon::getMainDIR() . DS . 'cron' . DS . 'cron.php';
        $vars['cron_last_run'] = custom\helpers\TimeDiffHelper::diff($cron_last_run)->minutes;
        $vars['cron_run_time_period'] = globalsetting\GlobalSetting::byKey(globalsetting\GlobalSettingEnum::CRON_RUN_TIME_PERIOD)->value;

        $vars['available_record_types'] = dns\Core::getAvailableRecordTypes();
        $vars['available_no_active_domains'] = Domain::getDomainsStatusesAvailableToDelete();
        $vars['available_no_active_service'] = Service::getServicesStatusesAvailableToDelete();
        $vars['minutes'] = array(0,5,10,15,20,40,60,120,180,360,720,1440,2880,4320,10080,43200);

        $vars['settings'] = array();
        foreach(globalsetting\Repository::factory()->get() as $setting) {
            $vars['settings'][$setting->key] = $setting->value;
        }


        $vars['settings']['cron_cleaner_zone_at_least_one'] = unserialize($vars['settings']['cron_cleaner_zone_at_least_one']);
        $vars['settings']['cron_cleaner_no_active_domains'] = unserialize($vars['settings']['cron_cleaner_no_active_domains']);
        $vars['settings']['cron_cleaner_no_active_service'] = unserialize($vars['settings']['cron_cleaner_no_active_service']);

        $vars['cron_last_run'] = intval($vars['cron_last_run']);

	    $then = new \DateTime(date('Y-m-d H:i:s', time() - $vars['cron_last_run'] * 60));
        $now = new \DateTime(date('Y-m-d H:i:s',time()));

        $diff = $then->diff($now);

	    $vars['cron_last_run_years'] = $diff->y;
	    $vars['cron_last_run_months'] = $diff->m;
	    $vars['cron_last_run_days'] = $diff->d;
	    $vars['cron_last_run_hours'] = $diff->h;
		$vars['cron_last_run_minutes'] = $diff->i;

        return array(
            'tpl'   => 'main',
            'vars' => $vars
        );
    }

    public function cronJSON($input, $vars = array()) {
        return AjaxResponse::I()->refreshPage($this->cronHTML($input, $vars))->toArray();
    }

    public function cronHTML($input, $vars = array())
    {
        return $this->indexHTML($input, $vars);
    }

    public function saveCronSettingsJSON($input, $vars = array())
    {
        $input['settings']['cron_cleaner_zone_at_least_one'] = serialize($input['settings']['cron_cleaner_zone_at_least_one']);
        $input['settings']['cron_cleaner_no_active_service'] = serialize($input['settings']['cron_cleaner_no_active_service']);
        $input['settings']['cron_cleaner_no_active_domains'] = serialize($input['settings']['cron_cleaner_no_active_domains']);

        foreach($input['settings'] as $k => $v)
        {
            $v = ($k == 'cron_cleaner_notify_only' && empty($v)) ? 0 : $v;
            globalsetting\GlobalSetting::set($k, $v);
        }

        $response = AjaxResponse::I()->addInfo('changes_saved');

        if((int)$input['settings']['cron_cleaner_run_each'] > 0  &&  $input['settings']['cron_cleaner_notify_only'] != 'on')
        {
            $response->addWarning('cron_cleaner_warning');
        }

        return $response->toArray();
    }
//===========================================================================================================
//===========================================MIGRATION=======================================================
//===========================================================================================================
    public function migrationJSON($input, $vars = array()) {
        return AjaxResponse::I()->refreshPage($this->migrationHTML($input, $vars))->toArray();
    }

    public function migrationHTML($input, $vars = array()) {
        $vars['imports'] = array();

        $new_migrations = custom\TaskManager::getXTasksObjects(0, 'Migration:main', 0, task\TaskStatusEnum::START);
        foreach($new_migrations as $migration) {
            $desc = $migration->description();
            $vars['migrations'][] = array(
                'id' => $migration->obj()->id,
                'desc' => $desc,
                'zones_moved' => '-',
                'zones_total' => '-',
                'progress' => -1,
                'error' => $desc == 'Migration:main'?main\mgLibs\lang::T('one_of_servers_has_been_removed'):false,
            );
        }

        $in_progress_migrations = custom\TaskManager::getXTasksObjects(0, 'Migration:main', 0, task\TaskStatusEnum::IN_PROGRESS);
        $finished_migrations    = custom\TaskManager::getXTasksObjects(0, 'Migration:main', 0, task\TaskStatusEnum::FINISHED);
        $migrations             = array_merge($in_progress_migrations,$finished_migrations);
        foreach($migrations as $migration) {
            $rep = new task\Repository();
            $rep->byParentID($migration->obj()->id)->byName('Migration:migrate');
            $zones_total = $rep->count();

            $rep->byStatus(task\TaskStatusEnum::FINISHED);
            $zones_moved = $rep->count();

            $task = custom\TaskManager::getXTasksObjects(1, 'Migration:fetchZonesList', $migration->obj()->id, false);
            if(end($task))
            {
                $error2 = $this->getTaskError(end($task));
            }
            
            $desc = $migration->description();
            $error = $desc == 'Migration:main'?main\mgLibs\lang::T('one_of_servers_has_been_removed'):false;

            $vars['migrations'][] = array(
                'id' => $migration->obj()->id,
                'desc' => $desc,
                'zones_moved' => $zones_moved,
                'zones_total' => $zones_total,
                'progress' => $zones_total == 0 ? 0 : ceil($zones_moved * 100 / $zones_total),
                'error' => $error?:$error2,
            );
        }

        return array(
            'tpl'   => 'migration',
            'vars' => $vars
        );
    }

    public function addMigrationJSON($input, $vars = array()) {
        $vars['servers'] = server\Repository::factory()->get();
        return AjaxResponse::I()->modal('add-migration', $vars)->toArray();
    }

    public function addMigrationSaveJSON($input, $vars = array()) {
        if( !isset($input['from_server'], $input['to_server']) )
        {
            return AjaxResponse::I()->toArray();
        }

        if($input['from_server'] == $input['to_server']) {
            AjaxResponse::I()->addError('you_have_to_choose_two_diffrent_servers');
            return AjaxResponse::I()->toArray();
        }

        server\Server::factory($input['from_server'])->getModule()->testConnection();
        server\Server::factory($input['to_server'])->getModule()->testConnection();

        $moveZone = $input['cron_migration_move_zone'] === 'on';
        custom\TaskManager::addTask('Migration:main', ['from' => $input['from_server'], 'to' => $input['to_server'], 'move_zone' => $moveZone]);

        AjaxResponse::I()->refreshPage($this->migrationHTML($input, $vars));
        AjaxResponse::I()->addInfo('new_task_added');
        return AjaxResponse::I()->toArray();
    }

    public function removeMigrationJSON($input, $vars = array()) {
        custom\TaskManager::removeTask($input['id']);
        AjaxResponse::I()->refreshPage($this->migrationHTML($input, $vars));
        AjaxResponse::I()->addInfo('migration_removed');
        return AjaxResponse::I()->toArray();
    }

    public function showListMigrationJSON($input, $vars = array()) {
        $vars['migrationid'] = $input['id'];
        $task = custom\TaskManager::getXTasks(1, 'Migration:fetchZonesList', $input['id'], false);
        $task = end($task);
        $vars['list'] = custom\TaskManager::getTaskResults($task->id);

        AjaxResponse::I()->refreshPage(array('tpl' => 'migration-list', 'vars' => $vars));
        return AjaxResponse::I()->toArray();
    }

    function refreshMigrationTableJSON($input, $vars = array()) {
        $task = custom\TaskManager::getXTasks(1, 'Migration:fetchZonesList', $input['id'], false);
        $task = end($task);
        $rep = task\result\Repository::factory()->byTaskID($task->id);

        $helper = new main\mgLibs\custom\RepoTableHelper($rep, $input, array('data'));

        $vars = $helper->getDataTableArray();

        foreach($helper->get() as $task) {
            $vars['data'][] = $this->dataTablesParseRow('migration-row', array('item' => $task, 'migrationid' => $input['id']));
        }

        return $vars;
    }

    public function migrateZonesJSON($input, $vars = array()) {
        foreach($input['zone'] as $result_id => $data) {
            if($data['migrate'] != 'on' && !isset($input['justOne']))
                continue;

            $result = new task\result\TaskResult($result_id);

            $task = custom\TaskManager::getTaskObjectByID($result->taskid);
            $main_task = $task->getParent(); //TODO: można zmniejszyć ilość danych poprzez odwołanie się do resulta
            $child = $main_task->addChild('migrate', array(
                'domain' => $result->data['domain'],
                'ip' => $result->data['ip'],
                'resultid' => $result_id
            ));

            $result->data['status'] = 'migrating';
            $result->data['taskid'] = $child->obj()->id;
            $result->save();

            if(isset($input['runNow'])) {
                $child->run();
                if($child->getStatus() != 'finished') {
                    AjaxResponse::I()->addError('something_went_wrong_during_migration');
                } else {
                    AjaxResponse::I()->addInfo('zone_migrated');
                }
            }
        }

        if(!isset($input['runNow'])) {
            AjaxResponse::I()->addInfo('new_task_added');
        }

        return AjaxResponse::I()->toArray();
        //return $this->showListMigrationJSON($input, $vars);
    }

    public function scheduleMigrationJSON($input, $vars = array()) {
        custom\TaskManager::getTaskObjectByID($input['id'])->run();
        AjaxResponse::I()->addInfo('migration_scheduled');
        AjaxResponse::I()->refreshPage($this->migrationHTML($input, $vars));
        return AjaxResponse::I()->toArray();
    }
//===========================================================================================================
//===========================================IMPORT==========================================================
//===========================================================================================================
    public function importJSON($input, $vars = array()) {
        return AjaxResponse::I()->refreshPage($this->importHTML($input, $vars))->toArray();
    }

    public function getClientsListJSON( $input, $vars = [] )
    {
        $repo   = new main\models\whmcs\clients\repository();
        $search = explode(' ', trim($input['q']));
        if( count($search) >= 2 )
        {
            $repo = new main\models\whmcs\clients\repository();
            $repo->addAndSearch(['firstname', 'lastname', 'companyname'], [$search[0], $search[1]]);
        }
        else
        {
            $repo->search($input['q'], ['id', 'firstname', 'lastname', 'companyname']);
            $total = $repo->count();

            $repo = new main\models\whmcs\clients\repository();
            $repo->search($input['q'], ['id', 'firstname', 'lastname', 'companyname']);
        }
        $repo->limit(30);
        $repo->offset(($input['page'] - 1) * 30);

        $items = [];
        foreach( $repo->get() as $client )
        {
            $name    = $client->firstname . ' ' . $client->lastname;
            $name    .= $client->companyname ? ' ( ' . $client->companyname . ' )' : '';
            $items[] = [
                'id'   => $client->id,
                'name' => $name,
            ];
        }
        AjaxResponse::I()->items = $items;
        AjaxResponse::I()->total = $total;
        echo json_encode(AjaxResponse::I()->toArray(), JSON_HEX_QUOT | JSON_HEX_TAG);
        die();
    }

    public function importHTML($input, $vars = array())
    {
        $vars['imports'] = array();

        $newImports = custom\TaskManager::getXTasksObjects(0, 'Import:main', 0, task\TaskStatusEnum::START);
        $this->parseNewImportTaskList($newImports, $vars['imports']);

        $newImportsToFile = custom\TaskManager::getXTasksObjects(0, 'ImportToFile:main', 0, task\TaskStatusEnum::START);
        $this->parseNewImportTaskList($newImportsToFile, $vars['imports']);


        $imports = custom\TaskManager::getXTasksObjects(0, 'Import:main', 0, task\TaskStatusEnum::IN_PROGRESS);
        $this->parseInProgresImportTaskList($imports, $vars['imports']);

        $toFileImports = custom\TaskManager::getXTasksObjects(0, 'ImportToFile:main', 0, task\TaskStatusEnum::IN_PROGRESS);
        $this->parseInProgresImportTaskList($toFileImports, $vars['imports'], 'ImportToFile');


        return array(
            'tpl'   => 'import',
            'vars' => $vars
        );
    }

    private function getTaskError($task) {
        $erorr = false;

        if($task->getStatus() == task\TaskStatusEnum::ERROR) {
            $erorr = 'Error';
            $results = $task->getResults();
            $result = end($results);
            if(isset($result->data['error'])) {
                $erorr .= ' (' . $result->data['error'] . ')';
            }
        }

        return $erorr;
    }

    public function showListImportJSON($input, $vars = array())
    {
        $vars['importid'] = $input['id'];

        $autocheckMatches = globalsetting\Repository::factory()->byKey(
            globalsetting\GlobalSettingEnum::IMPORT_AUTOCHECK_MATCHES)->one();

        $vars['autocheckMatches'] = $autocheckMatches->value == 'on' ? true : false;

        AjaxResponse::I()->refreshPage(array('tpl' => 'import-list', 'vars' => $vars));
        return AjaxResponse::I()->toArray();
    }

    function refreshImportTableJSON($input, $vars = array())
    {
        $pRep = task\Repository::factory()->byParentID($input['id'])->one();
        $pRepName = explode(':', $pRep->name);



        $task = custom\TaskManager::getXTasks(1, $pRepName[0].':fetchZonesList', $input['id'], false);

        $task = end($task);

        $rep = task\result\Repository::factory()->byTaskID($task->id);


        $helper = new main\mgLibs\custom\RepoTableHelper($rep, $input, array('data'));

        $vars = $helper->getDataTableArray();

        foreach($helper->get() as $task)
        {
            $hostingDomainUserId = $this->getUserIdByHostingDomain($task->data['domain']);
            $domainUserId        = $this->getUserIdByDomain($task->data['domain']);

            if( $hostingDomainUserId && $domainUserId )
            {
                $itemPriority = custom\manager\GlobalSettingHelper::getSetting(globalsetting\GlobalSettingEnum::IMPORT_PRIORITY);
                $userid       = (int)$itemPriority === 1 ? $hostingDomainUserId : $domainUserId;
            }
            else
            {
                $userid = $hostingDomainUserId ?? $domainUserId;
            }

            $user = false;
            if(!empty($userid))
            {
                $user = new main\models\whmcs\clients\client($userid);
            }

            $vars['data'][] = $this->dataTablesParseRow('import-row',
                array(
                    'item' => $task,
                    'importid' => $input['id'],
                    'user' => $user
                )
            );
        }

        return $vars;
    }

    public function importZonesJSON($input, $vars = array()) {
        $add = false;

        foreach($input['zone'] as $result_id => $data) {
            if($data['import'] != 'on' && !isset($input['justOne']) || empty($data['client']))
                continue;

            $result = new task\result\TaskResult($result_id);

            $task = custom\TaskManager::getTaskObjectByID($result->taskid);
            $main_task = $task->getParent(); //TODO: można zmniejszyć ilość danych poprzez odwołanie się do resulta
            $ex = explode('::', $data['service']);
            $child = $main_task->addChild('import', array(
                'clientid' => $data['client'],
                'domain' =>helpers\IdnaHelper::idnaDecode( $result->data['domain'] ),
                'ip' => $result->data['ip'],
                'resultid' => $result_id,
                'type' => $ex[0],
                'relid' => $ex[1],
            ));

            $result->data['status'] = 'importing';
            $result->data['taskid'] = $child->obj()->id;
            $result->save();

            if(isset($input['runNow'])) {
                $child->run();
                if($child->getStatus() != 'finished') {
                    AjaxResponse::I()->addError('something_went_wrong_during_import');
                } else {
                    AjaxResponse::I()->addInfo('zone_imported');
                }
            } else {
                if($add === false) {
                    AjaxResponse::I()->addInfo('new_task_added');
                    $add = true;
                }
            }

        }
        return AjaxResponse::I()->toArray();
        //return $this->showListImportJSON($input, $vars);
    }

    public function addImportJSON($input, $vars = array())
    {
        $fileManager = new main\mgLibs\custom\FileManager('zonesFilesStorage'.DIRECTORY_SEPARATOR.'bulkZones');
        $vars['isWritable'] = $fileManager->isStorageWritable();
        $vars['storagePath'] = $fileManager->getStoragePath();

        $rep = new server\Repository();
        $vars['servers'] = $rep->get();

        AjaxResponse::I()->modal('add-import', $vars);
        return AjaxResponse::I()->toArray();
    }

    public function addImportSaveJSON($input, $vars = array())
    {
        if(!isset($input['from_server']))
        {
            return ;
        }

        $server = server\Server::factory($input['from_server']);
        $server->getModule()->testConnection();

        if($input['toFile'] == 'on')
        {
            $fileName = helpers\ImportExportFileHelper::generateNewExportFileName($server->name);
            custom\TaskManager::addTask('ImportToFile:main', array('from' => $input['from_server'], 'toFile' => $fileName));
        }
        else
        {
            custom\TaskManager::addTask('Import:main', array('from' => $input['from_server']));
        }

        AjaxResponse::I()->refreshPage($this->importHTML($input, $vars));
        AjaxResponse::I()->addInfo('new_task_added');

        return AjaxResponse::I()->toArray();
    }

    public function removeImportJSON($input, $vars = array()) {
        custom\TaskManager::removeTask($input['id']);
        AjaxResponse::I()->refreshPage($this->importHTML($input, $vars));
        AjaxResponse::I()->addInfo('import_removed');
        return AjaxResponse::I()->toArray();
    }

    public function scheduleImportJSON($input, $vars = array()) {

        custom\TaskManager::getTaskObjectByID($input['id'])->run(true);
        AjaxResponse::I()->addInfo('import_scheduled');
        AjaxResponse::I()->refreshPage($this->importHTML($input, $vars));
        return AjaxResponse::I()->toArray();
    }

    public function getUserServicesJSON($input, $vars = array()) {
        $services = custom\manager\Par::getSortedArray($input['clientid']);
        $services[] = array(
            'group_name' => main\mgLibs\lang::T('none'),
            'package_name' => '',
            'type' => 0,
            'relid' => 0,
        );
        $vars['domain'] = strtolower($input['domain']);
        $vars['services'] = $services;
        $vars['id'] = $input['itemid'];
        AjaxResponse::I()->html = main\mgLibs\smarty::I()->view('user-services', $vars, main\addon::getModuleTemplatesDir().DS.'pages' . DS . 'tools');

        session_write_close();

        return AjaxResponse::I()->toArray();
    }

//===========================================================================================================
//===========================================TASKS===========================================================
//===========================================================================================================
    public function tasksHTML($input, $vars = array()) {
        return array(
            'tpl'   => 'tasks',
            'vars' => $vars
        );
    }

    public function tasksJSON($input, $vars = array()) {
        return AjaxResponse::I()->refreshPage($this->tasksHTML($input, $vars))->toArray();
    }

    public function refreshTasksTableJSON($input, $vars = array()) {
        $query = "SELECT dns_manager2_task.id AS id, dns_manager2_task.name AS name, dns_manager2_task.status AS status, dns_manager2_task.lastrun AS lastrun,
                            dns_manager2_task.nextrun AS nextrun, dns_manager2_task.date AS date
                            FROM dns_manager2_task
                        WHERE parentid = 0";
        $columns = array('id', 'name', 'status', 'lastrun', 'nextrun', 'date');

        $helper = new main\mgLibs\custom\RawQueryTableHelper($query, $input, $columns);

        $vars = $helper->getDataTableArray();
        $vars['setRecord'] = array();

        foreach($helper->get() as $task) {
            $obj = custom\TaskManager::getTaskObject(new task\Task($task['id']));
            $setRecords = $this->parseInProgresSetRecordList($obj, $vars['setRecord']);

            if($task['name'] != 'DnsRecord:main')
            {
                $setRecords[0] = null;
            }

            $vars['data'][] = $this->dataTablesParseRow('task-row', array('task' => $task,'setRecord' => $setRecords[0], 'name' => $obj->description()));
        }

        return $vars;
    }

    public function taskRunNowJSON($input, $vars = array()) {
        custom\TaskManager::getTaskObjectByID($input['id'])->run(true);
        return AjaxResponse::I()->addInfo('task_finished')->toArray();
    }

    public function removeTaskJSON($input, $vars = array()) {
        custom\TaskManager::getTaskObjectByID($input['id'])->remove();
        return AjaxResponse::I()->addInfo('task_removed')->toArray();
    }

    public function removeTasksWithErrorsJSON() {
        $rep = main\models\custom\task\Repository::factory()->byStatus(main\models\custom\task\TaskStatusEnum::ERROR);
        foreach($rep->get() as $task) {
            $obj = custom\TaskManager::getTaskObject($task);
            $obj->remove();
        }
        return AjaxResponse::I()->addInfo('success')->toArray();
    }

    public function getUserIdByHostingDomain($domainName)
    {
        if(helpers\IdnaHelper::isDomainIdn($domainName))
        {
            $userid = mysql\query::query("SELECT userid FROM tblhosting WHERE BINARY domain = BINARY :domain OR BINARY domain = BINARY :idnDomain",
                array('domain' => $domainName, 'idnDomain' => helpers\IdnaHelper::idnaDecode($domainName))
                )->fetchColumn("userid");
        }
        else
        {
            $userid = mysql\query::query("SELECT userid FROM tblhosting WHERE BINARY domain = BINARY :domain",
                    array('domain' => $domainName))->fetchColumn("userid");
        }

        return $userid;
    }

    public function getUserIdByDomain($domainName)
    {
        if(helpers\IdnaHelper::isDomainIdn($domainName))
        {
            $userid = mysql\query::query("SELECT userid FROM tbldomains WHERE BINARY domain = BINARY :domain OR BINARY domain = BINARY :idnDomain",
                array('domain' => $domainName, 'idnDomain' => helpers\IdnaHelper::idnaDecode($domainName))
                )->fetchColumn("userid");
        }
        else
        {
            $userid = mysql\query::query("SELECT userid FROM tbldomains WHERE BINARY domain = BINARY ?",
                array($domainName))->fetchColumn("userid");

        }
        return $userid;
    }

    public function parseNewImportTaskList($list, &$vars)
    {
        foreach($list as $import)
        {
            $vars[] = array(
                'id' => $import->obj()->id,
                'desc' => $import->description(),
                'parsedDesc' => $this->praseTaskDescription($import->description()),
                'zones_imported' => '-',
                'zones_total' => '-',
                'progress' => -1,
                'type' => $import->getTaskTypeCode()
            );
        }
    }

    private function praseTaskDescription($desc)
    {
        $parts = explode(' from: ', $desc);
        $parts[0] .= ' from: ';
        $tmpParts = explode(' to: ', $parts[1]);
        if(count($tmpParts) > 1)
        {
            $parts[1] = $tmpParts[0];
            $parts[2] = ' to: ';
            $parts[3] = $tmpParts[1];
        }

        return $parts;
    }

    public function parseInProgresImportTaskList($list, &$vars, $type = 'Import')
    {
        foreach($list as $import)
        {
            $rep = new task\Repository();

            $childTaskType = strpos($type, 'Export') === 0 ? 'export' : 'import';
            $rep->byParentID($import->obj()->id)->byName($type.':'.$childTaskType);

            $zones_total = $rep->count();

            $rep->byStatus(task\TaskStatusEnum::FINISHED);
            $zones_imported = $rep->count();

            $task = custom\TaskManager::getXTasksObjects(1, $type.':fetchZonesList', $import->obj()->id, false);

            if(end($task))
            {
                $error = $this->getTaskError(end($task));
            }
            
            $vars[] = array(
                'id' => $import->obj()->id,
                'desc' => $import->description(),
                'zones_imported' => $zones_imported,
                'zones_total' => $zones_total,
                'progress' => $zones_total == 0 ? 0 : ceil($zones_imported * 100 / $zones_total),
                'error' => $error,
                'parsedDesc' => $this->praseTaskDescription($import->description()),
                'type' => $import->getTaskTypeCode()//strpos($import->description(), 'Import') === 0 ? 'Import' : 'Export'
            );
        }
    }

    public function addExportJSON($input, $vars = array())
    {
        $fileManager = new main\mgLibs\custom\FileManager('zonesFilesStorage'.DIRECTORY_SEPARATOR.'bulkZones');
        $vars['isReadable'] = $fileManager->isStorageReadable();
        $vars['storagePath'] = $fileManager->getStoragePath();

        $rep = new server\Repository();
        $vars['servers'] = $rep->get();

        $filesList = main\mgLibs\custom\helpers\ImportExportFileHelper::listFilesForBulkExport($fileManager);
        $vars['bFiles'] = $filesList;

        AjaxResponse::I()->modal('add-export', $vars);
        return AjaxResponse::I()->toArray();
    }

    public function addExportSaveJSON($input, $vars = array())
    {
        if(!isset($input['toServer']))
        {
            return ;
        }

        $server = server\Server::factory($input['toServer']);
        $server->getModule()->testConnection();

        custom\TaskManager::addTask('ExportFromFile:main', array('fromFile' => $input['fromFile'], 'toServer' => $input['toServer']));

        AjaxResponse::I()->refreshPage($this->backupsHTML($input, $vars));
        AjaxResponse::I()->addInfo('new_task_added');

        return AjaxResponse::I()->toArray();
    }


    public function backupsHTML($input, $vars = array())
    {
        $vars['backupsTasks'] = array();

        $newImportsToFile = custom\TaskManager::getXTasksObjects(0, 'ImportToFileWHMCS:main', 0, task\TaskStatusEnum::START);
        $this->parseNewImportTaskList($newImportsToFile, $vars['backupsTasks']);

        $toFileImports = custom\TaskManager::getXTasksObjects(0, 'ImportToFileWHMCS:main', 0, task\TaskStatusEnum::IN_PROGRESS);
        $this->parseInProgresImportTaskList($toFileImports, $vars['backupsTasks'], 'ImportToFileWHMCS');

        $newImportsToFile = custom\TaskManager::getXTasksObjects(0, 'ExportFromFile:main', 0, task\TaskStatusEnum::START);
        $this->parseNewImportTaskList($newImportsToFile, $vars['backupsTasks']);

        $toFileImports = custom\TaskManager::getXTasksObjects(0, 'ExportFromFile:main', 0, task\TaskStatusEnum::IN_PROGRESS);
        $this->parseInProgresImportTaskList($toFileImports, $vars['backupsTasks'], 'ExportFromFile');

        return array(
            'tpl' => 'backups',
            'vars' => $vars
        );
    }

    public function backupsJSON($input, $vars = array())
    {
        return AjaxResponse::I()->refreshPage($this->backupsHTML($input, $vars))->toArray();
    }

    public function downloandBackupFileJSON($input, $vars = array())
    {
        $type = $input['type'];
        $fileName = $input['id'];

        $fileManager = new main\mgLibs\custom\FileManager('zonesFilesStorage'.DIRECTORY_SEPARATOR.$type.'Zones');
        if(!$fileManager->fileExists($fileName))
        {
            AjaxResponse::I()-> addError('fileDoesNotExist', array('file' => $fileName));
            return AjaxResponse::I()->toArray();
        }

        $filePatch = $fileManager->getStoragePath().$fileName;


        $url = html_entity_decode(str_replace('mg-action=backups', 'mg-action=downloandBackupFile', $_SERVER['HTTP_REFERER']));

        return array('seturlto' => $url.'&path='.$filePatch);
    }

    public function downloandBackupFileHTML($input, $vars = array())
    {
        $filePatch = $_GET['path'];
        if(!strpos($filePatch, 'DNSManager2'.DIRECTORY_SEPARATOR.'storage'.DIRECTORY_SEPARATOR.'zonesFilesStorage'))
        {
            $filePatch = false;
        }

        ob_clean();
        header('Content-Description: File Transfer');
        header('Content-Type: application/octet-stream');
        header('Content-Disposition: attachment; filename="'.basename($filePatch).'"');
        header('Expires: 0');
        header('Cache-Control: must-revalidate');
        header('Pragma: public');
        header('Content-Length: '.filesize($filePatch));
        readfile($filePatch);
        die();
    }

    public function removeBackupFileJSON($input, $vars = array())
    {
        $type = $input['type'];
        $fileName = $input['id'];
        $fileManager = new main\mgLibs\custom\FileManager('zonesFilesStorage'.DIRECTORY_SEPARATOR.$type.'Zones');
        if(!$fileManager->fileExists($fileName))
        {
            AjaxResponse::I()-> addError('fileDoesNotExist', array('file' => $fileName));
            return AjaxResponse::I()->toArray();
        }

        if($fileManager->deleteFile($fileName))
        {
            $clientId = explode('_', $fileName)[0];
            main\helpers\custom\ClientFilesManage::delete($clientId, $fileName);
            AjaxResponse::I()->refreshPage($this->backupsHTML($input, $vars));
            AjaxResponse::I()->addInfo('fileRemoved');

            return AjaxResponse::I()->toArray();
        }

        AjaxResponse::I()-> addError('fileDeleteFailed', array('file' => $fileName));
        return AjaxResponse::I()->toArray();
    }

    public function addBackupFileJSON($input, $vars = array())
    {
        AjaxResponse::I()->modal('add-backupFile', $vars);
        return AjaxResponse::I()->toArray();
    }

    public function uploadBackupFileJSON($input, $vars = array())
    {
        $fileName = main\mgLibs\custom\FileManager::removeFakePath($input['fileName']);

        if(!main\mgLibs\custom\FileManager::checkIfFileWasSent($fileName))
        {
            AjaxResponse::I()-> addError('sendingFailed', array('file' => $fileName));
            return AjaxResponse::I()->toArray();
        }


        $type = main\mgLibs\custom\FileManager::checkTypeByContent($fileName);
        if($type !== 'single' && $type !== 'bulk')
        {
            AjaxResponse::I()->addError('invalidContent', array('file' => $fileName));
            return AjaxResponse::I()->toArray();
        }

        $fileManager = new main\mgLibs\custom\FileManager('zonesFilesStorage'.DIRECTORY_SEPARATOR.$type.'Zones');

        if(!$fileManager->isStorageReadable() || !$fileManager->isStorageWritable())
        {
            AjaxResponse::I()-> addError('directoryPermissionWritableReadable', array('storageDir' => $fileManager->getStoragePath()));
            return AjaxResponse::I()->toArray();
        }


        if($fileManager->fileExists($fileName))
        {
            AjaxResponse::I()-> addError('fileAlreadyExist', array('file' => $fileName));
            return AjaxResponse::I()->toArray();
        }

        if($fileManager->uploadFile($fileName))
        {

            AjaxResponse::I()->refreshPage($this->backupsHTML($input, $vars));
            AjaxResponse::I()->addInfo('uploadSuccesfull');

            return AjaxResponse::I()->toArray();
        }

        if(!main\mgLibs\custom\FileManager::checkIfFileWasSent($fileName))
        {
            AjaxResponse::I()-> addError('sendingFailed', array('file' => $fileName));
            return AjaxResponse::I()->toArray();
        }
    }

    public function refreshBackupsTableJSON($input, $vars = array())
    {
        $vars['data'] = array();
        $vars['recordsTotal'] = 0;
        $vars['recordsFiltered'] = 0;

        $limit = $input['limit'];
        $offset = $input['offset'];



        $order = $input['order']['dir'] == 'desc' ? 1 : 0;

        $fileManager = new main\mgLibs\custom\FileManager('zonesFilesStorage'.DIRECTORY_SEPARATOR.'bulkZones');
        $filesList = main\mgLibs\custom\helpers\ImportExportFileHelper::listFilesForBulkExport($fileManager, false, $order);

        foreach($filesList as $fileName)
        {
            $fileRecord = clientfiles\Repository::factory()->byFile($fileName)->one();

            $client = !$fileRecord ? '-' : custom\manager\ClientHelper::getClientLink($fileRecord->clientid);

            $fileNameDisplay = $fileName;
            $result = explode('_', $fileNameDisplay);
            if($client != '-')
            {
                unset($result[count($result) -1]);
            }
            $fileNameDisplay = implode("_", $result);

            $vars['recordsTotal']++;
            if($input['search'] && $this->isFilenameMatch($fileName, $input['search']))
            {
                $vars['data'][] = $this->dataTablesParseRow('backup-row', array(
                    'fileName' => $fileName,
                    'fileNameDisplay' => $fileNameDisplay,
                    'client' => $client,
                    'type' => 'bulk'
                ));
                $vars['recordsFiltered']++;
            }
            elseif(!$input['search'])
            {
                $vars['data'][] = $this->dataTablesParseRow('backup-row', array(
                    'fileName' => $fileName,
                    'fileNameDisplay' => $fileNameDisplay,
                    'client' => $client,
                    'type' => 'bulk'
                ));
            }
        }

        $fileManager = new main\mgLibs\custom\FileManager('zonesFilesStorage'.DIRECTORY_SEPARATOR.'singleZones');

        $filesList = main\mgLibs\custom\helpers\ImportExportFileHelper::listFilesForBulkExport($fileManager);
        foreach($filesList as $fileName)
        {
            $vars['recordsTotal']++;
            if($input['search'] && $this->isFilenameMatch($fileName, $input['search']))
            {
                $vars['data'][] = $this->dataTablesParseRow('backup-row', array('fileName' => $fileName, 'client' => '-','type' => 'single'));
                $vars['recordsFiltered']++;
            }
            elseif(!$input['search'])
            {
                $vars['data'][] = $this->dataTablesParseRow('backup-row', array('fileName' => $fileName, 'client' => '-', 'type' => 'single'));
            }
        }

        $vars['recordsFiltered'] = $input['search'] ? $vars['recordsFiltered'] : $vars['recordsTotal'];

        $vars['data'] = array_slice($vars['data'], $offset, $limit);


        return $vars;
    }


    private function isFilenameMatch($fileName, $search)
    {
        if(strpos($fileName, $search) || strpos($fileName, $search) === 0)
        {
            return true;
        }

        return false;
    }

    public function addExportToFIleJSON($input, $vars = array())
    {
        $fileManager = new main\mgLibs\custom\FileManager('zonesFilesStorage'.DIRECTORY_SEPARATOR.'bulkZones');
        $vars['isWritable'] = $fileManager->isStorageWritable();
        $vars['storagePath'] = $fileManager->getStoragePath();

        $rep = new server\Repository();
        $vars['servers'] = $rep->get();

        AjaxResponse::I()->modal('add-exportToFile', $vars);
        return AjaxResponse::I()->toArray();
    }

    public function addExportToFileSaveJSON($input, $vars = array())
    {
        if(!isset($input['from_server']))
        {
            return ;
        }

        $server = server\Server::factory($input['from_server']);
        $server->getModule()->testConnection();

        $fileName = helpers\ImportExportFileHelper::generateNewExportFileName($server->name);
        custom\TaskManager::addTask('ImportToFile:main', array('from' => $input['from_server'], 'toFile' => $fileName));

        AjaxResponse::I()->refreshPage($this->backupsHTML($input, $vars));
        AjaxResponse::I()->addInfo('new_task_added');

        return AjaxResponse::I()->toArray();
    }

    public function backupScheduleImportJSON($input, $vars = array())
    {
        custom\TaskManager::getTaskObjectByID($input['id'])->run(true);
        AjaxResponse::I()->addInfo('import_scheduled');
        AjaxResponse::I()->refreshPage($this->backupsHTML($input, $vars));
        return AjaxResponse::I()->toArray();
    }

    public function backupScheduleExportJSON($input, $vars = array())
    {
        custom\TaskManager::getTaskObjectByID($input['id'])->run(true);
        AjaxResponse::I()->addInfo('exportScheduled');
        AjaxResponse::I()->refreshPage($this->backupsHTML($input, $vars));

        return AjaxResponse::I()->toArray();
    }

    public function backupRemoveTaskJSON($input, $vars = array())
    {
        custom\TaskManager::removeTask($input['id']);
        AjaxResponse::I()->refreshPage($this->backupsHTML($input, $vars));
        AjaxResponse::I()->addInfo('taskRemoved');

        return AjaxResponse::I()->toArray();
    }

    public function showListExportJSON($input, $vars = array())
    {
        $vars['exportId'] = $input['id'];

        $autocheckMatches = globalsetting\Repository::factory()->byKey(
            globalsetting\GlobalSettingEnum::IMPORT_AUTOCHECK_MATCHES)->one();

        $vars['autocheckMatches'] = $autocheckMatches->value == 'on' ? true : false;

        AjaxResponse::I()->refreshPage(array('tpl' => 'export-list', 'vars' => $vars));

        return AjaxResponse::I()->toArray();
    }

    function refreshExportTableJSON($input, $vars = array())
    {
        $pRep = task\Repository::factory()->byParentID($input['id'])->one();
        $pRepName = explode(':', $pRep->name);

        $task = custom\TaskManager::getXTasks(1, $pRepName[0].':fetchZonesList', $input['id'], false);
        $task = end($task);


        $rep = task\result\Repository::factory()->byTaskID($task->id);

        $helper = new main\mgLibs\custom\RepoTableHelper($rep, $input, array('data'));

        $vars = $helper->getDataTableArray();

        foreach($helper->get() as $task)
        {
            $userid = $this->getUserIdByHostingDomain($task->data['domain']);
            if(empty($userid))
            {
                $userid = $this->getUserIdByDomain($task->data['domain']);
            }

            $user = false;
            if(!empty($userid))
            {
                $user = new main\models\whmcs\clients\client($userid);
            }

            $vars['data'][] = $this->dataTablesParseRow('export-row',
                array(
                    'item' => $task,
                    'exportId' => $input['id'],
                    'user' => $user
                )
            );
        }

        return $vars;
    }

    public function showListImportToFileJSON($input, $vars = array())
    {
        $vars['importid'] = $input['id'];

        $autocheckMatches = globalsetting\Repository::factory()->byKey(
            globalsetting\GlobalSettingEnum::IMPORT_AUTOCHECK_MATCHES)->one();

        $vars['autocheckMatches'] = $autocheckMatches->value == 'on' ? true : false;

        AjaxResponse::I()->refreshPage(array('tpl' => 'import-list-to-file', 'vars' => $vars));

        return AjaxResponse::I()->toArray();
    }

    public function backupImportZonesJSON($input, $vars = array())
    {
        $add = false;

        foreach($input['zone'] as $resultId => $data)
        {
            if($data['import'] != 'on' && !isset($input['justOne']))
            {
                continue;
            }

            $result = new task\result\TaskResult($resultId);



            $task = custom\TaskManager::getTaskObjectByID($result->taskid);

            $main_task = $task->getParent();

            $ex = explode('::', $data['service']);

            $child = $main_task->addChild('import', array(
                'clientid' => $data['client'],
                'domain' => $result->data['domain'],
                'ip' => $result->data['ip'],
                'resultid' => $resultId,
                'type' => $ex[0],
                'relid' => $ex[1],
            ));

            $result->data['status'] = 'importing';
            $result->data['taskid'] = $child->obj()->id;
            $result->save();

            if(isset($input['runNow']))
            {
                $child->run();
                if($child->getStatus() !== 'finished')
                {
                    AjaxResponse::I()->addError('something_went_wrong_during_import');
                }
                else
                {
                    AjaxResponse::I()->addInfo('zone_imported');
                }
            }
            else
            {
                if($add === false)
                {
                    AjaxResponse::I()->addInfo('new_task_added');
                    $add = true;
                }
            }
        }

        return AjaxResponse::I()->toArray();
    }

    public function exportZonesJSON($input, $vars = array())
    {
        $add = false;

        foreach($input['zone'] as $result_id => $data)
        {
            if($data['export'] != 'on' && !isset($input['justOne']))
            {
                continue;
            }

            $result = new task\result\TaskResult($result_id);

            $task = custom\TaskManager::getTaskObjectByID($result->taskid);
            $main_task = $task->getParent(); //TODO: można zmniejszyć ilość danych poprzez odwołanie się do resulta
            $ex = explode('::', $data['service']);
            $child = $main_task->addChild('export', array(
                'clientid' => $data['client'],
                'domain' => $result->data['domain'],
                'ip' => $result->data['ip'],
                'resultid' => $result_id,
                'type' => $ex[0],
                'relid' => $ex[1],
            ));

            $result->data['status'] = 'exporting';
            $result->data['taskid'] = $child->obj()->id;
            $result->save();
            if(isset($input['runNow']))
            {
                $child->run();
                if($child->getStatus() !== 'finished')
                {
                    AjaxResponse::I()->addError('something_went_wrong_during_import');
                }
                else
                {
                    AjaxResponse::I()->addInfo('zone_imported');
                }
            }
            else
            {
                if($add === false)
                {
                    AjaxResponse::I()->addInfo('new_task_added');
                    $add = true;
                }
            }

        }

        return AjaxResponse::I()->toArray();
    }

    public function parseInProgresSetRecordList($record, $vars, $type = 'DnsRecord')
    {
        $rep = new task\Repository();
        $rep->byParentID($record->obj()->id)->byName($type.':changeRecordSet');
        $tasks_total = $rep->count();
        $rep->byStatus(task\TaskStatusEnum::FINISHED);
        $tasks_done = $rep->count();

        $task = custom\TaskManager::getXTasksObjects(1, $type.':changeRecordSet', $record->obj()->id, false);

        if(end($task))
        {
            $error = $this->getTaskError(end($task));
        }

        $vars[] = array(
            'id' => $record->obj()->id,
            'tasks_done' => $tasks_done,
            'tasks_total' => $tasks_total,
            'progress' => $tasks_total == 0 ? 0 : ceil($tasks_done * 100 / $tasks_total),
            'error' => $error,
        );

        return $vars;
    }
}