<?php

namespace backend\controllers;


use common\component\helpers\Constants;
use common\component\helpers\ExcelHelper;
use common\component\helpers\MedicusHelper;
use common\models\AutoExport;
use common\models\AutoGenerate;
use common\models\Biomarker;
use common\models\Lab;
use common\models\Language;
use common\models\LanguageSource;
use common\models\LanguageTranslate;
use common\models\Permission;
use common\models\Region;
use common\models\Version;
use Yii;
use yii\db\Query;
use yii\filters\AccessControl;
use yii\filters\VerbFilter;
use yii\helpers\ArrayHelper;
use yii\web\UploadedFile;
use ZipArchive;


/**
 * CountryController implements the CRUD actions for Country model.
 */
class ExportController extends BaseController
{
    /**
     * @inheritdoc
     */
    public function behaviors()
    {
        return [
            'access' => [
                'class' => AccessControl::className(),
                'rules' => Permission::checkPermission('export'),
            ],
            'verbs' => [
                'class' => VerbFilter::className(),
                'actions' => [
                    'delete' => ['POST'],
                ],
            ],
        ];
    }

    public function afterAction($action, $result)
    {
        $result = parent::afterAction($action, $result);
        MedicusHelper::logAction($action);
        return $result;
    }

    /**
     * Lists all Country models.
     * @return mixed
     */
    public function actionIndex()
    {
        return $this->render('index', []);
    }

    public function actionImportAll()
    {
        $test_res = [];

        MedicusHelper::changeDbConnection(Yii::$app->user->identity->last_database_name);
        if (Yii::$app->request->post()) {
            if ($uploadedFile = UploadedFile::getInstanceByName('file')) {
                if ($uploadedFile->extension != "zip" && $uploadedFile->type !== "application/x-zip-compressed") {
                    Yii::$app->session->setFlash("error", "Only zip files are allowed");
                } else {
                    $db_name = isset(\Yii::$app->user) ? \Yii::$app->user->identity->getCurrentLabDbName() : MedicusHelper::$DB_name;
                    $file_name = "File.zip";
                    $path = "export" . DIRECTORY_SEPARATOR . "import" . DIRECTORY_SEPARATOR;
                    ExcelHelper::removeAllFilesAndDirectoryFromDirectory($path);
                    if ($uploadedFile->saveAs($path . $file_name)) {
                        $zip = new ZipArchive();
                        if ($zip->open($path . $file_name) === TRUE) {
                            $zip->extractTo($path);
                            $zip->close();
                            unlink($path . $file_name);
                            $excel_files = ExcelHelper::getExcelFileNamesFromDirectory($path);
                            $auto_generate = new AutoGenerate();
                            $auto_generate->item = 'import-translation';
                            $auto_generate->sub_item = implode(' | ', $excel_files);
                            $auto_generate->database = $db_name;
                            $auto_generate->for_all = 0;
                            $auto_generate->status = "waiting";
                            $auto_generate->generated_date = strtotime("now");
                            $lab = Lab::find()->where(['db_name' => Lab::encryptECB(\Yii::$app->user->identity->getCurrentLabDbName())])->one() ?: Lab::findOne(1);
                            $auto_generate->lab_id = $lab->id; //\Yii::$app->user->identity->getCurrentLabId();
                            $auto_generate->save();
                            Yii::$app->session->setFlash("success", "Auto import for $uploadedFile->name is now working, this could take a little bit longer if the server is busy.");
                        } else {
                            Yii::$app->session->setFlash("error", Yii::t("app", "Unable to extract archive"));
                        }
                    } else {
                        Yii::$app->session->setFlash("error", Yii::t("app", "Unable to save zip file"));
                    }
                }
                return $this->redirect('import-all');
            } else {
                Yii::$app->session->setFlash("error", "Choose file before import");
            }
        }
var_dump('dsf'); die;
        $database = isset(\Yii::$app->user) ? \Yii::$app->user->identity->getCurrentLabDbName() : "centro_master";
        $current_generate_process = AutoGenerate::find()
            ->where(['item' => 'excel', 'database' => $database])
            ->andWhere(['not', ['status' => ['done', 'exception']]])
            ->orderBy(['generated_date' => SORT_DESC])->one();
        $validity = isset($current_generate_process) ? $current_generate_process->translation_validity : null;
        $validity = $validity == Constants::VALID ? "valid" : "for translation";
        $dateModified = isset($current_generate_process) ? "Excel Files are now Generating for \"$validity\"" : null;

        $current_export_process = AutoExport::find()
            ->where(['item' => 'individual-table-excel', 'database' => $database])
            ->andWhere(['not', ['status' => ['done', 'exception']]])
            ->orderBy(['generated_date' => SORT_DESC])->one();

        if (!empty($current_export_process)) {
            $table = $current_export_process->data;
            $table = $table == "doctor_cr" ? "Doctor CR" : ucwords(str_replace('_', ' ', $table));
            $individualTableGenerateStatus = $current_export_process->status !== 'exception';
            $individualTableGenerateDate = "Excel Files for {$table} are now generating";
        } else {
            $last_export_process = AutoExport::find()
                ->where(['item' => 'individual-table-excel', 'database' => $database])
                ->andWhere(['not', ['status' => ['waiting', 'generating']]])
                ->orderBy(['generated_date' => SORT_DESC])->one();
            if (!empty($last_export_process)) {
                $table = $last_export_process->data;
                $table = $table == "doctor_cr" ? "Doctor CR" : ucwords(str_replace('_', ' ', $table));
  

  $ts = (int)$last_export_process->generated_date;

                $export_date = $ts
                    ? (new \DateTime('@' . $ts))->setTimezone(new \DateTimeZone('GMT'))
                    : null;		$individualTableGenerateStatus = $last_export_process->status !== 'exception';
//
               // $export_date = Yii::$app->formatter->asDatetime(date($last_export_process->generated_date));
                $export_date = !empty($export_date) ? new \DateTime($export_date, new \DateTimeZone("GMT")) : null;
                if (isset($export_date)) {
                    $export_date->setTimezone(new \DateTimeZone("Asia/Damascus"));
                    $individualTableGenerateDate = "Last generated for {$table} in: " . Yii::$app->formatter->asDatetime($export_date);
                } else
                    $individualTableGenerateDate = 'N/A';
            } else {
                $individualTableGenerateStatus = true;
                $individualTableGenerateDate = 'Last generating date: N/A';
            }
        }

        $current_import_process = AutoGenerate::find()
            ->where(['item' => 'import-translation', 'database' => $database])
            ->andWhere(['status' => ['done', 'exception']])
            ->orderBy(['generated_date' => SORT_DESC])->one();

        $failMsg = '';
     if (!empty($current_import_process)) {
            if ($current_import_process->status === 'exception') {
                $importProcessFailFlag = true;
                $failMsg = $current_import_process->exception;
            } else
                $importProcessFailFlag = false;
            $importProcessMsg = "Last importing date: " . Yii::$app->formatter->asDatetime(date($current_import_process->generated_date)) .
                " | File: " . $current_import_process->sub_item .
                " | Added/Updated " . $current_import_process->milestone . " words.";
        } else {
            $importProcessFailFlag = false;
            $importProcessMsg = 'Last importing date: N/A';
        }

        if ($dateModified == null) {
            $generated_valid = AutoGenerate::find()
                ->where(['item' => 'excel', 'status' => 'done', 'translation_validity' => Constants::VALID, 'database' => $database])
                ->orderBy(['generated_date' => SORT_DESC])->one();
  //          $last_valid_generate_date = isset($generated_valid) ? Yii::$app->formatter->asDatetime(date($generated_valid->generated_date)) : null;
	              var_dump('s'); die; 
	    //      $valid_date = isset($last_valid_generate_date) ? new \DateTime($last_valid_generate_date, new \DateTimeZone("GMT")) : null;

$valid_date = null;

if (isset($generated_valid) && !empty($generated_valid->generated_date)) {
    $valid_date = (new \DateTime('@' . (int)$generated_valid->generated_date))
        ->setTimezone(new \DateTimeZone('GMT'));
}

	    if (isset($valid_date)) {
	   
	    $valid_date->setTimezone(new \DateTimeZone("Asia/Damascus"));
                $last_valid_generate_date = Yii::$app->formatter->asDatetime($valid_date);
            } else
                $last_valid_generate_date = 'N/A';

            $generated_unvalid = AutoGenerate::find()
                ->where(['item' => 'excel', 'status' => 'done', 'translation_validity' => Constants::FORTRANSLATION, 'database' => $database])
		->orderBy(['generated_date' => SORT_DESC])->one();


$for_translation_date = null;

if (isset($generated_unvalid) && !empty($generated_unvalid->generated_date)) {
    $for_translation_date = (new \DateTime('@' . (int)$generated_unvalid->generated_date))
        ->setTimezone(new \DateTimeZone('GMT'));
}

 //           $last_unvalid_generate_date = isset($generated_unvalid) ? Yii::$app->formatter->asDatetime(date($generated_unvalid->generated_date)) : null;
//         $for_translation_date = isset($last_unvalid_generate_date) ? new \DateTime($last_unvalid_generate_date, new \DateTimeZone("GMT")) : null;
            if (isset($for_translation_date)) {
                $for_translation_date->setTimezone(new \DateTimeZone("Asia/Damascus"));
                $last_unvalid_generate_date = Yii::$app->formatter->asDatetime($for_translation_date);
            }

            $dateModified = !is_null($last_valid_generate_date) ? "last generating date for \"valid\" is " . $last_valid_generate_date : $dateModified;
            if (!is_null($last_unvalid_generate_date))
                $dateModified .= " & last generating date for \"for translation \" is " . $last_unvalid_generate_date;
        }

        $tables = ArrayHelper::map(LanguageSource::find()->orderBy('category')->all(), 'category', 'category');
        foreach ($tables as $key => $table) {
            $name = str_replace('_', ' ', $table);
            if ($name == "doctor cr") {
                $name = "Doctor CR";
            } else {
                $name = ucwords($name);
            }
            $tables[$key] = $name;
        }
        $percentage = MedicusHelper::calculatePercentage($database);
        return $this->render('import-all', [
            'dateModified' => $dateModified,
            'importProcessMsg' => $importProcessMsg,
            'importProcessFailFlag' => $importProcessFailFlag,
            'failMsg' => $failMsg,
            'percentage' => $percentage,
            'tables' => $tables,
            'individualTableGenerateStatus' => $individualTableGenerateStatus,
            'individualTableGenerateDate' => $individualTableGenerateDate
        ]);
    }

    public function actionExportExcelFiles($isValid)
    {
        $db_name = isset(\Yii::$app->user) ? \Yii::$app->user->identity->getCurrentLabDbName() : "centro_master";
        $directory = $isValid ? "valid" : "for-translation";
        $path = 'export' . DIRECTORY_SEPARATOR . 'excel' . DIRECTORY_SEPARATOR . $db_name . DIRECTORY_SEPARATOR . $directory;
        //        DirectoryHelper::validateDirectory($path . DIRECTORY_SEPARATOR);
        if (!file_exists($path)) {
            $oldumask = umask(0);
            mkdir($path, 02775, true);
            umask($oldumask);
        }
        $zip_name = $db_name . "_" . date("Y-m-d_H-i-s");
        ExcelHelper::zipFiles($path, $zip_name . ".zip");
        if (file_exists($path . DIRECTORY_SEPARATOR . $zip_name . ".zip")) {
            return Yii::$app->response->sendFile($path . DIRECTORY_SEPARATOR . $zip_name . ".zip");
        }
        Yii::$app->session->setFlash('error', $path . "/" . $zip_name . ".zip" . " not found.");
        return $this->redirect(['import-all']);
    }

    public function actionGenerateSubdividedExcelFiles($table, $projects = null)
    {
        $db_name = isset(\Yii::$app->user) ? \Yii::$app->user->identity->getCurrentLabDbName() : "centro_master";
        MedicusHelper::changeDbConnection($db_name);
        $current_export_process = AutoEXport::find()
            ->where(['item' => 'individual-table-excel', 'database' => $db_name])
            ->andWhere(['not', ['status' => ['done', 'exception']]])
            ->all();

        if (count($current_export_process) > 0) {
            $table = $table == "doctor_cr" ? "Doctor CR" : ucwords(str_replace('_', ' ', $table));
            Yii::$app->session->setFlash(
                "info",
                "Auto exporting for {$table} Excel Files from $db_name has already started working."
            );
        } else {
            $path = 'export' . DIRECTORY_SEPARATOR . 'subdivided-excel';
            ExcelHelper::removeAllFilesAndDirectoryFromDirectory($path);
            $auto_export = new AutoExport();
            $auto_export->item = 'individual-table-excel';
            $auto_export->file = $db_name . "_" . date("Y-m-d_H-i-s");
            $auto_export->path = $path;
            $auto_export->type = 'excel';
            $auto_export->data = $table;
            $auto_export->database = $db_name;
            $auto_export->status = "waiting";
            $auto_export->sub_projects = !empty($projects) ? $projects : null;
            $auto_export->generated_date = strtotime("now");
            //send lab id
            $lab = Lab::find()->where(['db_name' => Lab::encryptECB(\Yii::$app->user->identity->getCurrentLabDbName())])->one() ?: Lab::findOne(1);
            $auto_export->lab_id = $lab->id;
            $table = $table == "doctor_cr" ? "Doctor CR" : ucwords(str_replace('_', ' ', $table));
            if (!$auto_export->save()) {
                Yii::$app->session->setFlash(
                    "error",
                    "Unable to export {$table} due to an error occurred:\n" . json_encode($auto_export->getFirstErrors())
                );
            } else {
                Yii::$app->session->setFlash(
                    "success",
                    "Auto exporting for {$table} Excel Files from $db_name is now working."
                );
            }
        }
        return $this->redirect(['import-all']);
    }

    public function actionExportSubdividedExcelFiles($table, $projects = null)
    {
        $db_name = isset(\Yii::$app->user) ? \Yii::$app->user->identity->getCurrentLabDbName() : "centro_master";
        MedicusHelper::changeDbConnection($db_name);

        $finished_export_process = AutoEXport::find()
            ->where(['item' => 'individual-table-excel', 'database' => $db_name])
            ->andWhere(['status' => 'done'])->orderBy(["generated_date" => SORT_DESC])->one();

        if (empty($finished_export_process)) {
            $table = $table == "doctor_cr" ? "Doctor CR" : ucwords(str_replace('_', ' ', $table));
            Yii::$app->session->setFlash(
                "info",
                "You need to generate the Excel files for {$table} before you can export them."
            );
        } else {
            $path = $finished_export_process->path;
            $zip_name = $finished_export_process->file;
            ExcelHelper::zipFiles($path, $zip_name . ".zip");
            if (file_exists($path . DIRECTORY_SEPARATOR . $zip_name . ".zip")) {
                return Yii::$app->response->sendFile($path . DIRECTORY_SEPARATOR . $zip_name . ".zip");
            }
            Yii::$app->session->setFlash('error', "" . $zip_name . ".zip" . " not found.");
        }
        return $this->redirect(['import-all']);
    }

    public function actionGenerateExcelFiles($isValid, $projects = null)
    {
        $db_name = isset(\Yii::$app->user) ? \Yii::$app->user->identity->getCurrentLabDbName() : "centro_master";
        $current_generate_process = AutoGenerate::find()
            ->where(['item' => 'excel', 'database' => $db_name])
            ->andWhere(['not', ['status' => ['done', 'exception']]])
            ->all();

        if (count($current_generate_process) > 0) {
            Yii::$app->session->setFlash(
                "info",
                "Auto generation for Excel files from $db_name has already started working."
            );
        } else {
            $directory = $isValid ? "valid" : "for-translation";
            $path = 'export' . DIRECTORY_SEPARATOR . 'excel' . DIRECTORY_SEPARATOR . $db_name . DIRECTORY_SEPARATOR . $directory;
            if (is_dir($path))
                ExcelHelper::removeAllFilesAndDirectoryFromDirectory($path . DIRECTORY_SEPARATOR);

            $auto_generate = new AutoGenerate();
            $auto_generate->item = 'excel';
            $auto_generate->sub_item = 'missing';
            $auto_generate->translation_validity = $isValid ? Constants::VALID : Constants::FORTRANSLATION;
            $auto_generate->database = $db_name;
            $auto_generate->status = "waiting";
            $auto_generate->for_all = 0;
            $auto_generate->sub_projects = !empty($projects) ? $projects : null;
            $auto_generate->generated_date = strtotime("now");
            $auto_generate->save();
            Yii::$app->session->setFlash(
                "success",
                "Auto generation for Excel Files databases from $db_name is now working."
            );
        }

        return $this->redirect(['import-all']);
    }

    public function actionExportBiomarker()
    {
        $request = Yii::$app->request;
        if (!$request->isPost) {
            $databases = ArrayHelper::map(Version::find()->select("db_name")->all(), "db_name", "db_name");
            $databases = ArrayHelper::merge(["centro_master" => "centro_master"], $databases);
            $regions = ArrayHelper::map(Region::find()->select(["id", "name", "parent_id"])->where(['leaf' => 1])->all(), "id", "name");
            return $this->render('export-biomarker', [
                'databases' => $databases,
                'regions' => $regions
            ]);
        } else {
            $database = $request->post('database');
            $region = $request->post('region');
            MedicusHelper::changeDbConnection($database);
            $biomarkers_synonyms = \common\models\BiomarkerSynonym::find()->asArray()->all();
            $biomarkers_synonyms = \yii\helpers\ArrayHelper::index($biomarkers_synonyms, null, ['biomarker_id', 'language']);
            $languages = ArrayHelper::getColumn(Language::find()->where(['status' => Language::STATUS_ACTIVE])->orderBy(['language_id' => SORT_ASC])->all(), 'language');
            $temp = (new Query())
                ->select('*')
                ->from(LanguageSource::tableName())
                ->leftJoin(LanguageTranslate::tableName(), 'language_source.id = language_translate.id')
                ->where(['category' => 'biomarker_region'])
                ->all(Yii::$app->dbMaster);

            $indexed_translations = [];
            foreach ($temp as $item) {
                if (empty($item['message'])) continue;
                $indexed_translations[MedicusHelper::cleanIndex($item['message']) . '_' . $item['language']] = $item['translation'];
            }

            $result = [];

            Biomarker::$static_region_id = $region;
            $biomarkers = ArrayHelper::index(Biomarker::find()->all(), 'id');
            foreach ($biomarkers as $id => $biomarker) {
                $t = [
                    'id' => $id,
                    'symbol' => $biomarker->symbol,
                ];
                foreach ($languages as $language) {
                    if ($language == 'en') {
                        $t['name_' . $language] = $biomarker->name;
                        $t['abbreviation_' . $language] = $biomarker->abbreviation;
                    } else {
                        $t['name_' . $language] = isset($indexed_translations[MedicusHelper::cleanIndex($biomarker->name) . '_' . $language]) ?
                            $indexed_translations[MedicusHelper::cleanIndex($biomarker->name) . '_' . $language] : '';
                        $t['abbreviation_' . $language] = isset($indexed_translations[MedicusHelper::cleanIndex($biomarker->abbreviation) . '_' . $language]) ?
                            $indexed_translations[MedicusHelper::cleanIndex($biomarker->abbreviation) . '_' . $language] : '';
                    }

                    $synonyms = isset($biomarkers_synonyms[$biomarker->id][$language]) ?
                        ArrayHelper::getColumn($biomarkers_synonyms[$biomarker->id][$language], 'name') : [];
                    if (!empty($synonyms)) {
                        $synonyms = implode(";\n", $synonyms);
                    } else {
                        $synonyms = '';
                    }
                    $t['synonyms_' . $language] = $synonyms;
                }
                $result[$t['id']] = $t;
            }
            $name = 'biomarkers.xlsx';
            $path = 'export/';
            ExcelHelper::exportBiomarkers($result, 'biomarkers', $path, 'biomarkers');
            $file = $path . '/' . $name;
            if (is_file($file)) {
                \Yii::$app->response->on(\yii\web\Response::EVENT_AFTER_SEND, function ($event) {
                    unlink($event->data);
                }, $file);
                return \Yii::$app->response->sendFile($file, $name);
            }
            return $this->redirect(['export/export-biomarker']);
        }
    }

    public function actionImportByText()
    {
        if (Yii::$app->request->post()) {

            $db_name = isset(\Yii::$app->user) ? \Yii::$app->user->identity->getCurrentLabDbName() : MedicusHelper::$DB_name;
            MedicusHelper::changeDbConnection($db_name);

            if ($uploadedFile = UploadedFile::getInstanceByName('translation-excel-file')) {
                $file = explode(".", $uploadedFile->name);

                $success = '';
                $failed = '';

                if (strtolower($file[count($file) - 1]) != "zip") {
                    Yii::$app->session->setFlash("error", "Only zip files are allowed");
                    return $this->redirect(['import-by-text']);
                } else {
                    $file_name = "translationText.zip";
                    $path = "export/dataImporter/";

                    ExcelHelper::removeAllFilesAndDirectoryFromDirectory($path);

                    if ($uploadedFile->saveAs($path . $file_name)) {
                        $zip = new ZipArchive();

                        if ($zip->open($path . $file_name) === TRUE) {
                            $zip->extractTo($path);
                            $zip->close();
                            unlink($path . $file_name);
                            $excel_files = ExcelHelper::getExcelFileNamesFromDirectory($path);

                            $errors = [];

                            if (count($errors) === 0) {

                                foreach ($excel_files as $excel_file) {

                                    $result = self::importTranslationExcelFile($path . $excel_file);
                                    $success = count($result[1]) > 1 ? $result[1][0] : '';
                                    array_splice($result[1], 0, 1);
                                    $success .= count($result[1]) > 0 ? implode(', ', $result[1]) : '';
                                    $failed .= count($result[0]) > 0 ? implode(', ', $result[0]) : '';
                                }
                            } else {
                                Yii::$app->session->setFlash("error", implode(',', $errors));
                                return $this->render('import-by-text');
                            }
                        }
                    }
                }
                if ($success != '') {
                    Yii::$app->session->setFlash("success", $success . '" have been added');
                }
                if ($failed != '') {
                    $failed = 'Couldn\'t add:  ' . $failed;
                    Yii::$app->session->setFlash("error", $failed);
                }
                return $this->render('import-by-text');
            }
            Yii::$app->session->setFlash("error", "Choose file before import");
        }
        return $this->render('import-by-text');
    }

    public static function importTranslationExcelFile($path)
    {
        $added = [];
        $added[] = 'Translations in rows: "';
        $missing = [];

        $excel_file = ExcelHelper::openExcelFile($path);
        $excel = $excel_file["rows"];
        unset($excel[key($excel)]); //remove file header

        $languageSource = LanguageSource::find()->where(['category' => ['coaching_step', 'coaching_quote', 'coaching_program']])->all();
        $sources = ArrayHelper::map($languageSource, 'id', 'message');
        $sourcesIDS = ArrayHelper::map($languageSource, 'id', 'id');

        $translation = LanguageTranslate::find()->where(['id' => $sourcesIDS])->all();
        $translationMap = [];
        foreach ($translation as $t) {
            $translationMap[] = $t->id . "_" . $t->language . '_' . $t->translation;
        }
        $insert = [];
        foreach ($excel as $key => $row) {

            $source = trim((string)$row["C"]);
            $arabic = trim((string)$row["D"]);
            $de = trim((string)$row["E"]);
            $fr = trim((string)$row["F"]);
            $th = trim((string)$row["R"]);
            $uk = trim((string)$row["S"]);

            $sourceID = array_search($source, $sources);

            if ($sourceID !== false) {
                $arModel = new LanguageTranslate();
                $arModel->id = $sourceID;
                $arModel->language = 'ar';
                $arModel->translation = $arabic;
                if ($arModel->validate() && array_search($arModel->id . "_" . $arModel->language . "_" . $arModel->translation, $translationMap) === false) {
                    $insert[] = $arModel->attributes;
                }

                $frModel = new LanguageTranslate();
                $frModel->id = $sourceID;
                $frModel->language = 'fr';
                $frModel->translation = $fr;
                if ($frModel->validate() && array_search($frModel->id . "_" . $frModel->language . "_" . $frModel->translation, $translationMap) === false) {
                    $insert[] = $frModel->attributes;
                }

                $thModel = new LanguageTranslate();
                $thModel->id = $sourceID;
                $thModel->language = 'th';
                $thModel->translation = $th;
                if ($thModel->validate() && array_search($thModel->id . "_" . $thModel->language . "_" . $thModel->translation, $translationMap) === false) {
                    $insert[] = $thModel->attributes;
                }

                $ukModel = new LanguageTranslate();
                $ukModel->id = $sourceID;
                $ukModel->language = 'en-GB';
                $ukModel->translation = $uk;
                if ($ukModel->validate() && array_search($ukModel->id . "_" . $ukModel->language . "_" . $ukModel->translation, $translationMap) === false) {
                    $insert[] = $ukModel->attributes;
                }

                $deModel = new LanguageTranslate();
                $deModel->id = $sourceID;
                $deModel->language = 'de';
                $deModel->translation = $de;
                if ($deModel->validate() && array_search($deModel->id . "_" . $deModel->language . "_" . $deModel->translation, $translationMap) === false) {
                    $insert[] = $deModel->attributes;
                }
            }
        }
        //        MedicusHelper::vdd($insert);
        if (count($insert) > 0) {
            $columnNameArray = ['id', 'language', 'translation'];
            Yii::$app->dbMaster->createCommand()
                ->batchInsert(
                    'language_translate',
                    $columnNameArray,
                    $insert
                )->execute();
        }
        $info[1] = $added;
        $info[0] = $missing;
        return $info;
    }

    public function actionGetImportStatus()
    {
        $request = Yii::$app->request;
        if ($request->isAjax) {
            if ($request->isPost) {
                $db_name = isset(\Yii::$app->user) ? \Yii::$app->user->identity->getCurrentLabDbName() : MedicusHelper::$DB_name;
                $import_record = AutoGenerate::find()->where(['item' => 'import-translation', 'status' => ['generating', 'waiting'], 'database' => $db_name])->orderBy(["generated_date" => SORT_DESC])->one();
                $result = isset($import_record) ? $import_record->sub_item : '';
                return $result;
            }
        }
    }
}