Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/console/controllers/actions/
Linux 9dbcd5f6333d 5.15.0-102-generic #112-Ubuntu SMP Tue Mar 5 16:50:32 UTC 2024 x86_64
Current File : /home/vmanager/www/console/controllers/actions/ImportNewsletterDeletedEmailsAction.php
<?php

namespace console\controllers\actions;

use \Yii;
use yii\base\Action;
use yii\helpers\ArrayHelper;
use yii\console\Controller;
use yii\validators\EmailValidator;
use common\models\Emails;
use common\models\Portals;
use common\models\UsersHasPortals;

class ImportNewsletterDeletedEmailsAction extends ImportAbstractAction
{       
    public $email;    
    public $limit;
    public $offset;
    
    private $emailsForDelete = [];
    private $existsEmails = [];
    private $portals = [];
    private $portalsSimilar = [];
    private $idsUsersForRefresh = [];
    private $idsCompaniesForRefresh = [];
    
    public function run() 
    { 
        $debugMode = self::DEBUG_MODE_OFF;
        
        $this->getEmailsForDelete();
        
        if(empty($this->emailsForDelete)) {
            var_dump('brak danych do przetworzenia');
            return Controller::EXIT_CODE_ERROR;
        }

        $innorrectImports = [];

        foreach($this->emailsForDelete as $emailData) {  
            $this->idsCompaniesForRefresh = $this->idsUsersForRefresh = [];
            
            if($this->checkIfSelectedRecordExists($emailData['email'])) {
                continue;
            }
            
            if($debugMode === self::DEBUG_MODE_ON) {
                echo "\n".'Email: '.$emailData['email'].' - ';
            } 
            $innorrectImports[$emailData['email']] = true;
            
            $transaction = Yii::$app->db->beginTransaction();
            
            list($flag, $message) = $this->deleteEmail($emailData, $debugMode);            
            if(!$flag) {
                if($debugMode === self::DEBUG_MODE_OFF) {
                    $this->saveOperationStatus(self::STATUS_FAIL, $emailData['email'], null, 'Error while removing email: '.$message);
                }  
                $transaction->rollBack();
                var_dump('Blad podczas usuwania emaila');
                continue;
            }
            
            if($debugMode === self::DEBUG_MODE_OFF) {
                $transaction->commit();                
                if(!empty($this->idsCompaniesForRefresh)) {
                    foreach($this->idsCompaniesForRefresh as $idCompanyForRefresh) {
                        \common\models\Emails::refreshForCompany($idCompanyForRefresh);
                    }
                }
                if(!empty($this->idsUsersForRefresh)) {
                    foreach($this->idsUsersForRefresh as $idUserForRefresh) {
                        \common\models\Emails::refreshForUser($idUserForRefresh);
                    }
                } 
                $this->saveOperationStatus(self::STATUS_OK, $emailData['email'], $emailData['email']);                
//                echo 'usunięty';
            } else {
                $transaction->rollBack();
                echo 'usunięty';
            }
            
            unset($innorrectImports[$emailData['email']]);
        }
        
        if(!empty($innorrectImports)) {
            echo "\n".'Nieusunięte emaile: '.implode(", ", array_keys($innorrectImports));
        }
    }
    
    private function getEmailsForDelete_old()
    {
        $this->emailsForDelete = [];
        
        if(!empty($this->limit)) {
            if(!empty($this->offset)) {
                $limit = 'LIMIT '.intval($this->offset).','.intval($this->limit);
            } else {
                $limit = 'LIMIT '.intval($this->limit);
            }
        } else {
            $limit = 'LIMIT 100';
        }
        
        if(!empty($this->email)) {
            $sql = 'SELECT adres_email, GROUP_CONCAT(DISTINCT id_portalu) AS portale FROM newsletter2_adresy WHERE (status_usera = "Z" OR status_usera = "U") AND adres_email = "'.$this->email.'" GROUP BY adres_email';   
        } else {
            $sql = 'SELECT adres_email, GROUP_CONCAT(DISTINCT id_portalu) AS portale FROM newsletter2_adresy WHERE status_usera = "Z" OR status_usera = "U" GROUP BY adres_email ORDER BY adres_email ASC '.$limit;
        }
        
        $rows = Yii::$app->dbVortale->createCommand($sql)->queryAll();
        if(empty($rows)) {
            return;
        }

        $validatorEmail = new EmailValidator();
        
        foreach($rows as $row) {            
            $row = $this->convertDataLatin2ToUTF8($row);
            if(!$validatorEmail->validate($row['adres_email'])) {
                continue;
            }
            
            $idsPortals = array_map('intval', array_map('trim', explode(",", $row['portale'])));
            
            if(!empty($idsPortals)) {
                foreach($idsPortals as $key => $idPortal) {
                    if(!isset($this->portals[$idPortal])) {
                        unset($idsPortals[$key]);
                    }
                }
            }
            
            if(empty($idsPortals)) {
                continue;
            }
            
            $this->emailsForDelete[$row['adres_email']] = [
                'email' => $row['adres_email'],
                'portals' => $idsPortals
            ]; 
        }        
        unset($rows); 
    }
    
    private function getEmailsForDelete()
    {
        $this->emailsForDelete = [];
        
        $documents = (new \yii\mongodb\Query())->from('emails_for_delete')->select(['email', 'portals'])->all();
        if(!empty($documents)) {
            foreach($documents as $document) {
                $this->emailsForDelete[$document['email']] = [
                    'email' => $document['email'],
                    'portals' => $document['portals']
                ];
            }
            unset($documents);
        }
    }
    
    public function init() 
    {
        Yii::$app->dbVortale->createCommand('SET NAMES latin2;')->execute();
        
        $this->portals = ArrayHelper::map(Portals::find()->select(['id_portal', 'domain'])->asArray()->all(), 'id_portal', 'domain');
        
        $this->existsEmails = [];
        $modelsEmails = \common\models\Emails::find()->all();
        if(!empty($modelsEmails)) {
            foreach($modelsEmails as $modelEmail) {
                $this->existsEmails[$modelEmail->email][] = $modelEmail;
            }
            unset($modelsEmails);
        }
        
        $this->portalsSimilar = [
            13 => [13, 14, 15],
            14 => [13, 14, 15],
            15 => [13, 14, 15],
            24 => [24, 40],
            40 => [24, 40],
            6 => [6, 11],
            11 => [6, 11]
        ]; //@todo uzupełnić
        
        parent::init();
    }
    
    protected function getOperationStatusCollectionName()
    {
        return 'import_newsletter_deleted_emails2';
    }
    
    protected function deleteEmail($emailData, $debugMode = self::DEBUG_MODE_OFF)
    {
        $email = $emailData['email'];
        
        $idsBlockedPortals = $emailData['portals'];  
        foreach($idsBlockedPortals as $idPortal) {
            if(isset($this->portalsSimilar[$idPortal])) {
                foreach($this->portalsSimilar[$idPortal] as $idPortal) {
                    $idsBlockedPortals[$idPortal] = $idPortal;
                }
            } else {
                $idsBlockedPortals[$idPortal] = $idPortal;
            }
        }
        $idsBlockedPortals = array_values($idsBlockedPortals);
        
        $flag = true;
            
        if(isset($this->existsEmails[$email])) {
            foreach($this->existsEmails[$email] as $key => $existEmailData) {
//                var_dump((string)$existEmailData->_id);
                
                //sprawdzamy, czy dany dokument-email jest niepowiązany z użytkownikiem/firmą
                if(empty($existEmailData->id_user) && empty($existEmailData->id_company)) {
                    //wpis-email niezwiązany z kontem użytkownika/firmy
//                    echo "\n Wpis usera newslettera. \n"; 
                    
                    $idsExistsPortals = [];                    
                    if(!empty($existEmailData->portals)) {
                        foreach($existEmailData->portals as $existPortal) {
                            $idExistPortal = intval($existPortal['id']);
                            $idsExistsPortals[$idExistPortal] = $idExistPortal;
                        }
                        $idsExistsPortals = array_values($idsExistsPortals);
                    }
                    $idsPortalsForRemove = array_intersect($idsExistsPortals, $idsBlockedPortals);

                    //jeśli nie ma żadnych portali, których dotyczy wykluczenie, to pomijamy dany element
                    if(empty($idsPortalsForRemove)) {
//                        echo "\n Nie ma portali, z ktorych trzeba dany e-mail usunac. \n"; 
                        continue;
                    }
                    
                    $existsPortals = $existEmailData->portals;
                    
                    //usuwamy przypisanie do zaznaczonych portali
                    foreach($idsPortalsForRemove as $idPortalForRemove) {
                        foreach($existsPortals as $key => $existPortal) {
                            if($idPortalForRemove === intval($existPortal['id'])) {
                                unset($existsPortals[$key]);
                                break;
                            }
                        }
                    }
                    $existEmailData->portals = $existsPortals;

                    //zapisujemy zmiany w dokumencie lub jeśli usunęliśmy wszystkie powiązania z portalami - usuwamy dokument
                    if($debugMode === self::DEBUG_MODE_OFF) {  
                        if(!empty($existEmailData->portals)) {
                            $flag = $existEmailData->save();
                            if(!$flag) {
                                return [$flag, 'Błąd podczas zapisu modelu Emails.'];
                            }
                        } else {
                            if($existEmailData->delete() === false) {
                                $flag = false;
                                return [$flag, 'Błąd podczas zapisu modelu Emails.'];
                            }
                        }
                    } 

                } elseif(!empty($existEmailData->id_company)) {
                    //wpis-email związany z firmą
//                    echo "\n Wpis firmy. \n"; 
                    
                    $idCompany = intval($existEmailData->id_company);

                    //nie możemy selektywnie wyłączyć emaili na portalach, więc ustawiamy emailom newsletter/mailing/reklamę na 0
                    $modelsContactData = $this->getModelsContactDataForCompany($idCompany, $email);
                    if(!empty($modelsContactData)) {
                        foreach($modelsContactData as $modelContactData) {
                            $settings = $modelContactData->settings;
                            $settings['purposes']['or_mailings'] = 0;
                            $settings['purposes']['or_newsletter'] = 0;
                            $settings['purposes']['or_ads'] = 0;
                            $modelContactData->settings = $settings;
                            $flag = $modelContactData->save(false);
                            if(!$flag) {
                                return [$flag, 'Błąd podczas zapisu modelu ContactData.'];
                            }
                        }

                        $this->idsCompaniesForRefresh[$idCompany] = $idCompany;
                    }

                } else {
                    //wpis-email związany z użytkownikiem
//                    echo "\n Wpis uzytkownika. \n"; 
                    
                    $idUser = intval($existEmailData->id_user);

                    //dla każdego portalu z $idsBlockedPortals ustawiamy aktywność usera na portalu na false
                    foreach($idsBlockedPortals as $idBlockedPortal) {
                        $flag = \common\models\UsersHasPortals::setInactivity($idUser, $idBlockedPortal);
                        if(!$flag) {
                            return [$flag, 'Błąd podczas zapisu modelu UsersHasPortals.'];
                        }
                    }

                    $this->idsUsersForRefresh[$idUser] = $idUser;
                }
            }
        }
        
        return [$flag, 'Wszystko OK'];
    }
    
    protected function getModelsContactDataForCompany($idCompany, $email)
    {
        $emailsFromCompanyContactData = \common\models\CompaniesContactData::find()
                ->where([
                    'id_company' => $idCompany, 
                    'data_value' => $email, 
                    'data_type' => \common\models\types\ContactDataType::EMAIL
                ])
                ->all();
                
        $emailsFromCompanyBranchesContactData = \common\models\CompaniesBranchesContactData::find()
                ->join('INNER JOIN', 'companies_branches', 'companies_branches.id_branch = companies_branches_contact_data.id_branch')
                ->where([
                    'companies_branches.id_company' => $idCompany, 
                    'companies_branches_contact_data.data_value' => $email, 
                    'companies_branches_contact_data.data_type' => \common\models\types\ContactDataType::EMAIL
                ])
                ->all();
        
        $emailsFromCompanyDepartmentsContactData = \common\models\CompaniesDepartmentsContactData::find()
                ->join('INNER JOIN', 'companies_departments', 'companies_departments.id_department = companies_departments_contact_data.id_department')
                ->where([
                    'companies_departments.id_company' => $idCompany, 
                    'companies_departments_contact_data.data_value' => $email, 
                    'companies_departments_contact_data.data_type' => \common\models\types\ContactDataType::EMAIL
                ])
                ->all();
        
        $emailsFromCompanyEmployeesContactData = \common\models\CompaniesEmployeesContactData::find()
                ->join('INNER JOIN', 'companies_employees', 'companies_employees.id_employee = companies_employees_contact_data.id_employee')
                ->where([
                    'companies_employees.id_company' => $idCompany, 
                    'companies_employees_contact_data.data_value' => $email, 
                    'companies_employees_contact_data.data_type' => \common\models\types\ContactDataType::EMAIL
                ])
                ->all();
        
        return array_merge($emailsFromCompanyContactData, $emailsFromCompanyBranchesContactData, $emailsFromCompanyDepartmentsContactData, $emailsFromCompanyEmployeesContactData);
        
    }
}
Creat By MiNi SheLL
Email: jattceo@gmail.com