OCA\RansomwareDetection\AppInfo\Application

Complexity

Total Complexity

3

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	23	1
A	registerNotificationNotifier()	0	3	1
B	__construct()	0	146	1

<?php

/**
 * @copyright Copyright (c) 2017 Matthias Held <matthias.held@uni-konstanz.de>
 * @author Matthias Held <matthias.held@uni-konstanz.de>
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

namespace OCA\RansomwareDetection\AppInfo;

use OC\Files\Filesystem;

The type OC\Files\Filesystem was not found. Maybe you did not declare it correctly or list all dependencies?

use OCA\RansomwareDetection\Monitor;
use OCA\RansomwareDetection\Events\FilesEvents;
use OCA\RansomwareDetection\FilesHooks;
use OCA\RansomwareDetection\Classifier;
use OCA\RansomwareDetection\Analyzer\EntropyAnalyzer;
use OCA\RansomwareDetection\Analyzer\SequenceAnalyzer;
use OCA\RansomwareDetection\Analyzer\SequenceSizeAnalyzer;
use OCA\RansomwareDetection\Analyzer\FileTypeFunnellingAnalyzer;
use OCA\RansomwareDetection\Analyzer\EntropyFunnellingAnalyzer;
use OCA\RansomwareDetection\Analyzer\FileCorruptionAnalyzer;
use OCA\RansomwareDetection\Analyzer\FileExtensionAnalyzer;
use OCA\RansomwareDetection\Entropy\Entropy;
use OCA\RansomwareDetection\Controller\DetectionController;
use OCA\RansomwareDetection\Notification\Notifier;
use OCA\RansomwareDetection\StorageWrapper;

The type OCA\RansomwareDetection\StorageWrapper was not found. Maybe you did not declare it correctly or list all dependencies?

use OCA\RansomwareDetection\Connector\Sabre\RequestPlugin;
use OCA\RansomwareDetection\Service\FileOperationService;
use OCA\RansomwareDetection\Service\RecoveredFileOperationService;
use OCA\RansomwareDetection\Service\DetectionService;
use OCA\RansomwareDetection\Mapper\FileOperationMapper;

The type OCA\RansomwareDetection\Mapper\FileOperationMapper was not found. Maybe you did not declare it correctly or list all dependencies?

use OCA\RansomwareDetection\Mapper\RecoveredFileOperationMapper;

The type OCA\RansomwareDetection\Mapper\RecoveredFileOperationMapper was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\AppFramework\App;

The type OCP\AppFramework\App was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\App\IAppManager;

The type OCP\App\IAppManager was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\Files\IRootFolder;

The type OCP\Files\IRootFolder was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\AppFramework\Utility\ITimeFactory;

The type OCP\AppFramework\Utility\ITimeFactory was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\Files\Storage\IStorage;

The type OCP\Files\Storage\IStorage was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\Notification\IManager;

The type OCP\Notification\IManager was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\Util;

The type OCP\Util was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\SabrePluginEvent;

The type OCP\SabrePluginEvent was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\ILogger;

The type OCP\ILogger was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\IConfig;

The type OCP\IConfig was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\IUserSession;

The type OCP\IUserSession was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\ISession;

The type OCP\ISession was not found. Maybe you did not declare it correctly or list all dependencies?

use OCP\IRequest;

The type OCP\IRequest was not found. Maybe you did not declare it correctly or list all dependencies?

class Application extends App
{
    const APP_ID = 'ransomware_detection';

    public function __construct()
    {
        parent::__construct(self::APP_ID);

        $container = $this->getContainer();

        // mapper
        $container->registerService('FileOperationMapper', function ($c) {
            return new FileOperationMapper(
                $c->query('ServerContainer')->getDb()
            );
        });

        $container->registerService('RecoveredFileOperationMapper', function ($c) {
            return new RecoveredFileOperationMapper(
                $c->query('ServerContainer')->getDb()
            );
        });

        $container->registerService('DetectionDeserializer', function ($c) {
            return new DetectionDeserializer(

The type OCA\RansomwareDetection\AppInfo\DetectionDeserializer was not found. Maybe you did not declare it correctly or list all dependencies?

                $c->query('FileOperationMapper')
            );
        });

        // services
        $container->registerService('FileOperationService', function ($c) {
            return new FileOperationService(

The call to OCA\RansomwareDetection\Service\FileOperationService::__construct() has too few arguments starting with userId.

                $c->query(FileOperationMapper::class),
                $c->query('ServerContainer')->getUserSession()->getUser()->getUID()
            );
        });

        $container->registerService('RecoveredFileOperationService', function ($c) {
            return new RecoveredFileOperationService(
                $c->query(FileOperationMapper::class),
                $c->query(RecoveredFileOperationMapper::class),
                $c->query('ServerContainer')->getUserSession()->getUser()->getUID()
            );
        });

        $container->registerService('DetectionService', function ($c) {
            return new DetectionService(

The call to OCA\RansomwareDetection\Service\DetectionService::__construct() has too few arguments starting with userId.

                $c->query(ILogger::class),
                $c->query('FileOperationService'),
                $c->query('DetectionDeserializer'),
                $c->query('OCP\IConfig'),
                $c->query(Classifier::class),
                $c->query('ServerContainer')->getUserSession()->getUser()->getUID()
            );
        });

        // classifier
        $container->registerService('Classifier', function ($c) {
            return new Classifier(
                $c->query(ILogger::class),
                $c->query(FileOperationMapper::class),
                $c->query(FileOperationService::class)
            );
        });

        // controller
        $container->registerService('DetectionController', function ($c) {
            return new DetectionController(
                $c->query('AppName'),
                $c->query('Request'),
                $c->query('DetectionService')
            );
        });

        // entropy
        $container->registerService('Entropy', function ($c) {
            return new Entropy(
                $c->query(ILogger::class)
            );
        });

        // analyzer
        $container->registerService('SequenceSizeAnalyzer', function ($c) {

The parameter $c is not used and could be removed.

            return new SequenceSizeAnalyzer();
        });

        $container->registerService('FileTypeFunnellingAnalyzer', function ($c) {

The parameter $c is not used and could be removed.

            return new FileTypeFunnellingAnalyzer();
        });

        $container->registerService('EntropyFunnellingAnalyzer', function ($c) {
            return new EntropyFunnellingAnalyzer(
                $c->query(ILogger::class)
            );
        });

        $container->registerService('FileExtensionAnalyzer', function ($c) {
            return new FileExtensionAnalyzer(
                $c->query(ILogger::class),
                $c->query(Entropy::class)

The call to OCA\RansomwareDetection\Analyzer\FileExtensionAnalyzer::__construct() has too many arguments starting with $c->query(OCA\RansomwareDetection\Entropy\Entropy::class).

            );
        });

        $container->registerService('SequenceAnalyzer', function ($c) {
            return new SequenceAnalyzer(
                $c->query(SequenceSizeAnalyzer::class),
                $c->query(FileTypeFunnellingAnalyzer::class),
                $c->query(EntropyFunnellingAnalyzer::class)
            );
        });

        $container->registerService('EntropyAnalyzer', function ($c) {
            return new EntropyAnalyzer(
                $c->query(ILogger::class),
                $c->query(IRootFolder::class),
                $c->query(Entropy::class),
                $c->query('ServerContainer')->getUserSession()->getUser()->getUID()
            );
        });

        $container->registerService('FileCorruptionAnalyzer', function ($c) {
            return new FileCorruptionAnalyzer(
                $c->query(ILogger::class),
                $c->query(IRootFolder::class),
                $c->query('ServerContainer')->getUserSession()->getUser()->getUID()
            );
        });

        $container->registerService('Monitor', function ($c) {
            return new Monitor(
                $c->query(IRequest::class),
                $c->query(IConfig::class),
                $c->query(ITimeFactory::class),
                $c->query(IAppManager::class),
                $c->query(ILogger::class),
                $c->query(IRootFolder::class),
                $c->query(EntropyAnalyzer::class),
                $c->query(FileOperationMapper::class),
                $c->query(FileExtensionAnalyzer::class),
                $c->query(FileCorruptionAnalyzer::class),
                $c->query('ServerContainer')->getUserSession()->getUser()->getUID()
            );
        });

        $container->registerService('FilesEvents', function ($c) {
            return new FilesEvents(
                $c->query(ILogger::class),
                $c->query(Monitor::class),
                $c->query('ServerContainer')->getUserSession()->getUser()->getUID()
            );
        });
    }

    /**
     * Register hooks.
     */
    public function register()
    {
        // register sabre plugin to catch the profind requests
        $eventDispatcher = $this->getContainer()->getServer()->getEventDispatcher();
        $eventDispatcher->addListener('OCA\DAV\Connector\Sabre::addPlugin', function (SabrePluginEvent $event) {
            $logger = $this->getContainer()->query(ILogger::class);
            $config = $this->getContainer()->query(IConfig::class);
            $userSession = $this->getContainer()->query(IUserSession::class);
            $session = $this->getContainer()->query(ISession::class);
            $service = $this->getContainer()->query(FileOperationService::class);
            $notifications = $this->getContainer()->query(IManager::class);
            $classifier = $this->getContainer()->query(Classifier::class);
            $sequenceAnalyzer = $this->getContainer()->query(SequenceAnalyzer::class);
            $event->getServer()->addPlugin(new RequestPlugin($logger, $config, $userSession, $session, $service, $notifications, $classifier, $sequenceAnalyzer));
        });
        Util::connectHook('OC_Filesystem', 'post_create', FilesHooks::class, 'onFileCreate');
        // Util::connectHook('OC_Filesystem', 'post_update', FilesHooks::class, 'onFileUpdate');
        Util::connectHook('OC_Filesystem', 'post_rename', FilesHooks::class, 'onFileRename');
        Util::connectHook('OC_Filesystem', 'post_write', FilesHooks::class, 'onFileWrite');
        Util::connectHook('OC_Filesystem', 'post_delete', FilesHooks::class, 'onFileDelete');
        // Util::connectHook('OC_Filesystem', 'post_touch', FilesHooks::class, 'onFileTouch');
        // Util::connectHook('OC_Filesystem', 'post_copy', FilesHooks::class, 'onFileCopy');
        $this->registerNotificationNotifier();
    }

    protected function registerNotificationNotifier()
    {
        $this->getContainer()->getServer()->getNotificationManager()->registerNotifierService(Notifier::class);
    }
}