silva
/
adrema
2
1
Fork 0
Code Issues 23 Pull Requests 1 Projects 1 Releases 104 Wiki Activity

Update

This commit is contained in:
philipp lang 2023-02-05 23:35:08 +01:00
parent af2cb5688a
commit 0ffce6b25e
19 changed files with 1034 additions and 989 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
app/Actions/MemberPullAction.php
View File

@ -1,193 +0,0 @@
<?php
namespace App\Actions;
use App\Activity;
use App\Confession;
use App\Country;
use App\Course\Models\Course;
use App\Fee;
use App\Gender;
use App\Group;
use App\Initialize\ActivityCreator;
use App\Member\Member;
use App\Member\Membership;
use App\Nationality;
use App\Region;
use App\Subactivity;
use Illuminate\Database\Eloquent\ModelNotFoundException;
use Zoomyboy\LaravelNami\Api;
use Zoomyboy\LaravelNami\Data\MembershipEntry;
use Zoomyboy\LaravelNami\Exceptions\RightException;
use Zoomyboy\LaravelNami\Member as NamiMember;
use Zoomyboy\LaravelNami\NamiException;
class MemberPullAction
{
private NamiMember $member;
private Api $api;
public function api(Api $api): self
{
$this->api = $api;
return $this;
}
public function member(int $groupId, int $memberId): self
{
$this->member = NamiMember::fromNami($this->api->member($groupId, $memberId));
return $this;
}
public function execute(): void
{
if (!$this->member->joined_at) {
return;
}
try {
$region = Region::firstWhere('nami_id', $this->member->region_id ?: -1);
$m = Member::updateOrCreate(['nami_id' => $this->member->id], [
'firstname' => $this->member->firstname,
'lastname' => $this->member->lastname,
'joined_at' => $this->member->joined_at,
'birthday' => $this->member->birthday,
'send_newspaper' => $this->member->send_newspaper,
'address' => $this->member->address,
'zip' => $this->member->zip,
'location' => $this->member->location,
'nickname' => $this->member->nickname,
'other_country' => $this->member->other_country,
'further_address' => $this->member->further_address,
'main_phone' => $this->member->main_phone,
'mobile_phone' => $this->member->mobile_phone,
'work_phone' => $this->member->work_phone,
'fax' => $this->member->fax,
'email' => $this->member->email,
'email_parents' => $this->member->email_parents,
'nami_id' => $this->member->id,
'group_id' => Group::firstOrCreate(['nami_id' => $this->member->group_id], ['nami_id' => $this->member->group_id, 'name' => $this->member->group_name])->id,
'gender_id' => optional(Gender::firstWhere('nami_id', $this->member->gender_id ?: -1))->id,
'confession_id' => optional(Confession::firstWhere('nami_id', $this->member->confession_id ?: -1))->id,
'region_id' => $region && !$region->is_null ? $region->id : null,
'country_id' => optional(Country::where('nami_id', $this->member->country_id)->first())->id,
'subscription_id' => $this->getSubscriptionId($this->member),
'nationality_id' => Nationality::where('nami_id', $this->member->nationality_id)->firstOrFail()->id,
'version' => $this->member->version,
]);
try {
foreach ($this->api->coursesFor($this->member->id) as $course) {
$m->courses()->updateOrCreate(['nami_id' => $course->id], [
'course_id' => Course::where('nami_id', $course->courseId)->firstOrFail()->id,
'organizer' => $course->organizer,
'event_name' => $course->eventName,
'completed_at' => $course->completedAt,
'nami_id' => $course->id,
]);
}
} catch (RightException $e) {
}
try {
foreach ($this->api->membershipsOf($this->member->id) as $membership) {
$existingMembership = Membership::where('nami_id', $membership->id)->first();
if (null !== $membership->endsAt && !$existingMembership) {
continue;
}
if (null !== $membership->endsAt && $existingMembership) {
$existingMembership->delete();
continue;
}
try {
[$activityId, $subactivityId, $groupId] = $this->fetchMembership($membership);
} catch (RightException $e) {
continue;
}
if (is_null($activityId)) {
continue;
}
$m->memberships()->updateOrCreate(['nami_id' => $membership->id], [
'nami_id' => $membership->id,
'from' => $membership->startsAt,
'group_id' => $groupId,
'activity_id' => $activityId,
'subactivity_id' => $subactivityId,
]);
}
} catch (RightException $e) {
}
} catch (ModelNotFoundException $e) {
dd($e->getMessage(), $this->member);
}
}
private function fetchMembership(MembershipEntry $membershipEntry): array
{
if ($this->shouldSyncMembership($membershipEntry)) {
$membership = $this->api->membership($this->member->id, $membershipEntry->id);
if (is_null($membership)) {
return [null, null, null];
}
app(ActivityCreator::class)->createFor($this->api, $membership->groupId);
$group = Group::firstOrCreate(['nami_id' => $membership->groupId], [
'nami_id' => $membership->groupId,
'name' => $membership->group,
]);
try {
$activityId = Activity::where('nami_id', $membership->activityId)->firstOrFail()->id;
$subactivityId = $membership->subactivityId
? Subactivity::where('nami_id', $membership->subactivityId)->firstOrFail()->id
: null;
return [$activityId, $subactivityId, $group->id];
} catch (ModelNotFoundException $e) {
return [null, null, null];
}
}
if (null === $membershipEntry->subactivity) {
$subactivityId = null;
} else {
$subactivityId = Subactivity::where('name', $membershipEntry->subactivity)->firstOrFail()->id;
}
preg_match('/\(([0-9]+)\)$/', $membershipEntry->activity, $activityMatches);
$activityId = Activity::where('nami_id', $activityMatches[1])->firstOrFail()->id;
$groupId = Group::where('name', $membershipEntry->group)->firstOrFail()->id;
return [$activityId, $subactivityId, $groupId];
}
private function shouldSyncMembership(MembershipEntry $membershipEntry): bool
{
if (!Group::where('name', $membershipEntry->group)->exists()) {
return true;
}
if (1 !== preg_match('/\(([0-9]+)\)/', $membershipEntry->activity, $activityMatches)) {
throw new NamiException("ID in taetigkeit string not found: {$membershipEntry->activity}");
}
if (!Activity::where('nami_id', (int) $activityMatches[1])->exists()) {
return true;
}
if (null === $membershipEntry->subactivity) {
return false;
}
return !Subactivity::where('name', $membershipEntry->subactivity)->exists();
}
public function getSubscriptionId(NamiMember $member): ?int
{
$fee = Fee::firstWhere('nami_id', $member->fee_id ?: -1);
if (is_null($fee)) {
return null;
}
return optional($fee->subscriptions()->first())->id;
}
}

75
app/Actions/PullMemberAction.php Normal file
View File

@ -0,0 +1,75 @@
<?php
namespace App\Actions;
use App\Confession;
use App\Country;
use App\Fee;
use App\Gender;
use App\Group;
use App\Member\Member;
use App\Nationality;
use App\Region;
use App\Setting\NamiSettings;
use Lorisleiva\Actions\Concerns\AsAction;
use Zoomyboy\LaravelNami\Api;
use Zoomyboy\LaravelNami\Data\Member as NamiMember;
class PullMemberAction
{
use AsAction;
public function handle(int $groupId, int $memberId): void
{
$member = $this->api()->member($groupId, $memberId);
if (!$member->joinedAt) {
return;
}
$region = Region::firstWhere('nami_id', $member->regionId ?: -1);
$m = Member::updateOrCreate(['nami_id' => $member->id], [
'firstname' => $member->firstname,
'lastname' => $member->lastname,
'joined_at' => $member->joinedAt,
'birthday' => $member->birthday,
'send_newspaper' => $member->sendNewspaper,
'address' => $member->address,
'zip' => $member->zip,
'location' => $member->location,
'nickname' => $member->nickname,
'other_country' => $member->otherCountry,
'further_address' => $member->furtherAddress,
'main_phone' => $member->mainPhone,
'mobile_phone' => $member->mobilePhone,
'work_phone' => $member->workPhone,
'fax' => $member->fax,
'email' => $member->email,
'email_parents' => $member->emailParents,
'nami_id' => $member->id,
'group_id' => Group::firstOrCreate(['nami_id' => $member->groupId], ['nami_id' => $member->groupId, 'name' => $member->groupName])->id,
'gender_id' => optional(Gender::firstWhere('nami_id', $member->genderId ?: -1))->id,
'confession_id' => optional(Confession::firstWhere('nami_id', $member->confessionId ?: -1))->id,
'region_id' => $region && !$region->is_null ? $region->id : null,
'country_id' => optional(Country::where('nami_id', $member->countryId)->first())->id,
'subscription_id' => $this->getSubscriptionId($member),
'nationality_id' => Nationality::where('nami_id', $member->nationalityId)->firstOrFail()->id,
'version' => $member->version,
]);
}
public function getSubscriptionId(NamiMember $member): ?int
{
$fee = Fee::firstWhere('nami_id', $member->feeId ?: -1);
if (is_null($fee)) {
return null;
}
return optional($fee->subscriptions()->first())->id;
}
private function api(): Api
{
return app(NamiSettings::class)->login();
}
}

106
app/Actions/PullMembershipsAction.php Normal file
View File

@ -0,0 +1,106 @@
<?php
namespace App\Actions;
use App\Activity;
use App\Group;
use App\Initialize\ActivityCreator;
use App\Member\Member;
use App\Member\Membership;
use App\Setting\NamiSettings;
use App\Subactivity;
use Lorisleiva\Actions\Concerns\AsAction;
use Zoomyboy\LaravelNami\Api;
use Zoomyboy\LaravelNami\Data\MembershipEntry as NamiMembershipEntry;
class PullMembershipsAction
{
use AsAction;
public function handle(Member $member): void
{
if (!$member->hasNami) {
return;
}
$memberships = $this->api()->membershipsOf($member->nami_id);
foreach ($memberships as $membership) {
$existingMembership = Membership::where('nami_id', $membership->id)->first();
$group = Group::where('name', $membership->group)->first();
if (!$group) {
continue;
}
if (null !== $this->overviewStrategy($member, $group, $membership)) {
continue;
}
$this->singleStrategy($member, $group, $membership);
}
}
private function overviewStrategy(Member $member, Group $group, NamiMembershipEntry $membership): ?Membership
{
$activity = 1 === preg_match('/\(([0-9]+)\)/', $membership->activity, $activityMatches)
? Activity::where('nami_id', (int) $activityMatches[1])->first()
: null;
if (!$activity) {
return null;
}
if (null !== $membership->subactivity) {
$subactivity = Subactivity::where('name', $membership->subactivity)->first();
if (!$subactivity) {
return null;
}
} else {
$subactivity = null;
}
return $member->memberships()->updateOrCreate(['nami_id' => $membership->id], [
'nami_id' => $membership->id,
'from' => $membership->startsAt,
'group_id' => $group->id,
'activity_id' => $activity->id,
'subactivity_id' => $subactivity?->id,
]);
}
private function singleStrategy(Member $member, Group $group, NamiMembershipEntry $membershipEntry): ?Membership
{
$membership = $this->api()->membership($member->nami_id, $membershipEntry->id);
app(ActivityCreator::class)->createFor($this->api(), $membership->groupId);
$activity = Activity::nami($membership->activityId);
if (!$activity) {
return null;
}
if (null !== $membership->subactivityId) {
$subactivity = Subactivity::nami($membership->subactivityId);
if (!$subactivity) {
return null;
}
} else {
$subactivity = null;
}
return $member->memberships()->updateOrCreate(['nami_id' => $membership->id], [
'nami_id' => $membership->id,
'from' => $membership->startsAt,
'group_id' => $group->id,
'activity_id' => $activity->id,
'subactivity_id' => $subactivity?->id,
]);
}
private function api(): Api
{
return app(NamiSettings::class)->login();
}
}

7
app/Group.php
View File

@ -2,6 +2,7 @@
namespace App;
use App\Nami\HasNamiField;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
@ -9,15 +10,11 @@ use Illuminate\Database\Eloquent\Relations\BelongsTo;
class Group extends Model
{
use HasFactory;
use HasNamiField;
public $fillable = ['nami_id', 'name', 'parent_id'];
public $timestamps = false;
public static function nami(int $id): self
{
return static::firstWhere('nami_id', $id);
}
public function parent(): BelongsTo
{
return $this->belongsTo(static::class, 'parent_id');

34
app/Member/Actions/NamiPutMemberAction.php
View File

@ -9,6 +9,7 @@ use App\Member\Member;
use App\Setting\NamiSettings;
use App\Subactivity;
use Lorisleiva\Actions\Concerns\AsAction;
use Zoomyboy\LaravelNami\Data\Member as NamiMember;
class NamiPutMemberAction
{
@ -17,36 +18,37 @@ class NamiPutMemberAction
public function handle(Member $member, ?Activity $activity = null, ?Subactivity $subactivity = null): void
{
$api = app(NamiSettings::class)->login();
$response = $api->putMember([
$response = $api->putMember(NamiMember::from([
'firstname' => $member->firstname,
'lastname' => $member->lastname,
'joined_at' => $member->joined_at,
'joinedAt' => $member->joined_at,
'birthday' => $member->birthday,
'send_newspaper' => $member->send_newspaper,
'sendNewspaper' => $member->send_newspaper,
'address' => $member->address,
'zip' => $member->zip,
'location' => $member->location,
'nickname' => $member->nickname,
'other_country' => $member->other_country,
'further_address' => $member->further_address,
'main_phone' => $member->main_phone,
'mobile_phone' => $member->mobile_phone,
'work_phone' => $member->work_phone,
'otherCountry' => $member->other_country,
'furtherAddress' => $member->further_address,
'mainPhone' => $member->main_phone,
'mobilePhone' => $member->mobile_phone,
'workPhone' => $member->work_phone,
'fax' => $member->fax,
'email' => $member->email,
'email_parents' => $member->email_parents,
'gender_id' => optional($member->gender)->nami_id,
'confession_id' => $member->confession ? $member->confession->nami_id : Confession::firstWhere('is_null', true)->nami_id,
'region_id' => optional($member->region)->nami_id,
'country_id' => $member->country->nami_id,
'fee_id' => $member->getNamiFeeId(),
'nationality_id' => $member->nationality->nami_id,
'group_id' => $member->group->nami_id,
'genderId' => optional($member->gender)->nami_id,
'confessionId' => $member->confession ? $member->confession->nami_id : Confession::firstWhere('is_null', true)->nami_id,
'regionId' => optional($member->region)->nami_id,
'countryId' => $member->country->nami_id,
'feeId' => $member->getNamiFeeId(),
'nationalityId' => $member->nationality->nami_id,
'groupId' => $member->group->nami_id,
'first_activity_id' => $activity ? $activity->nami_id : null,
'first_subactivity_id' => $subactivity ? $subactivity->nami_id : null,
'id' => $member->nami_id,
'version' => $member->version,
]);
'keepdata' => false,
]));
Member::withoutEvents(function () use ($response, $member, $api) {
$member->update(['nami_id' => $response['id']]);
app(MemberPullAction::class)->api($api)->member($member->group->nami_id, $member->nami_id)->execute();

9
app/Member/Member.php
View File

@ -7,6 +7,7 @@ use App\Country;
use App\Course\Models\CourseMember;
use App\Group;
use App\Letter\BillKind;
use App\Nami\HasNamiField;
use App\Nationality;
use App\Payment\Payment;
use App\Payment\Subscription;
@ -34,6 +35,7 @@ use Zoomyboy\LaravelNami\Data\MembershipEntry;
class Member extends Model
{
use Notifiable;
use HasNamiField;
use HasFactory;
use Sluggable;
@ -95,7 +97,7 @@ class Member extends Model
// ---------------------------------- Actions ----------------------------------
public function syncVersion(): void
{
$version = app(NamiSettings::class)->login()->member($this->group->nami_id, $this->nami_id)['version'];
$version = app(NamiSettings::class)->login()->member($this->group->nami_id, $this->nami_id)->version;
$this->update(['version' => $version]);
}
@ -156,11 +158,6 @@ class Member extends Model
: null;
}
public function getHasNamiAttribute(): bool
{
return null !== $this->nami_id;
}
/**
* @return Collection<int, MembershipEntry>
*/

2
app/Membership/Actions/MembershipStoreAction.php
View File

@ -26,7 +26,7 @@ class MembershipStoreAction
$from = now()->startOfDay();
try {
$namiId = $settings->login()->putMembership($member->nami_id, NamiMembership::fromArray([
$namiId = $settings->login()->putMembership($member->nami_id, NamiMembership::from([
'startsAt' => $from,
'groupId' => $member->group->nami_id,
'activityId' => $activity->nami_id,

15
app/Nami/HasNamiField.php
View File

@ -2,18 +2,15 @@
namespace App\Nami;
use Exception;
trait HasNamiField
{
public static function nami(int $id): self
public static function nami(int $id): ?self
{
$model = static::firstWhere('nami_id', $id);
return static::firstWhere('nami_id', $id);
}
if (is_null($model)) {
throw new Exception('Nami search on '.static::class.' with ID '.$id.' failed.');
}
return $model;
public function getHasNamiAttribute(): bool
{
return null !== $this->nami_id;
}
}

1189
composer.lock generated
View File

File diff suppressed because it is too large Load Diff

5
database/factories/CountryFactory.php
View File

@ -24,4 +24,9 @@ class CountryFactory extends Factory
'nami_id' => $this->faker->randomNumber(),
];
}
public function inNami(int $namiId): self
{
return $this->state(['nami_id' => $namiId]);
}
}

5
database/factories/FeeFactory.php
View File

@ -24,4 +24,9 @@ class FeeFactory extends Factory
'nami_id' => $this->faker->randomNumber(),
];
}
public function inNami(int $namiId): self
{
return $this->state(['nami_id' => $namiId]);
}
}

5
database/factories/GroupFactory.php
View File

@ -29,4 +29,9 @@ class GroupFactory extends Factory
{
return $this->state(['nami_id' => $namiId]);
}
public function name(string $name): self
{
return $this->state(['name' => $name]);
}
}

1
database/factories/Member/MemberFactory.php
View File

@ -36,6 +36,7 @@ class MemberFactory extends Factory
'address' => $this->faker->streetAddress,
'zip' => $this->faker->postcode,
'location' => $this->faker->city,
'email' => $this->faker->safeEmail(),
];
}

2
packages/laravel-nami

@ -1 +1 @@
Subproject commit e8d26ab774dbc101729c4942e5259a30fbe9e342
Subproject commit a2e5adfd4ce758a453f2ddbe2a25a88e9c932b0e

20
tests/Feature/Initialize/InitializeTest.php
View File

@ -169,26 +169,6 @@ class InitializeTest extends TestCase
->fakeActivities(9056, []);
},
],
'normal' => [
[
'aktivVon' => '2021-08-22 00:00:00',
'aktivBis' => '',
'gruppierung' => 'testgroup',
'id' => 1077,
'taetigkeit' => '€ leiter (305)',
'untergliederung' => 'wö',
],
function ($db) {
$db->assertDatabaseHas('memberships', [
'member_id' => Member::where('firstname', '::firstname::')->firstOrFail()->id,
'activity_id' => Activity::where('nami_id', 305)->firstOrFail()->id,
'subactivity_id' => Subactivity::where('nami_id', 306)->firstOrFail()->id,
'nami_id' => 1077,
'from' => '2021-08-22 00:00:00',
'group_id' => Group::where('name', 'testgroup')->firstOrFail()->id,
]);
},
],
'fetch_subactivity_from_group' => [
[
'gruppierung' => '::newgroup:: 22',

93
tests/Feature/Initialize/PullMemberActionTest.php Normal file
View File

@ -0,0 +1,93 @@
<?php
namespace Tests\Feature\Initialize;
use App\Actions\PullMemberAction;
use App\Country;
use App\Fee;
use App\Gender;
use App\Group;
use App\Nationality;
use App\Payment\Subscription;
use App\Region;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Tests\TestCase;
use Zoomyboy\LaravelNami\Fakes\MemberFake;
class PullMemberActionTest extends TestCase
{
use DatabaseTransactions;
public function setUp(): void
{
parent::setUp();
Subscription::factory()->name('test')->for(Fee::factory()->inNami(300))->create();
Gender::factory()->inNami(303)->create();
Country::factory()->inNami(302)->create();
Nationality::factory()->inNami(1054)->create();
$this->loginNami();
}
public function testFetchNormalMember(): void
{
app(MemberFake::class)->shows(1000, 1001, [
'vorname' => '::firstname::',
'nachname' => '::lastname::',
'beitragsartId' => 300,
'geburtsDatum' => '2014-07-11 00:00:00',
'gruppierungId' => 1000,
'geschlechtId' => 303,
'id' => 1001,
'eintrittsdatum' => '2020-11-17 00:00:00',
'landId' => 302,
'staatsangehoerigkeitId' => 1054,
'zeitschriftenversand' => true,
'strasse' => '::street::',
'plz' => '12346',
'ort' => '::location::',
'version' => 40,
'gruppierung' => 'SG Wald',
]);
app(PullMemberAction::class)->handle(1000, 1001);
$group = Group::firstWhere('nami_id', 1000);
$this->assertDatabaseHas('members', [
'firstname' => '::firstname::',
'lastname' => '::lastname::',
'subscription_id' => Subscription::firstWhere('name', 'test')->id,
'birthday' => '2014-07-11',
'group_id' => Group::nami(1000)->id,
'gender_id' => Gender::nami(303)->id,
'nami_id' => 1001,
'joined_at' => '2020-11-17',
'country_id' => Country::nami(302)->id,
'nationality_id' => Nationality::nami(1054)->id,
'send_newspaper' => 1,
'address' => '::street::',
'zip' => '12346',
'location' => '::location::',
'version' => '40',
]);
$this->assertDatabaseHas('groups', [
'name' => 'SG Wald',
'nami_id' => 1000,
]);
}
public function testRegionIdIsSetToNull(): void
{
Region::factory()->inNami(999)->name('nicht-de')->create(['is_null' => true]);
app(MemberFake::class)->shows(1000, 1001, [
'regionId' => 999,
]);
app(PullMemberAction::class)->handle(1000, 1001);
$this->assertDatabaseHas('members', [
'region_id' => null,
]);
}
}

142
tests/Feature/Initialize/PullMembershipsActionTest.php Normal file
View File

@ -0,0 +1,142 @@
<?php
namespace Tests\Feature\Initialize;
use App\Actions\PullMembershipsAction;
use App\Activity;
use App\Country;
use App\Fee;
use App\Gender;
use App\Group;
use App\Member\Member;
use App\Nationality;
use App\Payment\Subscription;
use App\Subactivity;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Support\Facades\Http;
use Tests\TestCase;
use Zoomyboy\LaravelNami\Fakes\ActivityFake;
use Zoomyboy\LaravelNami\Fakes\MembershipFake;
use Zoomyboy\LaravelNami\Fakes\SubactivityFake;
class PullMembershipsActionTest extends TestCase
{
use DatabaseTransactions;
public function setUp(): void
{
parent::setUp();
Subscription::factory()->name('test')->for(Fee::factory()->inNami(300))->create();
Gender::factory()->inNami(303)->create();
Country::factory()->inNami(302)->create();
Nationality::factory()->inNami(1054)->create();
$this->loginNami();
}
public function testItDoesntSyncMembershipisWhenMemberHasNoNami(): void
{
$member = Member::factory()->defaults()->for(Group::factory()->inNami(1000)->name('SG Wald'))->create();
app(PullMembershipsAction::class)->handle($member);
Http::assertSentCount(0);
}
public function testFetchMembershipViaOverviewIfMemberHasSameGroup(): void
{
$activity = Activity::factory()->inNami(1003)->name('Tätigkeit')->create();
$member = Member::factory()->defaults()->for(Group::factory()->inNami(1000)->name('SG Wald'))->inNami(1001)->create();
app(MembershipFake::class)->fetches(1001, [
[
'id' => 1077,
'entries_aktivBis' => '',
'entries_aktivVon' => '2021-08-22 00:00:00',
'entries_taetigkeit' => 'Tätigkeit (1003)',
'entries_gruppierung' => 'SG Wald',
'entries_untergliederung' => '',
],
]);
app(PullMembershipsAction::class)->handle($member);
$group = Group::firstWhere('nami_id', 1000);
$member = Member::nami(1001);
$this->assertDatabaseHas('memberships', [
'activity_id' => $activity->id,
'subactivity_id' => null,
'group_id' => $group->id,
'from' => '2021-08-22',
'nami_id' => 1077,
]);
}
public function testFetchMembershipsFromForeignGroup(): void
{
$activity = Activity::factory()->inNami(1003)->name('Tätigkeit')->create();
$group = Group::factory()->inNami(1099)->name('Gruppe')->create();
$member = Member::factory()->defaults()->for($group)->inNami(1001)->create();
app(MembershipFake::class)->fetches(1001, [
[
'id' => 1077,
'entries_aktivBis' => '',
'entries_aktivVon' => '2021-08-22 00:00:00',
'entries_taetigkeit' => 'Tätigkeit (1003)',
'entries_gruppierung' => 'Gruppe',
'entries_untergliederung' => '',
],
]);
app(PullMembershipsAction::class)->handle($member);
$this->assertDatabaseHas('memberships', [
'group_id' => $group->id,
'nami_id' => 1077,
]);
}
public function testFetchSingleMembership(): void
{
$member = Member::factory()->defaults()->for(Group::factory()->inNami(90))->inNami(1001)->create();
$group = Group::factory()->inNami(1005)->name('Gruppe')->create();
app(MembershipFake::class)->fetches(1001, [
[
'id' => 1077,
'entries_aktivBis' => '',
'entries_aktivVon' => '2021-08-22 00:00:00',
'entries_taetigkeit' => 'ReferentIn (33)',
'entries_gruppierung' => 'Gruppe',
'entries_untergliederung' => '',
],
]);
app(MembershipFake::class)->shows(1001, [
'id' => 1077,
'gruppierung' => 'Gruppe',
'gruppierungId' => 1005,
'taetigkeit' => 'ReferentIn',
'taetigkeitId' => 33,
'untergliederung' => 'Pfadfinder',
'untergliederungId' => 55,
'aktivVon' => '2021-08-22 00:00:00',
'aktivBis' => '',
]);
app(ActivityFake::class)->fetches(1005, [['descriptor' => 'ReferentIn2', 'id' => 33]]);
app(SubactivityFake::class)->fetches(33, [['descriptor' => 'Pfadfinder2', 'id' => 55]]);
app(PullMembershipsAction::class)->handle($member);
$this->assertDatabaseHas('activities', [
'name' => 'ReferentIn2',
'nami_id' => 33,
]);
$this->assertDatabaseHas('subactivities', [
'name' => 'Pfadfinder2',
'nami_id' => 55,
]);
$this->assertDatabaseHas('memberships', [
'group_id' => $group->id,
'activity_id' => Activity::nami(33)->id,
'subactivity_id' => Subactivity::nami(55)->id,
]);
}
}

112
tests/Feature/Member/MemberPullActionTest.php
View File

@ -1,112 +0,0 @@
<?php
namespace Tests\Feature\Member;
use App\Actions\MemberPullAction;
use App\Member\Member;
use App\Member\Membership;
use App\Nationality;
use App\Region;
use App\Setting\NamiSettings;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Tests\TestCase;
use Zoomyboy\LaravelNami\Fakes\CourseFake;
use Zoomyboy\LaravelNami\Fakes\MemberFake;
use Zoomyboy\LaravelNami\Fakes\MembershipFake;
class MemberPullActionTest extends TestCase
{
use DatabaseTransactions;
public function testItUpdatesMemberships(): void
{
$member = Member::factory()
->defaults()
->has(Membership::factory()->inNami(60)->in('€ LeiterIn', 63))
->inNami(123)
->create();
app(MemberFake::class)->shows(55, 123, [
'vorname' => '::firstname::',
'nachname' => '::lastname::',
'beitragsartId' => 300,
'geburtsDatum' => '2014-07-11 00:00:00',
'gruppierungId' => 1000,
'id' => 123,
'eintrittsdatum' => '2020-11-17 00:00:00',
'geschlechtId' => 303,
'landId' => 302,
'staatsangehoerigkeitId' => $member->nationality->nami_id,
'zeitschriftenversand' => true,
'strasse' => '::street',
'plz' => '12346',
'ort' => '::location::',
'gruppierung' => 'testgroup',
'version' => 40,
]);
app(MembershipFake::class)
->fetches(123, [['id' => 60]])
->shows(123, [
'id' => 60,
'untergliederungId' => 2,
'taetigkeitId' => 1,
'gruppierungId' => 1400,
'aktivVon' => '2022-02-03T00:00:00',
'aktivBis' => '2022-02-03T00:00:01',
]);
app(CourseFake::class)->fetches(123, []);
$this->withoutExceptionHandling()->login()->loginNami();
app(MemberPullAction::class)
->api(app(NamiSettings::class)->login())
->member(55, $member->nami_id)
->execute();
$this->assertDatabaseMissing('memberships', [
'member_id' => $member->id,
]);
}
public function testRegionIdIsSetToNull(): void
{
Nationality::factory()->inNami(1054)->create();
Region::factory()->inNami(999)->name('nicht-de')->create(['is_null' => true]);
app(MemberFake::class)->shows(55, 123, [
'gruppierungId' => 55,
'id' => 123,
'regionId' => 999,
]);
app(MembershipFake::class)->fetches(123, []);
app(CourseFake::class)->fetches(123, []);
$this->withoutExceptionHandling()->login()->loginNami();
app(MemberPullAction::class)
->api(app(NamiSettings::class)->login())
->member(55, 123)
->execute();
$this->assertDatabaseHas('members', [
'region_id' => null,
]);
}
public function testItSetsNormalAttributes(): void
{
Nationality::factory()->inNami(1054)->create();
$region = Region::factory()->inNami(999)->name('nicht-de')->create(['is_null' => false]);
app(MemberFake::class)->shows(55, 123, [
'regionId' => 999,
]);
app(MembershipFake::class)->fetches(123, []);
app(CourseFake::class)->fetches(123, []);
$this->withoutExceptionHandling()->login()->loginNami();
app(MemberPullAction::class)
->api(app(NamiSettings::class)->login())
->member(55, 123)
->execute();
$this->assertDatabaseHas('members', [
'region_id' => $region->id,
]);
}
}

8
tests/TestCase.php
View File

@ -8,6 +8,7 @@ use App\Setting\NamiSettings;
use App\User;
use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
use Illuminate\Http\RedirectResponse;
use Illuminate\Support\Facades\Http;
use Illuminate\Testing\TestResponse;
use Phake;
use Tests\Lib\TestsInertia;
@ -106,4 +107,11 @@ abstract class TestCase extends BaseTestCase
return $this;
}
public function fakeAllHttp(): self
{
Http::fake(['*' => Http::response('', 200)]);
return $this;
}
}