Refactoring

src/Data/Admin/Api/AbstractDataImporter.php

@@ -0,0 +1,246 @@
+<?php
+namespace Data\Admin\Api;
+
+use Classes\BaseService;
+use Classes\IceResponse;
+use Data\Common\Model\DataImport;
+use FieldNames\Common\Model\CustomField;
+use Utils\LogManager;
+
+abstract class AbstractDataImporter
+{
+
+    var $dataImport = null;
+
+    var $headerMapping = array();
+    var $primaryKeyColumn = 0;
+
+    var $rowObjects = array();
+    var $attachedObjects = array();
+    var $objectKeys;
+    var $customFields;
+    var $columnsCompeted = array();
+    var $relatedColumns = array();
+
+    public function getRowObjects()
+    {
+        return $this->rowObjects;
+    }
+
+    public function getHeaderMapping()
+    {
+        return $this->headerMapping;
+    }
+
+    public function processHeader($data)
+    {
+        $columns = $this->dataImport->columns;
+        $headers = json_decode($columns);
+
+        $counter = 0;
+        foreach ($headers as $column) {
+            $this->headerMapping[] = $column;
+            if ($column->idField == "Yes") {
+                $this->primaryKeyColumn = $counter;
+            }
+            //Update related columns
+            if (($column->type == "Reference" || $column->type == "Attached") && $column->isKeyField == "Yes") {
+                $this->relatedColumns[$counter] = array();
+                for ($i = 0; $i< count($headers); $i++) {
+                    $columnNew = $headers[$i];
+                    if ($columnNew->id != $column->id &&
+                        $columnNew->dependOn == $column->dependOn && $column->dependOn != "NULL") {
+                        $this->relatedColumns[$counter][$i] = $columnNew;
+                    }
+                }
+            }
+
+            $counter++;
+        }
+
+        $modelObject = $this->getModelObject();
+        $obj = new $modelObject();
+        $this->objectKeys = $obj->getObjectKeys();
+
+        $this->updateCustomFields();
+    }
+
+    public function setDataImportId($dataImportId)
+    {
+        $this->dataImport = new DataImport();
+        $this->dataImport->Load("id =?", array($dataImportId));
+    }
+
+    public function updateCustomFields()
+    {
+        $customField = new CustomField();
+        $customFields = $customField->Find("type = ?", array($this->getModelObject()));
+        $this->customFields = array();
+        foreach ($customFields as $cf) {
+            $this->customFields[$cf->name] = $cf;
+        }
+    }
+
+    public function addCustomField($column)
+    {
+        $customField = new CustomField();
+        $customField->type = $this->getModelObject();
+        $customField->name = $column->name;
+        $customField->display = "Form";
+        $customField->field_type = "text";
+        $customField->field_label = $column->title;
+        $customField->field_validation = "none";
+        $customField->display_order = 0;
+        $customField->Save();
+    }
+
+    public function markCellCompleted($row, $col)
+    {
+        if (!isset($this->columnsCompeted[$row])) {
+            $this->columnsCompeted[$row] = array();
+        }
+
+        $this->columnsCompeted[$row][$col] = true;
+    }
+
+    public function isCellCompleted($row, $col)
+    {
+        if (!isset($this->columnsCompeted[$row])) {
+            return false;
+        } else {
+            if (!isset($this->columnsCompeted[$row][$col])) {
+                return false;
+            }
+            return true;
+        }
+    }
+
+    public function processData($row, $column, $data, $allData)
+    {
+
+        LogManager::getInstance()->debug("processData:".json_encode($data));
+        if ($this->isCellCompleted($row, $column)) {
+            LogManager::getInstance()->debug("Already Competed");
+            return new IceResponse(IceResponse::SUCCESS, "Already Competed");
+        }
+
+        $headerColumn = $this->headerMapping[$column];
+
+        //Load row object if its empty
+        if (!isset($this->rowObjects[$row])) {
+            $modelObj = $this->getModelObject();
+            $this->rowObjects[$row] = new $modelObj();
+            if ($headerColumn->idField == "Yes") {
+                LogManager::getInstance()->debug("[processData] Load : $headerColumn->name = $data");
+                $this->rowObjects[$row]->Load("$headerColumn->name = ?", array($data));
+            }
+        }
+
+        //Check for non existing column names
+        if (!isset($this->objectKeys[$headerColumn->name])) {
+            if (!isset($this->customFields[$headerColumn->name])) {
+                $this->addCustomField($headerColumn);
+                $this->updateCustomFields();
+            }
+        }
+
+        if ($headerColumn->type == "Normal") {
+            $this->rowObjects[$row]->{$headerColumn->name} = $data;
+        } elseif ($headerColumn->type == "Reference" || $headerColumn->type == "Attached") {
+            if ($headerColumn->isKeyField == "Yes") {
+                $hcClass = BaseService::getInstance()->getFullQualifiedModelClassName($headerColumn->dependOn);
+                $hcField = $headerColumn->dependOnField;
+                /* @var \Model\BaseModel $hcObject */
+                $hcObject = new $hcClass();
+                if ($headerColumn->type == "Attached" && !empty($this->rowObjects[$row]->id)) {
+                    $hcObject->Load("$hcField = ? and employee = ?", array($data,$this->rowObjects[$row]->id));
+                } else {
+                    $hcObject->Load("$hcField = ?", array($data));
+                }
+
+                $hcObject->{$hcField} = $data;
+                foreach ($this->relatedColumns[$column] as $key => $val) {
+                    $tempValName = $val->name;
+                    if (strstr($val->name, "/")) {
+                        $tempValName = explode("/", $val->name)[1];
+                    }
+                    $hcObject->{$tempValName} = $allData[$key];
+                    $this->markCellCompleted($row, $key);
+                }
+
+                if ($headerColumn->type == "Reference") {
+                    $hcObject->Save();
+                } else {
+                    if (!isset($this->attachedObjects[$row])) {
+                        $this->attachedObjects[$row] = array();
+                    }
+                    $this->attachedObjects[$row][] = $hcObject;
+                }
+                $this->rowObjects[$row]->{$headerColumn->name} = $hcObject->id;
+            }
+        }
+
+        $this->markCellCompleted($row, $column);
+        return new IceResponse(IceResponse::SUCCESS, $this->rowObjects[$row]);
+    }
+
+    public function processDataRow($row, $data)
+    {
+
+        $result = array();
+
+        LogManager::getInstance()->debug("processDataRow:".json_encode($data));
+        $counter = 0;
+        foreach ($data as $cell) {
+            $this->processData($row, $counter, $cell, $data);
+            $counter++;
+        }
+        LogManager::getInstance()->debug("Row Object :" . print_r($this->rowObjects[$row], true));
+        $this->rowObjects[$row] = $this->fixBeforeSave($this->rowObjects[$row], $data);
+        if (!$this->isDuplicate($this->rowObjects[$row])) {
+            $ok = $this->rowObjects[$row]->Save();
+
+            if (!$ok) {
+                LogManager::getInstance()->error(
+                    "Row Object Error Saving Employee :" . $this->rowObjects[$row]->ErrorMsg()
+                );
+                $result['Error'] = "Row Object Error Saving Employee :" . $this->rowObjects[$row]->ErrorMsg();
+            } else {
+                $result['MainId'] = $this->rowObjects[$row]->id;
+                $class = $this->getModelObject();
+                $ele = new $class();
+
+                $result['CustomFields'] = array();
+                $customFields = $ele->getCustomFields($this->rowObjects[$row]);
+                foreach ($this->rowObjects[$row] as $k => $v) {
+                    if (isset($customFields[$k])) {
+                        BaseService::getInstance()->customFieldManager
+                            ->addCustomField($class, $this->rowObjects[$row]->id, $k, $v);
+                        $result['CustomFields'][] = array($class, $this->rowObjects[$row]->id, $k, $v);
+                    }
+                }
+
+                if (!empty($this->attachedObjects[$row])) {
+                    /* @var \Model\BaseModel $aObj */
+                    foreach ($this->attachedObjects[$row] as $aObj) {
+                        $aObj->employee = $this->rowObjects[$row]->id;
+
+                        $aObj->Save();
+                        $result['attachedObjects'][] = $aObj;
+                    }
+                }
+            }
+        } else {
+            $result['Error'] = "Duplicate Object Found";
+        }
+
+        return $result;
+    }
+
+    abstract public function getModelObject();
+    public function isDuplicate($obj)
+    {
+        return false;
+    }
+    abstract public function fixBeforeSave($object, $data);
+}

src/Data/Admin/Api/DataActionManager.php

@@ -0,0 +1,83 @@
+<?php
+/**
+ * Created by PhpStorm.
+ * User: Thilina
+ * Date: 8/19/17
+ * Time: 8:02 AM
+ */
+
+namespace Data\Admin\Api;
+
+use Classes\FileService;
+use Classes\IceResponse;
+use Classes\SubActionManager;
+use Data\Common\Model\DataImport;
+use Data\Common\Model\DataImportFile;
+use Utils\LogManager;
+
+class DataActionManager extends SubActionManager
+{
+
+    public function processDataFile($req)
+    {
+        $id = $req->id;
+        $dataFile = new DataImportFile();
+        $dataFile->Load("id = ?", array($id));
+        if (empty($dataFile->id)) {
+            return new IceResponse(IceResponse::ERROR, null);
+        }
+        $url = FileService::getInstance()->getFileUrl($dataFile->file);
+
+        if (strstr($url, CLIENT_BASE_URL) !== false) {
+            $url = str_replace(CLIENT_BASE_URL, CLIENT_BASE_PATH, $url);
+        }
+
+        LogManager::getInstance()->info("File Path:".$url);
+
+        $data = file_get_contents($url);
+
+        $data = str_replace("\r", "\n", $data);
+        $data = str_replace("\n\n", "\n", $data);
+
+        $lines = str_getcsv($data, "\n");
+
+        $headerProcessed = false;
+
+        $counter = 0;
+
+        $dataImport = new DataImport();
+        $dataImport->Load("id =?", array($dataFile->data_import_definition));
+        if (empty($dataImport->id)) {
+            return new IceResponse(IceResponse::ERROR, null);
+        }
+
+        $processClass = '\\Data\Admin\Import\\'.$dataImport->dataType;
+        $processObj = new $processClass();
+
+        LogManager::getInstance()->info("Line Count:".count($lines));
+
+        $res = array();
+
+        foreach ($lines as $line) {
+            $cells = str_getcsv($line, ",");
+            if ($headerProcessed === false) {
+                $processObj->setDataImportId($dataImport->id);
+                $processObj->processHeader($cells);
+                $headerProcessed = true;
+            } else {
+                $result = $processObj->processDataRow($counter, $cells);
+                $res[] = array($cells,$result);
+            }
+            $counter++;
+        }
+
+        $dataFile->status = "Processed";
+        $dataFile->details = json_encode($res, JSON_PRETTY_PRINT);
+        $dataFile->Save();
+        return new IceResponse(IceResponse::SUCCESS, $processObj->getRowObjects());
+    }
+
+    private function processHeader($dataImportId, $data)
+    {
+    }
+}

src/Data/Admin/Api/DataAdminManager.php

@@ -0,0 +1,27 @@
+<?php
+namespace Data\Admin\Api;
+
+use Classes\AbstractModuleManager;
+
+class DataAdminManager extends AbstractModuleManager
+{
+
+    public function initializeUserClasses()
+    {
+    }
+
+    public function initializeFieldMappings()
+    {
+        $this->addFileFieldMapping('DataImportFile', 'file', 'name');
+    }
+
+    public function initializeDatabaseErrorMappings()
+    {
+    }
+
+    public function setupModuleClassDefinitions()
+    {
+        $this->addModelClass('DataImport');
+        $this->addModelClass('DataImportFile');
+    }
+}

src/Data/Admin/Import/AttendanceDataImporter.php

@@ -0,0 +1,36 @@
+<?php
+namespace Data\Admin\Import;
+
+use Attendance\Common\Model\Attendance;
+use Data\Admin\Api\AbstractDataImporter;
+
+class AttendanceDataImporter extends AbstractDataImporter
+{
+
+    var $processed = array();
+
+    public function getModelObject()
+    {
+        return "\\Attendance\\Common\\Model\\Attendance";
+    }
+
+    public function fixBeforeSave($object, $data)
+    {
+        return $object;
+    }
+
+    public function isDuplicate($obj)
+    {
+        $old = new Attendance();
+        $data = $old->Find(
+            "employee = ? and in_time = ? and out_time = ?",
+            array($obj->employee, $obj->in_time, $obj->out_time)
+        );
+
+        if (count($data)>0) {
+            return true;
+        }
+
+        return false;
+    }
+}

src/Data/Admin/Import/EmployeeDataImporter.php

@@ -0,0 +1,25 @@
+<?php
+namespace Data\Admin\Import;
+
+use Data\Admin\Api\AbstractDataImporter;
+
+class EmployeeDataImporter extends AbstractDataImporter
+{
+
+    var $processed = array();
+
+    public function getModelObject()
+    {
+        return "\\Employees\\Common\\Model\\Employee";
+    }
+
+    public function fixBeforeSave($object, $data)
+    {
+
+        if (empty($object->status)) {
+            $object->status = "Active";
+        }
+
+        return $object;
+    }
+}

src/Data/Common/Model/DataImport.php

@@ -0,0 +1,19 @@
+<?php
+namespace Data\Common\Model;
+
+use Model\BaseModel;
+
+class DataImport extends BaseModel
+{
+    var $_table = 'DataImport';
+
+    public function getAdminAccess()
+    {
+        return array("get","element","save","delete");
+    }
+
+    public function getUserAccess()
+    {
+        return array("get","element");
+    }
+}

src/Data/Common/Model/DataImportFile.php

@@ -0,0 +1,28 @@
+<?php
+namespace Data\Common\Model;
+
+use Classes\IceResponse;
+use Model\BaseModel;
+
+class DataImportFile extends BaseModel
+{
+    var $_table = 'DataImportFiles';
+
+    public function getAdminAccess()
+    {
+        return array("get","element","save","delete");
+    }
+
+    public function getUserAccess()
+    {
+        return array("get","element");
+    }
+
+    public function executePreSaveActions($obj)
+    {
+        if (empty($obj->status)) {
+            $obj->status = "Not Processed";
+        }
+        return new IceResponse(IceResponse::SUCCESS, $obj);
+    }
+}