ntentan\nibii\DataOperations

Complexity

Total Complexity

36

Size/Duplication

Total Lines	212
Duplicated Lines	2.83 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

84.91%

Importance

Changes	3
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	6	6	1
C	doSave()	0	41	7
A	doValidate()	0	8	2
B	saveRecord()	0	58	7
A	validate()	0	20	4
B	isPrimaryKeySet()	0	16	7
A	assignValue()	0	7	2
A	getData()	0	3	1
A	getInvalidFields()	0	3	1
A	isItemDeletable()	0	7	2
A	runBehaviours()	0	6	2

<?php

/*
 * The MIT License
 *
 * Copyright 2015 ekow.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

namespace ntentan\nibii;

/**
 * Description of DataOperations
 *
 * @author ekow
 */
class DataOperations {

    private $wrapper;

    /**
     *
     * @var DriverAdapter
     */
    private $adapter;
    private $data;
    private $invalidFields;
    private $hasMultipleData;
    private $driver;
    private $container;

    const MODE_SAVE = 0;
    const MODE_UPDATE = 1;

    public function __construct(ORMContext $context, RecordWrapper $wrapper, DriverAdapter $adapter) {

This method seems to be duplicated in your project.

        $this->wrapper = $wrapper;
        $this->adapter = $adapter;
        $this->driver = $context->getDbContext()->getDriver();
        $this->container = $context->getContainer();
    }

    public function doSave($hasMultipleData) {
        $this->hasMultipleData = $hasMultipleData;
        $invalidFields = [];
        $data = $this->wrapper->getData();
        $primaryKey = $this->wrapper->getDescription()->getPrimaryKey();
        $singlePrimaryKey = null;

$singlePrimaryKey is not used, you could remove the assignment.

        $succesful = true;

        if (count($primaryKey) == 1) {
            $singlePrimaryKey = $primaryKey[0];

$singlePrimaryKey is not used, you could remove the assignment.

        }

        // Assign an empty array to force a validation error for empty models
        if (empty($data)) {
            $data = [[]];
        }

        $this->driver->beginTransaction();

        foreach ($data as $i => $datum) {
            $status = $this->saveRecord($datum, $primaryKey);

$primaryKey is of type array, but the function expects a object<ntentan\nibii\type>.

            $data[$i] = $datum;

            if (!$status['success']) {
                $succesful = false;
                $invalidFields[$i] = $status['invalid_fields'];
                $this->driver->rollback();
                break;
            }
        }

        if ($succesful) {
            $this->driver->commit();
        } else {
            $this->assignValue($this->invalidFields, $invalidFields);
        }

        $this->wrapper->setData($hasMultipleData ? $data : $data[0]);

        return $succesful;
    }
    
    public function doValidate() {

The return type could not be reliably inferred; please add a @return annotation.

        $record = $this->wrapper->getData()[0];
        $primaryKey = $this->wrapper->getDescription()->getPrimaryKey();
        $pkSet = $this->isPrimaryKeySet($primaryKey, $record);
        return $this->validate(
            $record, $pkSet ? DataOperations::MODE_UPDATE : DataOperations::MODE_SAVE
        );
    }

    /**
     * Save an individual record.
     * 
     * @param array $record The record to be saved
     * @param type $primaryKey The primary keys of the record
     * @return boolean

Should the return type not be array?

     */
    private function saveRecord(&$record, $primaryKey) {
        $status = [
            'success' => true,
            'pk_assigned' => null,
            'invalid_fields' => []
        ];

        // Determine if the primary key of the record is set.
        $pkSet = $this->isPrimaryKeySet($primaryKey, $record);

        // Reset the data in the model to contain only the data to be saved
        $this->wrapper->setData($record);

        // Run preUpdate or preSave callbacks on models and behaviours
        if ($pkSet) {
            $this->wrapper->preUpdateCallback();
            $record = $this->wrapper->getData();
            $record = reset($record) === false ? [] : reset($record);
            $record = $this->runBehaviours('preUpdateCallback', [$record]);
        } else {
            $this->wrapper->preSaveCallback();
            $record = $this->wrapper->getData();
            $record = reset($record) === false ? [] : reset($record);
            $record = $this->runBehaviours('preSaveCallback', [$record]);
        }

        // Validate the data
        $validity = $this->validate(
            $record, $pkSet ? DataOperations::MODE_UPDATE : DataOperations::MODE_SAVE
        );

        // Exit if data is invalid
        if ($validity !== true) {
            $status['invalid_fields'] = $validity;
            $status['success'] = false;
            return $status;
        }

        // Assign the data to the wrapper again
        $this->wrapper->setData($record);

        // Update or save the data and run post callbacks
        if ($pkSet) {
            $this->adapter->update($record);
            $this->wrapper->postUpdateCallback();
            $this->runBehaviours('postUpdateCallback', [$record]);
        } else {
            $this->adapter->insert($record);
            $keyValue = $this->driver->getLastInsertId();
            $this->wrapper->{$primaryKey[0]} = $keyValue;
            $this->wrapper->postSaveCallback($keyValue);
            $this->runBehaviours('postSaveCallback', [$record, $keyValue]);
        }

        // Reset the data so it contains any modifications made by callbacks
        $record = $this->wrapper->getData()[0];
        return $status;
    }

    private function validate($data, $mode) {

The return type could not be reliably inferred; please add a @return annotation.

        $valid = true;
        $validator = $this->container->resolve(
            ModelValidator::class, ['model' => $this->wrapper, 'mode' => $mode]
        );

        if (!$validator->validate($data)) {
            $valid = false;
        }

        if ($valid) {
            $valid = $this->wrapper->onValidate();
        }

        if ($valid === false) {
            $valid = $validator->getInvalidFields();
        }

        return $valid;
    }

    private function isPrimaryKeySet($primaryKey, $data) {
        if (is_string($primaryKey)) {
            if (isset($data[$primaryKey])) {
                return true;
            }
        }
        foreach ($primaryKey as $keyField) {
            if (!isset($data[$keyField])) {
                break;
            }
            if ($data[$keyField] !== '' && $data[$keyField] !== null) {
                return true;
            }
        }
        return false;
    }

    private function assignValue(&$property, $value) {
        if ($this->hasMultipleData) {
            $property = $value;
        } else {
            $property = $value[0];
        }
    }

    public function getData() {

The return type could not be reliably inferred; please add a @return annotation.

        return $this->data;
    }

    public function getInvalidFields() {

The return type could not be reliably inferred; please add a @return annotation.

        return $this->invalidFields;
    }

    public function isItemDeletable($primaryKey, $data) {
        if ($this->isPrimaryKeySet($primaryKey, $data)) {
            return true;
        } else {
            return false;
        }
    }

    private function runBehaviours($event, $args) {

The return type could not be reliably inferred; please add a @return annotation.

        foreach ($this->wrapper->getBehaviours() as $behaviour) {
            $args[0] = call_user_func_array([$behaviour, $event], $args);
        }
        return $args[0];
    }

}