2351 lines
102 KiB
PHP
Executable File
2351 lines
102 KiB
PHP
Executable File
<?php
|
||
|
||
namespace common\components\dictionaryManager;
|
||
|
||
use backend\models\applicationTypeHistory\ApplicationTypeHistory;
|
||
use backend\models\RBACAuthAssignment;
|
||
use Closure;
|
||
use common\components\AdmissionCampaignDictionaryManager\AdmissionCampaignDictionaryManager;
|
||
use common\components\AppUpdate;
|
||
use common\components\BooleanCaster;
|
||
use common\components\dictionaryManager\GetReferencesManager\GetContractorListManager;
|
||
use common\components\dictionaryManager\GetReferencesManager\GetReferencesManager;
|
||
use common\components\helpers\TableCreateHelper;
|
||
use common\components\PageRelationManager;
|
||
use common\components\ReferenceTypeManager\ContractorManager;
|
||
use common\components\ReferenceTypeManager\ReferenceTypeManager;
|
||
use common\components\soapException;
|
||
use common\models\AttachmentType;
|
||
use common\models\DebuggingSoap;
|
||
use common\models\dictionary\AdmissionBase;
|
||
use common\models\dictionary\AdmissionCategory;
|
||
use common\models\dictionary\AdmissionProcedure;
|
||
use common\models\dictionary\AvailableDocumentTypesForConcession;
|
||
use common\models\dictionary\BudgetLevel;
|
||
use common\models\dictionary\Contractor;
|
||
use common\models\dictionary\Country;
|
||
use common\models\dictionary\DictionaryCompetitiveGroupEntranceTest;
|
||
use common\models\dictionary\DictionaryDateTimeOfExamsSchedule;
|
||
use common\models\dictionary\DictionaryPredmetOfExamsSchedule;
|
||
use common\models\dictionary\DictionaryReasonForExam;
|
||
use common\models\dictionary\DocumentShipment;
|
||
use common\models\dictionary\DocumentType;
|
||
use common\models\dictionary\DocumentTypeAttributeSetting;
|
||
use common\models\dictionary\DocumentTypePropertiesSetting;
|
||
use common\models\dictionary\EducationDataFilter;
|
||
use common\models\dictionary\EducationType;
|
||
use common\models\dictionary\FamilyType;
|
||
use common\models\dictionary\ForeignLanguage;
|
||
use common\models\dictionary\Gender;
|
||
use common\models\dictionary\IndividualAchievementType;
|
||
use common\models\dictionary\Olympiad;
|
||
use common\models\dictionary\OlympiadFilter;
|
||
use common\models\dictionary\OwnageForm;
|
||
use common\models\dictionary\Privilege;
|
||
use common\models\dictionary\Speciality;
|
||
use common\models\dictionary\SpecialMark;
|
||
use common\models\dictionary\StoredReferenceType\SpecialRequirementReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredAdmissionCampaignReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredAvailableDocumentTypeFilterReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredCompetitiveGroupReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredContractorReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredCurriculumReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredDetailGroupReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredDisciplineFormReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredDisciplineReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredDocumentCheckStatusReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredDocumentSetReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredEducationFormReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredEducationLevelReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredEducationSourceReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredOlympicClassReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredOlympicKindReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredOlympicLevelReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredOlympicProfileReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredOlympicTypeReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredProfileReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredSubjectSetReferenceType;
|
||
use common\models\dictionary\StoredReferenceType\StoredVariantOfRetestReferenceType;
|
||
use common\models\EmptyCheck;
|
||
use common\models\errors\RecordNotValid;
|
||
use common\models\IndividualAchievementDocumentType;
|
||
use common\models\interfaces\IFillableReferenceDictionary;
|
||
use common\models\managers\BatchMaker;
|
||
use common\models\settings\CodeSetting;
|
||
use common\models\ToAssocCaster;
|
||
use common\models\User;
|
||
use common\modules\abiturient\models\AdditionalReceiptDateControl;
|
||
use common\modules\abiturient\models\bachelor\AdmissionAgreement;
|
||
use common\modules\abiturient\models\bachelor\AdmissionCampaign;
|
||
use common\modules\abiturient\models\bachelor\AgreementCondition;
|
||
use common\modules\abiturient\models\bachelor\ApplicationType;
|
||
use common\modules\abiturient\models\bachelor\BachelorPreferences;
|
||
use common\modules\abiturient\models\bachelor\CampaignInfo;
|
||
use common\modules\abiturient\models\bachelor\CgetChildSubject;
|
||
use common\modules\abiturient\models\bachelor\CgetEntranceTest;
|
||
use common\modules\abiturient\models\bachelor\CgetEntranceTestSet;
|
||
use common\modules\abiturient\models\bachelor\CgetRequiredPreference;
|
||
use common\modules\abiturient\models\PersonalData;
|
||
use League\CLImate\TerminalObject\Dynamic\Progress;
|
||
use Throwable;
|
||
use Yii;
|
||
use yii\base\Component;
|
||
use yii\db\Schema;
|
||
use yii\helpers\ArrayHelper;
|
||
use yii\helpers\VarDumper;
|
||
|
||
class dictionaryManager extends Component
|
||
{
|
||
private function getSuccessAnswer()
|
||
{
|
||
return [1, []];
|
||
}
|
||
|
||
public function loadSpecialMarks(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$response = GetReferencesManager::getReferences(SpecialMark::getReferenceClassName());
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if (empty($response->getReferences())) {
|
||
return [0, []];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = iterator_count($response->getReferences());
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_special_mark_ids = [];
|
||
foreach ($response->getReferences() as $I => $reference) {
|
||
if ($progress) {
|
||
$progress->current($I + 1);
|
||
}
|
||
$touched_special_mark_ids[] = ReferenceTypeManager::GetOrCreateReference(SpecialMark::class, $reference)->id;
|
||
}
|
||
SpecialMark::updateAll(['archive' => true], ['not', ['id' => $touched_special_mark_ids]]);
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadGender(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$response = GetReferencesManager::getReferences(Gender::getReferenceClassName());
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if (empty($response->getReferences())) {
|
||
return [0, []];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = iterator_count($response->getReferences());
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_gender_ids = [];
|
||
foreach ($response->getReferences() as $I => $reference) {
|
||
if ($progress) {
|
||
$progress->current($I + 1);
|
||
}
|
||
|
||
$touched_gender_ids[] = ReferenceTypeManager::GetOrCreateReference(Gender::class, $reference)->id;
|
||
}
|
||
Gender::updateAll(
|
||
['archive' => true],
|
||
['not', ['id' => $touched_gender_ids]]
|
||
);
|
||
|
||
$query = PersonalData::find()
|
||
->where(['gender_id' => null])
|
||
->andWhere(['not', ['gender' => null]]);
|
||
if ($query->exists()) {
|
||
foreach ($query->all() as $I => $item) {
|
||
$gen = Gender::findOne([
|
||
'code' => $item->gender,
|
||
'archive' => false
|
||
]);
|
||
|
||
if ($gen !== null) {
|
||
$item->gender_id = $gen->id;
|
||
$item->updateAttributes(['gender_id']);
|
||
$profile = ArrayHelper::getValue($item, 'abiturientQuestionary.user.userProfile');
|
||
if ($profile !== null) {
|
||
$profile->gender_id = $gen->id;
|
||
$profile->updateAttributes(['gender_id']);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadAdmissionFeatures(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredDetailGroupReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadIndividualAchievement(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetAllIndividualExams', [], DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled);
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if ($result === false) {
|
||
return [0, []];
|
||
}
|
||
|
||
if (isset($result->return->UniversalResponse->Complete) && $result->return->UniversalResponse->Complete == '0') {
|
||
Yii::error('Ошибка при выполнении метода GetAllIndividualExams: ' . $result->return->UniversalResponse->Description . ' ' . PHP_EOL . print_r($result, true));
|
||
return [0, []];
|
||
}
|
||
|
||
if (!isset($result->return->Predmet)) {
|
||
return [0, []];
|
||
}
|
||
|
||
if (is_array($result->return->Predmet) && !$result->return->Predmet) {
|
||
return [0, []];
|
||
}
|
||
|
||
$cache_storage = [];
|
||
|
||
|
||
if (!is_array($result->return->Predmet)) {
|
||
$result->return->Predmet = [$result->return->Predmet];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($result->return->Predmet);
|
||
$progress->total($progressCount);
|
||
}
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
|
||
try {
|
||
$touched_ia_type_ids = [];
|
||
|
||
foreach ($result->return->Predmet as $I => $ind_arch) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$ind_arch->Code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$ind_arch,
|
||
'SubjectRef',
|
||
'ReferenceId',
|
||
'Code'
|
||
);
|
||
$ind_arch->Name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$ind_arch,
|
||
'SubjectRef',
|
||
'ReferenceName',
|
||
'Name'
|
||
);
|
||
$ind_arch->IdPK = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$ind_arch,
|
||
'CampaignRef',
|
||
'ReferenceId',
|
||
'IdPK'
|
||
);
|
||
$individual_achievement = IndividualAchievementType::find()
|
||
->where([
|
||
'code' => (string)$ind_arch->Code,
|
||
'campaign_code' => (string)$ind_arch->IdPK,
|
||
]);
|
||
$curriculumRefId = ReferenceTypeManager::GetOrCreateReferenceIdWithCaching(StoredCurriculumReferenceType::class, $ind_arch->CurriculumRef, $cache_storage);
|
||
if (isset($curriculumRefId)) {
|
||
$individual_achievement = $individual_achievement
|
||
->andWhere(['ach_curriculum_ref_id' => $curriculumRefId]);
|
||
}
|
||
$individual_achievement = $individual_achievement->one();
|
||
|
||
if ($individual_achievement == null) {
|
||
$individual_achievement = new IndividualAchievementType();
|
||
}
|
||
$individual_achievement->scenario = IndividualAchievementType::$SCENARIO_WITHOUT_EXISTS_CHECK;
|
||
|
||
$individual_achievement->archive = false;
|
||
$individual_achievement->code = (string)$ind_arch->Code;
|
||
$individual_achievement->campaign_code = (string)$ind_arch->IdPK;
|
||
$individual_achievement->name = (string)$ind_arch->Name;
|
||
$individual_achievement->points_in_group_are_awarded_once = BooleanCaster::cast($ind_arch->PointsInGroupAreAwardedOnce ?? false);
|
||
$individual_achievement->loadRefKeysWithCaching($ind_arch, true, $cache_storage);
|
||
if (isset($curriculumRefId)) {
|
||
$individual_achievement->ach_curriculum_ref_id = $curriculumRefId;
|
||
}
|
||
|
||
if ($individual_achievement->validate()) {
|
||
$individual_achievement->save(false);
|
||
$touched_ia_type_ids[] = $individual_achievement->id;
|
||
} else {
|
||
throw new RecordNotValid($individual_achievement);
|
||
}
|
||
}
|
||
IndividualAchievementType::updateAll(['archive' => true], ['not', ['id' => $touched_ia_type_ids]]);
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadForeignLanguages(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$response = GetReferencesManager::getReferences(ForeignLanguage::getReferenceClassName());
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if (empty($response->getReferences())) {
|
||
return [0, []];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = iterator_count($response->getReferences());
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
|
||
try {
|
||
$touched_foreign_language_ids = [];
|
||
foreach ($response->getReferences() as $I => $reference) {
|
||
if ($progress) {
|
||
$progress->current($I + 1);
|
||
}
|
||
$touched_foreign_language_ids[] = ReferenceTypeManager::GetOrCreateReference(ForeignLanguage::class, $reference)->id;
|
||
}
|
||
ForeignLanguage::updateAll(['archive' => true], ['not', ['id' => $touched_foreign_language_ids]]);
|
||
|
||
|
||
$query = PersonalData::find()->where(['language_id' => null])->andWhere([
|
||
'not', ['language_code' => null]
|
||
]);
|
||
if ($query->exists()) {
|
||
foreach ($query->all() as $item) {
|
||
|
||
$lang = ForeignLanguage::findOne([
|
||
'code' => $item->language_code,
|
||
'archive' => false
|
||
]);
|
||
|
||
if ($lang) {
|
||
$item->language_id = $lang->id;
|
||
$item->updateAttributes(['language_id']);
|
||
}
|
||
}
|
||
}
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadEducationTypes(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$responses = GetReferencesManager::getReferences(EducationType::getReferenceClassName());
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
$references = $responses->getReferences();
|
||
|
||
if (empty($references)) {
|
||
return [0, []];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$references = iterator_to_array($references);
|
||
$progressCount = count($references);
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_edu_type_ids = [];
|
||
|
||
foreach ($references as $I => $reference) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$touched_edu_type_ids[] = ReferenceTypeManager::GetOrCreateReference(EducationType::class, $reference)->id;
|
||
}
|
||
EducationType::updateAll(['archive' => true], ['not', ['id' => $touched_edu_type_ids]]);
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
protected function getGetEntrantTestSetsGenerator()
|
||
{
|
||
foreach ($this->runMethodWithBatchLoad('GetEntrantTestSets') as $I => $result) {
|
||
if ($result && isset($result->return) && isset($result->return->CompetitiveGroupEntranceTest)) {
|
||
if (!is_array($result->return->CompetitiveGroupEntranceTest)) {
|
||
$result->return->CompetitiveGroupEntranceTest = [$result->return->CompetitiveGroupEntranceTest];
|
||
}
|
||
foreach ($result->return->CompetitiveGroupEntranceTest as $I => $item) {
|
||
yield $item;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
public function loadDictionaryCompetitiveGroupEntranceTests(?Progress $progress = null)
|
||
{
|
||
return (new dictionaryManagerDictionaryCompetitiveGroupEntranceTests)->loadDictionary($progress);
|
||
}
|
||
|
||
public function GetInterfaceVersion(string $method_name): ?string
|
||
{
|
||
$soapManager = \Yii::$app->soapClientAbit;
|
||
if (in_array($method_name, ['PostEntrantPackage', 'GetEntrantProfilePackage', 'GetEntrantPackage', 'PostFilesList', 'GetFilesList'])) {
|
||
$soapManager = \Yii::$app->soapClientWebApplication;
|
||
}
|
||
return Yii::$app->cache->getOrSet('GetInterfaceVersion' . $method_name, function () use ($soapManager, $method_name) {
|
||
try {
|
||
$response = $soapManager->load_with_caching('GetInterfaceVersion', [
|
||
'Name' => $method_name
|
||
]);
|
||
return $response->return;
|
||
} catch (Throwable $e) {
|
||
\Yii::error("Не удалось получить версию метода {$method_name}: {$e->getMessage()}");
|
||
}
|
||
return '0.0.0.0';
|
||
}, 3600);
|
||
}
|
||
|
||
|
||
|
||
|
||
public function fetchSpecialities()
|
||
{
|
||
foreach ($this->runMethodWithBatchLoad('GetStringsPriema') as $result) {
|
||
if ($result && $result->return) {
|
||
if (isset($result->return->StringsPlanPriema) && isset($result->return->StringsPlanPriema->StringPlanPriema)) {
|
||
if (!is_array($result->return->StringsPlanPriema->StringPlanPriema)) {
|
||
$result->return->StringsPlanPriema->StringPlanPriema = [$result->return->StringsPlanPriema->StringPlanPriema];
|
||
}
|
||
foreach ($result->return->StringsPlanPriema->StringPlanPriema as $item) {
|
||
yield $item;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
public function loadSpecialities(?Progress $progress = null)
|
||
{
|
||
$StringsPlanPriema = $this->fetchSpecialities();
|
||
|
||
$refCacheList = [];
|
||
$allRefsCacheList = [];
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$StringsPlanPriema = iterator_to_array($StringsPlanPriema);
|
||
$progressCount = count($StringsPlanPriema);
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
|
||
try {
|
||
$touched_speciality_ids = [];
|
||
foreach ($StringsPlanPriema as $I => $StringPlanPriema) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
$spec = Speciality::findOne(
|
||
ArrayHelper::merge([
|
||
'faculty_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'SubdivisionRef',
|
||
'ReferenceId',
|
||
'FacultetCode'
|
||
),
|
||
'speciality_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'DirectionRef',
|
||
'ReferenceId',
|
||
'SpecialityCode'
|
||
),
|
||
'profil_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'ProfileRef',
|
||
'ReferenceId',
|
||
'ProfilCode'
|
||
),
|
||
'edulevel_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationLevelRef',
|
||
'ReferenceId',
|
||
'EducationLevelCode'
|
||
),
|
||
'eduform_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationFormRef',
|
||
'ReferenceId',
|
||
'EducationFormCode'
|
||
),
|
||
'eduprogram_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationProgramRef',
|
||
'ReferenceId',
|
||
'EducationProgramCode'
|
||
),
|
||
'finance_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationSourceRef',
|
||
'ReferenceId',
|
||
'FinanceCode'
|
||
),
|
||
'group_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'CompetitiveGroupRef',
|
||
'ReferenceId',
|
||
'GroupCode'
|
||
),
|
||
'speciality_human_code' => (string)$StringPlanPriema->SpecialityCodeOKSO,
|
||
'campaign_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'CampaignRef',
|
||
'ReferenceId',
|
||
'IdPK'
|
||
),
|
||
'detail_group_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'DetailGroupRef',
|
||
'ReferenceId',
|
||
'DetailGroupCode'
|
||
),
|
||
'budget_level_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'LevelBudgetRef',
|
||
'ReferenceId',
|
||
'BudgetLevelCode'
|
||
),
|
||
'special_right' => (bool)$StringPlanPriema->SpecialRight,
|
||
], Speciality::getReferenceTypeSearchArray($StringPlanPriema, $refCacheList, $allRefsCacheList))
|
||
);
|
||
if (!$spec) {
|
||
$spec = new Speciality();
|
||
}
|
||
$spec->scenario = Speciality::$SCENARIO_WITHOUT_EXISTS_CHECK;
|
||
|
||
$spec->campaign_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'CampaignRef',
|
||
'ReferenceId',
|
||
'IdPK'
|
||
);
|
||
$spec->group_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'CompetitiveGroupRef',
|
||
'ReferenceName',
|
||
'GroupName'
|
||
);
|
||
$spec->group_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'CompetitiveGroupRef',
|
||
'ReferenceId',
|
||
'GroupCode'
|
||
);
|
||
$spec->profil_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'ProfileRef',
|
||
'ReferenceId',
|
||
'ProfilCode'
|
||
);
|
||
$spec->profil_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'ProfileRef',
|
||
'ReferenceName',
|
||
'ProfilName'
|
||
);
|
||
$spec->finance_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationSourceRef',
|
||
'ReferenceId',
|
||
'FinanceCode'
|
||
);
|
||
$spec->finance_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationSourceRef',
|
||
'ReferenceName',
|
||
'FinanceName'
|
||
);
|
||
$spec->faculty_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'SubdivisionRef',
|
||
'ReferenceId',
|
||
'FacultetCode'
|
||
);
|
||
$spec->faculty_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'SubdivisionRef',
|
||
'ReferenceName',
|
||
'FacultetName'
|
||
);
|
||
$spec->eduform_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationFormRef',
|
||
'ReferenceId',
|
||
'EducationFormCode'
|
||
);
|
||
$spec->eduform_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationFormRef',
|
||
'ReferenceName',
|
||
'EducationFormName'
|
||
);
|
||
$spec->speciality_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'DirectionRef',
|
||
'ReferenceId',
|
||
'SpecialityCode'
|
||
);
|
||
$spec->speciality_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'DirectionRef',
|
||
'ReferenceName',
|
||
'SpecialityName'
|
||
);
|
||
$spec->edulevel_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationLevelRef',
|
||
'ReferenceId',
|
||
'EducationLevelCode'
|
||
);
|
||
$spec->edulevel_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationLevelRef',
|
||
'ReferenceName',
|
||
'EducationLevelName'
|
||
);
|
||
$spec->detail_group_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'DetailGroupRef',
|
||
'ReferenceId',
|
||
'DetailGroupCode'
|
||
);
|
||
$spec->detail_group_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'DetailGroupRef',
|
||
'ReferenceName',
|
||
'DetailGroupName'
|
||
);
|
||
$spec->eduprogram_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationProgramRef',
|
||
'ReferenceId',
|
||
'EducationProgramCode'
|
||
);
|
||
$spec->eduprogram_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'EducationProgramRef',
|
||
'ReferenceName',
|
||
'EducationProgramName'
|
||
);
|
||
$spec->speciality_human_code = (string)$StringPlanPriema->SpecialityCodeOKSO;
|
||
$spec->budget_level_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'LevelBudgetRef',
|
||
'ReferenceId',
|
||
'BudgetLevelCode'
|
||
);
|
||
$spec->budget_level_name = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField(
|
||
$StringPlanPriema,
|
||
'LevelBudgetRef',
|
||
'ReferenceName',
|
||
'BudgetLevelName'
|
||
);
|
||
$spec->special_right = (bool)$StringPlanPriema->SpecialRight;
|
||
$spec->receipt_allowed = (bool)$StringPlanPriema->ReceiptAllow;
|
||
$spec->is_combined_competitive_group = (bool)$StringPlanPriema->CombinedCompetitiveGroup;
|
||
|
||
$spec->archive = false;
|
||
|
||
$spec->loadRefKeysWithCaching($StringPlanPriema, true, $refCacheList);
|
||
|
||
if (!$spec->save()) {
|
||
throw new RecordNotValid($spec);
|
||
}
|
||
$touched_speciality_ids[] = $spec->id;
|
||
unset($StringPlanPriema);
|
||
}
|
||
Speciality::updateAll(['archive' => true], ['not', ['id' => $touched_speciality_ids]]);
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
public function fetchAdmissionCampaigns(&$Campaigns)
|
||
{
|
||
try {
|
||
$result = AdmissionCampaignDictionaryManager::FetchAdmissionCampaign();
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if ($result === false) {
|
||
return [0, []];
|
||
}
|
||
|
||
if (isset($result->return->UniversalResponse->Complete) && $result->return->UniversalResponse->Complete == '0') {
|
||
Yii::error('Ошибка при выполнении метода GetPK: ' . $result->return->UniversalResponse->Description . ' ' . PHP_EOL . print_r($result, true));
|
||
return [0, []];
|
||
}
|
||
|
||
if (!isset($result->return->PK)) {
|
||
return [0, []];
|
||
}
|
||
|
||
if (is_array($result->return->PK) && !$result->return->PK) {
|
||
return [0, []];
|
||
}
|
||
|
||
$admissionCampaigns = $result->return->PK;
|
||
|
||
if (!is_array($admissionCampaigns)) {
|
||
$admissionCampaigns = [$admissionCampaigns];
|
||
}
|
||
|
||
$Campaigns = $admissionCampaigns;
|
||
|
||
return true;
|
||
}
|
||
|
||
public function loadAdmissionCampaigns(?Progress $progress = null)
|
||
{
|
||
$status = $this->fetchAdmissionCampaigns($admissionCampaignsFrom1C);
|
||
$progressCount = 0;
|
||
if ($progress && $admissionCampaignsFrom1C) {
|
||
$progressCount = count($admissionCampaignsFrom1C);
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
if ($status !== true) {
|
||
return $status;
|
||
}
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_record_ids = [];
|
||
|
||
foreach ($admissionCampaignsFrom1C as $I => $campaign) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$admission_campaign = AdmissionCampaignDictionaryManager::FindAdmissionCampaign($campaign);
|
||
|
||
if ($admission_campaign == null) {
|
||
$admission_campaign = new AdmissionCampaign();
|
||
}
|
||
$admission_campaign->code = (string)$campaign->IdPK;
|
||
$admission_campaign->api_token = (string)$campaign->CampaignToken;
|
||
$admission_campaign->archive = false;
|
||
$admission_campaign->name = (string)$campaign->Description;
|
||
$admission_campaign->reception_allowed = (int)$campaign->ReceptionAllowed;
|
||
$admission_campaign->limit_type = (string)$campaign->MaximalSpecialityType;
|
||
$admission_campaign->snils_is_required = (bool)$campaign->CheckSNILS;
|
||
$admission_campaign->max_speciality_count = (int)$campaign->MaximalSpeciality;
|
||
$admission_campaign->consents_allowed = (int)$campaign->AddModifyConsentsAllowed;
|
||
$admission_campaign->multiply_applications_allowed = (int)$campaign->IsAllowedMultipleApplicationsToOneGroup;
|
||
$admission_campaign->count_target_specs_separately = BooleanCaster::cast($campaign->CountAllDirectionsSeparatelyOnTargetQuotasRegardlessOfMultiprofileCompetition ?? false);
|
||
$admission_campaign->require_previous_passport = BooleanCaster::cast($campaign->RequirePreviousPassports ?? false);
|
||
$admission_campaign->allow_multiply_education_documents = BooleanCaster::cast($campaign->AllowMultiplyEducationDocuments ?? false);
|
||
$admission_campaign->common_education_document = BooleanCaster::cast($campaign->CommonEducationDocument ?? false);
|
||
$admission_campaign->separate_statement_for_full_payment_budget = BooleanCaster::cast($campaign->SeparateSpecialitiesForBudgetAndFullPayment ?? false);
|
||
$admission_campaign->use_common_agreements = BooleanCaster::cast($campaign->UseCommonAgreements ?? false);
|
||
|
||
if (!empty($campaign->CampaignRef)) {
|
||
$admission_campaign->loadRefKey($campaign->CampaignRef);
|
||
}
|
||
|
||
if (!$admission_campaign->save()) {
|
||
throw new RecordNotValid($admission_campaign);
|
||
}
|
||
|
||
$touched_record_ids[] = $admission_campaign->id;
|
||
|
||
if (isset($campaign->PriorityConditions)) {
|
||
$conditions = [];
|
||
if (is_array($campaign->PriorityConditions)) {
|
||
$conditions = $campaign->PriorityConditions;
|
||
} else {
|
||
if (isset($campaign->PriorityConditions->ConditionRef)) {
|
||
if (is_array($campaign->PriorityConditions->ConditionRef)) {
|
||
$conditions = $campaign->PriorityConditions->ConditionRef;
|
||
} else {
|
||
$conditions[] = $campaign->PriorityConditions->ConditionRef;
|
||
}
|
||
} else {
|
||
$conditions[] = $campaign->PriorityConditions;
|
||
}
|
||
}
|
||
$old_mode_names = ArrayHelper::getColumn($admission_campaign->specialityGroupingModes, 'code_name');
|
||
$needs_reset_priorities = false;
|
||
foreach ($conditions as $condition) {
|
||
$conditionRef = $condition;
|
||
if (isset($condition->ConditionRef)) {
|
||
$conditionRef = $condition->ConditionRef;
|
||
}
|
||
$code_name = (string)$conditionRef->PredefinedDataName ?? null;
|
||
$description = (string)$conditionRef->ReferenceName ?? null;
|
||
if ($code_name && $description) {
|
||
$new_mode = $admission_campaign->addSpecialityGroupingMode($code_name, $description);
|
||
if (!in_array($new_mode->code_name, $old_mode_names)) {
|
||
$needs_reset_priorities = true;
|
||
}
|
||
}
|
||
}
|
||
if ($needs_reset_priorities) {
|
||
$admission_campaign->resetComputedSpecialityGroupingPriorities();
|
||
}
|
||
}
|
||
|
||
$this->updateAgreementConditions($campaign, $admission_campaign);
|
||
}
|
||
AdmissionCampaign::updateAll(['archive' => true], ['not', ['id' => $touched_record_ids]]);
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
protected function updateAgreementConditions($raw_campaign, AdmissionCampaign $admission_campaign)
|
||
{
|
||
$touched_agreement_conditions = [];
|
||
|
||
if (isset($raw_campaign->AgreementConditions)) {
|
||
$agreement_conditions = [];
|
||
if (is_array($raw_campaign->AgreementConditions)) {
|
||
$agreement_conditions = $raw_campaign->AgreementConditions;
|
||
} else {
|
||
if (isset($raw_campaign->AgreementConditions->EducationSourceRef)) {
|
||
if (is_array($raw_campaign->AgreementConditions->EducationSourceRef)) {
|
||
$agreement_conditions = $raw_campaign->AgreementConditions->EducationSourceRef;
|
||
} else {
|
||
$agreement_conditions[] = $raw_campaign->AgreementConditions->EducationSourceRef;
|
||
}
|
||
} else {
|
||
$agreement_conditions[] = $raw_campaign->AgreementConditions;
|
||
}
|
||
}
|
||
|
||
foreach ($agreement_conditions as $agreement_condition) {
|
||
$conditionRef = $agreement_condition;
|
||
if (isset($agreement_condition->EducationSourceRef)) {
|
||
$conditionRef = $agreement_condition->EducationSourceRef;
|
||
}
|
||
|
||
$edu_source_ref = ReferenceTypeManager::GetOrCreateReference(
|
||
StoredEducationSourceReferenceType::class,
|
||
$conditionRef
|
||
);
|
||
|
||
$local_agreement_condition = AgreementCondition::find()->andWhere([
|
||
'campaign_id' => $admission_campaign->id,
|
||
'education_source_ref_id' => $edu_source_ref->id
|
||
])->one();
|
||
|
||
if ($local_agreement_condition === null) {
|
||
$local_agreement_condition = new AgreementCondition();
|
||
$local_agreement_condition->campaign_id = $admission_campaign->id;
|
||
}
|
||
|
||
$local_agreement_condition->archive = false;
|
||
$local_agreement_condition->education_source_ref_id = $edu_source_ref->id;
|
||
if (!$local_agreement_condition->save()) {
|
||
throw new RecordNotValid($local_agreement_condition);
|
||
}
|
||
$touched_agreement_conditions[] = $local_agreement_condition->id;
|
||
}
|
||
}
|
||
|
||
AgreementCondition::updateAll(['archive' => true], [
|
||
'and',
|
||
[
|
||
'not in', 'id', $touched_agreement_conditions,
|
||
],
|
||
[
|
||
'campaign_id' => $admission_campaign->id
|
||
]
|
||
]);
|
||
}
|
||
|
||
public function loadCampaignInfo(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$user = Yii::$app->user->identity;
|
||
} catch (Throwable $th) {
|
||
$tnUser = User::tableName();
|
||
$tnRbac = RBACAuthAssignment::tableName();
|
||
$user = User::find()
|
||
->leftJoin($tnRbac, "{$tnUser}.id = {$tnRbac}.user_id")
|
||
->where(["{$tnRbac}.item_name" => User::ROLE_ADMINISTRATOR])
|
||
->orderBy('id')
|
||
->one();
|
||
}
|
||
$campaigns = AdmissionCampaign::findAll(['archive' => false, 'reception_allowed' => 1]);
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($campaigns);
|
||
$progress->total($progressCount);
|
||
}
|
||
CampaignInfo::updateAll(['detail_group_code' => ''], ['detail_group_code' => '0']);
|
||
|
||
$cache_storage = [];
|
||
$allRefsCacheList = [];
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_campaign_ids = [];
|
||
|
||
foreach ($campaigns as $I => $campaign) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$applicationType = ApplicationType::findOne(['campaign_id' => $campaign->id, 'archive' => false]);
|
||
if ($applicationType) {
|
||
|
||
ApplicationTypeHistory::createNewEntry(
|
||
$user,
|
||
ApplicationTypeHistory::UPDATE_CAMPAIGN_INFO_DICTIONARY,
|
||
$applicationType->id
|
||
);
|
||
}
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetPKInfo', [
|
||
'IdPK' => $campaign->code,
|
||
'CampaignRef' => ReferenceTypeManager::GetReference($campaign, 'referenceType')
|
||
], DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled);
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if ($result === false) {
|
||
continue;
|
||
}
|
||
|
||
if (isset($result->return->UniversalResponse->Complete) && $result->return->UniversalResponse->Complete == '0') {
|
||
Yii::error('Ошибка при выполнении метода GetPKInfo: ' . $result->return->UniversalResponse->Description . ' ' . PHP_EOL . print_r($result, true));
|
||
}
|
||
|
||
if (!isset($result->return->Stage)) {
|
||
continue;
|
||
}
|
||
|
||
if (is_array($result->return->Stage) && !$result->return->Stage) {
|
||
continue;
|
||
}
|
||
|
||
if (!is_array($result->return->Stage)) {
|
||
$result->return->Stage = [$result->return->Stage];
|
||
}
|
||
|
||
foreach ($result->return->Stage as $info) {
|
||
$campaign_info = null;
|
||
|
||
$searchArrayOData = [];
|
||
$admissionCategoryId = null;
|
||
if (isset($info->AdmissionCategoryRef)) {
|
||
$admissionCategoryId = ReferenceTypeManager::GetOrCreateReferenceIdWithCaching(AdmissionCategory::class, $info->AdmissionCategoryRef, $cache_storage);
|
||
if ($admissionCategoryId) {
|
||
$searchArrayOData['admission_category_id'] = $admissionCategoryId;
|
||
}
|
||
}
|
||
|
||
$campaign_info = CampaignInfo::find()
|
||
->where(
|
||
ArrayHelper::merge([
|
||
'campaign_id' => $campaign->id,
|
||
'finance_code' => (string)$info->Finance,
|
||
'eduform_code' => (string)$info->EducationForm,
|
||
'detail_group_code' => (string)($info->DetailGroupCode == '0' ? '' : $info->DetailGroupCode),
|
||
'category_code' => (string)$info->CategoryCode,
|
||
], CampaignInfo::getReferenceTypeSearchArray($info, $cache_storage, $allRefsCacheList), $searchArrayOData)
|
||
)
|
||
->andWhere(['not', ['id' => $touched_campaign_ids]])
|
||
->one();
|
||
|
||
if ($campaign_info == null) {
|
||
$campaign_info = new CampaignInfo();
|
||
}
|
||
$campaign_info->campaign_id = $campaign->id;
|
||
$campaign_info->finance_code = (string)$info->Finance;
|
||
$campaign_info->eduform_code = (string)$info->EducationForm;
|
||
$campaign_info->date_start = date('Y-m-d H:i:s', strtotime((string)$info->DateStart));
|
||
$campaign_info->date_final = date('Y-m-d H:i:s', strtotime((string)$info->DateFinal));
|
||
$campaign_info->date_order_start = date('Y-m-d H:i:s', strtotime((string)$info->DateStartOrder));
|
||
$campaign_info->date_order_end = date('Y-m-d 23:59:59', strtotime((string)$info->DateFinalOrder));
|
||
$campaign_info->category_code = (string)$info->CategoryCode;
|
||
$campaign_info->archive = false;
|
||
$campaign_info->detail_group_code = (string)($info->DetailGroupCode == '0' ? '' : $info->DetailGroupCode);
|
||
if ($admissionCategoryId) {
|
||
$campaign_info->admission_category_id = $admissionCategoryId;
|
||
}
|
||
$campaign_info->loadRefKeysWithCaching($info, true, $cache_storage);
|
||
|
||
if ($campaign_info->validate()) {
|
||
$campaign_info->save(false);
|
||
$touched_campaign_ids[] = $campaign_info->id;
|
||
if (isset($info->CampaignEventPeriods) && !EmptyCheck::isEmpty($info->CampaignEventPeriods)) {
|
||
if (!is_array($info->CampaignEventPeriods->CampaignEventPeriod ?? [])) {
|
||
$info->CampaignEventPeriods->CampaignEventPeriod = array_values(array_filter([$info->CampaignEventPeriods->CampaignEventPeriod]));
|
||
}
|
||
$campaign_info->updatePeriods($info->CampaignEventPeriods->CampaignEventPeriod ?? []);
|
||
}
|
||
} else {
|
||
throw new RecordNotValid($campaign_info);
|
||
}
|
||
}
|
||
}
|
||
CampaignInfo::updateAll(['archive' => true], ['not', ['id' => $touched_campaign_ids]]);
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadGetOlympiad(?Progress $progress = null)
|
||
{
|
||
$key_names = [
|
||
'code',
|
||
'type',
|
||
'place',
|
||
'level',
|
||
'class',
|
||
'education_class',
|
||
'kind',
|
||
'profile',
|
||
'need_ege',
|
||
'name',
|
||
'year',
|
||
'ref_id',
|
||
'olympic_type_ref_id',
|
||
'olympic_level_ref_id',
|
||
'olympic_kind_ref_id',
|
||
'olympic_class_ref_id',
|
||
'olympic_profile_ref_id',
|
||
];
|
||
sort($key_names);
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetAllOlympiads', [], DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled);
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
if ($result === false || !isset($result->return->AllOlympiads)) {
|
||
return [0, []];
|
||
}
|
||
if (isset($result->return->UniversalResponse->Complete) && $result->return->UniversalResponse->Complete == '0') {
|
||
Yii::error("Ошибка при выполнении метода GetCatalogOlympiad: {$result->return->UniversalResponse->Description} " . PHP_EOL . print_r($result, true));
|
||
return [0, []];
|
||
}
|
||
$cache_storage = [];
|
||
|
||
if (!is_array($result->return->AllOlympiads)) {
|
||
$result->return->AllOlympiads = [$result->return->AllOlympiads];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($result->return->AllOlympiads);
|
||
$progress->total($progressCount);
|
||
}
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_ids = [];
|
||
foreach ($result->return->AllOlympiads as $I => $olimpic) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$attributes = [];
|
||
$attributes['code'] = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olimpic, 'OlympicRef', 'ReferenceId', 'Code');
|
||
$attributes['type'] = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olimpic, 'OlympicTypeRef', 'ReferenceName', 'Type');
|
||
$attributes['place'] = (string)$olimpic->Place;
|
||
$attributes['level'] = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olimpic, 'OlympicLevelRef', 'ReferenceName', 'Level');
|
||
$attributes['class'] = (int)ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olimpic, 'OlympicClassRef', 'ReferenceName', 'Class');
|
||
$attributes['education_class'] = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olimpic, 'OlympicClassRef', 'ReferenceName', 'Class');
|
||
$attributes['kind'] = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olimpic, 'OlympicKindRef', 'ReferenceName', 'Kind');
|
||
$attributes['profile'] = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olimpic, 'OlympicProfileRef', 'ReferenceName', 'Profile');
|
||
$attributes['need_ege'] = (bool)$olimpic->ConfirmationEGE;
|
||
$attributes['name'] = (string)$olimpic->Name;
|
||
$attributes['year'] = substr((string)$olimpic->Date, 0, 4) != '0001' ? date('Y', strtotime((string)$olimpic->Date)) : 'Не указан';
|
||
|
||
$all_props = ArrayHelper::merge((new Olympiad())->loadRefKeysWithCaching($olimpic, true, $cache_storage)->attributes, $attributes);
|
||
$attributes = array_intersect_key($all_props, array_flip($key_names));
|
||
|
||
$local = Olympiad::find()->andWhere($attributes)->one();
|
||
if (!$local) {
|
||
$local = new Olympiad();
|
||
$local->attributes = $attributes;
|
||
if (!$local->save()) {
|
||
throw new RecordNotValid($local);
|
||
}
|
||
}
|
||
$touched_ids[] = $local->id;
|
||
}
|
||
BachelorPreferences::updateAll(['olympiad_id' => null], ['not', ['olympiad_id' => $touched_ids]]);
|
||
OlympiadFilter::updateAll(['olympiad_id' => null], ['not', ['olympiad_id' => $touched_ids]]);
|
||
Olympiad::deleteAll(['not', ['id' => $touched_ids]]);
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
|
||
$this->loadOneReferenceDictionary(StoredOlympicTypeReferenceType::class, null, null, null, $progress);
|
||
$this->loadOneReferenceDictionary(StoredOlympicLevelReferenceType::class, null, null, null, $progress);
|
||
$this->loadOneReferenceDictionary(StoredOlympicKindReferenceType::class, null, null, null, $progress);
|
||
$this->loadOneReferenceDictionary(StoredOlympicClassReferenceType::class, null, null, null, $progress);
|
||
$this->loadOneReferenceDictionary(StoredOlympicProfileReferenceType::class, null, null, null, $progress);
|
||
|
||
$transaction->commit();
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
protected function runMethodWithBatchLoad(string $method_name)
|
||
{
|
||
$admission_campaigns = AdmissionCampaign::find()->active()->all();
|
||
foreach ($admission_campaigns as $admission_campaign) {
|
||
$competitiveGroups = $admission_campaign->getCompetitiveGroups()->all();
|
||
$competitiveGroups = array_chunk($competitiveGroups, $this->getDictionaryBatchSize());
|
||
foreach ($competitiveGroups as $competitiveGroupChunk) {
|
||
$result = Yii::$app->soapClientAbit->load(
|
||
$method_name,
|
||
[
|
||
'CampaignRef' => ReferenceTypeManager::GetReference($admission_campaign->referenceType),
|
||
'CompetitiveGroupRefs' => [
|
||
'CompetitiveGroupRef' => array_map(
|
||
function ($competitiveGroup) {
|
||
return ReferenceTypeManager::GetReference($competitiveGroup);
|
||
},
|
||
$competitiveGroupChunk
|
||
)
|
||
]
|
||
],
|
||
DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled
|
||
);
|
||
yield $result;
|
||
}
|
||
}
|
||
}
|
||
|
||
protected function getGetOlympiadGenerator()
|
||
{
|
||
foreach ($this->runMethodWithBatchLoad('GetOlympiad') as $result) {
|
||
if (isset($result->return->Olympiad)) {
|
||
if (!is_array($result->return->Olympiad)) {
|
||
$result->return->Olympiad = [$result->return->Olympiad];
|
||
}
|
||
foreach ($result->return->Olympiad as $item) {
|
||
yield $item;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
public function loadGetOlympiadFilter(?Progress $progress = null)
|
||
{
|
||
$key_names = [
|
||
'id_pk',
|
||
'olympiad_code',
|
||
'specific_mark_code',
|
||
'campaign_ref_id',
|
||
'special_mark_id',
|
||
'olympiad_id',
|
||
'curriculum_ref_id',
|
||
'variant_of_retest_ref_id',
|
||
];
|
||
sort($key_names);
|
||
$OlympiadGenerator = $this->getGetOlympiadGenerator();
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$OlympiadGenerator = iterator_to_array($OlympiadGenerator);
|
||
$progressCount = count($OlympiadGenerator);
|
||
$progress->total($progressCount);
|
||
}
|
||
$cache_storage = [];
|
||
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
OlympiadFilter::deleteAll();
|
||
foreach ($OlympiadGenerator as $I => $olympic) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
$buffer = [];
|
||
$buffer['id_pk'] = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olympic, 'CampaignRef', 'ReferenceId', 'IdPK');
|
||
$buffer['olympiad_code'] = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olympic, 'OlympicRef', 'ReferenceId', 'OlympiadCode');
|
||
$buffer['specific_mark_code'] = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($olympic, 'SpecialMarkRef', 'ReferenceId', 'SpecialMarkCode');
|
||
|
||
$all_props = ArrayHelper::merge((new OlympiadFilter())->loadRefKeysWithCaching($olympic, true, $cache_storage)->attributes, $buffer);
|
||
$buffer = array_intersect_key($all_props, array_flip($key_names));
|
||
|
||
try {
|
||
Yii::$app->db->createCommand()->insert(
|
||
'dictionary_olympiads_filter',
|
||
$buffer
|
||
)->execute();
|
||
} catch (Throwable $e) {
|
||
Yii::error("Ошибка заполнения словаря GetOlympiad: {$e->getMessage()}" . PHP_EOL . print_r($buffer, true));
|
||
throw $e;
|
||
}
|
||
}
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadGetAdmissionProcedures(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetAllAdmissionProcedures', [], DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled);
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if ($result === false || !isset($result->return->AdmissionProcedures)) {
|
||
return [0, []];
|
||
}
|
||
if (isset($result->return->UniversalResponse->Complete) && $result->return->UniversalResponse->Complete == '0') {
|
||
Yii::error("Ошибка при выполнении метода GetPreferences: {$result->return->UniversalResponse->Description} " . PHP_EOL . print_r($result, true));
|
||
return [0, []];
|
||
}
|
||
$cache_storage = [];
|
||
$allRefsCacheList = [];
|
||
if (!is_array($result->return->AdmissionProcedures)) {
|
||
$result->return->AdmissionProcedures = [$result->return->AdmissionProcedures];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($result->return->AdmissionProcedures);
|
||
$progress->total($progressCount);
|
||
}
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_proc_ids = [];
|
||
foreach ($result->return->AdmissionProcedures as $I => $admissionProcedure) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$pref = AdmissionProcedure::findOne(ArrayHelper::merge([
|
||
'id_pk' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'CampaignRef', 'ReferenceId', 'IdPK'),
|
||
'category_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'AdmissionCategoryRef', 'ReferenceId', 'CategoryCode'),
|
||
'finance_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'EducationSourceRef', 'ReferenceId', 'FinanceCode'),
|
||
'privilege_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'BenefitRef', 'ReferenceId', 'PrivilegeCode'),
|
||
'special_mark_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'SpecialMarkRef', 'ReferenceId', 'SpecialMarkCode'),
|
||
'individual_value' => (bool)$admissionProcedure->IndividualValue,
|
||
'priority_right' => (bool)$admissionProcedure->PriorityRight
|
||
], AdmissionProcedure::getReferenceTypeSearchArray($admissionProcedure, $cache_storage, $allRefsCacheList)));
|
||
|
||
if ($pref == null) {
|
||
$pref = new AdmissionProcedure();
|
||
$pref->attributes = [
|
||
'id_pk' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'CampaignRef', 'ReferenceId', 'IdPK'),
|
||
'category_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'AdmissionCategoryRef', 'ReferenceId', 'CategoryCode'),
|
||
'finance_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'EducationSourceRef', 'ReferenceId', 'FinanceCode'),
|
||
'privilege_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'BenefitRef', 'ReferenceId', 'PrivilegeCode'),
|
||
'special_mark_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($admissionProcedure, 'SpecialMarkRef', 'ReferenceId', 'SpecialMarkCode'),
|
||
'individual_value' => (bool)$admissionProcedure->IndividualValue,
|
||
'priority_right' => (bool)$admissionProcedure->PriorityRight
|
||
];
|
||
$pref->loadRefKeysWithCaching($admissionProcedure, true, $cache_storage);
|
||
} else {
|
||
$pref->archive = false;
|
||
}
|
||
$pref->scenario = AdmissionProcedure::$SCENARIO_WITHOUT_EXISTS_CHECK;
|
||
if (!$pref->save()) {
|
||
throw new RecordNotValid($pref);
|
||
}
|
||
$touched_proc_ids[] = $pref->id;
|
||
}
|
||
AdmissionProcedure::updateAll(['archive' => true], ['not', ['id' => $touched_proc_ids]]);
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadGetAllDocumentTypesAbiturient(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetAllDocumentTypesAbiturient', [], DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled);
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if (isset($result->return->UniversalResponse->Complete) && $result->return->UniversalResponse->Complete == '0') {
|
||
Yii::error("Ошибка при выполнении метода GetAvailableDocumentTypesForConcession : {$result->return->UniversalResponse->Description} " . PHP_EOL . print_r($result, true));
|
||
$exceptionFrom1C = new soapException('Ошибка обновления из 1с', '110022', 'GetAvailableDocumentTypesForConcession', $result->return->UniversalResponse->Description);
|
||
return [-1, $exceptionFrom1C];
|
||
}
|
||
|
||
if ($result === false || !isset($result->return->DocumentTypeAbiturient)) {
|
||
return [0, []];
|
||
}
|
||
|
||
$cache_storage = [];
|
||
$allRefsCacheList = [];
|
||
|
||
if (!is_array($result->return->DocumentTypeAbiturient)) {
|
||
$result->return->DocumentTypeAbiturient = [$result->return->DocumentTypeAbiturient];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($result->return->DocumentTypeAbiturient);
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_att_type_ids = [];
|
||
foreach ($result->return->DocumentTypeAbiturient as $I => $type) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
$attachment_type = AttachmentType::find()
|
||
->andWhere(['from1c' => true])
|
||
->andWhere(AttachmentType::getReferenceTypeSearchArray($type, $cache_storage, $allRefsCacheList))
|
||
->one();
|
||
|
||
if ($attachment_type == null) {
|
||
$attachment_type = new AttachmentType();
|
||
$attachment_type->hidden = false;
|
||
}
|
||
|
||
if (isset($type->DocumentTypeRef) && !ReferenceTypeManager::isReferenceTypeEmpty($type->DocumentTypeRef)) {
|
||
$document_type = ReferenceTypeManager::GetOrCreateReference(DocumentType::class, $type->DocumentTypeRef);
|
||
} else {
|
||
$document_type = DocumentType::find()
|
||
->where(['code' => $type->DocumentTypeCode])
|
||
->active()
|
||
->one();
|
||
}
|
||
$attachment_type->attributes = [
|
||
'document_type_guid' => $document_type ? $document_type->ref_key : '',
|
||
'name' => $document_type ? $document_type->description : '',
|
||
'required' => $type->ScanRequired == 'true' || (bool)$type->NeedOneOfDocuments,
|
||
'from1c' => true,
|
||
'need_one_of_documents' => (bool)$type->NeedOneOfDocuments,
|
||
'campaign_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($type, 'CampaignRef', 'ReferenceId', 'idPK'),
|
||
'related_entity' => PageRelationManager::RELATED_ENTITY_APPLICATION,
|
||
'document_type' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($type, 'DocumentTypeRef', 'ReferenceId', 'DocumentTypeCode'),
|
||
'document_set_code' => ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($type, 'DocumentSetRef', 'ReferenceId', 'DocumentSetCode'),
|
||
'is_using' => true
|
||
];
|
||
$attachment_type->loadRefKeysWithCaching($type, true, $cache_storage);
|
||
|
||
if ($attachment_type->validate()) {
|
||
$attachment_type->save(false);
|
||
$touched_att_type_ids[] = $attachment_type->id;
|
||
} else {
|
||
throw new RecordNotValid($attachment_type);
|
||
}
|
||
}
|
||
|
||
AttachmentType::updateAll(['is_using' => false], [
|
||
'and',
|
||
['from1c' => true],
|
||
['not', ['id' => $touched_att_type_ids]]
|
||
]);
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadGetAvailableDocumentTypes(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetAvailableDocumentTypes', [], DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled);
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if ($result === false || !isset($result->return->CampaignAvailableDocumentTypes)) {
|
||
return [0, []];
|
||
}
|
||
if (!is_array($result->return->CampaignAvailableDocumentTypes)) {
|
||
$result->return->CampaignAvailableDocumentTypes = [$result->return->CampaignAvailableDocumentTypes];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($result->return->CampaignAvailableDocumentTypes);
|
||
$progress->total($progressCount);
|
||
}
|
||
$cache_storage = [];
|
||
$allRefsCacheList = [];
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_doc_type_ids = [];
|
||
foreach ($result->return->CampaignAvailableDocumentTypes as $I => $campaignAvailableDocumentType) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
if (!isset($campaignAvailableDocumentType->DocumentSets)) {
|
||
continue;
|
||
}
|
||
if (!is_array($campaignAvailableDocumentType->DocumentSets)) {
|
||
$campaignAvailableDocumentType->DocumentSets = [$campaignAvailableDocumentType->DocumentSets];
|
||
}
|
||
foreach ($campaignAvailableDocumentType->DocumentSets as $documentSet) {
|
||
$document_types = $documentSet->DocumentTypes ?? [];
|
||
if (!is_array($document_types)) {
|
||
$document_types = [$document_types];
|
||
}
|
||
if (empty($document_types)) {
|
||
continue;
|
||
}
|
||
$filters = $documentSet->Filters ?? [];
|
||
if (!is_array($filters)) {
|
||
$filters = [$filters];
|
||
}
|
||
foreach ($filters as $filter) {
|
||
$class = null;
|
||
if (isset($filter->FilterTypeName)) {
|
||
if ($filter->FilterTypeName == 'ОсобыеОтметки') {
|
||
$class = AvailableDocumentTypesForConcession::class;
|
||
} elseif ($filter->FilterTypeName == 'Льготы') {
|
||
$class = AvailableDocumentTypesForConcession::class;
|
||
} elseif ($filter->FilterTypeName == 'ИндивидуальныеДостижения') {
|
||
$class = IndividualAchievementDocumentType::class;
|
||
}
|
||
}
|
||
if ($class === null) {
|
||
continue;
|
||
}
|
||
foreach ($document_types as $document_type) {
|
||
$data_to_search = (object)[
|
||
'CampaignRef' => $campaignAvailableDocumentType->CampaignRef,
|
||
'DocumentSetRef' => $documentSet->DocumentSetRef,
|
||
'DocumentTypeRef' => $document_type->DocumentTypeRef,
|
||
];
|
||
$local = $class::find()
|
||
->where(ArrayHelper::merge(
|
||
[
|
||
'scan_required' => (bool)$document_type->ScanRequired
|
||
],
|
||
$class::getReferenceTypeSearchArray($data_to_search, $cache_storage, $allRefsCacheList)
|
||
));
|
||
if ($class == AvailableDocumentTypesForConcession::class) {
|
||
$local = $local
|
||
->joinWith(['filterJunctions filter_junctions'])
|
||
->andWhere(['filter_junctions.subject_type' => (string)$filter->FilterTypeName]);
|
||
}
|
||
$local = $local
|
||
->joinWith(['availableDocumentTypeFilterRef available_document_type_filter_ref'])
|
||
->andWhere(['available_document_type_filter_ref.reference_uid' => $filter->FilterValueRef->ReferenceUID]);
|
||
$local = $local->one();
|
||
|
||
if (!$local) {
|
||
$local = new $class();
|
||
}
|
||
$local->campaign_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($data_to_search, 'CampaignRef', 'ReferenceId', 'IdPK');
|
||
$local->document_type = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($data_to_search, 'DocumentTypeRef', 'ReferenceId', 'DocumentType');
|
||
$local->document_set_code = ReferenceTypeManager::GetOneSFieldByRefTypeOrSimpleField($data_to_search, 'DocumentSetRef', 'ReferenceId', 'DocumentSetCode');
|
||
$local->scan_required = (bool)$document_type->ScanRequired || (bool)$documentSet->NeedOneOfDocuments;
|
||
$local->need_one_of_documents = (bool)$documentSet->NeedOneOfDocuments;
|
||
|
||
$local->archive = false;
|
||
if ($local instanceof IndividualAchievementDocumentType) {
|
||
$local->from1c = true;
|
||
$local->scenario = $class::$SCENARIO_WITHOUT_EXISTS_CHECK;
|
||
}
|
||
$local->loadRefKeysWithCaching($data_to_search, true, $cache_storage);
|
||
|
||
if (!$local->save()) {
|
||
throw new RecordNotValid($local);
|
||
}
|
||
if (!isset($touched_doc_type_ids[$class])) {
|
||
$touched_doc_type_ids[$class] = [];
|
||
}
|
||
$touched_doc_type_ids[$class][] = $local->id;
|
||
$local_filter = ReferenceTypeManager::GetOrCreateReference(StoredAvailableDocumentTypeFilterReferenceType::class, $filter->FilterValueRef);
|
||
$local->link(
|
||
'availableDocumentTypeFilterRef',
|
||
$local_filter,
|
||
($local instanceof AvailableDocumentTypesForConcession) ? ['subject_type' => (string)$filter->FilterTypeName] : []
|
||
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
AvailableDocumentTypesForConcession::updateAll(['archive' => true], ['not', ['id' => $touched_doc_type_ids[AvailableDocumentTypesForConcession::class] ?? []]]);
|
||
IndividualAchievementDocumentType::updateAll(['archive' => true], [
|
||
'and',
|
||
['from1c' => true],
|
||
['not', ['id' => $touched_doc_type_ids[IndividualAchievementDocumentType::class] ?? []]]
|
||
]);
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadReasonsForExam(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetReasons', [], DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled);
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if (isset($result->return->UniversalResponse->Complete) && $result->return->UniversalResponse->Complete == '0') {
|
||
Yii::error("Ошибка при выполнении метода GetReasons : {$result->return->UniversalResponse->Description} " . PHP_EOL . print_r($result, true));
|
||
$exceptionFrom1C = new soapException('Ошибка обновления из 1с', '110022', 'GetReasons', $result->return->UniversalResponse->Description);
|
||
return [-1, $exceptionFrom1C];
|
||
}
|
||
|
||
if ($result === false || !isset($result->return->Reason)) {
|
||
return [0, []];
|
||
}
|
||
|
||
if (!is_array($result->return->Reason)) {
|
||
$result->return->Reason = [$result->return->Reason];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($result->return->Reason);
|
||
$progress->total($progressCount);
|
||
}
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_reason_ids = [];
|
||
foreach ($result->return->Reason as $I => $reason) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$local_reason = DictionaryReasonForExam::findOne(
|
||
[
|
||
'code' => (string)$reason->ReasonCode,
|
||
]
|
||
);
|
||
if (is_null($local_reason)) {
|
||
$local_reason = new DictionaryReasonForExam();
|
||
}
|
||
$local_reason->code = (string)$reason->ReasonCode;
|
||
$local_reason->name = (string)$reason->ReasonName;
|
||
$local_reason->archive = false;
|
||
|
||
if ($local_reason->validate()) {
|
||
$local_reason->save(false);
|
||
$touched_reason_ids[] = $local_reason->id;
|
||
} else {
|
||
throw new RecordNotValid($local_reason);
|
||
}
|
||
}
|
||
DictionaryReasonForExam::updateAll(['archive' => true], ['not', ['id' => $touched_reason_ids]]);
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadFamilyTypes(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$respones = GetReferencesManager::getReferences(FamilyType::getReferenceClassName());
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
$references = $respones->getReferences();
|
||
|
||
if (empty($references)) {
|
||
return [0, []];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$references = iterator_to_array($references);
|
||
$progressCount = count($references);
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_family_type_ids = [];
|
||
foreach ($references as $I => $reference) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$touched_family_type_ids[] = ReferenceTypeManager::GetOrCreateReference(FamilyType::class, $reference)->id;
|
||
}
|
||
FamilyType::updateAll(['archive' => true], ['not', ['id' => $touched_family_type_ids]]);
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadSpecialRequirements(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$response = GetReferencesManager::getReferences(SpecialRequirementReferenceType::getReferenceClassName());
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
|
||
if (empty($response->getReferences())) {
|
||
return [0, []];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = iterator_count($response->getReferences());
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
$touched_record_ids = [];
|
||
foreach ($response->getReferences() as $I => $reference) {
|
||
if ($progress) {
|
||
$progress->current($I + 1);
|
||
}
|
||
$touched_record_ids[] = ReferenceTypeManager::GetOrCreateReference(SpecialRequirementReferenceType::class, $reference)->id;
|
||
}
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
|
||
SpecialRequirementReferenceType::updateAll(['archive' => true], ['not', ['id' => $touched_record_ids]]);
|
||
|
||
$transaction->commit();
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadGetEducationLevelDocumentTypeMap(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetEducationLevelDocumentTypeMap', [], DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled);
|
||
} catch (\Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
if ($result === false) {
|
||
return [0, []];
|
||
}
|
||
if (!isset($result->return->EducationLevelDocumentTypeMap)) {
|
||
return [0, []];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($result->return->EducationLevelDocumentTypeMap);
|
||
$progress->total($progressCount);
|
||
}
|
||
$cache_storage = [];
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
EducationDataFilter::deleteAll();
|
||
|
||
if (!is_array($result->return->EducationLevelDocumentTypeMap)) {
|
||
$result->return->EducationLevelDocumentTypeMap = [$result->return->EducationLevelDocumentTypeMap];
|
||
}
|
||
foreach ($result->return->EducationLevelDocumentTypeMap as $I => $record) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$tmp = new EducationDataFilter();
|
||
$tmp->loadRefKeysWithCaching($record, true, $cache_storage);
|
||
$tmp->period = $record->Period ?? null;
|
||
$tmp->actual = $record->Actual ?? null;
|
||
$tmp->allow_profile_input = $record->AllowProfileInput ?? false;
|
||
if (!$tmp->save()) {
|
||
throw new RecordNotValid($tmp);
|
||
}
|
||
}
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (\Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadGetAdditionalReceiptDateControl(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetAdditionalReceiptDateControl', [], DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled);
|
||
} catch (\Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
if ($result === false) {
|
||
return [0, []];
|
||
}
|
||
if (!isset($result->return->AdditionalReceiptDateControl)) {
|
||
return [0, []];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($result->return->AdditionalReceiptDateControl);
|
||
$progress->total($progressCount);
|
||
}
|
||
$cache_storage = [];
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
AdditionalReceiptDateControl::deleteAll();
|
||
|
||
if (!is_array($result->return->AdditionalReceiptDateControl)) {
|
||
$result->return->AdditionalReceiptDateControl = [$result->return->AdditionalReceiptDateControl];
|
||
}
|
||
foreach ($result->return->AdditionalReceiptDateControl as $I => $record) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$tmp = new AdditionalReceiptDateControl();
|
||
$tmp->loadRefKeysWithCaching($record, true, $cache_storage);
|
||
$tmp->stage = $record->Stage ?? null;
|
||
$tmp->date_start = $record->DateStart ?? null;
|
||
$tmp->date_end = $record->DateFinal ?? null;
|
||
$tmp->scenario = AdditionalReceiptDateControl::$SCENARIO_WITHOUT_EXISTS_CHECK;
|
||
if (!$tmp->save()) {
|
||
throw new RecordNotValid($tmp);
|
||
}
|
||
}
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (\Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadDocumentTypePropertySettings(?Progress $progress = null)
|
||
{
|
||
try {
|
||
$result = Yii::$app->soapClientAbit->load('GetDocumentTypePropertySettings', [], DebuggingSoap::getInstance()->enable_logging_for_dictionary_soap);
|
||
} catch (\Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
if ($result === false) {
|
||
return [0, []];
|
||
}
|
||
if (!isset($result->return->DocumentTypeProperties)) {
|
||
return [0, []];
|
||
}
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($result->return->DocumentTypeProperties);
|
||
$progress->total($progressCount);
|
||
}
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
if (!is_array($result->return->DocumentTypeProperties)) {
|
||
$result->return->DocumentTypeProperties = [$result->return->DocumentTypeProperties];
|
||
}
|
||
DocumentTypeAttributeSetting::deleteAll();
|
||
DocumentTypePropertiesSetting::deleteAll();
|
||
|
||
foreach ($result->return->DocumentTypeProperties as $I => $record) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
|
||
|
||
|
||
$documentType = ReferenceTypeManager::GetOrCreateReference(DocumentType::class, $record->DocumentTypeRef);
|
||
$documentTypeSetting = DocumentTypePropertiesSetting::getOrCreateByDocumentType($documentType);
|
||
foreach ($record->Properties as $property) {
|
||
$documentTypeSetting->setupPropertySetting($property->Name, $property->IsUsed, $property->FillChecking);
|
||
}
|
||
}
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function linkRefODataFields()
|
||
{
|
||
AdmissionCategory::updateLinks();
|
||
DocumentType::updateLinks();
|
||
Privilege::updateLinks();
|
||
SpecialMark::updateLinks();
|
||
Olympiad::updateLinks();
|
||
EducationType::updateLinks();
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadDictionaryPredmetOfExamsSchedule(?Progress $progress = null)
|
||
{
|
||
$campaigns = AdmissionCampaign::findAll(['archive' => false]);
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($campaigns);
|
||
$progress->total($progressCount);
|
||
}
|
||
$cacheStorage = [];
|
||
$allRefsCacheList = [];
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
DictionaryPredmetOfExamsSchedule::updateAll(['archive' => true]);
|
||
|
||
foreach ($campaigns as $I => $campaign) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
try {
|
||
$refData = ReferenceTypeManager::GetReference($campaign, 'referenceType');
|
||
$result = Yii::$app->soapClientAbit->load(
|
||
'GetPredmetsOfExamsSchedule',
|
||
['CampaignRef' => $refData],
|
||
DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled
|
||
);
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
if ($result === false) {
|
||
continue;
|
||
}
|
||
if (!isset($result->return->PredmetOfExamsSchedule)) {
|
||
continue;
|
||
}
|
||
if (!is_array($result->return->PredmetOfExamsSchedule)) {
|
||
$result->return->PredmetOfExamsSchedule = [$result->return->PredmetOfExamsSchedule];
|
||
}
|
||
|
||
foreach ($result->return->PredmetOfExamsSchedule as $schedule) {
|
||
$predmetOfExamsSchedule = DictionaryPredmetOfExamsSchedule::find()
|
||
->andWhere(DictionaryPredmetOfExamsSchedule::getReferenceTypeSearchArray($schedule, $cacheStorage, $allRefsCacheList))
|
||
->one();
|
||
|
||
if (!$predmetOfExamsSchedule) {
|
||
$predmetOfExamsSchedule = new DictionaryPredmetOfExamsSchedule();
|
||
}
|
||
$predmetOfExamsSchedule->archive = false;
|
||
$predmetOfExamsSchedule->predmet_guid = $schedule->PredmetGUID;
|
||
$predmetOfExamsSchedule->loadRefKeysWithCaching($schedule, true, $cacheStorage);
|
||
if (!$predmetOfExamsSchedule->save()) {
|
||
throw new RecordNotValid($predmetOfExamsSchedule);
|
||
}
|
||
}
|
||
}
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadDictionaryDateTimeOfExamsSchedule(?Progress $progress = null)
|
||
{
|
||
$campaigns = AdmissionCampaign::findAll(['archive' => false]);
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = count($campaigns);
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
$cacheStorage = [];
|
||
$allRefsCacheList = [];
|
||
$transaction = Yii::$app->db->beginTransaction();
|
||
try {
|
||
DictionaryDateTimeOfExamsSchedule::updateAll(['archive' => true]);
|
||
|
||
foreach ($campaigns as $I => $campaign) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
try {
|
||
$refData = ReferenceTypeManager::GetReference($campaign, 'referenceType');
|
||
$result = Yii::$app->soapClientAbit->load(
|
||
'GetDateTimeOfExamsSchedule',
|
||
['CampaignRef' => $refData],
|
||
DebuggingSoap::getInstance()->isLoggingForDictionarySoapEnabled
|
||
);
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
if ($result === false) {
|
||
continue;
|
||
}
|
||
if (!isset($result->return->DateTimeOfExamsSchedule)) {
|
||
continue;
|
||
}
|
||
if (!is_array($result->return->DateTimeOfExamsSchedule)) {
|
||
$result->return->DateTimeOfExamsSchedule = [$result->return->DateTimeOfExamsSchedule];
|
||
}
|
||
|
||
foreach ($result->return->DateTimeOfExamsSchedule as $schedule) {
|
||
$dateTimeOfExamsSchedule = DictionaryDateTimeOfExamsSchedule::find()
|
||
->andWhere(DictionaryDateTimeOfExamsSchedule::getReferenceTypeSearchArray($schedule, $cacheStorage, $allRefsCacheList))
|
||
->andWhere([
|
||
'predmet_guid' => $schedule->PredmetGUID,
|
||
'guid_date_time' => $schedule->GUIDDateTime,
|
||
])
|
||
->one();
|
||
|
||
if (!$dateTimeOfExamsSchedule) {
|
||
$dateTimeOfExamsSchedule = new DictionaryDateTimeOfExamsSchedule();
|
||
}
|
||
$dateTimeOfExamsSchedule->archive = false;
|
||
$dateTimeOfExamsSchedule->note = $schedule->Note;
|
||
$dateTimeOfExamsSchedule->endDate = $schedule->EndDate;
|
||
$dateTimeOfExamsSchedule->startDate = $schedule->StartDate;
|
||
$dateTimeOfExamsSchedule->predmet_guid = $schedule->PredmetGUID;
|
||
$dateTimeOfExamsSchedule->guid_date_time = $schedule->GUIDDateTime;
|
||
$dateTimeOfExamsSchedule->registrationDate = $schedule->RegistrationDate;
|
||
|
||
$dateTimeOfExamsSchedule->loadRefKeysWithCaching($schedule, true, $cacheStorage);
|
||
if (!$dateTimeOfExamsSchedule->save()) {
|
||
throw new RecordNotValid($dateTimeOfExamsSchedule);
|
||
}
|
||
}
|
||
}
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
$transaction->rollBack();
|
||
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
protected function loadOneReferenceDictionary(
|
||
$class,
|
||
Closure $onBeginFilling = null,
|
||
Closure $onNextReference = null,
|
||
Closure $onEndFilling = null,
|
||
?Progress $progress = null
|
||
) {
|
||
$updateManager = new AppUpdate();
|
||
try {
|
||
$updateManager->updateReferenceTable($class, $onBeginFilling, $onNextReference, $onEndFilling, $progress);
|
||
return $this->getSuccessAnswer();
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
}
|
||
|
||
public function loadDocumentTypes(?Progress $progress = null)
|
||
{
|
||
$onEndFilling = function () {
|
||
$doc = DocumentType::findOne([
|
||
'predefined_data_name' => AdmissionAgreement::DOCUMENT_TYPE_PREDEFINED_DATA_NAME,
|
||
'archive' => false
|
||
]);
|
||
|
||
$code_setting = CodeSetting::findOne(['name' => 'agreement_document_type_guid']);
|
||
if ($code_setting) {
|
||
$code_setting->value = $doc->ref_key;
|
||
if (!$code_setting->save(true, ['value'])) {
|
||
Yii::error('Не удалось обновить код по умолчанию agreement_document_type_guid ' . VarDumper::dumpAsString($code_setting->errors));
|
||
}
|
||
}
|
||
};
|
||
|
||
return $this->loadOneReferenceDictionary(DocumentType::class, null, null, $onEndFilling, $progress);
|
||
}
|
||
|
||
public function loadPrivileges(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(Privilege::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadAdmissionBase(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(AdmissionBase::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadBudgetLevel(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(BudgetLevel::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadAdmissionCategory(?Progress $progress = null)
|
||
{
|
||
$onEndFilling = function () {
|
||
$cat_all = CodeSetting::find()->where([
|
||
'name' => 'category_all',
|
||
'description' => 'Код категории приема на общих основаниях'
|
||
])->one();
|
||
if ($cat_all == null) {
|
||
$cat_all = new CodeSetting();
|
||
$cat_all->attributes = [
|
||
'name' => 'category_all',
|
||
'description' => 'Код категории приема на общих основаниях'
|
||
];
|
||
}
|
||
$admission_category = AdmissionCategory::find()->active()->andWhere(['description' => 'На общих основаниях'])->one();
|
||
$cat_all->value = ArrayHelper::getValue($admission_category, 'ref_key', '');
|
||
$cat_all->save();
|
||
|
||
$cat_lgota = CodeSetting::find()
|
||
->where([
|
||
'name' => 'category_specific_law',
|
||
'description' => 'Код категории приема поступающих имеющих особое право'
|
||
])
|
||
->one();
|
||
if ($cat_lgota == null) {
|
||
$cat_lgota = new CodeSetting();
|
||
$cat_lgota->attributes = [
|
||
'name' => 'category_specific_law',
|
||
'description' => 'Код категории приема поступающих имеющих особое право'
|
||
];
|
||
}
|
||
$admission_category = AdmissionCategory::find()->active()->andWhere(['description' => 'Имеющие особое право'])->one();
|
||
$cat_lgota->value = ArrayHelper::getValue($admission_category, 'ref_key', '');
|
||
$cat_lgota->save();
|
||
};
|
||
|
||
$onNextRef = function ($index, $countReferences, $reference) {
|
||
$predefined_name = $reference->PredefinedDataName ?? '';
|
||
|
||
return !in_array((string)$predefined_name, ['БезВступительныхИспытаний', 'УдалитьБезВступительныхИспытаний']);
|
||
};
|
||
|
||
return $this->loadOneReferenceDictionary(AdmissionCategory::class, null, $onNextRef, $onEndFilling, $progress);
|
||
}
|
||
|
||
public function loadDocumentShipment(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(DocumentShipment::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadCountry(?Progress $progress = null)
|
||
{
|
||
$onNextRef = function ($index, $countReferences, &$reference) {
|
||
$reference->ReferenceName = mb_convert_case(mb_strtolower((string)$reference->ReferenceName, 'UTF-8'), MB_CASE_TITLE, 'UTF-8');
|
||
return true;
|
||
};
|
||
|
||
return $this->loadOneReferenceDictionary(Country::class, null, $onNextRef, null, $progress);
|
||
}
|
||
|
||
public function loadOwnageForms(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(OwnageForm::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredProfileReferenceType(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredProfileReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredEducationLevelReferenceType(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredEducationLevelReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredEducationFormReferenceType(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredEducationFormReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredDisciplineReferenceType(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredDisciplineReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredDisciplineFormReferenceType(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredDisciplineFormReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredEducationSourceReferenceType(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredEducationSourceReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredDocumentSetReferenceType(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredDocumentSetReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredVariantOfRetestReferenceType(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredVariantOfRetestReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredDocumentCheckStatusReferenceType(?Progress $progress = null)
|
||
{
|
||
return $this->loadOneReferenceDictionary(StoredDocumentCheckStatusReferenceType::class, null, null, null, $progress);
|
||
}
|
||
|
||
public function loadStoredCompetitiveGroupReferenceType(?Progress $progress = null)
|
||
{
|
||
$admissionCampaign = AdmissionCampaign::find()->active()->each();
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$admissionCampaign = iterator_to_array($admissionCampaign);
|
||
$progressCount = count($admissionCampaign);
|
||
$progress->total($progressCount);
|
||
}
|
||
try {
|
||
$touched_ids = [];
|
||
foreach ($admissionCampaign as $I => $campaign) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$campaignReferenceType = ArrayHelper::getValue($campaign, 'referenceType');
|
||
$result = GetReferencesManager::getReferences(
|
||
StoredCompetitiveGroupReferenceType::getReferenceClassToFill(),
|
||
'',
|
||
GetReferencesManager::FILTER_TYPE_AP,
|
||
[
|
||
'SimpleFilters' => [
|
||
[
|
||
'Field' => 'ПриемнаяКампания',
|
||
'Comparison' => 'Equal',
|
||
'Values' => [
|
||
'ValueType' => StoredAdmissionCampaignReferenceType::getReferenceClassName(),
|
||
'ValueRef' => ReferenceTypeManager::getReference($campaignReferenceType),
|
||
]
|
||
]
|
||
]
|
||
]
|
||
);
|
||
$references = $result->getReferences();
|
||
foreach ($references as $index => $reference) {
|
||
|
||
|
||
$storedReference = ReferenceTypeManager::GetOrCreateReference(StoredCompetitiveGroupReferenceType::class, $reference);
|
||
$storedReference->fillDictionary();
|
||
$campaignReferenceType->link('competitiveGroups', $storedReference);
|
||
$touched_ids[] = $storedReference->id;
|
||
}
|
||
}
|
||
StoredCompetitiveGroupReferenceType::updateAll(
|
||
[StoredCompetitiveGroupReferenceType::getArchiveColumnName() => StoredCompetitiveGroupReferenceType::getArchiveColumnPositiveValue()],
|
||
['not', ['id' => $touched_ids]]
|
||
);
|
||
foreach ($touched_ids as $touched_id) {
|
||
$record = StoredCompetitiveGroupReferenceType::findOne($touched_id);
|
||
$record->restoreDictionary();
|
||
}
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (Throwable $e) {
|
||
return [-1, $e];
|
||
}
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
public function loadContractorList(?Progress $progress = null)
|
||
{
|
||
$contractors = GetContractorListManager::getReferences(StoredContractorReferenceType::getReferenceClassName());
|
||
$progressCount = 0;
|
||
if ($progress) {
|
||
$progressCount = iterator_count($contractors->getReferences());
|
||
$progress->total($progressCount);
|
||
}
|
||
|
||
$transaction = \Yii::$app->db->beginTransaction();
|
||
|
||
try {
|
||
Contractor::updateAll(['archive' => true]);
|
||
|
||
foreach ($contractors->getReferences() as $I => $contractor) {
|
||
if ($progress && $I % 3 == 0) {
|
||
$progress->current($I);
|
||
}
|
||
|
||
$raw_contractor = ToAssocCaster::getAssoc($contractor);
|
||
$model = ContractorManager::GetOrCreateContractor($raw_contractor);
|
||
|
||
if ($model === null) {
|
||
Yii::error(
|
||
'Не удалось добавить/обновить контрагента: ' . VarDumper::dumpAsString($contractor),
|
||
'loadContractorList'
|
||
);
|
||
continue;
|
||
}
|
||
}
|
||
|
||
$transaction->commit();
|
||
|
||
if ($progress && $progressCount) {
|
||
$progress->current($progressCount);
|
||
}
|
||
} catch (\Throwable $e) {
|
||
$transaction->rollBack();
|
||
return [-1, $e];
|
||
}
|
||
|
||
return $this->getSuccessAnswer();
|
||
}
|
||
|
||
private function getDictionaryBatchSize(): int
|
||
{
|
||
|
||
|
||
$batchSize = getenv('DICTIONARY_REQUEST_BATCH_SIZE');
|
||
if (!$batchSize || !is_numeric($batchSize)) {
|
||
$batchSize = 300;
|
||
}
|
||
return (int)$batchSize;
|
||
}
|
||
}
|