common/models/TaskModel.php - dev - v.bolshakov/AIEcosystem-Testing

common/models/TaskModel.php
368 строк12 KB
Developer
Initial commit
03 авг 2026, 17:43
03 авг 2026, 17:437433917
<?php

namespace common\models;

use common\behaviors\CloneBehavior;
use common\behaviors\DefaultBehavior;
use common\behaviors\PositionBehavior;
use common\helpers\AppHelper;
use common\helpers\GlossaryHelper;
use common\helpers\TextHelper;
use common\helpers\TmHelper;
use common\kdf\KModelStatus;
use common\kdf\KPromtFormat;
use common\models\link\LinkRequestGlossary;
use common\models\link\LinkTaskGlossary;
use common\models\tm\LinkRequestTm;
use common\models\tm\LinkTaskTm;
use common\models\tm\Tm;
use common\models\tm\TmTerm;
use Yii;
use yii\db\ActiveQuery;
use yii\helpers\ArrayHelper;
use yii\helpers\VarDumper;
use yii\web\ServerErrorHttpException;

/**
 * Таблица - задачи
 *
 * @property int $project_id
 * @property int $model_id
 * @property string $top_p
 * @property string $temperature
 * @property int $promt_id
 * @property int $promt_format_id
 * @property int $task_id
 * @property int $is_default
 * @property int $version
 * @property string $description
 * @property string $promt
 *
 * @author Dmitry E. Semenov <sde.tomsk@gmail.com>
 * @copyright Self (c) 2024-2025
 */
class TaskModel extends \common\models\base\BaseModel
{
    /**
     * {@inheritdoc}
     */
    public static function tableName()
    {
        return 'task_model';
    }

    /**
     * {@inheritdoc}
     */
    public function rules()
    {
        return ArrayHelper::merge(parent::rules(), [
            [['top_p', 'temperature'], 'default', 'value' => 0.0],
            [['is_default', 'version'], 'default', 'value' => 1],
            [['project_id'], 'default', 'value' => Project::DEFAULT_PROJECT],
            ['promt_format_id', 'default', 'value' => KPromtFormat::T_TEXT],
            [
                [
                    'project_id',
                    'model_id',
                    'task_id',
                    'is_default',
                    'version',
                    'promt_format_id'
                ],
                'required'
            ],
            [
                [
                    'project_id',
                    'top_p',
                    'temperature',
                    'is_default',
                    'version',
                    'promt_format_id',
                    'promt_id'
                ],
                'number'
            ],
            [['description'], 'string', 'max' => 500]
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function attributeLabels()
    {
        return ArrayHelper::merge(parent::attributeLabels(), [
            'task_id'         => Yii::t('app', 'Task'),
            'project_id'      => Yii::t('app', 'Project'),
            'model_id'        => Yii::t('app', 'Model'),
            'promt_format_id' => Yii::t('app', 'Promt type'),
            'top_p'           => Yii::t('app', 'Top P'),
            'temperature'     => Yii::t('app', 'Temperature'),
            'promt_id'        => Yii::t('app', 'Promt'),
            'is_default'      => Yii::t('app', 'Is default'),
            'version'         => Yii::t('app', 'Version'),
            'description'     => Yii::t('app', 'Description'),
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function behaviors()
    {
        return ArrayHelper::merge(parent::behaviors(), [
            'CloneBehavior'    => [
                'class'          => CloneBehavior::class,
                'parent_field'   => 'task_id',
                'default_values' => [
                    'version'    => null,
                    'is_default' => 1
                ],
            ],
            'DefaultBehavior'  => [
                'class' => DefaultBehavior::className(),
                'scope' => [
                    'task_id'
                ]
            ],
            'PositionBehavior' => [
                'class'             => PositionBehavior::className(),
                'positionAttribute' => 'version',
                'scopeQuery'        => function ($query) {
                    return self::find()
                        ->andWhere(['task_id' => $this->task_id]);
                },
            ],
        ]);
    }

    /**
     * @return ActiveQuery
     */
    public function getModel()
    {
        return $this->hasOne(ModelAI::class, ['id' => 'model_id']);
    }

    /**
     * @return ActiveQuery
     */
    public function getTask()
    {
        return $this->hasOne(Task::class, ['id' => 'task_id']);
    }

    /**
     * @return ActiveQuery
     */
    public function getProject()
    {
        return $this->hasOne(Project::class, ['id' => 'project_id']);
    }

    /**
     * Получить промт
     * @return string|null
     */
    public function getPromt()
    {
        return TextSegment::getText($this->promt_id);
    }

    /**
     * @return ActiveQuery
     */
    public function getPromtSement()
    {
        return $this->hasOne(TextSegment::class, ['id' => 'promt_id']);
    }

    /**
     * @return ActiveQuery
     */
    public function getPromtFormat()
    {
        return $this->hasOne(KPromtFormat::class, ['id' => 'promt_format_id']);
    }

    /**
     * @inheritdoc
     */
    public function afterSave($insert, $changedAttributes)
    {
        parent::afterSave($insert, $changedAttributes); // TODO: Change the autogenerated stub

        if ($this->is_default) {

            $is_default = TaskDefault::find()
                ->andWhere([
                    'task_id' => $this->task_id
                ])
                ->exists();

            if ($is_default) {
                $ct_list = ClonedTask::find()
                    ->select('cloned_task_id')
                    ->innerJoin(['t' => Task::tableName()], 't.id = cloned_task_id')
                    ->andWhere([
                        't.rec_status' => KModelStatus::PUBLISHED,
                        'task_id'      => $this->task_id
                    ]);

                $updated = TaskModel::updateAll([
                    'project_id'      => $this->project_id,
                    'model_id'        => $this->model_id,
                    'top_p'           => $this->top_p,
                    'temperature'     => $this->temperature,
                    'promt_format_id' => $this->promt_format_id,
                    'promt_id'        => $this->promt_id
                ], [
                    'task_id' => $ct_list
                ]);

                Yii::debug(VarDumper::dumpAsString([
                    'updated' => $updated
                ]));
            }
        }
    }

    /**
     * Получить доп параметры
     *
     * @param Request $r
     * @return array
     */
    public function getOptions(Request $r)
    {
        $replace = [];
        $replace['{source_lang}'] = $r->sourceLanguage->title;
        $replace['{target_lang}'] = $r->targetLanguage->title;
        $replace['{subject_area}'] = $r->subjectArea->title;

        $input_text = $r->getText();
        $word_count = TextHelper::countWordsWithFilter($input_text);

        /** @var ModelAI $modelAI */
        $modelAI = $this->model;
        $promt_template = $this->promt;

        if (false !== strpos($promt_template, '{glossary_terms}')) {
            $glossary_terms = '';
            AppHelper::log('use glossary_terms...');

            /** @var LinkTaskGlossary $link */
            $link = LinkTaskGlossary::find()
                ->andWhere([
                    'task_id' => $this->task_id
                ])
                ->one();

            if ($link) {
                $a = Glossary::getAlias();
                $g = Glossary::find()
                    ->alias($a)
                    ->andWhere([
                        $a . '.id' => $link->glossary_id
                    ])
                    ->published()
                    ->one();

                if ($g) {
                    $data = GlossaryHelper::doAnalysis($input_text, $g);
                    if ($data['is_ok']) {
                        LinkRequestGlossary::deleteAll(['request_id' => $r->id]);
                        foreach ($data['raw'] as $row) {
                            if ($row['score'] >= $link->passing_score) {
                                $l = LinkRequestGlossary::findOrNew([
                                    'request_id' => $r->id,
                                    'term_id'    => $row['id'],
                                ]);
                                $l->score = $row['score'];
                                if (!$l->save()) {
                                    Yii::debug(VarDumper::dumpAsString([
                                        'errors' => $l->errors
                                    ]));
                                    throw new ServerErrorHttpException(Yii::t('app', 'Error analysis glossary'));
                                }
                            }
                        }
                        $data = GlossaryTerm::find()
                            ->select([
                                'term'        => 'term',
                                'translation' => 'translation'
                            ])
                            ->prepareRequest($r->id)
                            ->asArray()
                            ->all();

                        $glossary_terms = GlossaryHelper::toJsonl($data);
                    }
                }
            }
            $replace['{glossary_terms}'] = $glossary_terms;
        }

        if (false !== strpos($promt_template, '{tm}')) {
            AppHelper::log('use tm...');

            $tm_segments = '';
            /** @var LinkTaskTm $link */
            $link = LinkTaskTm::find()
                ->andWhere([
                    'task_id' => $this->task_id
                ])
                ->one();
            if ($link) {
                $a = Tm::getAlias();
                /** @var Tm $tm */
                $tm = Tm::find()
                    ->alias($a)
                    ->andWhere([
                        $a . '.id' => $link->tm_id
                    ])
                    ->published()
                    ->one();

                if ($tm) {
                    $data = TmHelper::doAnalysis($r->getText(PHP_EOL), $tm);
                    if ($data['is_ok']) {
                        LinkRequestTm::deleteAll(['request_id' => $r->id]);
                        foreach ($data['raw'] as $row) {
                            if ($row['score'] >= $link->passing_score) {
                                $l = LinkRequestTm::findOrNew([
                                    'request_id' => $r->id,
                                    'tm_term_id' => $row['id'],
                                ]);
                                $l->score = $row['score'];
                                if (!$l->save()) {
                                    Yii::debug(VarDumper::dumpAsString([
                                        'errors' => $l->errors
                                    ]));
                                    throw new ServerErrorHttpException(Yii::t('app', 'Error analysis glossary'));
                                }
                            }
                        }
                        $tm_segments = $tm->toJsonl($r->id);
                    }
                }
            }
            $replace['{tm}'] = $tm_segments;
        }

        $promt = str_replace(array_keys($replace), array_values($replace), $promt_template);

        return [
            'project_id'      => $this->project_id,
            'modelUid'        => $modelAI->guid,
            'temperature'     => $this->temperature,
            'top_p'           => $this->top_p,
            'promt_format_id' => $this->promt_format_id,
            'promt_template'  => $promt_template,
            'promt'           => $promt,
            'word_count'      => $word_count
        ];
    }
}