Devil Killer Is Here MiNi Shell
MiNi SheLL

Current Path : /home/vmanager/www/backend/controllers/
Linux 9dbcd5f6333d 5.15.0-153-generic #163-Ubuntu SMP Thu Aug 7 16:37:18 UTC 2025 x86_64
Current File : //home/vmanager/www/backend/controllers/ImagesopenaiController.php
<?php

namespace backend\controllers;

use Yii;
use common\models\TasksGeneratingImages;
use common\models\types\TaskOpenAIImagePurpose;
use backend\models\TasksGeneratingImagesSearch;
use yii\web\Controller;
use yii\web\NotFoundHttpException;
use yii\web\UploadedFile;
use yii\filters\AccessControl;

/**
 * ImagesopenaiController implements the CRUD actions for TasksGeneratingImages model.
 */
class ImagesopenaiController extends Controller
{
    use \backend\components\traits\OpenAITasksFunctions;
    
    /**
     * @inheritdoc
     */
    public function behaviors()
    {
        return [
            'access' => [
                'class' => AccessControl::className(),
                'rules' => [
                    ['allow' => true, 'actions' => ['index'], 'roles' => ['indexTasksGeneratingImages']],
                    ['allow' => true, 'actions' => ['view', 'show-image'], 'roles' => ['viewTasksGeneratingImages']],
                    [
                        'allow' => true, 
                        'actions' => [
                            'create', 'update', 'items-list', 'get-item-data', 'run-now', 'set-as-waiting', 'delete-image'
                        ], 
                        'roles' => ['modifyTasksGeneratingImages']
                    ],
                    ['allow' => true, 'actions' => ['delete'], 'roles' => ['deleteTasksGeneratingImages']],
                ]
            ]
        ];
    }
    
    /**
     * @inheritdoc
     */
    public function actions()
    {
        return [
            'set-as-waiting' => [
                'class' => '\backend\controllers\actions\SetTaskOpenAIAsWaitingAction',
                'modelClass' => '\common\models\TasksGeneratingImages',
                'additionalFields' => ['output_image']
            ],
        ];
    }

    /**
     * Lists all TasksGeneratingImages models.
     * @return mixed
     */
    public function actionIndex()
    {            
        $searchModel = new TasksGeneratingImagesSearch();
        $dataProvider = $searchModel->search(Yii::$app->request->queryParams);
              
        if($searchModel->purpose === \common\models\types\TaskOpenAIImagePurpose::ARTICLE_MAIN_IMAGE) {
            Yii::$app->params['activeMenuItem'] = 'images-open-ai-for-articles';
        } elseif($searchModel->purpose === \common\models\types\TaskOpenAIImagePurpose::PRODUCT_MAIN_IMAGE) {
            Yii::$app->params['activeMenuItem'] = 'images-open-ai-for-products';
        }

        return $this->render('index', [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }

    /**
     * Displays a single TasksGeneratingImages model.
     * @param string $id
     * @return mixed
     */
    public function actionView($id)
    {
        $model = $this->findModel($id);
        
        if($model->purpose === TaskOpenAIImagePurpose::ARTICLE_MAIN_IMAGE) {
            Yii::$app->params['activeMenuItem'] = 'images-open-ai-for-articles';
        } elseif($model->purpose === TaskOpenAIImagePurpose::PRODUCT_MAIN_IMAGE) { 
            Yii::$app->params['activeMenuItem'] = 'images-open-ai-for-products';
        } 
        
        return $this->render('view', [
            'model' => $model,
        ]);
    }

    /**
     * Creates a new TasksGeneratingImages model.
     * If creation is successful, the browser will be redirected to the 'view' page.
     * @return mixed
     */
    public function actionCreate()
    {     
        $model = new TasksGeneratingImages();
        $model->status = \common\models\types\TaskOpenAIStatus::WAITING;
        $model->dimensions = TasksGeneratingImages::getAvailableDimensions()[0];
        $model->quality = \common\models\types\TaskOpenAIImageQuality::MEDIUM;
        $model->compression = 80;

        if(Yii::$app->request->get('purpose') === \common\models\types\TaskOpenAIImagePurpose::ARTICLE_MAIN_IMAGE) {
            $model->purpose = \common\models\types\TaskOpenAIImagePurpose::ARTICLE_MAIN_IMAGE;
            Yii::$app->params['activeMenuItem'] = 'images-open-ai-for-articles';
        } elseif(Yii::$app->request->get('purpose') === \common\models\types\TaskOpenAIImagePurpose::PRODUCT_MAIN_IMAGE) {
            $model->purpose = \common\models\types\TaskOpenAIImagePurpose::PRODUCT_MAIN_IMAGE;
            Yii::$app->params['activeMenuItem'] = 'images-open-ai-for-products';
        }
        
        $outputParams = [
            'model' => $model,
            'orDisabledPurpose' => !empty($model->purpose)
        ]; 
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $model->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($model, ['id_item', 'emails']);
        }
        
        if(Yii::$app->request->getIsPost()) {            
            if(!$model->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('create', $outputParams);
            }
            $model->uploadedImages = UploadedFile::getInstances($model, 'uploadedImages');
            
            $model->status = \common\models\types\TaskOpenAIStatus::WAITING;
                     
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('create', $outputParams);
            }
            
            if($model->save(false)) {
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['view', 'id' => $model->_id]);
            } else {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));
            }
        }
        
        return $this->render('create', $outputParams);
    }
    
    /**
     * Updates an existing TasksGeneratingImages model.
     * If update is successful, the browser will be redirected to the 'view' page.
     * @param string $id
     * @return mixed
     */
    public function actionUpdate($id)
    {     
        $model = $this->findModel($id);
        
        if($model->purpose === TaskOpenAIImagePurpose::ARTICLE_MAIN_IMAGE) {
            $itemName = $this->getArticleTitle($model->id_item);
            Yii::$app->params['activeMenuItem'] = 'images-open-ai-for-articles';
        } elseif($model->purpose === TaskOpenAIImagePurpose::PRODUCT_MAIN_IMAGE) { 
            $itemName = $this->getProductName($model->id_item);
            Yii::$app->params['activeMenuItem'] = 'images-open-ai-for-products';
        } else {
            $itemName = null;
        } 
        
        $outputParams = [
            'model' => $model,
            'itemName' => $itemName,
            'orDisabledPurpose' => !empty($model->purpose)
        ]; 
        
        if (Yii::$app->request->isAjax && !Yii::$app->request->isPjax && $model->load(Yii::$app->request->post())) {
            Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
            return \yii\bootstrap\ActiveForm::validate($model, ['id_item', 'emails']);
        }
        
        if(Yii::$app->request->getIsPost()) { 
            $oldStatus = $model->status;
            if(!$model->load(Yii::$app->request->post())) {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd podczas przesyłania danych.'));
                return $this->render('update', $outputParams);
            }
            $model->uploadedImages = UploadedFile::getInstances($model, 'uploadedImages');
            
            if($oldStatus !== \common\models\types\TaskOpenAIStatus::WAITING && $model->status === \common\models\types\TaskOpenAIStatus::WAITING) {
                $model->error_message = null;
                $model->parsed_command = null;
                $model->raw_response = null;
            }
            
            if($oldStatus === \common\models\types\TaskOpenAIStatus::UNUSED && $model->status === \common\models\types\TaskOpenAIStatus::WAITING && !empty($model->output_image)) {
                $model->images = !empty($model->images) ? array_merge($model->images, [$model->output_image]) : [$model->output_image]; 
                $model->output_image = null;
            }
                     
            if(!$model->validate()) {
                Yii::$app->session->addFlash('error', $model->getErrors());
                return $this->render('update', $outputParams);
            }
            
            if($model->save(false)) {
                Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie zapisano dane.')); 
                return $this->redirect(['update', 'id' => $model->_id]);
            } else {
                Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas zapisu.'));
            }
        }
        
        return $this->render('update', $outputParams);
    }
    
    /**
     * Deletes an existing TasksGeneratingImages model.
     * If deletion is successful, the browser will be redirected to the 'index' page.
     * @param string $id
     * @return mixed
     */
    public function actionDelete($id)
    {
        $model = $this->findModel($id); 
                
        if($model->delete() !== false) {
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie usunięto dane.'));
        } else {
            Yii::$app->session->addFlash('error', Yii::t('backend', 'Błąd podczas usuwania danych.'));
        }        
        
        return $this->redirect(['index', 'TasksGeneratingImagesSearch[purpose]' => !empty($model->purpose) ? $model->purpose : null]);
    }
    
    public function actionGetItemData() 
    {         
        Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
        $this->layout = false;        
        
        $id = (int)Yii::$app->request->get('id');
        if(!$id) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
        
        $purpose = Yii::$app->request->get('purpose');
        if($purpose === TaskOpenAIImagePurpose::ARTICLE_MAIN_IMAGE) {
            $name = \common\models\Articles::find()->select(['title'])->where(['id_article' => $id])->scalar();
        } elseif($purpose === TaskOpenAIImagePurpose::PRODUCT_MAIN_IMAGE) { 
            $name = \common\models\Products::find()->select(['name'])->where(['id_product' => $id])->scalar();
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }  
                
        return [
            'name' => $name
        ];
    }

    /**
     * Finds the TasksGeneratingImages model based on its primary key value.
     * If the model is not found, a 404 HTTP exception will be thrown.
     * @param string $id
     * @return TasksGeneratingArticles the loaded model
     * @throws NotFoundHttpException if the model cannot be found
     */
    protected function findModel($id)
    {
        if (($model = TasksGeneratingImages::findOne((string)$id)) !== null) {
            return $model;
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
    }
    
    public function actionItemsList()
    {   
        $purpose = Yii::$app->request->get('purpose');
        
        $queryParams = Yii::$app->request->queryParams;
        
        if($purpose === TaskOpenAIImagePurpose::ARTICLE_MAIN_IMAGE) {
            $searchModel = new \backend\models\ArticlesSearch();
            $viewName = 'articles_list';
        } elseif($purpose === TaskOpenAIImagePurpose::PRODUCT_MAIN_IMAGE) { 
            $searchModel = new \backend\models\ProductsSearch();
            $viewName = 'products_list';
        } else {
            throw new NotFoundHttpException('The requested page does not exist.');
        }        
        
        $dataProvider = $searchModel->search($queryParams);

        return $this->renderAjax($viewName, [
            'searchModel' => $searchModel,
            'dataProvider' => $dataProvider,
        ]);
    }
    
    public function actionShowImage($id)
    {
        $idImage = Yii::$app->request->get('id_image');
        $orSource = !!(int)Yii::$app->request->get('or_source');
        $outputWidth = (int)Yii::$app->request->get('width');
        $orDownload = !!(int)Yii::$app->request->get('or_download');
        if(!$idImage) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }
        
        $model = $this->findModel($id); 
        $selectedImage = null;
        if($orSource) {
            foreach($model->images as $image) {
                if($image['id'] === $idImage) {
                    $selectedImage = $image;
                    break;
                }
            }
        } elseif(!empty($model->output_image) && $model->output_image['id'] === $idImage) {
            $selectedImage = $model->output_image;
        }
        
        if(!$selectedImage) {
            throw new NotFoundHttpException('The requested page does not exist.');
        }

        if(!empty($outputWidth)) {
            $image = \yii\imagine\Image::getImagine()->load($selectedImage['data']);
            $size = $image->getSize();
            $outputHeight = (int)round($size->getHeight() * $outputWidth / $size->getWidth());
            $image->resize(new \Imagine\Image\Box($outputWidth, $outputHeight));
            $data = $image->get(ltrim($selectedImage['contentType'], 'image/'));
        } else {
            $data = $selectedImage['data'];
        }
        
        return Yii::$app->response->sendContentAsFile(
            $data,
            $selectedImage['filename'],
            [
                'mimeType' => $selectedImage['contentType'],
                'inline' => !$orDownload,
            ]
        );
    }
    
    public function actionDeleteImage()
    {
        Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
        $this->layout = false;

        $idTask = Yii::$app->request->post('id_task');
        $idImage = Yii::$app->request->post('id_image');
        
        $model = $this->findModel($idTask);

        if(empty($model->images)) {
            return ['success' => true];
        }
        
        $images = $model->images;
        foreach($images as $key => $image) {
            if($image['id'] === $idImage) {
                unset($images[$key]);
                break;
            }
        }        
        $model->images = array_values($images);

        if($model->save(false)) {
            return ['success' => true];
        }

        return [
            'success' => false,
            'error' => 'Nie udało się usunąć zdjęcia.',
        ];
    }

    
    public function actionRunNow($id)
    {
        $modelTask = $this->findModel($id);

        if($modelTask->status !== \common\models\types\TaskOpenAIStatus::WAITING) {
            Yii::$app->session->addFlash('warning', Yii::t('backend', 'Nie można wykonać żądanej akcji.'));
            return $this->redirect(['view', 'id' => $modelTask->_id]); 
        }
        
        exec('php ../../yii open-ai/generate-image --idTask='.(string)$modelTask->_id, $output, $resultCode);
        
        if($resultCode === 0) {
            Yii::$app->session->addFlash('confirm', Yii::t('backend', 'Poprawnie wykonano zadanie.')); 
        } else {
            Yii::$app->session->addFlash('error', Yii::t('backend', 'Wystąpił błąd: {error}', ['error' => array_pop($output)]));
        }
        
        return $this->redirect(['view', 'id' => (string)$modelTask->_id]);        
    }
    
}
Creat By MiNi SheLL
Email: jattceo@gmail.com