madmis/activity-log-bundle

Activity log bundle - Extended doctrine loggable bundle

Symfony ActivityLog Component

![Build Status][testing-image] [][coverage-link] , _(*1)

ActivityLogBundle - Extended doctrine loggable (StofDoctrineExtensionsBundle), _(*2)

What's inside

ActivityLogBundle uses Loggable extension from StofDoctrineExtensionsBundle and DoctrineExtensions, _(*3)

This bundle extend Gedmo\Loggable\Entity\MappedSuperclass\AbstractLogEntry with below fields:, _(*4)

• parentId - store depedency to "main entity"
• parentClass - store "main entity" type
• oldData - data that were changed
• name - entry name (to show in activity log)
• user - associations mapping with user who changed data

Bundle contain extended listener (LoggableListener) to process above fields., _(*5)

Also available formatter to preprocessing activity log before show in view (html)., _(*6)

Installation

Pretty simple with Composer, run:, _(*7)

``` bash composer require madmis/activity-log-bundle, <sub>(*8)</sub>

Then enable the bundle in the kernel:

``` php
public function registerBundles()
{
    $bundles = [
        // ...
        new ActivityLogBundle\ActivityLogBundle(),
        // ...
    ];
    ...
}

Configure bundle:, <sub>(*9)</sub>

``` yml, <sub>(*10)</sub>

app/config/config.yml

doctrine: dbal: #... orm: #... resolve_target_entities: Symfony\Component\Security\Core\User\UserInterface: AppBundle\Entity\User mappings: gedmo_loggable: type: annotation prefix: Gedmo\Loggable\Entity dir: "%kernel.root_dir%/../src/AppBundle/Entity/" alias: GedmoLoggable is_bundle: false, <sub>(*11)</sub>

stof_doctrine_extensions: class: loggable: ActivityLogBundle\Listener\LoggableListener orm: default: loggable: true, <sub>(*12)</sub>

Create entity and make it loggable:

```php

namespace AppBundle\Entity;

use Doctrine\ORM\Mapping as ORM;
use Gedmo\Mapping\Annotation as Gedmo;
use ActivityLogBundle\Entity\Interfaces\StringableInterface;

/**
 * @package AppBundle\Entity
 * @ORM\Entity(repositoryClass="ProjectRepository")
 * @ORM\Table
 * @Gedmo\Loggable(logEntryClass="ActivityLogBundle\Entity\LogEntry")
 */
class Project implements StringableInterface
{
    /**
     * @var int
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @var string
     * @ORM\Column(type="string", length=128)
     * @Gedmo\Versioned
     */
    private $name;

    /**
     * @var string
     * @ORM\Column(type="string", length=16)
     * @Gedmo\Versioned
     */
    private $key;

    //...

StringableInterface required to save LogEntry::name., <sub>(*13)</sub>

Then run command to update database schema:, <sub>(*14)</sub>

``` bash php bin/console doctrine:schema:update --force, <sub>(*15)</sub>

Using formatter to data view
------------

Formatter class: **ActivityLogBundle\Service\ActivityLog\ActivityLogFormatter**
Formatter service: **activity_log.formatter**

required: **LoggerInterface** as dependency

By default entity without custom formatter class formatted by **ActivityLogBundle\Service\ActivityLog\EntityFormatter\UniversalFormatter**

But you can implement custom formatter for each entity.

To register a custom formatter, add a service tag with the following (required) properties:
* name: 'activity_log.formatter'
* entity: Class name of the entity that should be formatted by the registered formatter


Example:
```php
services:
    app.formatter.project:
        class: AppBundle\Service\ActivityFormatter\Project
        tags:
            -  { name: activity_log.formatter, entity: 'Project'}

As example formatter for AppBundle\Entity\Project entity:, <sub>(*16)</sub>

namespace AppBundle\Service\ActivityFormatter;

class Project extends AbstractFormatter implements FormatterInterface
{
    /**
     * @param LogEntryInterface $log
     * @return array
     */
    public function format(LogEntryInterface $log)
    {
        $result = $log->toArray();

        if ($log->isCreate()) {
            $result['message'] = sprintf('The <b>Project <span class="font-green-jungle">"%s"</span></b> was created.', $log->getName());
        } else if ($log->isRemove()) {
            $result['message'] = sprintf('The <b>Project <span class="font-red-flamingo">"%s"</span></b> was removed.', $log->getName());
        } else if ($log->isUpdate()) {
            $result['message'] = '<dl><dt>The <b>Project <span class="font-yellow-gold">"%s"</span></b> was updated.</dt>%s</dl>';
            $data = $log->getData();
            $oldData = $log->getOldData();

            $text = '';
            foreach ($data as $field => $value) {
                $value = $this->normalizeValue($field, $value);

                if (array_key_exists($field, $oldData)) {
                    $oldValue = $this->normalizeValue($field, $oldData[$field]);
                    $subText = sprintf('from "<b>%s</b>" to "<b>%s</b>".', $oldValue, $value);
                } else {
                    $subText = sprintf('to "<b>%s</b>".', $value);
                }
                $text .= sprintf('<dd>Property "<b>%s</b>" was changed: %s</dd>', $field, $subText);
            }

            $result['message'] = sprintf($result['message'], $log->getName(), $text);
        } else {
            $result['message'] = "Undefined action: {$log->getAction()}.";
        }

        return $result;
    }
}

If entity has association with other entity it can be resolved by AbstractFormatter::normalizeValue. This method call method from the entity formatter class, which named as appropriate property., <sub>(*17)</sub>

For example, Project entity has association mapping ManyToOne to Type entity. To get Type name we can add method type to Project formatter:, <sub>(*18)</sub>

namespace AppBundle\Service\ActivityFormatter;

class Project extends AbstractFormatter implements FormatterInterface
{
    //...

    /**
     * @param array $value
     * @return string
     */
    protected function type(array $value)
    {
        if (isset($value['id'])) {
            /** @var Type $entity */
            $entity = $this->entityManager->getRepository('AppBundle:Type')
                ->find($value['id']);

            if ($entity) {
                return $entity->getName();
            }
        }

        return '';
    }

As result we have formatted response to show in view., <sub>(*19)</sub>

Using activity log in controller

$em = $this->getDoctrine()->getManager();
// get log entries for entity
$entries =  $em
            ->getRepository('AppBundle:LogEntry')
            ->getLogEntriesQueryBuilder($entity)
           ->getQuery()
          ->getResult();
// format log entries to show in the view
$entries = $this
            ->get('activity_log.formatter')
            ->format($entries);

For $entity should be configured Entity formatter., <sub>(*20)</sub>