');
    }

    protected function filterInputField($field, $value)
    {
        if (in_array($field, $this->notFilteringFields)) {
            return $value;
        }
        $methodName = 'filterInputField' . ucfirst($field);
        if (method_exists($this, $methodName)) {
            $value = $this->$methodName($value);
        }
        return $value;
    }

    protected function filterInput(&$data)
    {
        foreach ($this->readOnlyFields as $field) {
            unset($data[$field]);
        }

        foreach ($data as $key => $value) {
            if (is_array($data[$key])) {
                foreach ($data[$key] as $i => $v) {
                    $data[$key][$i] = $this->filterInputField($i, $data[$key][$i]);
                }
            } else if ($data[$key] instanceof \stdClass) {
                $propertyList = get_object_vars($data[$key]);
                foreach ($propertyList as $property => $value) {
                    $data[$key]->$property = $this->filterInputField($property, $data[$key]->$property);
                }
            } else {
                $data[$key] = $this->filterInputField($key, $data[$key]);
            }
        }
    }

    protected function handleInput(&$data)
    {

    }

    public function createEntity($data)
    {
        $entity = $this->getRepository()->get();

        $this->filterInput($data);
        $this->handleInput($data);

        $entity->set($data);

        $this->beforeCreate($entity);

        if (!$this->isValid($entity)) {
            throw new BadRequest();
        }

        if (empty($data['forceDuplicate'])) {
            $duplicates = $this->checkEntityForDuplicate($entity);
            if (!empty($duplicates)) {
                $reason = array(
                    'reason' => 'Duplicate',
                    'data' => $duplicates
                );
                throw new Conflict(json_encode($reason));
            }
        }

        if ($this->storeEntity($entity)) {
            $this->afterCreate($entity);
            $this->prepareEntityForOutput($entity);
            return $entity;
        }

        throw new Error();
    }


    public function updateEntity($id, $data)
    {
        unset($data['deleted']);

        if (empty($id)) {
            throw BadRequest();
        }

        $this->filterInput($data);
        $this->handleInput($data);

        if ($this->getEntityBeforeUpdate) {
            $entity = $this->getEntity($id);
        } else {
            $entity = $this->getRepository()->get($id);
        }

        if (!$entity) {
            throw new NotFound();
        }

        if (!$this->getAcl()->check($entity, 'edit')) {
            throw new Forbidden();
        }

        $entity->set($data);

        $this->beforeUpdate($entity);

        if (!$this->isValid($entity)) {
            throw new BadRequest();
        }

        if ($this->storeEntity($entity)) {
            $this->afterUpdate($entity);
            $this->prepareEntityForOutput($entity);
            return $entity;
        }

        throw new Error();
    }

    protected function beforeCreate(Entity $entity)
    {
    }

    protected function afterCreate(Entity $entity)
    {
    }

    protected function beforeUpdate(Entity $entity)
    {
    }

    protected function afterUpdate(Entity $entity)
    {
    }

    protected function beforeDelete(Entity $entity)
    {
    }

    protected function afterDelete(Entity $entity)
    {
    }

    public function deleteEntity($id)
    {
        if (empty($id)) {
            throw BadRequest();
        }

        $entity = $this->getRepository()->get($id);

        if (!$entity) {
            throw new NotFound();
        }

        if (!$this->getAcl()->check($entity, 'delete')) {
            throw new Forbidden();
        }

        $this->beforeDelete($entity);

        $result = $this->getRepository()->remove($entity);
        if ($result) {
            $this->afterDelete($entity);
            return $result;
        }
    }

    public function findEntities($params)
    {
        $selectParams = $this->getSelectManager($this->entityName)->getSelectParams($params, true);
        $collection = $this->getRepository()->find($selectParams);

        foreach ($collection as $e) {
            $this->loadParentNameFields($e);
            $this->prepareEntityForOutput($e);
        }

        return array(
            'total' => $this->getRepository()->count($selectParams),
            'collection' => $collection,
        );
    }

    public function findLinkedEntities($id, $link, $params)
    {
        $entity = $this->getEntity($id);
        $foreignEntityName = $entity->relations[$link]['entity'];

        if (!$this->getAcl()->check($entity, 'read')) {
            throw new Forbidden();
        }
        if (!$this->getAcl()->check($foreignEntityName, 'read')) {
            throw new Forbidden();
        }

        $selectParams = $this->getSelectManager($foreignEntityName)->getSelectParams($params, true);

        if (array_key_exists($link, $this->linkSelectParams)) {
            $selectParams = array_merge($selectParams, $this->linkSelectParams[$link]);
        }

        $collection = $this->getRepository()->findRelated($entity, $link, $selectParams);

        $recordService = $this->getRecordService($foreignEntityName);

        foreach ($collection as $e) {
            $this->loadParentNameFields($e);
            $recordService->prepareEntityForOutput($e);
        }

        return array(
            'total' => $this->getRepository()->countRelated($entity, $link, $selectParams),
            'collection' => $collection,
        );
    }

    public function linkEntity($id, $link, $foreignId)
    {
        $entity = $this->getEntity($id);

        $entityName = $entity->getEntityName($entity);
        $foreignEntityName = $entity->relations[$link]['entity'];

        if (!$this->getAcl()->check($entity, 'edit')) {
            throw new Forbidden();
        }

        if (empty($foreignEntityName)) {
            throw new Error();
        }

        $foreignEntity = $this->getEntityManager()->getEntity($foreignEntityName, $foreignId);

        if (!$this->getAcl()->check($foreignEntity, 'edit')) {
            throw new Forbidden();
        }

        if (!empty($foreignEntity)) {
            $this->getRepository()->relate($entity, $link, $foreignEntity);
            return true;
        }
    }

    public function unlinkEntity($id, $link, $foreignId)
    {
        $entity = $this->getEntity($id);

        $entityName = $entity->getEntityName($entity);
        $foreignEntityName = $entity->relations[$link]['entity'];

        if (!$this->getAcl()->check($entity, 'edit')) {
            throw new Forbidden();
        }

        if (empty($foreignEntityName)) {
            throw new Error();
        }

        $foreignEntity = $this->getEntityManager()->getEntity($foreignEntityName, $foreignId);

        if (!$this->getAcl()->check($foreignEntity, 'edit')) {
            throw new Forbidden();
        }

        if (!empty($foreignEntity)) {
            $this->getRepository()->unrelate($entity, $link, $foreignEntity);
            return true;
        }
    }

    public function massUpdate($attributes = array(), $ids = array(), $where = array())
    {
        $idsUpdated = array();
        $repository = $this->getRepository();

        if (!empty($ids)) {
            foreach ($ids as $id) {
                $entity = $this->getEntity($id);
                if ($this->getAcl()->check($entity, 'edit')) {
                    $entity->set(get_object_vars($attributes));
                    if ($repository->save($entity)) {
                        $idsUpdated[] = $id;
                    }
                }
            }
        }

        return $idsUpdated;

        // TODO update $where
    }

    public function massRemove($ids = array(), $where = array())
    {
        $idsRemoved = array();
        $repository = $this->getRepository();

        if (!empty($ids)) {
            foreach ($ids as $id) {
                $entity = $this->getEntity($id);
                if ($this->getAcl()->check($entity, 'remove')) {
                    if ($repository->remove($entity)) {
                        $idsRemoved[] = $id;
                    }
                }
            }
        }

        return $idsRemoved;

        // TODO update $where
    }

    public function follow($id, $userId = null)
    {
        $entity = $this->getEntity($id);
        if (!$this->getAcl()->check($entity, 'read')) {
            throw new Forbidden();
        }

        if (empty($userId)) {
            $userId = $this->getUser()->id;
        }

        return $this->getStreamService()->followEntity($entity, $userId);
    }

    public function unfollow($id, $userId = null)
    {
        $entity = $this->getEntity($id);
        if (!$this->getAcl()->check($entity, 'read')) {
            throw new Forbidden();
        }

        if (empty($userId)) {
            $userId = $this->getUser()->id;
        }

        return $this->getStreamService()->unfollowEntity($entity, $userId);
    }

    protected function getDuplicateWhereClause(Entity $entity)
    {
        return false;
    }

    public function checkEntityForDuplicate(Entity $entity)
    {
        $where = $this->getDuplicateWhereClause($entity);

        if ($where) {
            $duplicates = $this->getRepository()->where($where)->find();
            if (count($duplicates)) {
                $result = array();
                foreach ($duplicates as $e) {
                    $result[$e->id] = $e->get('name');
                }
                return $result;
            }
        }
        return false;
    }

    public function export($ids, $where)
    {
        if (!empty($ids)) {
            $where = array(
                array(
                    'type' => 'in',
                    'field' => 'id',
                    'value' => $ids
                )
            );
        }

        $selectParams = $this->getSelectManager($this->entityName)->getSelectParams(array('where' => $where), true);
        $collection = $this->getRepository()->find($selectParams);

        $arr = array();

        $collection->toArray();

        $fieldsToSkip = array(
            'modifiedByName',
            'createdByName',
            'modifiedById',
            'createdById',
            'modifiedAt',
            'createdAt',
            'deleted',
        );

        $fields = null;
        foreach ($collection as $entity) {
            if (empty($fields)) {
                $fields = array();
                foreach ($entity->getFields() as $field => $defs) {
                    if (in_array($field, $fieldsToSkip)) {
                        continue;
                    }

                    if (empty($defs['notStorable'])) {
                        $fields[] = $field;
                    } else {
                        if (in_array($defs['type'], array('email', 'phone'))) {
                            $fields[] = $field;
                        } else if ($defs['name'] == 'name') {
                            $fields[] = $field;
                        }
                    }
                }
            }

            $row = array();
            foreach ($fields as $field) {
                $value = $this->getFieldFromEntityForExport($entity, $field);
                $row[$field] = $value;
            }
            $arr[] = $row;
        }

        $delimiter = $this->getPreferences()->get('exportDelimiter');
        if (empty($delimiter)) {
        	$delimiter = $this->getConfig()->get('exportDelimiter', ';');
        }

        $fp = fopen('php://temp', 'w');
        fputcsv($fp, array_keys($arr[0]), $delimiter);
        foreach ($arr as $row) {
            fputcsv($fp, $row, $delimiter);
        }
        rewind($fp);
        $csv = stream_get_contents($fp);
        fclose($fp);

        $fileName = "Export_{$this->entityName}.csv";

        $attachment = $this->getEntityManager()->getEntity('Attachment');
        $attachment->set('name', $fileName);
        $attachment->set('role', 'Export File');
        $attachment->set('type', 'text/csv');

        $this->getEntityManager()->saveEntity($attachment);

        if (!empty($attachment->id)) {
            $this->getInjection('fileManager')->putContents('data/upload/' . $attachment->id, $csv);
            // TODO cron job to remove file
            return $attachment->id;
        }
        throw new Error();
    }

    protected function getFieldFromEntityForExport(Entity $entity, $field)
    {
        $defs = $entity->getFields();
        if (!empty($defs[$field]) && !empty($defs[$field]['type'])) {
            $type = $defs[$field]['type'];
            switch ($type) {
                case 'jsonArray':
                    $value = $entity->get($field);
                    if (is_array($value)) {
                        return implode(',', $value);
                    } else {
                        return null;
                    }
                    break;
                case 'password':
                    return null;
                    break;
            }
        }
        return $entity->get($field);
    }

    public function prepareEntityForOutput(Entity $entity)
    {
        foreach ($this->internalFields as $field) {
            $entity->clear($field);
        }
    }

    public function merge($id, array $sourceIds = array())
    {
        if (empty($id)) {
            throw new Error();
        }

        $entity = $this->getEntity($id);

        if (!$entity) {
            throw new NotFound();
        }

        if (!$this->getAcl()->check($entity, 'edit')) {
            throw new Forbidden();
        }

        $pdo = $this->getEntityManager()->getPDO();

        $sourceList = array();
        foreach ($sourceIds as $sourceId) {
            $source = $this->getEntity($sourceId);
            $sourceList[] = $source;
            if (!$this->getAcl()->check($source, 'edit') || !$this->getAcl()->check($source, 'delete')) {
                throw new Forbidden();
            }
        }

        foreach ($sourceList as $source) {
            $sql = "
                UPDATE `note`
                    SET
                        `parent_id` = " . $pdo->quote($entity->id) . ",
                        `parent_type` = " . $pdo->quote($entity->getEntityName()) . "
                WHERE
                    `type` IN ('Post', 'EmailSent', 'EmailReceived') AND
                    `parent_id` = " . $pdo->quote($source->id) . " AND
                    `parent_type` = ".$pdo->quote($source->getEntityName())." AND
                    `deleted` = 0
            ";
            $pdo->query($sql);
        }

        $repository = $this->getEntityManager()->getRepository($entity->getEntityName());

        foreach ($sourceList as $source) {
            foreach ($this->mergeLinkList as $link) {
                $linkedList = $repository->findRelated($source, $link);
                foreach ($linkedList as $linked) {
                    $repository->relate($entity, $link, $linked);
                }
            }
        }


        foreach ($sourceList as $source) {
            $this->getEntityManager()->removeEntity($source);
        }

        return true;
    }
}