├── tests
    ├── Helpers
    │   ├── Actors.php
    │   ├── Models.php
    │   ├── Objects.php
    │   ├── Targets.php
    │   ├── migrations.php
    │   └── factories
    │   │   └── ModelFactory.php
    ├── Unit
    │   ├── FeedTest.php
    │   └── FacadeTest.php
    └── TestCase.php
├── src
    ├── Events
    │   ├── Event.php
    │   ├── FeedCreated.php
    │   ├── FeedDeleted.php
    │   ├── ActivityCreated.php
    │   └── ActivityDeleted.php
    ├── Contracts
    │   ├── ReturnsExtraData.php
    │   ├── ActivityActor.php
    │   ├── ActivityObject.php
    │   ├── ActivityTarget.php
    │   └── Followable.php
    ├── Exceptions
    │   ├── InvalidActorException.php
    │   └── InvalidActivityVerbException.php
    ├── Models
    │   ├── Follow.php
    │   ├── FeedActivity.php
    │   ├── Feed.php
    │   └── Activity.php
    ├── ActivityStreamsFacade.php
    ├── Traits
    │   ├── HasFeed.php
    │   └── Followable.php
    ├── Console
    │   └── Commands
    │   │   └── MakeFeedCommand.php
    ├── Managers
    │   ├── ConfigurationManager.php
    │   └── ActivityManager.php
    ├── ValueObjects
    │   ├── Actor.php
    │   ├── Target.php
    │   ├── ActivityObject.php
    │   └── Verbs.php
    ├── ActivityStreamsServiceProvider.php
    └── ActivityStreams.php
├── config
    └── activity_streams.php
├── .travis.yml
├── .gitignore
├── phpunit.xml
├── composer.json
├── database
    └── migrations
    │   └── create_activity_streams_tables.php
└── README.md


/tests/Helpers/Actors.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 


--------------------------------------------------------------------------------
/src/Events/Event.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Musonza\ActivityStreams\Events;
4 | 
5 | class Event {}


--------------------------------------------------------------------------------
/config/activity_streams.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [
4 |     // Additional verbs here
5 |     'verbs' => [
6 | //        'FOO' => 'foo',
7 | //        'BAR' => 'bar',
8 |     ],
9 | ];


--------------------------------------------------------------------------------
/src/Contracts/ReturnsExtraData.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace Musonza\ActivityStreams\Contracts;
5 | 
6 | interface ReturnsExtraData
7 | {
8 |     public function getExtraData();
9 | }


--------------------------------------------------------------------------------
/src/Exceptions/InvalidActorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Exceptions;
 4 | 
 5 | use Exception;
 6 | 
 7 | class InvalidActorException extends Exception
 8 | {
 9 | 
10 | }


--------------------------------------------------------------------------------
/src/Exceptions/InvalidActivityVerbException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Exceptions;
 4 | 
 5 | use Exception;
 6 | 
 7 | class InvalidActivityVerbException extends Exception
 8 | {
 9 | 
10 | }


--------------------------------------------------------------------------------
/src/Contracts/ActivityActor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Contracts;
 4 | 
 5 | interface ActivityActor
 6 | {
 7 |     public function getType(): string ;
 8 |     public function getIdentifier(): string ;
 9 |     public function getExtraData(): array ;
10 | }


--------------------------------------------------------------------------------
/src/Contracts/ActivityObject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Contracts;
 4 | 
 5 | interface ActivityObject
 6 | {
 7 |     public function getType(): string ;
 8 |     public function getIdentifier(): string ;
 9 |     public function getExtraData(): array ;
10 | }


--------------------------------------------------------------------------------
/src/Contracts/ActivityTarget.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Contracts;
 4 | 
 5 | interface ActivityTarget
 6 | {
 7 |     public function getType(): string ;
 8 |     public function getIdentifier(): string ;
 9 |     public function getExtraData(): array ;
10 | }


--------------------------------------------------------------------------------
/src/Contracts/Followable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Contracts;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Illuminate\Database\Eloquent\Relations\MorphMany;
 7 | 
 8 | interface Followable
 9 | {
10 |     public function follow(Model $followable);
11 |     public function follows(): MorphMany;
12 | }


--------------------------------------------------------------------------------
/src/Events/FeedCreated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Events;
 4 | 
 5 | use Musonza\ActivityStreams\Models\Feed;
 6 | 
 7 | class FeedCreated extends Event
 8 | {
 9 |     /**
10 |      * @var Feed
11 |      */
12 |     public $feed;
13 | 
14 |     public function __construct(Feed $feed)
15 |     {
16 |         $this->feed = $feed;
17 |     }
18 | }


--------------------------------------------------------------------------------
/src/Events/FeedDeleted.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Events;
 4 | 
 5 | use Musonza\ActivityStreams\Models\Feed;
 6 | 
 7 | class FeedDeleted extends Event
 8 | {
 9 |     /**
10 |      * @var Feed
11 |      */
12 |     public $feed;
13 | 
14 |     public function __construct(Feed $feed)
15 |     {
16 |         $this->feed = $feed;
17 |     }
18 | }


--------------------------------------------------------------------------------
/src/Events/ActivityCreated.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Events;
 4 | 
 5 | use Musonza\ActivityStreams\Models\Activity;
 6 | 
 7 | class ActivityCreated extends Event
 8 | {
 9 |     /**
10 |      * @var Activity
11 |      */
12 |     public $activity;
13 | 
14 |     public function __construct(Activity $activity)
15 |     {
16 |         $this->activity  = $activity;
17 |     }
18 | }


--------------------------------------------------------------------------------
/src/Events/ActivityDeleted.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Events;
 4 | 
 5 | use Musonza\ActivityStreams\Models\Activity;
 6 | 
 7 | class ActivityDeleted extends Event
 8 | {
 9 |     /**
10 |      * @var Activity
11 |      */
12 |     public $activity;
13 | 
14 |     public function __construct(Activity $activity)
15 |     {
16 |         $this->activity  = $activity;
17 |     }
18 | }


--------------------------------------------------------------------------------
/src/Models/Follow.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | 
 7 | class Follow extends Model
 8 | {
 9 |     protected $fillable = [
10 |         'follower_id',
11 |         'follower_type',
12 |     ];
13 | 
14 |     public function feeds()
15 |     {
16 |         return $this->morphedByMany(Feed::class, 'followable');
17 |     }
18 | }


--------------------------------------------------------------------------------
/src/ActivityStreamsFacade.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams;
 4 | 
 5 | use Illuminate\Support\Facades\Facade;
 6 | 
 7 | class ActivityStreamsFacade extends Facade
 8 | {
 9 |     /**
10 |      * Get the registered name of the component.
11 |      *
12 |      * @return string
13 |      * @codeCoverageIgnore
14 |      */
15 |     protected static function getFacadeAccessor()
16 |     {
17 |         return 'activity_streams';
18 |     }
19 | }


--------------------------------------------------------------------------------
/src/Models/FeedActivity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | 
 7 | class FeedActivity extends Model
 8 | {
 9 |     protected $fillable = [
10 |         'feed_id',
11 |         'activity_id',
12 |     ];
13 | 
14 |     public function feed()
15 |     {
16 |         return $this->belongsTo(Feed::class, 'feed_id');
17 |     }
18 | 
19 |     public function activity()
20 |     {
21 |         return $this->belongsTo(Activity::class, 'activity_id');
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Helpers/Models.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Tests\Helpers\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Musonza\ActivityStreams\Contracts\ReturnsExtraData;
 7 | use Musonza\ActivityStreams\Traits\HasFeed;
 8 | 
 9 | class User extends Model implements ReturnsExtraData
10 | {
11 |     use HasFeed;
12 | 
13 |     public function getExtraData()
14 |     {
15 |         return [
16 |             'title' => 'This is a test',
17 |         ];
18 |     }
19 | }
20 | 
21 | class Blog extends Model {}


--------------------------------------------------------------------------------
/tests/Helpers/Objects.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Tests\Helpers;
 4 | 
 5 | use Musonza\ActivityStreams\Contracts\ActivityObject;
 6 | 
 7 | class SampleObject implements ActivityObject
 8 | {
 9 |     public function getType(): string
10 |     {
11 |         return 'photo.album';
12 |     }
13 | 
14 |     public function getIdentifier(): string
15 |     {
16 |         return 'tag:example.org,2011:abc123';
17 |     }
18 | 
19 |     public function getExtraData(): array
20 |     {
21 |         return [];
22 |     }
23 | }


--------------------------------------------------------------------------------
/tests/Helpers/Targets.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Tests\Helpers\Targets;
 4 | 
 5 | use Musonza\ActivityStreams\Contracts\ActivityTarget;
 6 | 
 7 | class SampleTarget implements ActivityTarget
 8 | {
 9 |     public function getType(): string
10 |     {
11 |         return 'medium.blog';
12 |     }
13 | 
14 |     public function getIdentifier(): string
15 |     {
16 |         return 'tag:example.org,2011:abc123';
17 |     }
18 | 
19 |     public function getExtraData(): array
20 |     {
21 |         // TODO: Implement getTargetDetails() method.
22 |         return [];
23 |     }
24 | }


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | matrix:
 4 |   include:
 5 |     - php: 7.1
 6 |       env: ILLUMINATE_VERSION=5.6.*
 7 |     - php: 7.1
 8 |       env: ILLUMINATE_VERSION=5.7.*
 9 |     - php: 7.1
10 |       env: ILLUMINATE_VERSION=5.8.*
11 |     - php: 7.2
12 |       env: ILLUMINATE_VERSION=6.0
13 |     - php: 7.2
14 |       env: ILLUMINATE_VERSION=6.*
15 | php:
16 |   - 7.2
17 | 
18 | sudo: false
19 | 
20 | before_install:
21 |   - composer require "illuminate/support:${ILLUMINATE_VERSION}" --no-update
22 | 
23 | install: composer update --prefer-source --no-interaction --dev
24 | 
25 | script: vendor/bin/phpunit --testdox


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Folders #
 2 | ###########
 3 | dist/
 4 | vendor/
 5 | node_modules/
 6 | CVS/
 7 | .idea
 8 | deploy.php
 9 | composer.lock
10 | # Compiled source #
11 | ###################
12 | *.com
13 | *.class
14 | *.dll
15 | *.exe
16 | *.o
17 | *.so
18 | 
19 | # Packages #
20 | ############
21 | # it's better to unpack these files and commit the raw source
22 | # git has its own built in compression methods
23 | *.7z
24 | *.dmg
25 | *.gz
26 | *.iso
27 | *.jar
28 | *.rar
29 | *.tar
30 | *.zip
31 | 
32 | # Logs and databases #
33 | ######################
34 | *.log
35 | *.sqlite
36 | 
37 | # OS generated files #
38 | ######################
39 | .DS_Store
40 | .DS_Store?
41 | ._*
42 | .Spotlight-V100
43 | .Trashes
44 | ehthumbs.db
45 | Thumbs.db
46 | .phpunit.result.cache


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |          backupStaticAttributes="false"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 |          convertErrorsToExceptions="true"
 7 |          convertNoticesToExceptions="true"
 8 |          convertWarningsToExceptions="true"
 9 |          processIsolation="false"
10 |          stopOnFailure="false"
11 | >
12 |     <testsuites>
13 |         <testsuite name="Package Test Suite">
14 |             <directory suffix=".php">./tests/Unit</directory>
15 |         </testsuite>
16 |     </testsuites>
17 |     <filter>
18 |         <whitelist>
19 |             <directory suffix=".php">src/</directory>
20 |         </whitelist>
21 |     </filter>
22 | </phpunit>


--------------------------------------------------------------------------------
/tests/Unit/FeedTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Tests\Unit;
 4 | 
 5 | use Musonza\ActivityStreams\Tests\Helpers\Models\User;
 6 | use Musonza\ActivityStreams\Tests\TestCase;
 7 | 
 8 | class FeedTest extends TestCase
 9 | {
10 |     public function testCreateModelFeed()
11 |     {
12 |         /** @var User $user */
13 |         $user = factory(User::class)->create();
14 | 
15 |         $data = [
16 |             'title' => 'My Feed',
17 |             'description' => 'My description'
18 |         ];
19 | 
20 |         $feed = $user->createFeed($data);
21 | 
22 |         $this->assertEquals($data, $feed->extra);
23 | 
24 |         $this->assertDatabaseHas(TestCase::FEEDS_TABLE, [
25 |             'id' => 1,
26 |             'feedable_type' => get_class($user),
27 |             'feedable_id' => $user->id
28 |         ]);
29 |     }
30 | }


--------------------------------------------------------------------------------
/tests/Helpers/migrations.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Database\Migrations\Migration;
 4 | use Illuminate\Database\Schema\Blueprint;
 5 | use Illuminate\Support\Facades\Schema;
 6 | 
 7 | class CreateTestTables extends Migration
 8 | {
 9 |     /**
10 |      * Run the migrations.
11 |      *
12 |      * @return void
13 |      */
14 |     public function up()
15 |     {
16 |         Schema::create('users', function (Blueprint $table) {
17 |             $table->bigIncrements('id');
18 |             $table->string('name');
19 |             $table->string('email')->unique();
20 |             $table->string('password');
21 |             $table->rememberToken();
22 |             $table->timestamps();
23 |         });
24 |     }
25 | 
26 |     /**
27 |      * Reverse the migrations.
28 |      *
29 |      * @return void
30 |      */
31 |     public function down()
32 |     {
33 |         Schema::dropIfExists('users');
34 |     }
35 | }


--------------------------------------------------------------------------------
/src/Traits/HasFeed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Traits;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Illuminate\Database\Eloquent\Relations\MorphOne;
 7 | use Illuminate\Database\Eloquent\Relations\MorphTo;
 8 | use Musonza\ActivityStreams\Models\Feed;
 9 | 
10 | trait HasFeed
11 | {
12 |     /**
13 |      * Get all of the owning has models.
14 |      *
15 |      * @return MorphTo
16 |      */
17 |     public function feedable(): MorphTo
18 |     {
19 |         return $this->morphTo();
20 |     }
21 | 
22 |     public function feed(): MorphOne
23 |     {
24 |         return $this->morphOne(Feed::class, 'feedable');
25 |     }
26 | 
27 |     /**
28 |      * Create a feed.
29 |      *
30 |      * @param array $extra
31 |      * @return false|Model
32 |      */
33 |     public function createFeed(array $extra = [])
34 |     {
35 |         return $this->feed()->save(new Feed(['extra' => $extra]));
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Console/Commands/MakeFeedCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Console\Commands;
 4 | 
 5 | use Exception;
 6 | use Illuminate\Console\Command;
 7 | use Musonza\ActivityStreams\Models\Feed;
 8 | 
 9 | final class MakeFeedCommand extends Command
10 | {
11 |     protected $signature = 'streams:make:feed {class : Full namespaced class} {id : Unique identifier for the Resource type}';
12 | 
13 |     protected $description = 'Create a new Feed for a specific class';
14 | 
15 |     protected $id;
16 | 
17 |     public function handle()
18 |     {
19 |         $class = $this->argument('class');
20 |         $this->id = $this->argument('id');
21 | 
22 |         try {
23 |             app($class);
24 | 
25 |             $feed = new Feed([
26 |                 'feedable_type' => $class,
27 |                 'feedable_id'  => $this->id,
28 |             ]);
29 | 
30 |             $feed->save();
31 | 
32 |             dd($feed->toArray());
33 |         } catch (Exception $exception) {
34 |             $this->error($exception->getMessage());
35 |         }
36 | 
37 |     }
38 | }


--------------------------------------------------------------------------------
/src/Models/Feed.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Musonza\ActivityStreams\Events\FeedCreated;
 7 | use Musonza\ActivityStreams\Events\FeedDeleted;
 8 | use Musonza\ActivityStreams\Traits\Followable;
 9 | 
10 | class Feed extends Model
11 | {
12 |     use Followable;
13 | 
14 |     protected $fillable = [
15 |         'extra',
16 |         'feedable_type',
17 |         'feedable_id'
18 |     ];
19 |     protected $casts = [
20 |         'extra' => 'array',
21 |     ];
22 | 
23 |     public static function boot()
24 |     {
25 |         parent::boot();
26 | 
27 |         static::created(function($feed) {
28 |             event(new FeedCreated($feed));
29 |         });
30 | 
31 |         static::deleted(function($feed) {
32 |             event(new FeedDeleted($feed));
33 |         });
34 |     }
35 | 
36 |     public function activities()
37 |     {
38 |         return $this->belongsToMany(
39 |             Activity::class,
40 |             'feed_activities',
41 |             'feed_id',
42 |             'activity_id'
43 |         );
44 |     }
45 | }


--------------------------------------------------------------------------------
/src/Managers/ConfigurationManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Managers;
 4 | 
 5 | use Illuminate\Config\Repository;
 6 | use Illuminate\Support\Arr;
 7 | use Musonza\ActivityStreams\Exceptions\InvalidActivityVerbException;
 8 | use Musonza\ActivityStreams\ValueObjects\Verbs;
 9 | use ReflectionClass;
10 | 
11 | class ConfigurationManager
12 | {
13 |     /**
14 |      * @var Repository
15 |      */
16 |     private $configuration;
17 | 
18 |     public function __construct()
19 |     {
20 |         $this->configuration = config('activity_streams');
21 |     }
22 | 
23 |     /**
24 |      * @param string $verb
25 |      * @throws InvalidActivityVerbException
26 |      */
27 |     public function validateVerb(string $verb)
28 |     {
29 |         if (!in_array($verb, $this->getVerbs())) {
30 |             throw new InvalidActivityVerbException(sprintf('Invalid verb provided: %s', $verb));
31 |         }
32 |     }
33 | 
34 |     public function getVerbs()
35 |     {
36 |         $verbsDefinitions = new ReflectionClass(Verbs::class);
37 |         $verbs = array_merge($verbsDefinitions->getConstants(), $this->configuration['verbs']);
38 | 
39 |         return $verbs;
40 |     }
41 | }


--------------------------------------------------------------------------------
/src/Models/Activity.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Models;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Musonza\ActivityStreams\Events\ActivityCreated;
 7 | use Musonza\ActivityStreams\Events\ActivityDeleted;
 8 | 
 9 | class Activity extends Model
10 | {
11 |     protected $fillable = [
12 |         'actor_type',
13 |         'actor_id',
14 |         'actor_data',
15 |         'verb',
16 |         'target_type',
17 |         'target_id',
18 |         'target_data',
19 |         'object_type',
20 |         'object_id',
21 |         'object_data',
22 |     ];
23 |     protected $casts = [
24 |         'actor_data' => 'array',
25 |         'target_data' => 'array',
26 |         'object_data' => 'array',
27 |     ];
28 | 
29 |     public static function boot()
30 |     {
31 |         parent::boot();
32 | 
33 |         static::created(function ($activity) {
34 |             event(new ActivityCreated($activity));
35 |         });
36 | 
37 |         static::deleted(function ($activity) {
38 |             event(new ActivityDeleted($activity));
39 |         });
40 |     }
41 | 
42 |     public function feeds()
43 |     {
44 |         return $this->hasMany(FeedActivity::class);
45 |     }
46 | }


--------------------------------------------------------------------------------
/src/Traits/Followable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Traits;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Musonza\ActivityStreams\Models\Follow;
 7 | 
 8 | trait Followable
 9 | {
10 |     public function follow(Model $followable)
11 |     {
12 |         $follow = new Follow([
13 |             'follower_id' => $this->getKey(),
14 |             'follower_type' => get_class($followable),
15 |         ]);
16 | 
17 |         return $followable->follows()->save($follow);
18 |     }
19 | 
20 |     public function unfollow(Model $followable)
21 |     {
22 |         $followable->follows()
23 |             ->where('follower_id', $this->getKey())
24 |             ->where('follower_type', get_class($followable))
25 |             ->delete();
26 |     }
27 | 
28 |     public function isFollowed(Model $followable)
29 |     {
30 |         return !!$this->follows()
31 |             ->where('follower_id', $followable->getKey())
32 |             ->where('follower_type', get_class($followable))
33 |             ->count();
34 |     }
35 | 
36 |     public function getFollowersCountAttribute()
37 |     {
38 |         return $this->follows()->count();
39 |     }
40 | 
41 |     public function follows()
42 |     {
43 |         return $this->morphMany(Follow::class, 'followable');
44 |     }
45 | 
46 |     public function followers()
47 |     {
48 |         return $this->morphTo();
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/ValueObjects/Actor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\ValueObjects;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Musonza\ActivityStreams\Contracts\ActivityActor;
 7 | use Musonza\ActivityStreams\Contracts\ReturnsExtraData;
 8 | 
 9 | class Actor implements ActivityActor
10 | {
11 |     /**
12 |      * @var string
13 |      */
14 |     protected $actorType;
15 |     /**
16 |      * @var string
17 |      */
18 |     protected $actorIdentifier;
19 |     /**
20 |      * @var array
21 |      */
22 |     protected $extraData;
23 | 
24 |     public function __construct(string $actorType, string $actorIdentifier, array $extraData = [])
25 |     {
26 |         $this->actorType = $actorType;
27 |         $this->actorIdentifier = $actorIdentifier;
28 |         $this->extraData = $extraData;
29 |     }
30 | 
31 |     public static function createFromModel(Model $model, $extraData = []): Actor
32 |     {
33 |         if ($model instanceof ReturnsExtraData) {
34 |             $extraData = $model->getExtraData();
35 |         }
36 | 
37 |         return new static(get_class($model), $model->getKey(), $extraData);
38 |     }
39 | 
40 |     public function getType(): string
41 |     {
42 |         return $this->actorType;
43 |     }
44 | 
45 |     public function getIdentifier(): string
46 |     {
47 |         return $this->actorIdentifier;
48 |     }
49 | 
50 |     public function getExtraData(): array
51 |     {
52 |         return $this->extraData;
53 |     }
54 | }


--------------------------------------------------------------------------------
/src/ValueObjects/Target.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\ValueObjects;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Musonza\ActivityStreams\Contracts\ActivityTarget;
 7 | use Musonza\ActivityStreams\Contracts\ReturnsExtraData;
 8 | 
 9 | class Target implements ActivityTarget
10 | {
11 |     /**
12 |      * @var string
13 |      */
14 |     private $targetType;
15 | 
16 |     /**
17 |      * @var string
18 |      */
19 |     private $targetIdentifier;
20 | 
21 |     /**
22 |      * @var array
23 |      */
24 |     private $extraData;
25 | 
26 |     public function __construct(string $targetType, string $targetIdentifier, array $extraData = [])
27 |     {
28 |         $this->targetType = $targetType;
29 |         $this->targetIdentifier = $targetIdentifier;
30 |         $this->extraData = $extraData;
31 |     }
32 | 
33 |     public static function createFromModel(Model $model, $extraData = []): Target
34 |     {
35 |         if ($model instanceof ReturnsExtraData) {
36 |             $extraData = $model->getExtraData();
37 |         }
38 | 
39 |         return new static(get_class($model), $model->getKey(), $extraData);
40 |     }
41 | 
42 |     public function getType(): string
43 |     {
44 |         return $this->targetType;
45 |     }
46 | 
47 |     public function getIdentifier(): string
48 |     {
49 |         return $this->targetIdentifier;
50 |     }
51 | 
52 |     public function getExtraData(): array
53 |     {
54 |         return $this->extraData;
55 |     }
56 | }


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "musonza/laravel-activity-streams",
 3 |     "description": "Laravel Package to help with feeds and activity streams in your application",
 4 |     "type": "library",
 5 |     "license": "MIT",
 6 |     "authors": [
 7 |         {
 8 |             "name": "tmusonza",
 9 |             "email": "tinashemusonza@gmail.com"
10 |         }
11 |     ],
12 |     "require": {
13 |         "php": ">=7.1",
14 |         "laravel/framework": "5.6.*|5.7.*|5.8.*|^6.0|^7.0"
15 |     },
16 |     "require-dev": {
17 |         "phpunit/phpunit": "^7.0|^8.0",
18 |         "orchestra/testbench": "^3.6|^3.6|^3.8|^4.0",
19 |         "orchestra/database": "^3.6|^3.6|^3.8|^4.0",
20 |         "mockery/mockery": "^1.0.0"
21 |     },
22 |     "autoload": {
23 |         "psr-4": {
24 |             "Musonza\\ActivityStreams\\": "src/"
25 |         }
26 |     },
27 |     "autoload-dev": {
28 |         "psr-4": {
29 |             "Musonza\\ActivityStreams\\Tests\\": "tests"
30 |         },
31 |         "files": [
32 |             "tests/Helpers/Models.php",
33 |             "tests/Helpers/Targets.php",
34 |             "tests/Helpers/Objects.php"
35 |         ]
36 |     },
37 |     "scripts": {
38 |         "test": "phpunit"
39 |     },
40 |     "extra": {
41 |         "laravel": {
42 |             "providers": [
43 |                 "Musonza\\ActivityStreams\\ActivityStreamsServiceProvider"
44 |             ],
45 |             "aliases": {
46 |                 "ActivityStreams": "Musonza\\ActivityStreams\\ActivityStreamsFacade"
47 |             }
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/ValueObjects/ActivityObject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\ValueObjects;
 4 | 
 5 | use Illuminate\Database\Eloquent\Model;
 6 | use Musonza\ActivityStreams\Contracts\ActivityObject as ActivityObjectInterface;
 7 | use Musonza\ActivityStreams\Contracts\ReturnsExtraData;
 8 | 
 9 | class ActivityObject implements ActivityObjectInterface
10 | {
11 |     /**
12 |      * @var string
13 |      */
14 |     protected $objectType;
15 | 
16 |     /**
17 |      * @var string
18 |      */
19 |     protected $objectIdentifier;
20 | 
21 |     /**
22 |      * @var array
23 |      */
24 |     protected $extraData;
25 | 
26 |     /**
27 |      * ActivityObject constructor.
28 |      * @param string $objectType
29 |      * @param string $objectIdentifier
30 |      * @param array $extraData
31 |      */
32 |     public function __construct(string $objectType, string $objectIdentifier, array $extraData = [])
33 |     {
34 |         $this->objectType = $objectType;
35 |         $this->objectIdentifier = $objectIdentifier;
36 |         $this->extraData = $extraData;
37 |     }
38 | 
39 |     public static function createFromModel(Model $model, $extraData = []): ActivityObject
40 |     {
41 |         if ($model instanceof ReturnsExtraData) {
42 |             $extraData = $model->getExtraData();
43 |         }
44 | 
45 |         return new static(get_class($model), $model->getKey(), $extraData);
46 |     }
47 | 
48 |     public function getType(): string
49 |     {
50 |         return $this->objectType;
51 |     }
52 | 
53 |     public function getIdentifier(): string
54 |     {
55 |         return $this->objectIdentifier;
56 |     }
57 | 
58 |     public function getExtraData(): array
59 |     {
60 |         return $this->extraData;
61 |     }
62 | }


--------------------------------------------------------------------------------
/tests/Helpers/factories/ModelFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Faker\Generator as Faker;
 4 | use Musonza\ActivityStreams\Models\Activity;
 5 | use Musonza\ActivityStreams\Tests\Helpers\Models\User;
 6 | use Musonza\ActivityStreams\Tests\Helpers\SampleObject;
 7 | use Musonza\ActivityStreams\Tests\Helpers\Targets\SampleTarget;
 8 | use Musonza\ActivityStreams\ValueObjects\Verbs;
 9 | 
10 | /*
11 | |--------------------------------------------------------------------------
12 | | Model Factories
13 | |--------------------------------------------------------------------------
14 | |
15 | | This directory should contain each of the model factory definitions for
16 | | your application. Factories provide a convenient way to generate new
17 | | model instances for testing / seeding your application's database.
18 | |
19 |  */
20 | 
21 | $factory->define(User::class, function (Faker $faker) {
22 |     static $password;
23 | 
24 |     return [
25 |         'name' => $faker->name,
26 |         'email' => $faker->unique()->safeEmail,
27 |         'password' => $password ?: $password = bcrypt('secret'),
28 |         'remember_token' => 'vdvNDHDHHDXY798e9',
29 |     ];
30 | });
31 | 
32 | $factory->define(Activity::class, function (Faker $faker) {
33 |     $actor = factory(User::class)->create();
34 |     $activityObject = new SampleObject();
35 |     $target = new SampleTarget();
36 | 
37 |     return [
38 |         'verb' => Verbs::VERB_PURCHASE,
39 |         'actor_type' => get_class($actor),
40 |         'actor_id' => $actor->getKey(),
41 |         'actor_data' => $actor->toArray(),
42 |         'object_type' => $activityObject->getType(),
43 |         'object_id' => $activityObject->getIdentifier(),
44 |         'object_data' => $activityObject->getExtraData(),
45 |         'target_type' => $target->getType(),
46 |         'target_id' => $target->getIdentifier(),
47 |         'target_data' => $target->getExtraData(),
48 |     ];
49 | });


--------------------------------------------------------------------------------
/src/ActivityStreamsServiceProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams;
 4 | 
 5 | use Illuminate\Support\ServiceProvider;
 6 | use Musonza\ActivityStreams\Console\Commands\MakeFeedCommand;
 7 | 
 8 | class ActivityStreamsServiceProvider extends ServiceProvider
 9 | {
10 |     /**
11 |      * Indicates if loading of the provider is deferred.
12 |      *
13 |      * @var bool
14 |      */
15 |     protected $defer = false;
16 | 
17 |     /**
18 |      * Bootstrap application services.
19 |      *
20 |      * @return void
21 |      */
22 |     public function boot()
23 |     {
24 |         $this->publishMigrations();
25 |         $this->publishConfig();
26 |     }
27 | 
28 |     public function register(): void
29 |     {
30 |         $this->registerBinds();
31 |         $this->registerCommands();
32 |     }
33 | 
34 |     /**
35 |      * Publish package's migrations.
36 |      *
37 |      * @return void
38 |      */
39 |     public function publishMigrations()
40 |     {
41 |         $timestamp = date('Y_m_d_His', time());
42 |         $stub = __DIR__.'/../database/migrations/create_activity_streams_tables.php';
43 |         $target = $this->app->databasePath() . '/migrations/' . $timestamp . '_create_activity_streams_tables.php';
44 |         $this->publishes([$stub => $target], 'activity.streams.migrations');
45 |     }
46 | 
47 |     /**
48 |      * Publish package's config file.
49 |      *
50 |      * @return void
51 |      */
52 |     public function publishConfig()
53 |     {
54 |         $this->publishes([
55 |             __DIR__.'/../config' => config_path(),
56 |         ], 'activity.streams.config');
57 |     }
58 | 
59 |     private function registerBinds(): void
60 |     {
61 |         $this->app->bind('activity_streams', function () {
62 |             return $this->app->make(ActivityStreams::class);
63 |         });
64 |     }
65 | 
66 |     private function registerCommands(): void
67 |     {
68 |         if ($this->app->runningInConsole()) {
69 |             $this->commands([
70 |                 MakeFeedCommand::class
71 |             ]);
72 |         }
73 |     }
74 | }


--------------------------------------------------------------------------------
/tests/TestCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\Tests;
 4 | 
 5 | require __DIR__.'/../database/migrations/create_activity_streams_tables.php';
 6 | require __DIR__.'/Helpers/migrations.php';
 7 | 
 8 | use CreateTestTables;
 9 | use CreateActivityStreamsTables;
10 | use Illuminate\Foundation\Application;
11 | use Musonza\ActivityStreams\ActivityStreamsFacade;
12 | use Musonza\ActivityStreams\ActivityStreamsServiceProvider;
13 | use Orchestra\Database\ConsoleServiceProvider;
14 | 
15 | class TestCase extends \Orchestra\Testbench\TestCase
16 | {
17 |     const FEEDS_TABLE = 'feeds';
18 |     const ACTIVITIES_TABLE = 'activities';
19 | 
20 |     public function setUp(): void
21 |     {
22 |         parent::setUp();
23 | 
24 |         $this->artisan('migrate', ['--database' => 'testbench']);
25 |         $this->withFactories(__DIR__ . '/Helpers/factories');
26 | 
27 |         (new CreateActivityStreamsTables())->up();
28 |         (new CreateTestTables())->up();
29 |     }
30 | 
31 |     /**
32 |      * Define environment setup.
33 |      *
34 |      * @param Application $app
35 |      *
36 |      * @return void
37 |      */
38 |     protected function getEnvironmentSetUp($app)
39 |     {
40 |         parent::getEnvironmentSetUp($app);
41 | 
42 |         // Setup default database to use sqlite :memory:
43 |         $app['config']->set('database.default', 'testbench');
44 |         $app['config']->set('database.connections.testbench', [
45 |             'driver'   => 'sqlite',
46 |             'database' => ':memory:',
47 |             'prefix'   => '',
48 |         ]);
49 | 
50 |         $app['config']->set('activity_streams', include(__DIR__ . '/../config/activity_streams.php'));
51 |     }
52 | 
53 |     protected function getPackageProviders($app)
54 |     {
55 |         return [
56 |             ConsoleServiceProvider::class,
57 |             ActivityStreamsServiceProvider::class,
58 |         ];
59 |     }
60 | 
61 |     protected function getPackageAliases($app)
62 |     {
63 |         return [
64 |             'ActivityStreams' => ActivityStreamsFacade::class,
65 |         ];
66 |     }
67 | 
68 |     public function tearDown(): void
69 |     {
70 |         (new CreateActivityStreamsTables())->down();
71 |         (new CreateTestTables())->down();
72 |         parent::tearDown();
73 |     }
74 | }


--------------------------------------------------------------------------------
/database/migrations/create_activity_streams_tables.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Database\Migrations\Migration;
 4 | use Illuminate\Database\Schema\Blueprint;
 5 | use Illuminate\Support\Facades\Schema;
 6 | 
 7 | class CreateActivityStreamsTables extends Migration
 8 | {
 9 |     /**
10 |      * Run the migrations.
11 |      *
12 |      * @return void
13 |      */
14 |     public function up()
15 |     {
16 |         Schema::create('feeds', function (Blueprint $table) {
17 |             $table->bigIncrements('id');
18 |             $table->string('feedable_type');
19 |             $table->bigInteger('feedable_id')->unsigned();
20 |             $table->unique(['feedable_id', 'feedable_type']);
21 |             $table->text('extra')->nullable();
22 |             $table->timestamps();
23 |         });
24 | 
25 |         Schema::create('activities', function (Blueprint $table) {
26 |             $table->bigIncrements('id');
27 |             $table->string('actor_type');
28 |             $table->string('actor_id');
29 |             $table->text('actor_data')->nullable();
30 |             $table->string('verb');
31 |             $table->string('object_type');
32 |             $table->string('object_id');
33 |             $table->text('object_data')->nullable();
34 |             $table->string('target_type')->nullable();
35 |             $table->string('target_id')->nullable();
36 |             $table->text('target_data')->nullable();
37 |             $table->timestamps();
38 |         });
39 | 
40 |         Schema::create('feed_activities', function (Blueprint $table) {
41 |             $table->bigIncrements('id');
42 |             $table->bigInteger('activity_id')->unsigned();
43 |             $table->bigInteger('feed_id')->unsigned();
44 |             $table->unique(['feed_id', 'activity_id']);
45 |             $table->text('extra')->nullable();
46 |             $table->timestamps();
47 | 
48 |             $table->foreign('activity_id')
49 |                 ->references('id')
50 |                 ->on('activities')
51 |                 ->onDelete('cascade');
52 | 
53 |             $table->foreign('feed_id')
54 |                 ->references('id')
55 |                 ->on('feeds')
56 |                 ->onDelete('cascade');
57 |                 
58 |         });
59 | 
60 |         Schema::create('follows', function (Blueprint $table) {
61 |             $table->bigIncrements('id');
62 |             $table->string('follower_id');
63 |             $table->string('follower_type');
64 |             $table->string('followable_id');
65 |             $table->string('followable_type');
66 |             $table->timestamps();
67 |         });
68 |     }
69 | 
70 |     /**
71 |      * Reverse the migrations.
72 |      *
73 |      * @return void
74 |      */
75 |     public function down()
76 |     {
77 |         Schema::dropIfExists('follows');
78 |         Schema::dropIfExists('feed_activities');
79 |         Schema::dropIfExists('activities');
80 |         Schema::dropIfExists('feeds');
81 |     }
82 | }


--------------------------------------------------------------------------------
/src/ValueObjects/Verbs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Musonza\ActivityStreams\ValueObjects;
 4 | 
 5 | class Verbs
 6 | {
 7 |     const VERB_POST = 'post';
 8 |     const VERB_ACCEPT = 'accept';
 9 |     const VERB_ACCESS = 'access';
10 |     const VERB_ACKNOWLEDGE = 'acknowledge';
11 |     const VERB_ADD = 'add';
12 |     const VERB_AGREE = 'agree';
13 |     const VERB_APPEND = 'append';
14 |     const VERB_APPROVE = 'approve';
15 |     const VERB_ARCHIVE = 'archive';
16 |     const VERB_ASSIGN = 'assign';
17 |     const VERB_AT = 'at';
18 |     const VERB_ATTACH = 'attach';
19 |     const VERB_ATTEND = 'attend';
20 |     const VERB_AUTHOR = 'author';
21 |     const VERB_AUTHORIZE = 'authorize';
22 |     const VERB_BORROW = 'borrow';
23 |     const VERB_BUILD = 'build';
24 |     const VERB_CANCEL = 'cancel';
25 |     const VERB_CHECKIN = 'checkin';
26 |     const VERB_CLOSE  = 'close';
27 |     const VERB_COMPLETE = 'complete';
28 |     const VERB_CONFIRM = 'confirm';
29 |     const VERB_CONSUME = 'consume';
30 |     const VERB_CREATE = 'create';
31 |     const VERB_DELETE = 'delete';
32 |     const VERB_DELIVER = 'deliver';
33 |     const VERB_DENY = 'deny';
34 |     const VERB_DISAGREE = 'disagree';
35 |     const VERB_DISLIKE = 'dislike';
36 |     const VERB_EXPERIENCE = 'experience';
37 |     const VERB_FAVORITE = 'favorite';
38 |     const VERB_FIND = 'find';
39 |     const VERB_FLAG_AS_INAPPROPRIATE = 'flag-as-inappropriate';
40 |     const VERB_FOLLOW = 'follow';
41 |     const VERB_GIVE = 'give';
42 |     const VERB_HOST = 'host';
43 |     const VERB_IGNORE = 'ignore';
44 |     const VERB_INSERT = 'insert';
45 |     const VERB_INSTALL = 'install';
46 |     const VERB_INTERACT = 'interact';
47 |     const VERB_INVITE = 'invite';
48 |     const VERB_JOIN = 'join';
49 |     const VERB_LEAVE = 'leave';
50 |     const VERB_LIKE = 'like';
51 |     const VERB_LISTEN = 'listen';
52 |     const VERB_LOSE = 'lose';
53 |     const VERB_MAKE_FRIEND = 'make-friend';
54 |     const VERB_OPEN = 'open';
55 |     const VERB_PLAY = 'play';
56 |     const VERB_PRESENT = 'present';
57 |     const VERB_PURCHASE = 'purchase';
58 |     const VERB_QUALIFY = 'qualify';
59 |     const VERB_READ = 'read';
60 |     const VERB_RECEIVE = 'receive';
61 |     const VERB_REJECT = 'reject';
62 |     const VERB_REMOVE = 'remove';
63 |     const VERB_REMOVE_FRIEND = 'remove-friend';
64 |     const VERB_REPLACE = 'replace';
65 |     const VERB_REQUEST = 'request';
66 |     const VERB_REQUEST_FRIEND = 'request-friend';
67 |     const VERB_RESOLVE = 'resolve';
68 |     const VERB_RETRACT = 'retract';
69 |     const VERB_RETURN = 'return';
70 |     const VERB_RSVP_MAYBE = 'rsvp-maybe';
71 |     const VERB_RSVP_NO = 'rsvp-no';
72 |     const VERB_RSVP_YES = 'rsvp-yes';
73 |     const VERB_SATISFY = 'satisfy';
74 |     const VERB_SAVE = 'save';
75 |     const VERB_SCHEDULE = 'schedule';
76 |     const VERB_SEARCH = 'search';
77 |     const VERB_SELL = 'sell';
78 |     const VERB_SEND = 'send';
79 |     const VERB_SHARE = 'share';
80 |     const VERB_SPONSOR = 'sponsor';
81 |     const VERB_START = 'start';
82 |     const VERB_STOP_FOLLOWING = 'stop-following';
83 |     const VERB_SUBMIT = 'submit';
84 |     const VERB_TAG = 'tag';
85 |     const VERB_TERMINATE = 'terminate';
86 |     const VERB_TIE = 'tie';
87 |     const VERB_UNFAVORITE = 'unfavorite';
88 |     const VERB_UNLIKE = 'unlike';
89 |     const VERB_UNSATISFY = 'unsatisfy';
90 |     const VERB_UNSAVE = 'unsave';
91 |     const VERB_UNSHARE = 'unshare';
92 |     const VERB_UPDATE = 'update';
93 |     const VERB_USE = 'use';
94 |     const VERB_WATCH = 'watch';
95 |     const VERB_WIN = 'win';
96 | }


--------------------------------------------------------------------------------
/src/Managers/ActivityManager.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Musonza\ActivityStreams\Managers;
  4 | 
  5 | use Illuminate\Database\Eloquent\Model;
  6 | use Illuminate\Support\Collection;
  7 | use Musonza\ActivityStreams\Contracts\ActivityActor;
  8 | use Musonza\ActivityStreams\Contracts\ActivityObject;
  9 | use Musonza\ActivityStreams\Contracts\ActivityTarget;
 10 | use Musonza\ActivityStreams\Exceptions\InvalidActivityVerbException;
 11 | use Musonza\ActivityStreams\Models\Activity;
 12 | use Musonza\ActivityStreams\Models\Feed;
 13 | use Musonza\ActivityStreams\ValueObjects\Target;
 14 | 
 15 | class ActivityManager
 16 | {
 17 |     /**
 18 |      * @var Activity
 19 |      */
 20 |     protected $activity;
 21 | 
 22 |     /**
 23 |      * @var string
 24 |      */
 25 |     protected $verb;
 26 | 
 27 |     /**
 28 |      * @var ActivityTarget
 29 |      */
 30 |     protected $target;
 31 | 
 32 |     /**
 33 |      * @var ActivityActor
 34 |      */
 35 |     protected $actor;
 36 | 
 37 |     /**
 38 |      * @var ActivityObject
 39 |      */
 40 |     private $activityObject;
 41 | 
 42 |     /**
 43 |      * @var ConfigurationManager
 44 |      */
 45 |     protected $configurationManager;
 46 | 
 47 |     /**
 48 |      * ActivityManager constructor.
 49 |      * @param Activity $activity
 50 |      * @param ConfigurationManager $configurationManager
 51 |      */
 52 |     public function __construct(Activity $activity, ConfigurationManager $configurationManager)
 53 |     {
 54 |         $this->activity = $activity;
 55 |         $this->configurationManager = $configurationManager;
 56 |     }
 57 | 
 58 |     /**
 59 |      * @param ActivityActor $actor
 60 |      * @return $this
 61 |      */
 62 |     public function setActor(ActivityActor $actor): self
 63 |     {
 64 |         $this->actor = $actor;
 65 | 
 66 |         return $this;
 67 |     }
 68 | 
 69 |     /**
 70 |      * @param string $verb
 71 |      * @return ActivityManager
 72 |      * @throws InvalidActivityVerbException
 73 |      */
 74 |     public function setVerb(string $verb): self
 75 |     {
 76 |         $this->configurationManager->validateVerb($verb);
 77 | 
 78 |         $this->verb = $verb;
 79 | 
 80 |         return $this;
 81 |     }
 82 | 
 83 |     public function targetModel(Model $model)
 84 |     {
 85 |         return $this->setTarget(Target::createFromModel($model));
 86 |     }
 87 | 
 88 |     public function setTarget(ActivityTarget $target): self
 89 |     {
 90 |         $this->target = $target;
 91 | 
 92 |         return $this;
 93 |     }
 94 | 
 95 |     public function setObject(ActivityObject $activityObject): self
 96 |     {
 97 |         $this->activityObject = $activityObject;
 98 | 
 99 |         return $this;
100 |     }
101 | 
102 |     public function createActivity(): Activity
103 |     {
104 |         $activityData = [
105 |             'actor_type' => $this->actor->getType(),
106 |             'actor_id' => $this->actor->getIdentifier(),
107 |             'actor_data' => $this->actor->getExtraData(),
108 |             'verb' => $this->verb,
109 |             'object_type' => $this->activityObject->getType(),
110 |             'object_id' => $this->activityObject->getIdentifier(),
111 |             'object_data' => $this->activityObject->getExtraData(),
112 |             'target_type' => $this->target->getType(),
113 |             'target_id' => $this->target->getIdentifier(),
114 |             'target_data' => $this->target->getExtraData(),
115 |         ];
116 | 
117 |         $activity = $this->activity->newInstance($activityData);
118 | 
119 |         $activity->save();
120 | 
121 |         return $activity;
122 |     }
123 | 
124 |     public function addActivityToFeed(Feed $feed, Activity $activity): void
125 |     {
126 |         $feed->activities()->attach($activity);
127 |     }
128 | 
129 |     public function addMultipleActivitiesToFeed(Feed $feed, Collection $filteredActivities)
130 |     {
131 |         $feed->activities()->insert($filteredActivities->toArray()[0]);
132 |     }
133 | }


--------------------------------------------------------------------------------
/src/ActivityStreams.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Musonza\ActivityStreams;
  4 | 
  5 | use Illuminate\Database\Eloquent\Model;
  6 | use Illuminate\Support\Collection;
  7 | use Musonza\ActivityStreams\Managers\ActivityManager;
  8 | use Musonza\ActivityStreams\Managers\ConfigurationManager;
  9 | use Musonza\ActivityStreams\Models\Activity;
 10 | use Musonza\ActivityStreams\Models\Feed;
 11 | use Musonza\ActivityStreams\ValueObjects\ActivityObject;
 12 | use Musonza\ActivityStreams\ValueObjects\Actor;
 13 | use Musonza\ActivityStreams\ValueObjects\Target;
 14 | 
 15 | class ActivityStreams
 16 | {
 17 |     /**
 18 |      * @var ActivityManager
 19 |      */
 20 |     public $activityManager;
 21 | 
 22 |     /**
 23 |      * @var ConfigurationManager
 24 |      */
 25 |     protected $configurationManager;
 26 | 
 27 |     /**
 28 |      * ActivityStreams constructor.
 29 |      * @param ActivityManager $activityManager
 30 |      * @param ConfigurationManager $configurationManager
 31 |      */
 32 |     public function __construct(ActivityManager $activityManager, ConfigurationManager $configurationManager)
 33 |     {
 34 |         $this->activityManager = $activityManager;
 35 |         $this->configurationManager = $configurationManager;
 36 |     }
 37 | 
 38 |     /**
 39 |      * Add an activity to a feed.
 40 |      *
 41 |      * @param Feed $feed
 42 |      * @param $activity
 43 |      */
 44 |     public function addActivityToFeed(Feed $feed, $activity): void
 45 |     {
 46 |           if ($activity instanceof Collection) {
 47 |               $filteredActivities = $activity->whereInstanceOf(Activity::class);
 48 | 
 49 |               // TODO batch insert
 50 |               foreach ($filteredActivities as $activity) {
 51 |                   $this->activityManager->addActivityToFeed($feed, $activity);
 52 |               }
 53 | //              $this->activityManager->addMultipleActivitiesToFeed($feed, $filteredActivities);
 54 |               return;
 55 |           }
 56 | 
 57 |         $this->activityManager->addActivityToFeed($feed, $activity);
 58 |     }
 59 | 
 60 |     public function addActivityToMultipleFeeds(Collection $feeds, Activity $activity)
 61 |     {
 62 |         $filteredFeeds = $feeds->whereInstanceOf(Feed::class);
 63 | 
 64 |         foreach ($filteredFeeds as $feed) {
 65 |             $this->activityManager->addActivityToFeed($feed, $activity);
 66 |         }
 67 |     }
 68 | 
 69 |     /**
 70 |      * Sets activity actor.
 71 |      *
 72 |      * @param $actor
 73 |      * @return ActivityStreams
 74 |      */
 75 |     public function setActor($actor): self
 76 |     {
 77 |         if ($actor instanceof Model) {
 78 |             $actor = $this->actorFromModel($actor);
 79 |         }
 80 | 
 81 |         $this->activityManager->setActor($actor);
 82 | 
 83 |         return $this;
 84 |     }
 85 | 
 86 |     /**
 87 |      * @param Model $model
 88 |      * @return Actor
 89 |      */
 90 |     public function actorFromModel(Model $model)
 91 |     {
 92 |         return Actor::createFromModel($model);
 93 |     }
 94 | 
 95 |     /**
 96 |      * @param string $verb
 97 |      * @return $this
 98 |      * @throws Exceptions\InvalidActivityVerbException
 99 |      */
100 |     public function setVerb(string $verb)
101 |     {
102 |         $this->activityManager->setVerb($verb);
103 | 
104 |         return $this;
105 |     }
106 | 
107 |     /**
108 |      * Set activity target.
109 |      *
110 |      * @param $target
111 |      * @return ActivityStreams
112 |      */
113 |     public function setTarget($target): self
114 |     {
115 |         if ($target instanceof Model) {
116 |             $target = $this->targetFromModel($target);
117 |         }
118 | 
119 |         $this->activityManager->setTarget($target);
120 | 
121 |         return $this;
122 |     }
123 | 
124 |     /**
125 |      * @param Model $model
126 |      * @return Target
127 |      */
128 |     public function targetFromModel(Model $model)
129 |     {
130 |         return Target::createFromModel($model);
131 |     }
132 | 
133 |     /**
134 |      * Sets activity object.
135 |      *
136 |      * @param $activityObject
137 |      * @return ActivityStreams
138 |      */
139 |     public function setObject($activityObject): self
140 |     {
141 |         if ($activityObject instanceof Model) {
142 |             $activityObject = $this->objectFromModel($activityObject);
143 |         }
144 | 
145 |         $this->activityManager->setObject($activityObject);
146 | 
147 |         return $this;
148 |     }
149 | 
150 |     /**
151 |      * @param Model $model
152 |      * @return ActivityObject
153 |      */
154 |     public function objectFromModel(Model $model)
155 |     {
156 |         return ActivityObject::createFromModel($model);
157 |     }
158 | 
159 |     /**
160 |      * Gets supported verbs.
161 |      *
162 |      * @return array
163 |      */
164 |     public function verbs(): array
165 |     {
166 |         return $this->configurationManager->getVerbs();
167 |     }
168 | 
169 |     /**
170 |      * Persist the activity.
171 |      *
172 |      * @return Activity
173 |      */
174 |     public function createActivity(): Activity
175 |     {
176 |         return $this->activityManager->createActivity();
177 |     }
178 | }
179 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![Build Status](https://travis-ci.org/musonza/laravel-activity-streams.svg?branch=master)](https://travis-ci.org/musonza/laravel-activity-streams)
  2 | 
  3 | 
  4 | # Laravel Activity Streams
  5 | 
  6 | 
  7 | ## Table of Contents
  8 | 
  9 | <details><summary>Click to expand</summary><p>
 10 |   
 11 | - [Introduction](#introduction)
 12 | - [Installation](#installation)
 13 | - [Usage](#usage)
 14 |   - [Facade](#facade)
 15 |   - [Giving a model an ability to have a Feed](#Giving-a-model-an-ability-to-have-a-Feed)
 16 |   - [Create a model Feed](#create-a-model-feed)
 17 |   - [On-Demand Feeds](#On-Demand-Feeds)
 18 |   - [Create an Activity](#create-an-activity)
 19 |   - [Actors](#actors)
 20 |     - [Valid Actors](#valid-actors)
 21 |   - [Targets](#targets)
 22 |     - [Valid Targets](#valid-targets)
 23 |   - [Objects](#objects)
 24 |     - [Valid Objects](#valid-objects)
 25 |   - [Get supported verbs](#Get-supported-verbs)
 26 |   - [Add an activity to a Feed](#Add-an-activity-to-a-Feed)
 27 |   - [Add multiple activities to a Feed](#Add-multiple-activities-to-a-Feed)
 28 | - [Events](#events)
 29 | - [Configuration](#configuration)
 30 | - [FAQ](#faq)
 31 | 
 32 | </details>
 33 | 
 34 | ## Introduction
 35 | 
 36 | This package enables you to have activity streams in your laravel applications.
 37 | 
 38 | ## Installation
 39 | 
 40 | Install with composer
 41 | 
 42 | ```sh
 43 | composer require musonza/laravel-activity-streams
 44 | ```
 45 | 
 46 | Once the composer installation is finished, you can add alias for the facade. Open `config/app.php`, and make the following update:
 47 | 
 48 | 1) Add a new item to the `aliases` array:
 49 | 
 50 |     ```php
 51 |     'ActivityStreams' => Musonza\ActivityStreams\ActivityStreamsFacade::class,
 52 |     ```
 53 | 
 54 | 1) Publish the configuration file into your app's `config` directory, by running the following command:
 55 | 
 56 |     ```
 57 |     php artisan vendor:publish --tag="activity.streams.config"
 58 |     ```
 59 |     
 60 | 1) Publish the migrations into your app's `migrations` directory, by running the following command:
 61 | 
 62 |     ```
 63 |     php artisan vendor:publish --tag="activity.streams.migrations"
 64 |     ```
 65 |     
 66 | 1) Run the migrations:
 67 | 
 68 |     ```
 69 |     php artisan migrate
 70 |     ```
 71 |     
 72 | ## Usage
 73 | 
 74 | #### Facade
 75 | 
 76 | Whenever you use the `ActivityStreams` facade in your code, remember to add the following line to your namespace imports:
 77 | 
 78 | ```php
 79 | use ActivityStreams;
 80 | ```
 81 | 
 82 | #### Giving a model an ability to have a Feed
 83 | 
 84 | Use the `HasFeed` trait to allow a model to have a feed.
 85 | ```php
 86 | <?php
 87 | 
 88 | use Illuminate\Database\Eloquent\Model;
 89 | use Musonza\ActivityStreams\Traits\HasFeed;
 90 | 
 91 | class User extends Model
 92 | {
 93 |     use HasFeed;
 94 | }
 95 | ``` 
 96 | 
 97 | #### Create a model Feed
 98 | 
 99 | After adding the `HasFeed` trait you can create a feed for the Model as follows
100 | ```php
101 | $feed = $user->createFeed();
102 | ```
103 | 
104 | #### On-Demand Feeds
105 | 
106 | Sometimes you may want to create a Feed that's does not belong to a Model. For example,
107 | you want to add activities to a Trending Feed for your application:
108 | 
109 | Create a class to represent the Trending feed under a namespace of choice
110 | 
111 | ```php
112 | <?php
113 | 
114 | namespace App;
115 | 
116 | class Trending
117 | {
118 |     // Optional implementation
119 | }
120 | 
121 | ```
122 | Then run an artisan command that ships with the package
123 | 
124 | ```php
125 | php artisan streams:make:feed 'App\Trending' 'some-unique-id'
126 | ```
127 | 
128 | `some-unique-id` is unique with respect to `$table->unique(['some-unique-id', 'App\Trending']);`
129 | 
130 | #### Create an Activity
131 | 
132 | An example of an activity will be something like **John liked a photo in 2018Album**
133 | 
134 | |         |            | 
135 | | ------------- |:-------------:|
136 | | Actor          |John |
137 | | Verb          | like |
138 | | Object        | photo      |
139 | | Target        | 2018Album      |
140 | 
141 | 
142 | ```php
143 | use ActivityStreams;
144 | use Musonza\ActivityStreams\ValueObjects\Verbs;
145 | 
146 | $activity = ActivityStreams::setActor($actor)
147 |     ->setVerb(Verbs::VERB_LIKE)
148 |     ->setObject($object)
149 |     ->setTarget($target)
150 |     ->createActivity();
151 | ```
152 | 
153 | #### Actors
154 | 
155 | ##### Valid Actors
156 | 
157 | You can pass in an Eloquent Model as an actor or any Object that implements `Musonza\ActivityStreams\Contracts\ActivityActor` interface
158 | 
159 | #### Targets
160 | 
161 | ##### Valid Targets
162 | 
163 | You can pass in an Eloquent Model as a target or any Object that implements `Musonza\ActivityStreams\Contracts\ActivityTarget` interface
164 | 
165 | #### Objects
166 | 
167 | ##### Valid Objects
168 | 
169 | You can pass in an Eloquent Model as an object or any Object that implements `Musonza\ActivityStreams\Contracts\ActivityObject` interface
170 | 
171 | 
172 | #### Get supported verbs
173 | ```php
174 | $verbs = ActivityStreams::verbs();
175 | ```
176 | 
177 | #### Add an activity to a Feed
178 | ```php
179 | ActivityStreams::addActivityToFeed($feed, $activity);
180 | ```
181 | 
182 | #### Add multiple activities to a Feed
183 | Adds a `Collection` of activities to a `Feed`
184 | 
185 | ```php
186 | ActivityStreams::addActivityToFeed($feed, $activities);
187 | ```
188 | 
189 | #### Add an activity to multiple Feeds
190 | Adds an `Activity` to a `Collection` feeds
191 | 
192 | ```php
193 | ActivityStreams::addActivityToMultipleFeeds($feeds, $activity);
194 | ```
195 | 
196 | ## Events
197 | 
198 | You can leverage and listen for the following events to perform actions in 
199 | your application. For instance you can listen for an `ActivityCreated` event and depending on 
200 | your business logic add the created event to a `Feed` or multiple feeds.
201 | 
202 | #### ActivityCreated
203 | `Musonza\ActivityStreams\Models\Activity\ActivityCreated`
204 | 
205 | #### ActivityDeleted
206 | `Musonza\ActivityStreams\Models\Activity\ActivityDeleted`
207 | 
208 | #### FeedCreated
209 | `Musonza\ActivityStreams\Models\Activity\FeedCreated`
210 | 
211 | #### FeedDeleted
212 | `Musonza\ActivityStreams\Models\Activity\FeedDeleted`
213 | 
214 | ## Configuration
215 | 
216 | 
217 | ## FAQ
218 | See more on Activity Streams specifications [here](http://activitystrea.ms/)
219 | 


--------------------------------------------------------------------------------
/tests/Unit/FacadeTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Musonza\ActivityStreams\Tests\Unit;
  4 | 
  5 | use Illuminate\Support\Collection;
  6 | use Musonza\ActivityStreams\ActivityStreams;
  7 | use Musonza\ActivityStreams\Exceptions\InvalidActivityVerbException;
  8 | use Musonza\ActivityStreams\Models\Activity;
  9 | use Musonza\ActivityStreams\Models\Feed;
 10 | use Musonza\ActivityStreams\Tests\Helpers\Models\User;
 11 | use Musonza\ActivityStreams\Tests\Helpers\SampleObject;
 12 | use Musonza\ActivityStreams\Tests\Helpers\Targets\SampleTarget;
 13 | use Musonza\ActivityStreams\Tests\TestCase;
 14 | use Musonza\ActivityStreams\ValueObjects\Actor;
 15 | use Musonza\ActivityStreams\ValueObjects\Verbs;
 16 | 
 17 | class FacadeTest extends TestCase
 18 | {
 19 |     /**
 20 |      * @var ActivityStreams
 21 |      */
 22 |     private $activityStreams;
 23 | 
 24 |     public function setUp(): void
 25 |     {
 26 |         parent::setUp();
 27 |         $this->activityStreams = app(ActivityStreams::class);
 28 |     }
 29 | 
 30 |     public function testGetDefinedVerbs()
 31 |     {
 32 |         $verbs = $this->activityStreams->verbs();
 33 | 
 34 |         $this->assertIsArray($verbs);
 35 |         $this->assertEquals('post', $verbs['VERB_POST']);
 36 |     }
 37 | 
 38 |     /**
 39 |      * @dataProvider activitiesDataProvider
 40 |      * @throws InvalidActivityVerbException
 41 |      */
 42 |     public function testCreateActivity($actor, $target, $object)
 43 |     {
 44 |         $actor = isset($actor['is_model']) ? factory(User::class)->create() : $actor['value'];
 45 |         $target = isset($target['is_model']) ? factory(User::class)->create() : $target['value'];
 46 |         $object = isset($object['is_model']) ? factory(User::class)->create() : $object['value'];
 47 | 
 48 |         $activity = $this->activityStreams->setActor($actor)
 49 |             ->setVerb(Verbs::VERB_POST)
 50 |             ->setTarget($target)
 51 |             ->setObject($object)
 52 |             ->createActivity();
 53 | 
 54 |         $this->assertInstanceOf(Activity::class, $activity);
 55 |     }
 56 | 
 57 |     public function testAddActivityToFeed()
 58 |     {
 59 |         $user = factory(User::class)->create();
 60 |         $feed = $user->createFeed();
 61 | 
 62 |         $activity = $this->activityStreams->setActor($user)
 63 |             ->setVerb(Verbs::VERB_POST)
 64 |             ->setObject(new SampleObject())
 65 |             ->setTarget(new SampleTarget())
 66 |             ->createActivity();
 67 | 
 68 |         $this->activityStreams->addActivityToFeed($feed, $activity);
 69 | 
 70 |         $this->assertEquals(1, $feed->activities()->count());
 71 |     }
 72 | 
 73 |     public function testAddMultipleActivitiesToFeed()
 74 |     {
 75 |         $user = factory(User::class)->create();
 76 | 
 77 |         /** @var Feed $feed */
 78 |         $feed = $user->createFeed();
 79 | 
 80 |         $activities = factory(Activity::class, 2)->create();
 81 | 
 82 |         $this->activityStreams->addActivityToFeed($feed, $activities);
 83 | 
 84 |         $this->assertEquals(2, $feed->activities()->count());
 85 |     }
 86 | 
 87 |     public function testAddActivityToMultipleFeeds()
 88 |     {
 89 |         $users = factory(User::class, 5)->create();
 90 | 
 91 |         $feeds = [];
 92 |         foreach ($users as $user) {
 93 |            $feeds[] = $user->createFeed();
 94 |         }
 95 | 
 96 |         $feeds = collect($feeds);
 97 | 
 98 |         /** @var Activity $activity */
 99 |         $activity = factory(Activity::class)->create();
100 | 
101 |         $this->activityStreams->addActivityToMultipleFeeds($feeds, $activity);
102 | 
103 |         $this->assertEquals(5, $activity->feeds()->count());
104 |     }
105 | 
106 |     public function testFeedFollowing()
107 |     {
108 |         /** @var User $user1 */
109 |         $user1 = factory(User::class)->create();
110 |         /** @var Feed $user1Feed */
111 |         $user1Feed = $user1->createFeed();
112 | 
113 |         /** @var User $user1 */
114 |         $user2 = factory(User::class)->create();
115 |         /** @var Feed $user2Feed */
116 |         $user2Feed = $user2->createFeed();
117 | 
118 |         $user1Feed->follow($user2Feed);
119 | 
120 |         $this->assertDatabaseHas('follows',[
121 |             'follower_id' => $user1Feed->getKey(),
122 |             'follower_type' => get_class($user1Feed),
123 |             'followable_type' => get_class($user2Feed),
124 |             'followable_id' => $user2Feed->getKey(),
125 |         ]);
126 | 
127 |     }
128 | 
129 |     public function activitiesDataProvider()
130 |     {
131 |         return [
132 |             [
133 |                 'actor' => [
134 |                     'is_model' => true,
135 |                     'value' => null,
136 |                 ],
137 |                 'target' => [
138 |                     'is_model' => true,
139 |                     'value' => null,
140 |                 ],
141 |                 'object' => [
142 |                     'is_model' => true,
143 |                     'value' => null,
144 |                 ],
145 |             ],
146 |             [
147 |                 'actor' => [
148 |                     'value' => new Actor('twitter_user', 126626)
149 |                 ],
150 |                 'target' => [
151 |                     'value' => new SampleTarget()
152 |                 ],
153 |                 'object' => [
154 |                     'is_model' => true,
155 |                     'value' => null,
156 |                 ],
157 |             ],
158 |             [
159 |                 'actor' => [
160 |                     'is_model' => true,
161 |                     'value' => null,
162 |                 ],
163 |                 'target' => [
164 |                     'value' => new SampleTarget()
165 |                 ],
166 |                 'object' => [
167 |                     'value' => new SampleObject()
168 |                 ],
169 |             ],
170 |             [
171 |                 'actor' => [
172 |                     'value' => new Actor('twitter_user', 126626)
173 |                 ],
174 |                 'target' => [
175 |                     'value' => new SampleTarget()
176 |                 ],
177 |                 'object' => [
178 |                     'value' => new SampleObject()
179 |                 ],
180 |             ],
181 |             [
182 |                 'actor' => [
183 |                     'value' => new Actor('twitter_user', 126626)
184 |                 ],
185 |                 'target' => [
186 |                     'value' => new SampleTarget()
187 |                 ],
188 |                 'object' => [
189 |                     'is_model' => true,
190 |                     'value' => null,
191 |                 ],
192 |             ],
193 |         ];
194 |     }
195 | }


--------------------------------------------------------------------------------