OCA\Ocr\Service\JobService

Complexity

Total Complexity

38

Size/Duplication

Total Lines	379
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

8.16%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	14	1
C	process()	0	40	7
B	deleteJob()	0	25	4
A	getAllJobsForUser()	0	18	3
A	checkForFinishedJobs()	0	15	3
A	jobFinished()	0	16	3
B	handleProcessed()	0	23	4
A	handleFailed()	0	19	3
A	getTempFile()	0	12	2
A	transformJob()	0	8	3
A	checkForAcceptedLanguages()	0	8	2
A	noLanguage()	0	7	2
A	handleException()	0	7	1

<?php

/**
 * Nextcloud - OCR
 * This file is licensed under the Affero General Public License version 3 or
 * later.
 * See the COPYING file.
 * 
 * @author Janis Koehr <janiskoehr@icloud.com>
 * @copyright Janis Koehr 2017
 */
namespace OCA\Ocr\Service;

use OCA\Ocr\Db\OcrJobMapper;
use OC\Files\View;
use OCP\ILogger;
use OCP\IL10N;
use OCP\ITempManager;
use OCA\Ocr\Db\OcrJob;
use OCA\Ocr\Constants\OcrConstants;
use OCA\Ocr\Util\PHPUtil;
use Exception;
use OCP\AppFramework\Db\DoesNotExistException;


/**
 * Class JobService
 * 
 * @package OCA\Ocr\Service
 */
class JobService {

    /**
     *
     * @var ILogger
     */
    private $logger;

    /**
     *
     * @var RedisService
     */
    private $redisService;

    /**
     *
     * @var OcrJobMapper
     */
    private $jobMapper;

    /**
     *
     * @var View
     */
    private $view;

    /**
     *
     * @var String
     */
    private $userId;

    /**
     *
     * @var IL10N
     */
    private $l10n;

    /**
     *
     * @var FileService
     */
    private $fileService;

    /**
     *
     * @var ITempManager
     */
    private $tempM;

    /**
     *
     * @var AppConfigService
     */
    private $appConfigService;

    /**
     *
     * @var PHPUtil
     */
    private $phpUtil;

    /**
     * JobService constructor.
     * 
     * @param IL10N $l10n            
     * @param ILogger $logger            
     * @param string $userId            
     * @param View $view            
     * @param RedisService $queueService            
     * @param OcrJobMapper $mapper            
     * @param FileService $fileService            
     * @param AppConfigService $appConfigService            
     * @param PHPUtil $phpUtil            
     */
    public function __construct(IL10N $l10n, ILogger $logger, $userId, View $view, ITempManager $tempManager, 
            RedisService $queueService, OcrJobMapper $mapper, FileService $fileService, 
            AppConfigService $appConfigService, PHPUtil $phpUtil) {
        $this->logger = $logger;
        $this->redisService = $queueService;
        $this->jobMapper = $mapper;
        $this->view = $view;
        $this->userId = $userId;
        $this->l10n = $l10n;
        $this->fileService = $fileService;
        $this->tempM = $tempManager;
        $this->appConfigService = $appConfigService;
        $this->phpUtil = $phpUtil;
    }

    /**
     * Processes and prepares the files for OCR.
     * Sends the stuff to the client in order to OCR async.
     * 
     * @param string[] $languages            
     * @param array $files            
     * @return string
     */
    public function process($languages, $files) {
        try {
            $this->logger->debug('Will now process files: {files} with languages: {languages}', 
                    [
                            'files' => json_encode($files),
                            'languages' => json_encode($languages)
                    ]);
            // Check if files and language not empty
            $noLang = $this->noLanguage($languages);
            if (!empty($files) && ($this->checkForAcceptedLanguages($languages) || $noLang)) {
                // language part:
                if ($noLang) {
                    $languages = [];
                }
                // file part:
                $fileInfo = $this->fileService->buildFileInfo($files);
                foreach ($fileInfo as $fInfo) {
                    // Check Shared
                    $shared = $this->fileService->checkSharedWithInitiator($fInfo);
                    $target = $this->fileService->buildTarget($fInfo, $shared);
                    $source = $this->fileService->buildSource($fInfo, $shared);
                    // set the running type
                    $fType = $this->fileService->getCorrectType($fInfo);
                    // create a temp file for ocr processing purposes
                    $tempFile = $this->getTempFile($fType);
                    // Create job object
                    $job = new OcrJob(OcrConstants::STATUS_PENDING, $source, $target, $tempFile, $fType, $this->userId, 
                            false, $fInfo->getName(), null);

Consider using $fInfo->name. There is an issue with getName() and APC-enabled PHP versions.

                    // Init client and send task / job
                    // Feed the worker
                    $this->redisService->sendJob($job, $languages);
                }
                return 'PROCESSING';
            } else {
                throw new NotFoundException($this->l10n->t('Empty parameters passed.'));
            }
        } catch (Exception $e) {
            $this->handleException($e);
        }
    }

    /**
     * Delete an ocr job for a given id and userId.
     * 
     * @param
     *            $jobId
     * @param string $userId            
     * @return OcrJob
     */
    public function deleteJob($jobId, $userId) {
        try {
            $job = $this->jobMapper->find($jobId);
            if ($job->getUserId() !== $userId) {
                throw new NotFoundException($this->l10n->t('Cannot delete. Wrong owner.'));
            } else {
                $job = $this->jobMapper->delete($job);
            }
            $job->setTarget(null);
            $job->setSource(null);
            $job->setStatus(null);
            $job->setTempFile(null);
            $job->setType(null);
            $job->setUserId(null);
            $job->setErrorDisplayed(null);
            return $job;
        } catch (Exception $e) {
            if ($e instanceof DoesNotExistException) {

The class OCP\AppFramework\Db\DoesNotExistException does not exist. Did you forget a USE statement, or did you not list all dependencies?

                $ex = new NotFoundException($this->l10n->t('Cannot delete. Wrong ID.'));
                $this->handleException($ex);
            } else {
                $this->handleException($e);
            }
        }
    }

    /**
     * Gets all job objects for a specific user.
     * 
     * @param string $userId            
     * @return array
     */
    public function getAllJobsForUser($userId) {
        try {
            $jobs = $this->jobMapper->findAll($userId);
            $jobsNew = array();
            foreach ($jobs as $job) {
                $job->setTarget(null);
                $job->setSource(null);
                $job->setTempFile(null);
                $job->setType(null);
                $job->setUserId(null);
                $job->setErrorDisplayed(null);
                array_push($jobsNew, $job);
            }
            return $jobsNew;
        } catch (Exception $e) {
            $this->handleException($e);
        }
    }

    /**
     * The function checks if there are finished jobs to process finally.
     * 
     * @throws NotFoundException
     */
    public function checkForFinishedJobs() {
        try {
            $finishedJobs = $this->redisService->readingFinishedJobs();
            foreach ($finishedJobs as $finishedJob) {
                $fJob = $this->transformJob($finishedJob);
                $this->logger->debug('The following job finished: {job}', 
                        [
                                'job' => $fJob
                        ]);
                $this->jobFinished($fJob->id, $fJob->error, $fJob->log);
            }
        } catch (Exception $e) {
            throw new NotFoundException($this->l10n->t('Reading the finished jobs from redis went wrong.'));
        }
    }

    /**
     * The function the worker will call in order to set the jobs status.
     * The worker should call it automatically after each processing step.
     * 
     * @param integer $jobId            
     * @param boolean $error            
     * @param string $log            
     */
    public function jobFinished($jobId, $error, $log) {
        try {
            $job = $this->jobMapper->find($jobId);
            if (!$error) {
                $job->setStatus(OcrConstants::STATUS_PROCESSED);
                $this->jobMapper->update($job);
            } else {
                $job->setStatus(OcrConstants::STATUS_FAILED);
                $job->setErrorLog($log);
                $this->jobMapper->update($job);
                $this->logger->error($log);
            }
        } catch (Exception $e) {
            $this->handleException($e);
        }
    }

    /**
     * Finishes all Processed files by copying them to the right path and deleteing the temp files.
     * Returns the number of processed files.
     * 
     * @return array
     */
    public function handleProcessed() {
        try {
            $this->logger->debug('Check if files were processed by ocr and if so, put them to the right dirs.');
            $processed = $this->jobMapper->findAllProcessed($this->userId);
            foreach ($processed as $job) {
                if ($this->fileService->fileExists($job->getTempFile())) {
                    // Save the tmp file with newname
                    $this->view->file_put_contents($job->getTarget(), 
                            $this->fileService->getFileContents($job->getTempFile()));
                    $this->jobMapper->delete($job);
                    $this->fileService->execRemove($job->getTempFile());
                } else {
                    $job->setStatus(OcrConstants::STATUS_FAILED);
                    $job->setErrorLog('Temp file does not exist.');
                    $this->jobMapper->update($job);
                    throw new NotFoundException($this->l10n->t('Temp file does not exist.'));
                }
            }
            return $processed;
        } catch (Exception $e) {
            $this->handleException($e);
        }
    }

    /**
     * Handles all failed orders of ocr processing queue and returns the job objects.
     * 
     * @return array
     */
    public function handleFailed() {
        try {
            $failed = $this->jobMapper->findAllFailed($this->userId);
            foreach ($failed as $job) {
                // clean the tempfile
                $this->fileService->execRemove($job->getTempFile());
                // set error displayed
                $job->setErrorDisplayed(true);
                $this->jobMapper->update($job);
            }
            $this->logger->debug('Following jobs failed: {failed}', 
                    [
                            'failed' => json_encode($failed)
                    ]);
            return $failed;
        } catch (Exception $e) {
            $this->handleException($e);
        }
    }

    /**
     * Gives a temp file name back depending on the type of the OCR.
     * Later in the worker this file is used as an output.
     * 
     * @param integer $type            
     * @return string
     */
    private function getTempFile($type) {
        if ($type === OcrConstants::TESSERACT) {
            $fileName = $this->phpUtil->tempnamWrapper($this->tempM->getTempBaseDir(), OcrConstants::TEMPFILE_PREFIX);
            $this->phpUtil->unlinkWrapper($fileName);
            $fileNameWithPostfix = $fileName . '.txt';
            $this->phpUtil->touchWrapper($fileNameWithPostfix);
            $this->phpUtil->chmodWrapper($fileNameWithPostfix, 0600);
            return $fileNameWithPostfix;
        } else {
            return $this->phpUtil->tempnamWrapper($this->tempM->getTempBaseDir(), 'ocr_');
        }
    }

    /**
     * Takes care of transforming an incoming finished job into a php readable object.
     * 
     * @param string $job            
     * @throws NotFoundException
     * @return mixed
     */
    private function transformJob($job) {
        $decoded = json_decode($job);
        if ($decoded !== null && isset($decoded->id)) {
            return $decoded;
        } else {
            throw new NotFoundException($this->l10n->t('The finished job retrieved by Redis was corrupt.'));
        }
    }

    /**
     * Checks if the given languages are supported or not.
     * 
     * @param string[] $languages            
     * @return boolean
     */
    private function checkForAcceptedLanguages($languages) {
        $installedLanguages = explode(';', $this->appConfigService->getAppValue('languages'));
        if (count(array_diff($languages, $installedLanguages)) === 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Checks if the process should be initiated without any language specified.
     * 
     * @param string[] $languages            
     * @return boolean
     */
    private function noLanguage($languages) {
        if (in_array('any', $languages)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Handle the possible thrown Exceptions from all methods of this class.
     * 
     * @param Exception $e            
     * @throws Exception
     * @throws NotFoundException
     */
    private function handleException($e) {
        $this->logger->logException($e, 
                [
                        'message' => 'Exception during job service function processing'
                ]);
        throw $e;
    }
}