jonphipps /
Metadata-Registry
| Total Complexity | 92 |
| Total Lines | 497 |
| Duplicated Lines | 0 % |
| Changes | 0 | ||
Complex classes like SyncProduction often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use SyncProduction, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 29 | class SyncProduction implements ShouldQueue |
||
| 30 | { |
||
| 31 | use Dispatchable, InteractsWithQueue, Queueable, SerializesModels; |
||
| 32 | private $firstRun; |
||
| 33 | private $lastRunTimestamp; |
||
| 34 | |||
| 35 | /** |
||
| 36 | * Create a new job instance. |
||
| 37 | * |
||
| 38 | * @param $firstRun |
||
| 39 | */ |
||
| 40 | public function __construct(bool $firstRun) |
||
| 41 | { |
||
| 42 | ob_implicit_flush(1); |
||
| 43 | |||
| 44 | $this->firstRun = $firstRun; |
||
| 45 | if (! $this->firstRun) { |
||
| 46 | Cache::forget('last_run_timestamp'); |
||
| 47 | } |
||
| 48 | |||
| 49 | //set last run to 0 if it wasn't cached |
||
| 50 | $this->lastRunTimestamp = Cache::get('last_run_timestamp', |
||
| 51 | function () { |
||
|
1 ignored issue
–
show
|
|||
| 52 | return Carbon::createFromTimestamp(0)->toDateTimeString(); |
||
| 53 | }); |
||
| 54 | } |
||
| 55 | |||
| 56 | /** |
||
| 57 | * Execute the job. |
||
| 58 | * |
||
| 59 | * @return void |
||
| 60 | */ |
||
| 61 | public function handle() |
||
| 62 | { |
||
| 63 | //for each table in the list: |
||
| 64 | /* |
||
| 65 | * user |
||
| 66 | * reg_agent |
||
| 67 | * reg_agent_has_user |
||
| 68 | * reg_vocabulary_has_user |
||
| 69 | * reg_schema |
||
| 70 | * schema_has_user |
||
| 71 | * reg_file_import_history |
||
| 72 | * reg_vocabulary |
||
| 73 | */ |
||
| 74 | |||
| 75 | //*************** |
||
| 76 | // MUST DO A ONE-WAY UPDATE OF BETA FROM PRODUCTION ONCE BEFORE RUNNING |
||
| 77 | //*************** |
||
| 78 | $this->updateUsers(); |
||
| 79 | $this->updateAgents(); |
||
| 80 | $this->updateAgentUsers(); |
||
| 81 | $this->updateVocabularies(); |
||
| 82 | $this->updateVocabularyUsers(); |
||
| 83 | $this->updateSchema(); |
||
| 84 | $this->updateSchemaUsers(); |
||
| 85 | $this->updateImportHistory(); |
||
| 86 | |||
| 87 | /* for each history table |
||
| 88 | * reg-concept_property_history |
||
| 89 | * reg_schema_property_element_history |
||
| 90 | * open the beta table and get the date of last created date |
||
| 91 | * open the omr table and get everything created newer than the last beta update |
||
| 92 | * step through the history and create or update the concept and schema_property tables |
||
| 93 | * reg_concept |
||
| 94 | * reg_schema_property |
||
| 95 | * ...and write it to beta |
||
| 96 | * and then |
||
| 97 | * reg_concept_property |
||
| 98 | * reg_schema_property_element |
||
| 99 | */ |
||
| 100 | Cache::rememberForever('last_run_timestamp', |
||
| 101 | function () { |
||
| 102 | return now()->toDateTimeString(); |
||
| 103 | }); |
||
| 104 | } |
||
| 105 | |||
| 106 | private function updateUsers(): void |
||
| 107 | { |
||
| 108 | $betaUsers = betaUser::where('updated_at', '>', $this->lastRunTimestamp)->get(); |
||
| 109 | foreach ($betaUsers as $betaUser) { |
||
| 110 | echo $betaUser->id . ', '; |
||
| 111 | $omrUser = omrUser::withTrashed()->find($betaUser->id); |
||
| 112 | if ($omrUser) { |
||
| 113 | //if it's the first run, then we always update beta |
||
| 114 | if ($this->firstRun || $omrUser->last_updated->gt($betaUser->updated_at)) { |
||
| 115 | $betaUser->deleted_at = $omrUser->deleted_at; |
||
| 116 | $betaUser->nickname = $omrUser->nickname; |
||
| 117 | $betaUser->name = $omrUser->nickname; |
||
| 118 | $betaUser->salutation = $omrUser->salutation; |
||
| 119 | $betaUser->first_name = $omrUser->first_name; |
||
| 120 | $betaUser->last_name = $omrUser->last_name; |
||
| 121 | $betaUser->email = $omrUser->email; |
||
| 122 | $betaUser->confirmation_code = $betaUser->confirmation_code ?? md5($omrUser->sha1_password . $omrUser->salt); |
||
| 123 | if ($betaUser->isDirty()) { |
||
| 124 | $betaUser->updated_at = $omrUser->last_updated; |
||
| 125 | $betaUser->save(); |
||
| 126 | } |
||
| 127 | } |
||
| 128 | if (! $this->firstRun && $betaUser->updated_at->gt($omrUser->last_updated)) { |
||
| 129 | $omrUser->deleted_at = $betaUser->deleted_at; |
||
| 130 | $omrUser->nickname = $betaUser->nickname; |
||
| 131 | $omrUser->salutation = $betaUser->salutation; |
||
| 132 | $omrUser->first_name = $betaUser->first_name; |
||
| 133 | $omrUser->last_name = $betaUser->last_name; |
||
| 134 | $omrUser->email = $betaUser->email; |
||
| 135 | if ($omrUser->isDirty()) { |
||
| 136 | $omrUser->last_updated = $betaUser->updated_at; |
||
| 137 | $omrUser->save(); |
||
| 138 | } |
||
| 139 | } |
||
| 140 | } else { //we have a betaUser that doesn't exist in the OMR |
||
| 141 | $omrUser = new omrUser(); |
||
| 142 | $omrUser->id = $betaUser->id; |
||
| 143 | $omrUser->created_at = $betaUser->created_at; |
||
| 144 | $omrUser->last_updated = $betaUser->updated_at; |
||
| 145 | $omrUser->deleted_at = $betaUser->deleted_at; |
||
| 146 | $omrUser->nickname = $betaUser->nickname; |
||
| 147 | $omrUser->salutation = $betaUser->salutation; |
||
| 148 | $omrUser->first_name = $betaUser->first_name; |
||
| 149 | $omrUser->last_name = $betaUser->last_name; |
||
| 150 | $omrUser->email = $betaUser->email; |
||
| 151 | $omrUser->save(); |
||
| 152 | } |
||
| 153 | } |
||
| 154 | $betaId = betaUser::latest()->first()->id; |
||
| 155 | $omrUsers = omrUser::where('id', '>', $betaId)->get(); |
||
| 156 | foreach ($omrUsers as $omrUser) { |
||
| 157 | $betaUser = new betaUser(); |
||
| 158 | $betaUser->id = $omrUser->id; |
||
| 159 | $betaUser->created_at = $omrUser->created_at; |
||
| 160 | $betaUser->updated_at = $omrUser->last_updated; |
||
| 161 | $betaUser->deleted_at = $omrUser->deleted_at; |
||
| 162 | $betaUser->nickname = $omrUser->nickname; |
||
| 163 | $betaUser->name = $omrUser->nickname; |
||
| 164 | $betaUser->salutation = $omrUser->salutation; |
||
| 165 | $betaUser->first_name = $omrUser->first_name; |
||
| 166 | $betaUser->last_name = $omrUser->last_name; |
||
| 167 | $betaUser->email = $omrUser->email; |
||
| 168 | $betaUser->confirmation_code = $betaUser->confirmation_code ?? md5($omrUser->sha1_password . $omrUser->salt); |
||
| 169 | $betaUser->save(); |
||
| 170 | } |
||
| 171 | } |
||
| 172 | |||
| 173 | private function updateAgents(): void |
||
| 174 | { |
||
| 175 | $betaProjects = Project::where('updated_at', '>', $this->lastRunTimestamp)->get(); |
||
| 176 | foreach ($betaProjects as $betaProject) { |
||
| 177 | echo $betaProject->id . ', '; |
||
| 178 | $omrAgent = Agent::withTrashed()->find($betaProject->id); |
||
| 179 | if ($omrAgent) { |
||
| 180 | //if it's the first run, then we always update beta |
||
| 181 | if ($this->firstRun || $omrAgent->last_updated->gt($betaProject->updated_at)) { |
||
| 182 | $this->UpdateMatchingAgent($betaProject, $omrAgent); |
||
| 183 | } |
||
| 184 | if (! $this->firstRun && $betaProject->updated_at->gt($omrAgent->last_updated)) { |
||
| 185 | $this->UpdateMatchingAgent($omrAgent, $betaProject); |
||
| 186 | } |
||
| 187 | } else { //we have a betaProject that doesn't exist in the OMR |
||
| 188 | $this->UpdateMatchingAgent(new Agent(), $betaProject, true); |
||
| 189 | } |
||
| 190 | } |
||
| 191 | $betaId = Project::latest()->first()->id; |
||
| 192 | $omrAgents = Agent::where('id', '>', $betaId)->get(); |
||
| 193 | foreach ($omrAgents as $omrAgent) { |
||
| 194 | $this->UpdateMatchingAgent(new Project(), $omrAgent, true); |
||
| 195 | } |
||
| 196 | } |
||
| 197 | |||
| 198 | private function updateAgentUsers(): void |
||
| 199 | { |
||
| 200 | $betaProjectUsers = ProjectUser::where('updated_at', '>', $this->lastRunTimestamp)->get(); |
||
| 201 | foreach ($betaProjectUsers as $betaProjectUser) { |
||
| 202 | echo $betaProjectUser->id . ', '; |
||
| 203 | $omrAgentUser = AgentUser::withTrashed()->find($betaProjectUser->id); |
||
| 204 | if ($omrAgentUser) { |
||
| 205 | //if it's the first run, then we always update beta |
||
| 206 | if ($this->firstRun || $omrAgentUser->updated_at->gt($betaProjectUser->updated_at)) { |
||
| 207 | $this->UpdateMatchingAgentUser($betaProjectUser, $omrAgentUser); |
||
| 208 | } |
||
| 209 | if (! $this->firstRun && $betaProjectUser->updated_at->gt($omrAgentUser->updated_at)) { |
||
| 210 | $this->UpdateMatchingAgentUser($omrAgentUser, $betaProjectUser); |
||
| 211 | } |
||
| 212 | } else { //we have a betaProject that doesn't exist in the OMR |
||
| 213 | $this->UpdateMatchingAgentUser(new AgentUser(), $betaProjectUser, true); |
||
| 214 | } |
||
| 215 | } |
||
| 216 | $betaId = ProjectUser::latest()->first()->id; |
||
| 217 | $omrAgentUsers = AgentUser::where('id', '>', $betaId)->get(); |
||
| 218 | foreach ($omrAgentUsers as $omrAgentUser) { |
||
| 219 | $this->UpdateMatchingAgentUser(new ProjectUser(), $omrAgentUser, true); |
||
| 220 | } |
||
| 221 | } |
||
| 222 | |||
| 223 | private function updateVocabularies(): void |
||
| 224 | { |
||
| 225 | $betaVocabularies = betaVocabulary::where('updated_at', '>', $this->lastRunTimestamp)->get(); |
||
| 226 | foreach ($betaVocabularies as $betaVocabulary) { |
||
| 227 | echo $betaVocabulary->id . ', '; |
||
| 228 | $omrVocabulary = omrVocabulary::withTrashed()->find($betaVocabulary->id); |
||
| 229 | if ($omrVocabulary) { |
||
| 230 | //if it's the first run, then we always update beta |
||
| 231 | if ($this->firstRun || $omrVocabulary->last_updated->gt($betaVocabulary->updated_at)) { |
||
| 232 | $this->UpdateMatchingVocabulary($betaVocabulary, $omrVocabulary); |
||
| 233 | } |
||
| 234 | if (! $this->firstRun && $betaVocabulary->updated_at->gt($omrVocabulary->last_updated)) { |
||
| 235 | $this->UpdateMatchingVocabulary($omrVocabulary, $betaVocabulary); |
||
| 236 | } |
||
| 237 | } else { //we have a betaProject that doesn't exist in the OMR |
||
| 238 | $this->UpdateMatchingVocabulary(new omrVocabulary(), $betaVocabulary, true); |
||
| 239 | } |
||
| 240 | } |
||
| 241 | $betaId = betaVocabulary::latest()->first()->id; |
||
| 242 | $omrVocabularies = omrVocabulary::where('id', '>', $betaId)->get(); |
||
| 243 | foreach ($omrVocabularies as $omrVocabulary) { |
||
| 244 | $this->UpdateMatchingVocabulary(new betaVocabulary(), $omrVocabulary, true); |
||
| 245 | } |
||
| 246 | } |
||
| 247 | |||
| 248 | private function updateVocabularyUsers(): void |
||
| 270 | } |
||
| 271 | } |
||
| 272 | |||
| 273 | private function updateSchema(): void |
||
| 274 | { |
||
| 275 | $elementsets = Elementset::where('updated_at', '>', $this->lastRunTimestamp)->get(); |
||
| 276 | foreach ($elementsets as $elementset) { |
||
| 277 | echo $elementset->id . ', '; |
||
| 278 | $schema = Schema::withTrashed()->find($elementset->id); |
||
| 279 | if ($schema) { |
||
| 280 | //if it's the first run, then we always update beta |
||
| 281 | if ($this->firstRun || $schema->updated_at->gt($elementset->updated_at)) { |
||
| 282 | $this->UpdateMatchingSchema($elementset, $schema); |
||
| 283 | } |
||
| 284 | if (! $this->firstRun && $elementset->updated_at->gt($schema->updated_at)) { |
||
| 285 | $this->UpdateMatchingSchema($schema, $elementset); |
||
| 286 | } |
||
| 287 | } else { //we have a betaProject that doesn't exist in the OMR |
||
| 288 | $this->UpdateMatchingSchema(new Schema(), $elementset, true); |
||
| 289 | } |
||
| 290 | } |
||
| 291 | $betaId = Elementset::latest()->first()->id; |
||
| 292 | $schemas = Schema::where('id', '>', $betaId)->get(); |
||
| 293 | foreach ($schemas as $schema) { |
||
| 294 | $this->UpdateMatchingSchema(new Elementset(), $schema, true); |
||
| 295 | } |
||
| 296 | } |
||
| 297 | |||
| 298 | private function updateSchemaUsers(): void |
||
| 299 | { |
||
| 300 | $elementsetUsers = ElementsetUser::where('updated_at', '>', $this->lastRunTimestamp)->get(); |
||
| 301 | foreach ($elementsetUsers as $elementsetUser) { |
||
| 302 | echo $elementsetUser->id . ', '; |
||
| 303 | $schemaUser = SchemaUser::withTrashed()->find($elementsetUser->id); |
||
| 304 | if ($schemaUser) { |
||
| 305 | //if it's the first run, then we always update beta |
||
| 306 | if ($this->firstRun || $schemaUser->updated_at->gt($elementsetUser->updated_at)) { |
||
| 307 | $this->UpdateMatchingSchemaUser($elementsetUser, $schemaUser); |
||
| 308 | } |
||
| 309 | if (! $this->firstRun && $elementsetUser->updated_at->gt($schemaUser->updated_at)) { |
||
| 310 | $this->UpdateMatchingSchemaUser($schemaUser, $elementsetUser); |
||
| 311 | } |
||
| 312 | } else { //we have a betaProject that doesn't exist in the OMR |
||
| 313 | $this->UpdateMatchingSchemaUser(new SchemaUser(), $elementsetUser, true); |
||
| 314 | } |
||
| 315 | } |
||
| 316 | $betaId = ElementsetUser::latest()->first()->id; |
||
| 317 | $omrVocabularyUsers = SchemaUser::where('id', '>', $betaId)->get(); |
||
| 318 | foreach ($omrVocabularyUsers as $schemaUser) { |
||
| 319 | $this->UpdateMatchingSchemaUser(new ElementsetUser(), $schemaUser, true); |
||
| 320 | } |
||
| 321 | } |
||
| 322 | |||
| 323 | private function updateImportHistory(): void |
||
| 345 | } |
||
| 346 | } |
||
| 347 | |||
| 348 | private function UpdateMatchingAgent($toModel, $fromModel, $create = false): void |
||
| 349 | { |
||
| 350 | if ($create) { |
||
| 351 | $toModel->id = $fromModel->id; |
||
| 352 | $toModel->created_at = $fromModel->created_at; |
||
| 353 | } |
||
| 354 | $toModel->deleted_at = $fromModel->deleted_at; |
||
| 355 | $toModel->org_email = $fromModel->org_email; |
||
| 356 | $toModel->org_name = $fromModel->org_name; |
||
| 357 | $toModel->ind_affiliation = $fromModel->ind_affiliation; |
||
| 358 | $toModel->ind_role = $fromModel->ind_role; |
||
| 359 | $toModel->address1 = $fromModel->address1; |
||
| 360 | $toModel->address2 = $fromModel->address2; |
||
| 361 | $toModel->city = $fromModel->city; |
||
| 362 | $toModel->state = $fromModel->state; |
||
| 363 | $toModel->postal_code = $fromModel->postal_code; |
||
| 364 | $toModel->country = $fromModel->country; |
||
| 365 | $toModel->phone = $fromModel->phone; |
||
| 366 | $toModel->web_address = $fromModel->web_address; |
||
| 367 | $toModel->type = $fromModel->type; |
||
| 368 | if ($toModel->isDirty()) { |
||
| 369 | if ($toModel instanceof Agent) { |
||
| 370 | $toModel->updated_at = $fromModel->last_updated; |
||
| 371 | } else { |
||
| 372 | $toModel->last_updated = $fromModel->updated_at; |
||
| 373 | } |
||
| 374 | $toModel->save(); |
||
| 375 | } |
||
| 376 | } |
||
| 377 | |||
| 378 | private function UpdateMatchingAgentUser($toModel, $fromModel, $create = false): void |
||
| 379 | { |
||
| 380 | if ($create) { |
||
| 381 | $toModel->id = $fromModel->id; |
||
| 382 | $toModel->created_at = $fromModel->created_at; |
||
| 383 | } |
||
| 384 | $toModel->deleted_at = $fromModel->deleted_at; |
||
| 385 | $toModel->user_id = $fromModel->user_id; |
||
| 386 | $toModel->agent_id = $fromModel->agent_id; |
||
| 387 | $toModel->is_registrar_for = $fromModel->is_registrar_for; |
||
| 388 | $toModel->is_admin_for = $fromModel->is_admin_for; |
||
| 389 | if ($toModel->isDirty()) { |
||
| 390 | $toModel->updated_at = $fromModel->updated_at; |
||
| 391 | $toModel->save(); |
||
| 392 | } |
||
| 393 | } |
||
| 394 | |||
| 395 | private function UpdateMatchingVocabulary($toModel, $fromModel, $create = false): void |
||
| 396 | { |
||
| 397 | if ($create) { |
||
| 398 | $toModel->id = $fromModel->id; |
||
| 399 | $toModel->created_at = $fromModel->created_at; |
||
| 400 | } |
||
| 401 | $toModel->deleted_at = $fromModel->deleted_at; |
||
| 402 | $toModel->agent_id = $fromModel->agent_id; |
||
| 403 | $toModel->name = $fromModel->name; |
||
| 404 | $toModel->note = $fromModel->note; |
||
| 405 | $toModel->uri = $fromModel->uri; |
||
| 406 | $toModel->url = $fromModel->url; |
||
| 407 | $toModel->base_domain = $fromModel->base_domain; |
||
| 408 | $toModel->token = $fromModel->token; |
||
| 409 | $toModel->status_id = $fromModel->status_id; |
||
| 410 | $toModel->language = $fromModel->language; |
||
| 411 | $toModel->languages = $fromModel->languages; |
||
| 412 | $toModel->profile_id = $fromModel->profile_id; |
||
| 413 | $toModel->ns_type = $fromModel->ns_type; |
||
| 414 | $toModel->prefixes = $fromModel->prefixes; |
||
| 415 | $toModel->repo = $fromModel->repo; |
||
| 416 | $toModel->prefix = $fromModel->prefix; |
||
| 417 | $toModel->created_user_id = $fromModel->created_user_id; |
||
| 418 | $toModel->updated_user_id = $fromModel->updated_user_id; |
||
| 419 | $toModel->child_updated_at = $fromModel->child_updated_at; |
||
| 420 | $toModel->child_updated_user_id = $fromModel->child_updated_user_id; |
||
| 421 | if ($toModel->isDirty()) { |
||
| 422 | if ($toModel instanceof omrVocabulary) { |
||
| 423 | $toModel->updated_at = $fromModel->last_updated; |
||
| 424 | } else { |
||
| 425 | $toModel->last_updated = $fromModel->updated_at; |
||
| 426 | } |
||
| 427 | $toModel->save(); |
||
| 428 | } |
||
| 429 | } |
||
| 430 | |||
| 431 | private function UpdateMatchingVocabularyUser($toModel, $fromModel, $create = false): void |
||
| 432 | { |
||
| 433 | if ($create) { |
||
| 434 | $toModel->id = $fromModel->id; |
||
| 435 | $toModel->created_at = $fromModel->created_at; |
||
| 436 | } |
||
| 437 | $toModel->deleted_at = $fromModel->deleted_at; |
||
| 438 | $toModel->vocabulary_id = $fromModel->vocabulary_id; |
||
| 439 | $toModel->user_id = $fromModel->user_id; |
||
| 440 | $toModel->is_maintainer_for = $fromModel->is_maintainer_for; |
||
| 441 | $toModel->is_registrar_for = $fromModel->is_registrar_for; |
||
| 442 | $toModel->is_admin_for = $fromModel->is_admin_for; |
||
| 443 | $toModel->languages = $fromModel->languages; |
||
| 444 | $toModel->default_language = $fromModel->default_language; |
||
| 445 | $toModel->current_language = $fromModel->current_language; |
||
| 446 | if ($toModel->isDirty()) { |
||
| 447 | $toModel->updated_at = $fromModel->updated_at; |
||
| 448 | $toModel->save(); |
||
| 449 | } |
||
| 450 | } |
||
| 451 | |||
| 452 | private function UpdateMatchingSchema($toModel, $fromModel, $create = false): void |
||
| 453 | { |
||
| 454 | if ($create) { |
||
| 455 | $toModel->id = $fromModel->id; |
||
| 456 | $toModel->created_at = $fromModel->created_at; |
||
| 457 | } |
||
| 458 | $toModel->deleted_at = $fromModel->deleted_at; |
||
| 459 | $toModel->agent_id = $fromModel->agent_id; |
||
| 460 | $toModel->created_user_id = $fromModel->created_user_id; |
||
| 461 | $toModel->updated_user_id = $fromModel->updated_user_id; |
||
| 462 | $toModel->child_updated_at = $fromModel->child_updated_at; |
||
| 463 | $toModel->child_updated_user_id = $fromModel->child_updated_user_id; |
||
| 464 | $toModel->name = $fromModel->name; |
||
| 465 | $toModel->note = $fromModel->note; |
||
| 466 | $toModel->uri = $fromModel->uri; |
||
| 467 | $toModel->url = $fromModel->url; |
||
| 468 | $toModel->base_domain = $fromModel->base_domain; |
||
| 469 | $toModel->token = $fromModel->token; |
||
| 470 | $toModel->community = $fromModel->community; |
||
| 471 | $toModel->last_uri_id = $fromModel->last_uri_id; |
||
| 472 | $toModel->status_id = $fromModel->status_id; |
||
| 473 | $toModel->language = $fromModel->language; |
||
| 474 | $toModel->profile_id = $fromModel->profile_id; |
||
| 475 | $toModel->ns_type = $fromModel->ns_type; |
||
| 476 | $toModel->prefixes = $fromModel->prefixes; |
||
| 477 | $toModel->languages = $fromModel->languages; |
||
| 478 | $toModel->repo = $fromModel->repo; |
||
| 479 | if ($toModel->isDirty()) { |
||
| 480 | $toModel->updated_at = $fromModel->updated_at; |
||
| 481 | $toModel->save(); |
||
| 482 | } |
||
| 483 | } |
||
| 484 | |||
| 485 | private function UpdateMatchingSchemaUser($toModel, $fromModel, $create = false): void |
||
| 503 | } |
||
| 504 | } |
||
| 505 | |||
| 506 | private function UpdateMatchingImport($toModel, $fromModel, $create = false): void |
||
| 507 | { |
||
| 508 | if ($create) { |
||
| 509 | $toModel->id = $fromModel->id; |
||
| 510 | $toModel->created_at = $fromModel->created_at; |
||
| 511 | } |
||
| 512 | $toModel->map = $fromModel->map; |
||
| 526 | } |
||
| 527 | } |
||
| 528 | } |
||
| 529 |
Loading history...
This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue.
If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. Please note the @ignore annotation hint above.