adalal/solidtime
1
0
Fork 0
mirror of https://github.com/solidtime-io/solidtime.git synced 2026-06-15 05:22:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feature/import' into feature/add_frontend_dashboard

Browse Source 
# Conflicts:
#	app/Http/Controllers/Api/V1/TimeEntryController.php
#	app/Providers/JetstreamServiceProvider.php
This commit is contained in:
Constantin Graf
2024-03-12 17:55:49 +01:00
parent 8438828f32 74197fe5c7
commit ea98572f98
96 changed files with 3444 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.env.example
View File

@@ -37,7 +37,7 @@ MAIL_PORT=1025
MAIL_USERNAME=null
MAIL_PASSWORD=null
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS="hello@example.com"
MAIL_FROM_ADDRESS="no-reply@solidtime.test"
MAIL_FROM_NAME="${APP_NAME}"
AWS_ACCESS_KEY_ID=

1
.gitignore vendored
View File

@@ -26,3 +26,4 @@ yarn-error.log
/blob-report/
/playwright/.cache/
/coverage
/extensions/*

1
README.md
View File

@@ -38,6 +38,7 @@ Add the following entry to your `/etc/hosts`
```
127.0.0.1 solidtime.test
127.0.0.1 playwright.solidtime.test
127.0.0.1 mail.solidtime.test
```
## Running E2E Tests

22
app/Actions/Fortify/CreateNewUser.php
View File

@@ -6,9 +6,12 @@ namespace App\Actions\Fortify;
use App\Models\Organization;
use App\Models\User;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\ValidationException;
use Korridor\LaravelModelValidationRules\Rules\UniqueEloquent;
use Laravel\Fortify\Contracts\CreatesNewUsers;
use Laravel\Jetstream\Jetstream;
@@ -20,12 +23,27 @@ class CreateNewUser implements CreatesNewUsers
* Create a newly registered user.
*
* @param array<string, string> $input
*
* @throws ValidationException
*/
public function create(array $input): User
{
Validator::make($input, [
'name' => ['required', 'string', 'max:255'],
'email' => ['required', 'string', 'email', 'max:255', 'unique:users'],
'name' => [
'required',
'string',
'max:255',
],
'email' => [
'required',
'string',
'email',
'max:255',
new UniqueEloquent(User::class, 'email', function (Builder $builder): Builder {
/** @var Builder<User> $builder */
return $builder->where('is_placeholder', '=', false);
}),
],
'password' => $this->passwordRules(),
'terms' => Jetstream::hasTermsAndPrivacyPolicyFeature() ? ['accepted', 'required'] : '',
])->validate();

34
app/Actions/Jetstream/AddOrganizationMember.php
View File

@@ -8,8 +8,11 @@ use App\Models\Organization;
use App\Models\User;
use Closure;
use Illuminate\Contracts\Validation\Rule;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\Gate;
use Illuminate\Support\Facades\Validator;
use Korridor\LaravelModelValidationRules\Rules\ExistsEloquent;
use Laravel\Jetstream\Contracts\AddsTeamMembers;
use Laravel\Jetstream\Events\AddingTeamMember;
use Laravel\Jetstream\Events\TeamMemberAdded;
@@ -21,21 +24,24 @@ class AddOrganizationMember implements AddsTeamMembers
/**
* Add a new team member to the given team.
*/
public function add(User $user, Organization $organization, string $email, ?string $role = null): void
public function add(User $owner, Organization $organization, string $email, ?string $role = null): void
{
Gate::forUser($user)->authorize('addTeamMember', $organization);
Gate::forUser($owner)->authorize('addTeamMember', $organization);
$this->validate($organization, $email, $role);
$newTeamMember = Jetstream::findUserByEmailOrFail($email);
$newOrganizationMember = User::query()
->where('email', $email)
->where('is_placeholder', '=', false)
->firstOrFail();
AddingTeamMember::dispatch($organization, $newTeamMember);
AddingTeamMember::dispatch($organization, $newOrganizationMember);
$organization->users()->attach(
$newTeamMember, ['role' => $role]
$newOrganizationMember, ['role' => $role]
);
TeamMemberAdded::dispatch($organization, $newTeamMember);
TeamMemberAdded::dispatch($organization, $newOrganizationMember);
}
/**
@@ -46,9 +52,7 @@ class AddOrganizationMember implements AddsTeamMembers
Validator::make([
'email' => $email,
'role' => $role,
], $this->rules(), [
'email.exists' => __('We were unable to find a registered user with this email address.'),
])->after(
], $this->rules())->after(
$this->ensureUserIsNotAlreadyOnTeam($organization, $email)
)->validateWithBag('addTeamMember');
}
@@ -56,12 +60,18 @@ class AddOrganizationMember implements AddsTeamMembers
/**
* Get the validation rules for adding a team member.
*
* @return array<string, array<Rule|string>>
* @return array<string, array<ValidationRule|Rule|string>>
*/
protected function rules(): array
{
return array_filter([
'email' => ['required', 'email', 'exists:users'],
'email' => [
'required',
'email',
(new ExistsEloquent(User::class, 'email', function (Builder $builder) {
return $builder->where('is_placeholder', '=', false);
}))->withMessage(__('We were unable to find a registered user with this email address.')),
],
'role' => Jetstream::hasRoles()
? ['required', 'string', new Role]
: null,
@@ -75,7 +85,7 @@ class AddOrganizationMember implements AddsTeamMembers
{
return function ($validator) use ($team, $email) {
$validator->errors()->addIf(
$team->hasUserWithEmail($email),
$team->hasRealUserWithEmail($email),
'email',
__('This user already belongs to the team.')
);

11
app/Actions/Jetstream/InviteOrganizationMember.php
View File

@@ -34,6 +34,7 @@ class InviteOrganizationMember implements InvitesTeamMembers
InvitingTeamMember::dispatch($organization, $email, $role);
/** @var OrganizationInvitation $invitation */
$invitation = $organization->teamInvitations()->create([
'email' => $email,
'role' => $role,
@@ -50,9 +51,7 @@ class InviteOrganizationMember implements InvitesTeamMembers
Validator::make([
'email' => $email,
'role' => $role,
], $this->rules($organization), [
'email.unique' => __('This user has already been invited to the team.'),
])->after(
], $this->rules($organization))->after(
$this->ensureUserIsNotAlreadyOnTeam($organization, $email)
)->validateWithBag('addTeamMember');
}
@@ -68,10 +67,10 @@ class InviteOrganizationMember implements InvitesTeamMembers
'email' => [
'required',
'email',
new UniqueEloquent(OrganizationInvitation::class, 'email', function (Builder $builder) use ($organization) {
(new UniqueEloquent(OrganizationInvitation::class, 'email', function (Builder $builder) use ($organization) {
/** @var Builder<OrganizationInvitation> $builder */
return $builder->whereBelongsTo($organization, 'organization');
}),
}))->withMessage(__('This user has already been invited to the team.')),
],
'role' => Jetstream::hasRoles()
? ['required', 'string', new Role]
@@ -86,7 +85,7 @@ class InviteOrganizationMember implements InvitesTeamMembers
{
return function ($validator) use ($organization, $email) {
$validator->errors()->addIf(
$organization->hasUserWithEmail($email),
$organization->hasRealUserWithEmail($email),
'email',
__('This user already belongs to the team.')
);

50
app/Exceptions/Api/ApiException.php Normal file
View File

@@ -0,0 +1,50 @@
<?php
declare(strict_types=1);
namespace App\Exceptions\Api;
use Exception;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use LogicException;
abstract class ApiException extends Exception
{
public const string KEY = 'api_exception';
/**
* Render the exception into an HTTP response.
*/
public function render(Request $request): JsonResponse
{
return response()
->json([
'error' => true,
'key' => $this->getKey(),
'message' => $this->getTranslatedMessage(),
], 400);
}
/**
* Get the key for the exception.
*/
public function getKey(): string
{
$key = static::KEY;
if ($key === ApiException::KEY) {
throw new LogicException('API exceptions need the KEY constant defined.');
}
return $key;
}
/**
* Get the translated message for the exception.
*/
public function getTranslatedMessage(): string
{
return __('exceptions.api.'.$this->getKey());
}
}

10
app/Exceptions/Api/TimeEntryStillRunningApiException.php Normal file
View File

@@ -0,0 +1,10 @@
<?php
declare(strict_types=1);
namespace App\Exceptions\Api;
class TimeEntryStillRunningApiException extends ApiException
{
public const string KEY = 'time_entry_still_running';
}

10
app/Exceptions/Api/UserNotPlaceholderApiException.php Normal file
View File

@@ -0,0 +1,10 @@
<?php
declare(strict_types=1);
namespace App\Exceptions\Api;
class UserNotPlaceholderApiException extends ApiException
{
public const string KEY = 'user_not_placeholder';
}

24
app/Exceptions/ApiException.php
View File

@@ -1,24 +0,0 @@
<?php
declare(strict_types=1);
namespace App\Exceptions;
use Exception;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ApiException extends Exception
{
/**
* Render the exception into an HTTP response.
*/
public function render(Request $request): JsonResponse
{
return response()
->json([
'error' => true,
'message' => $this->getMessage(),
], 400);
}
}

9
app/Exceptions/TimeEntryStillRunning.php
View File

@@ -1,9 +0,0 @@
<?php
declare(strict_types=1);
namespace App\Exceptions;
class TimeEntryStillRunning extends ApiException
{
}

11
app/Filament/Resources/ClientResource.php
View File

@@ -6,6 +6,8 @@ namespace App\Filament\Resources;
use App\Filament\Resources\ClientResource\Pages;
use App\Models\Client;
use Filament\Forms\Components\Select;
use Filament\Forms\Components\TextInput;
use Filament\Forms\Form;
use Filament\Resources\Resource;
use Filament\Tables;
@@ -26,7 +28,14 @@ class ClientResource extends Resource
{
return $form
->schema([
//
TextInput::make('name')
->label('Name')
->required(),
Select::make('organization_id')
->relationship(name: 'organization', titleAttribute: 'name')
->label('Organization')
->searchable(['name'])
->required(),
]);
}

60
app/Filament/Resources/OrganizationResource.php
View File

@@ -5,12 +5,21 @@ declare(strict_types=1);
namespace App\Filament\Resources;
use App\Filament\Resources\OrganizationResource\Pages;
use App\Filament\Resources\OrganizationResource\RelationManagers\UsersRelationManager;
use App\Models\Organization;
use App\Service\Import\Importers\ImporterProvider;
use App\Service\Import\Importers\ImportException;
use App\Service\Import\Importers\ReportDto;
use App\Service\Import\ImportService;
use Filament\Forms;
use Filament\Forms\Components\Select;
use Filament\Forms\Form;
use Filament\Notifications\Notification;
use Filament\Resources\Resource;
use Filament\Tables;
use Filament\Tables\Actions\Action;
use Filament\Tables\Table;
use Illuminate\Support\Facades\Storage;
class OrganizationResource extends Resource
{
@@ -60,6 +69,55 @@ class OrganizationResource extends Resource
])
->actions([
Tables\Actions\EditAction::make(),
Action::make('Import')
->icon('heroicon-o-inbox-arrow-down')
->action(function (Organization $record, array $data) {
try {
/** @var ReportDto $report */
$report = app(ImportService::class)->import(
$record,
$data['type'],
Storage::disk(config('filament.default_filesystem_disk'))->get($data['file'])
);
Notification::make()
->title('Import successful')
->success()
->body(
'Imported time entries: '.$report->timeEntriesCreated.'<br>'.
'Imported clients: '.$report->clientsCreated.'<br>'.
'Imported projects: '.$report->projectsCreated.'<br>'.
'Imported tasks: '.$report->tasksCreated.'<br>'.
'Imported tags: '.$report->tagsCreated.'<br>'.
'Imported users: '.$report->usersCreated
)
->persistent()
->send();
} catch (ImportException $exception) {
report($exception);
Notification::make()
->title('Import failed, changes rolled back')
->danger()
->body('Message: '.$exception->getMessage())
->persistent()
->send();
}
})
->tooltip(fn (Organization $record): string => 'Import into '.$record->name)
->form([
Forms\Components\FileUpload::make('file')
->label('File')
->required(),
Select::make('type')
->required()
->options(function (): array {
$select = [];
foreach (app(ImporterProvider::class)->getImporterKeys() as $key) {
$select[$key] = $key;
}
return $select;
}),
]),
])
->bulkActions([
Tables\Actions\BulkActionGroup::make([
@@ -71,7 +129,7 @@ class OrganizationResource extends Resource
public static function getRelations(): array
{
return [
//
UsersRelationManager::class,
];
}

51
app/Filament/Resources/OrganizationResource/RelationManagers/UsersRelationManager.php Normal file
View File

@@ -0,0 +1,51 @@
<?php
declare(strict_types=1);
namespace App\Filament\Resources\OrganizationResource\RelationManagers;
use Filament\Forms;
use Filament\Forms\Form;
use Filament\Resources\RelationManagers\RelationManager;
use Filament\Tables;
use Filament\Tables\Table;
class UsersRelationManager extends RelationManager
{
protected static string $relationship = 'users';
public function form(Form $form): Form
{
return $form
->schema([
Forms\Components\TextInput::make('name')
->required()
->maxLength(255),
]);
}
public function table(Table $table): Table
{
return $table
->recordTitleAttribute('name')
->columns([
Tables\Columns\TextColumn::make('name'),
Tables\Columns\TextColumn::make('role'),
])
->filters([
//
])
->headerActions([
Tables\Actions\CreateAction::make(),
])
->actions([
Tables\Actions\EditAction::make(),
Tables\Actions\DeleteAction::make(),
])
->bulkActions([
Tables\Actions\BulkActionGroup::make([
Tables\Actions\DeleteBulkAction::make(),
]),
]);
}
}

20
app/Filament/Resources/TaskResource.php
View File

@@ -6,9 +6,12 @@ namespace App\Filament\Resources;
use App\Filament\Resources\TaskResource\Pages;
use App\Models\Task;
use Filament\Forms;
use Filament\Forms\Components\Select;
use Filament\Forms\Form;
use Filament\Resources\Resource;
use Filament\Tables;
use Filament\Tables\Filters\SelectFilter;
use Filament\Tables\Table;
class TaskResource extends Resource
@@ -25,7 +28,18 @@ class TaskResource extends Resource
{
return $form
->schema([
//
Forms\Components\TextInput::make('name')
->label('Name')
->required()
->maxLength(255),
Select::make('project_id')
->relationship(name: 'project', titleAttribute: 'name')
->searchable(['name'])
->required(),
Select::make('organization_id')
->relationship(name: 'organization', titleAttribute: 'name')
->searchable(['name'])
->required(),
]);
}
@@ -46,7 +60,9 @@ class TaskResource extends Resource
->sortable(),
])
->filters([
//
SelectFilter::make('organization')
->relationship('organization', 'name')
->searchable(),
])
->defaultSort('created_at', 'desc')
->actions([

6
app/Filament/Resources/TimeEntryResource.php
View File

@@ -14,6 +14,7 @@ use Filament\Forms\Form;
use Filament\Resources\Resource;
use Filament\Tables;
use Filament\Tables\Columns\TextColumn;
use Filament\Tables\Filters\SelectFilter;
use Filament\Tables\Table;
class TimeEntryResource extends Resource
@@ -67,6 +68,7 @@ class TimeEntryResource extends Resource
return $table
->columns([
TextColumn::make('description')
->searchable()
->label('Description'),
TextColumn::make('user.email')
->label('User'),
@@ -89,7 +91,9 @@ class TimeEntryResource extends Resource
->sortable(),
])
->filters([
//
SelectFilter::make('organization')
->relationship('organization', 'name')
->searchable(),
])
->defaultSort('created_at', 'desc')
->actions([

14
app/Filament/Resources/UserResource.php
View File

@@ -5,12 +5,16 @@ declare(strict_types=1);
namespace App\Filament\Resources;
use App\Filament\Resources\UserResource\Pages;
use App\Filament\Resources\UserResource\RelationManagers\OrganizationsRelationManager;
use App\Filament\Resources\UserResource\RelationManagers\OwnedOrganizationsRelationManager;
use App\Models\User;
use Filament\Forms;
use Filament\Forms\Components\TextInput;
use Filament\Forms\Form;
use Filament\Resources\Resource;
use Filament\Tables;
use Filament\Tables\Table;
use Illuminate\Support\Facades\Hash;
class UserResource extends Resource
{
@@ -41,10 +45,11 @@ class UserResource extends Resource
->label('Email')
->required()
->maxLength(255),
Forms\Components\TextInput::make('password')
->label('Password')
->required()
TextInput::make('password')
->password()
->dehydrateStateUsing(fn ($state) => Hash::make($state))
->dehydrated(fn ($state) => filled($state))
->required(fn (string $context): bool => $context === 'create')
->maxLength(255),
]);
}
@@ -77,7 +82,8 @@ class UserResource extends Resource
public static function getRelations(): array
{
return [
//
OwnedOrganizationsRelationManager::class,
OrganizationsRelationManager::class,
];
}

14
app/Filament/Resources/UserResource/Pages/CreateUser.php
View File

@@ -5,9 +5,23 @@ declare(strict_types=1);
namespace App\Filament\Resources\UserResource\Pages;
use App\Filament\Resources\UserResource;
use App\Models\Organization;
use App\Models\User;
use Filament\Resources\Pages\CreateRecord;
class CreateUser extends CreateRecord
{
protected static string $resource = UserResource::class;
protected function afterCreate(): void
{
/** @var User $user */
$user = $this->record;
$user->ownedTeams()->save(Organization::forceCreate([
'user_id' => $user->id,
'name' => explode(' ', $user->name, 2)[0]."'s Organization",
'personal_team' => true,
]));
}
}

50
app/Filament/Resources/UserResource/RelationManagers/OrganizationsRelationManager.php Normal file
View File

@@ -0,0 +1,50 @@
<?php
declare(strict_types=1);
namespace App\Filament\Resources\UserResource\RelationManagers;
use Filament\Forms;
use Filament\Forms\Form;
use Filament\Resources\RelationManagers\RelationManager;
use Filament\Tables;
use Filament\Tables\Table;
class OrganizationsRelationManager extends RelationManager
{
protected static string $relationship = 'organizations';
public function form(Form $form): Form
{
return $form
->schema([
Forms\Components\TextInput::make('name')
->required()
->maxLength(255),
]);
}
public function table(Table $table): Table
{
return $table
->recordTitleAttribute('name')
->columns([
Tables\Columns\TextColumn::make('name'),
])
->filters([
//
])
->headerActions([
Tables\Actions\CreateAction::make(),
])
->actions([
Tables\Actions\EditAction::make(),
Tables\Actions\DeleteAction::make(),
])
->bulkActions([
Tables\Actions\BulkActionGroup::make([
Tables\Actions\DeleteBulkAction::make(),
]),
]);
}
}

47
app/Filament/Resources/UserResource/RelationManagers/OwnedOrganizationsRelationManager.php Normal file
View File

@@ -0,0 +1,47 @@
<?php
declare(strict_types=1);
namespace App\Filament\Resources\UserResource\RelationManagers;
use Filament\Forms;
use Filament\Forms\Form;
use Filament\Resources\RelationManagers\RelationManager;
use Filament\Tables;
use Filament\Tables\Table;
class OwnedOrganizationsRelationManager extends RelationManager
{
protected static ?string $title = 'Owned Organizations';
protected static string $relationship = 'ownedTeams';
public function form(Form $form): Form
{
return $form
->schema([
Forms\Components\TextInput::make('name')
->required()
->maxLength(255),
]);
}
public function table(Table $table): Table
{
return $table
->recordTitleAttribute('name')
->columns([
Tables\Columns\TextColumn::make('name'),
])
->filters([
//
])
->headerActions([
])
->actions([
Tables\Actions\EditAction::make(),
])
->bulkActions([
]);
}
}

63
app/Http/Controllers/Api/V1/ImportController.php Normal file
View File

@@ -0,0 +1,63 @@
<?php
declare(strict_types=1);
namespace App\Http\Controllers\Api\V1;
use App\Http\Requests\V1\Import\ImportRequest;
use App\Models\Organization;
use App\Service\Import\Importers\ImportException;
use App\Service\Import\ImportService;
use Illuminate\Auth\Access\AuthorizationException;
use Illuminate\Http\JsonResponse;
class ImportController extends Controller
{
/**
* Import data into the organization
*
* @throws AuthorizationException
*/
public function import(Organization $organization, ImportRequest $request, ImportService $importService): JsonResponse
{
$this->checkPermission($organization, 'import');
try {
$report = $importService->import(
$organization,
$request->input('type'),
$request->input('data')
);
return new JsonResponse([
/** @var array{
* clients: array{
* created: int,
* },
* projects: array{
* created: int,
* },
* tasks: array{
* created: int,
* },
* time-entries: array{
* created: int,
* },
* tags: array{
* created: int,
* },
* users: array{
* created: int,
* }
* } $report Import report */
'report' => $report->toArray(),
], 200);
} catch (ImportException $exception) {
report($exception);
return new JsonResponse([
'message' => $exception->getMessage(),
], 400);
}
}
}

7
app/Http/Controllers/Api/V1/TimeEntryController.php
View File

@@ -4,7 +4,7 @@ declare(strict_types=1);
namespace App\Http\Controllers\Api\V1;
use App\Exceptions\TimeEntryStillRunning;
use App\Exceptions\Api\TimeEntryStillRunningApiException;
use App\Http\Requests\V1\TimeEntry\TimeEntryIndexRequest;
use App\Http\Requests\V1\TimeEntry\TimeEntryStoreRequest;
use App\Http\Requests\V1\TimeEntry\TimeEntryUpdateRequest;
@@ -104,7 +104,7 @@ class TimeEntryController extends Controller
/**
* Create time entry
*
* @throws AuthorizationException|TimeEntryStillRunning
* @throws AuthorizationException|TimeEntryStillRunningApiException
*
* @operationId createTimeEntry
*/
@@ -118,8 +118,7 @@ class TimeEntryController extends Controller
if ($request->get('end') === null && TimeEntry::query()->where('user_id', $request->get('user_id'))->where('end', null)->exists()) {
// TODO: API documentation
// TODO: Create concept for api exceptions
throw new TimeEntryStillRunning('User already has an active time entry');
throw new TimeEntryStillRunningApiException();
}
$timeEntry = new TimeEntry();

56
app/Http/Controllers/Api/V1/UserController.php Normal file
View File

@@ -0,0 +1,56 @@
<?php
declare(strict_types=1);
namespace App\Http\Controllers\Api\V1;
use App\Exceptions\Api\UserNotPlaceholderApiException;
use App\Http\Requests\V1\User\UserIndexRequest;
use App\Http\Resources\V1\User\UserCollection;
use App\Models\Organization;
use App\Models\User;
use Illuminate\Auth\Access\AuthorizationException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Laravel\Jetstream\Contracts\InvitesTeamMembers;
class UserController extends Controller
{
/**
* List all users in an organization
*
* @throws AuthorizationException
*/
public function index(Organization $organization, UserIndexRequest $request): UserCollection
{
$this->checkPermission($organization, 'users:view');
$users = $organization->users()
->paginate();
return UserCollection::make($users);
}
/**
* Invite a placeholder user to become a real user in the organization
*
* @throws AuthorizationException|UserNotPlaceholderApiException
*/
public function invitePlaceholder(Organization $organization, User $user, Request $request): JsonResponse
{
$this->checkPermission($organization, 'users:invite-placeholder');
if (! $user->is_placeholder) {
throw new UserNotPlaceholderApiException();
}
app(InvitesTeamMembers::class)->invite(
$request->user(),
$organization,
$user->email,
'employee'
);
return response()->json($user);
}
}

2
app/Http/Middleware/ValidateSignature.php
View File

@@ -13,7 +13,7 @@ class ValidateSignature extends Middleware
*
* @var array<int, string>
*/
protected $except = [
protected array $except = [
// 'fbclid',
// 'utm_campaign',
// 'utm_content',

30
app/Http/Requests/V1/Import/ImportRequest.php Normal file
View File

@@ -0,0 +1,30 @@
<?php
declare(strict_types=1);
namespace App\Http\Requests\V1\Import;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Foundation\Http\FormRequest;
class ImportRequest extends FormRequest
{
/**
* Get the validation rules that apply to the request.
*
* @return array<string, array<string|ValidationRule>>
*/
public function rules(): array
{
return [
'type' => [
'required',
'string',
],
'data' => [
'required',
'string',
],
];
}
}

3
app/Http/Requests/V1/Project/ProjectStoreRequest.php
View File

@@ -6,6 +6,7 @@ namespace App\Http\Requests\V1\Project;
use App\Models\Client;
use App\Models\Organization;
use App\Rules\ColorRule;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Foundation\Http\FormRequest;
@@ -25,6 +26,7 @@ class ProjectStoreRequest extends FormRequest
{
return [
'name' => [
// TODO: unique
'required',
'string',
'min:1',
@@ -34,6 +36,7 @@ class ProjectStoreRequest extends FormRequest
'required',
'string',
'max:255',
new ColorRule(),
],
'client_id' => [
'nullable',

3
app/Http/Requests/V1/Project/ProjectUpdateRequest.php
View File

@@ -6,6 +6,7 @@ namespace App\Http\Requests\V1\Project;
use App\Models\Client;
use App\Models\Organization;
use App\Rules\ColorRule;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Foundation\Http\FormRequest;
@@ -25,6 +26,7 @@ class ProjectUpdateRequest extends FormRequest
{
return [
'name' => [
// TODO: unique
'required',
'string',
'max:255',
@@ -33,6 +35,7 @@ class ProjectUpdateRequest extends FormRequest
'required',
'string',
'max:255',
new ColorRule(),
],
'client_id' => [
'nullable',

1
app/Http/Requests/V1/Tag/TagStoreRequest.php
View File

@@ -18,6 +18,7 @@ class TagStoreRequest extends FormRequest
{
return [
'name' => [
// TODO: unique
'required',
'string',
'min:1',

1
app/Http/Requests/V1/Tag/TagUpdateRequest.php
View File

@@ -18,6 +18,7 @@ class TagUpdateRequest extends FormRequest
{
return [
'name' => [
// TODO: unique
'required',
'string',
'min:1',

5
app/Http/Requests/V1/TimeEntry/TimeEntryIndexRequest.php
View File

@@ -30,10 +30,7 @@ class TimeEntryIndexRequest extends FormRequest
'uuid',
new ExistsEloquent(User::class, null, function (Builder $builder): Builder {
/** @var Builder<User> $builder */
return $builder->whereHas('organizations', function (Builder $builder) {
/** @var Builder<Organization> $builder */
return $builder->whereKey($this->organization->getKey());
});
return $builder->belongsToOrganization($this->organization);
}),
],
// Filter only time entries that have a start date before (not including) the given date (example: 2021-12-31)

7
app/Http/Requests/V1/TimeEntry/TimeEntryStoreRequest.php
View File

@@ -33,10 +33,7 @@ class TimeEntryStoreRequest extends FormRequest
'uuid',
new ExistsEloquent(User::class, null, function (Builder $builder): Builder {
/** @var Builder<User> $builder */
return $builder->whereHas('organizations', function (Builder $builder) {
/** @var Builder<Organization> $builder */
return $builder->whereKey($this->organization->getKey());
});
return $builder->belongsToOrganization($this->organization);
}),
],
// ID of the task that the time entry should belong to
@@ -64,7 +61,7 @@ class TimeEntryStoreRequest extends FormRequest
'description' => [
'nullable',
'string',
'max:255',
'max:500',
],
// List of tag IDs
'tags' => [

2
app/Http/Requests/V1/TimeEntry/TimeEntryUpdateRequest.php
View File

@@ -51,7 +51,7 @@ class TimeEntryUpdateRequest extends FormRequest
'description' => [
'nullable',
'string',
'max:255',
'max:500',
],
// List of tag IDs
'tags' => [

26
app/Http/Requests/V1/User/UserIndexRequest.php Normal file
View File

@@ -0,0 +1,26 @@
<?php
declare(strict_types=1);
namespace App\Http\Requests\V1\User;
use App\Models\Organization;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Foundation\Http\FormRequest;
/**
* @property Organization $organization
*/
class UserIndexRequest extends FormRequest
{
/**
* Get the validation rules that apply to the request.
*
* @return array<string, array<string|ValidationRule>>
*/
public function rules(): array
{
return [
];
}
}

17
app/Http/Resources/V1/User/UserCollection.php Normal file
View File

@@ -0,0 +1,17 @@
<?php
declare(strict_types=1);
namespace App\Http\Resources\V1\User;
use Illuminate\Http\Resources\Json\ResourceCollection;
class UserCollection extends ResourceCollection
{
/**
* The resource that this resource collects.
*
* @var string
*/
public $collects = UserResource::class;
}

40
app/Http/Resources/V1/User/UserResource.php Normal file
View File

@@ -0,0 +1,40 @@
<?php
declare(strict_types=1);
namespace App\Http\Resources\V1\User;
use App\Http\Resources\V1\BaseResource;
use App\Models\Membership;
use App\Models\User;
use Illuminate\Http\Request;
/**
* @property User $resource
*/
class UserResource extends BaseResource
{
/**
* Transform the resource into an array.
*
* @return array<string, string|bool|int|null|array<string>>
*/
public function toArray(Request $request): array
{
/** @var Membership $membership */
$membership = $this->resource->getRelationValue('membership');
return [
/** @var string $id ID */
'id' => $this->resource->id,
/** @var string $name Name */
'name' => $this->resource->name,
/** @var string $email Email */
'email' => $this->resource->email,
/** @var string $role Role */
'role' => $membership->role,
/** @var bool $is_placeholder Placeholder user for imports, user might not really exist and does not know about this placeholder membership */
'is_placeholder' => $this->resource->is_placeholder,
];
}
}

30
app/Listeners/RemovePlaceholder.php Normal file
View File

@@ -0,0 +1,30 @@
<?php
declare(strict_types=1);
namespace App\Listeners;
use App\Models\User;
use App\Service\UserService;
use Laravel\Jetstream\Events\TeamMemberAdded;
class RemovePlaceholder
{
/**
* Handle the event.
*/
public function handle(TeamMemberAdded $event): void
{
/** @var UserService $userService */
$userService = app(UserService::class);
$placeholders = User::query()
->where('is_placeholder', '=', true)
->where('email', '=', $event->user->email)
->belongsToOrganization($event->team)
->get();
foreach ($placeholders as $placeholder) {
$userService->assignOrganizationEntitiesToDifferentUser($event->team, $placeholder, $event->user);
}
}
}

44
app/Models/Organization.php
View File

@@ -5,12 +5,15 @@ declare(strict_types=1);
namespace App\Models;
use Database\Factories\OrganizationFactory;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Concerns\HasUuids;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Laravel\Jetstream\Events\TeamCreated;
use Laravel\Jetstream\Events\TeamDeleted;
use Laravel\Jetstream\Events\TeamUpdated;
use Laravel\Jetstream\Jetstream;
use Laravel\Jetstream\Team as JetstreamTeam;
/**
@@ -18,6 +21,8 @@ use Laravel\Jetstream\Team as JetstreamTeam;
* @property string $name
* @property bool $personal_team
* @property User $owner
* @property Collection<User> $users
* @property Collection<string, User> $realUsers
*
* @method HasMany<OrganizationInvitation> teamInvitations()
* @method static OrganizationFactory factory()
@@ -57,4 +62,43 @@ class Organization extends JetstreamTeam
'updated' => TeamUpdated::class,
'deleted' => TeamDeleted::class,
];
/**
* Get all the non-placeholder users of the organization including its owner.
*
* @return Collection<string, User>
*/
public function allRealUsers(): Collection
{
return $this->realUsers->merge([$this->owner]);
}
public function hasRealUserWithEmail(string $email): bool
{
return $this->allRealUsers()->contains(function (User $user) use ($email): bool {
return $user->email === $email;
});
}
/**
* Get all the users that belong to the team.
*
* @return BelongsToMany<User>
*/
public function users(): BelongsToMany
{
return $this->belongsToMany(Jetstream::userModel(), Jetstream::membershipModel())
->withPivot('role')
->withTimestamps()
->as('membership');
}
/**
* @return BelongsToMany<User>
*/
public function realUsers(): BelongsToMany
{
return $this->users()
->where('is_placeholder', false);
}
}

35
app/Models/User.php
View File

@@ -6,6 +6,8 @@ namespace App\Models;
use Database\Factories\UserFactory;
use Filament\Panel;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Concerns\HasUuids;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
@@ -21,9 +23,16 @@ use Laravel\Passport\HasApiTokens;
* @property string $id
* @property string $name
* @property string $email
* @property string|null $email_verified_at
* @property string|null $password
* @property bool $is_placeholder
* @property Collection<Organization> $organizations
* @property Collection<TimeEntry> $timeEntries
*
* @method HasMany<Organization> ownedTeams()
* @method static UserFactory factory()
* @method static Builder<User> query()
* @method Builder<User> belongsToOrganization(Organization $organization)
*/
class User extends Authenticatable
{
@@ -64,8 +73,11 @@ class User extends Authenticatable
* @var array<string, string>
*/
protected $casts = [
'name' => 'string',
'email' => 'string',
'email_verified_at' => 'datetime',
'is_admin' => 'boolean',
'is_placeholder' => 'boolean',
];
/**
@@ -94,4 +106,27 @@ class User extends Authenticatable
->withTimestamps()
->as('membership');
}
/**
* @return HasMany<TimeEntry>
*/
public function timeEntries(): HasMany
{
return $this->hasMany(TimeEntry::class);
}
/**
* @param Builder<User> $builder
* @return Builder<User>
*/
public function scopeBelongsToOrganization(Builder $builder, Organization $organization): Builder
{
return $builder->where(function (Builder $builder) use ($organization): Builder {
return $builder->whereHas('organizations', function (Builder $query) use ($organization): void {
$query->whereKey($organization->getKey());
})->orWhereHas('ownedTeams', function (Builder $query) use ($organization): void {
$query->whereKey($organization->getKey());
});
});
}
}

2
app/Providers/AppServiceProvider.php
View File

@@ -46,6 +46,7 @@ class AppServiceProvider extends ServiceProvider
Model::preventLazyLoading(! $this->app->isProduction());
Model::preventSilentlyDiscardingAttributes(! $this->app->isProduction());
Model::preventAccessingMissingAttributes(! $this->app->isProduction());
Relation::enforceMorphMap([
'membership' => Membership::class,
'organization' => Organization::class,
@@ -74,6 +75,7 @@ class AppServiceProvider extends ServiceProvider
if (config('app.force_https', false) || App::isProduction()) {
URL::forceScheme('https');
request()->server->set('HTTPS', request()->header('X-Forwarded-Proto', 'https') === 'https' ? 'on' : 'off');
}
}
}

6
app/Providers/EventServiceProvider.php
View File

@@ -4,10 +4,11 @@ declare(strict_types=1);
namespace App\Providers;
use App\Listeners\RemovePlaceholder;
use Illuminate\Auth\Events\Registered;
use Illuminate\Auth\Listeners\SendEmailVerificationNotification;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;
use Illuminate\Support\Facades\Event;
use Laravel\Jetstream\Events\TeamMemberAdded;
class EventServiceProvider extends ServiceProvider
{
@@ -20,6 +21,9 @@ class EventServiceProvider extends ServiceProvider
Registered::class => [
SendEmailVerificationNotification::class,
],
TeamMemberAdded::class => [
RemovePlaceholder::class,
],
];
/**

7
app/Providers/JetstreamServiceProvider.php
View File

@@ -74,6 +74,9 @@ class JetstreamServiceProvider extends ServiceProvider
'clients:delete',
'organizations:view',
'organizations:update',
'import',
'users:invite-placeholder',
'users:view',
])->description('Administrator users can perform any action.');
Jetstream::role('manager', 'Manager', [
@@ -94,6 +97,7 @@ class JetstreamServiceProvider extends ServiceProvider
'tags:update',
'tags:delete',
'organizations:view',
'users:view',
])->description('Managers have the ability to read, create, and update their own time entries as well as those of their team.');
Jetstream::role('employee', 'Employee', [
@@ -105,5 +109,8 @@ class JetstreamServiceProvider extends ServiceProvider
'time-entries:delete:own',
'organizations:view',
])->description('Employees have the ability to read, create, and update their own time entries.');
Jetstream::role('placeholder', 'Placeholder', [
])->description('Placeholders are used for importing data. They cannot log in and have no permissions.');
}
}

32
app/Rules/ColorRule.php Normal file
View File

@@ -0,0 +1,32 @@
<?php
declare(strict_types=1);
namespace App\Rules;
use App\Service\ColorService;
use Closure;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Translation\PotentiallyTranslatedString;
class ColorRule implements ValidationRule
{
/**
* Run the validation rule.
*
* @param Closure(string): PotentiallyTranslatedString $fail
*/
public function validate(string $attribute, mixed $value, Closure $fail): void
{
if (! is_string($value)) {
$fail(__('validation.string'));
return;
}
if (! app(ColorService::class)->isValid($value)) {
$fail(__('validation.color'));
return;
}
}
}

45
app/Service/ColorService.php Normal file
View File

@@ -0,0 +1,45 @@
<?php
declare(strict_types=1);
namespace App\Service;
class ColorService
{
/**
* @var array<string>
*/
private const array COLORS = [
'#ef5350',
'#ec407a',
'#ab47bc',
'#7e57c2',
'#5c6bc0',
'#42a5f5',
'#29b6f6',
'#26c6da',
'#26a69a',
'#66bb6a',
'#9ccc65',
'#d4e157',
'#ffee58',
'#ffca28',
'#ffa726',
'#ff7043',
'#8d6e63',
'#bdbdbd',
'#78909c',
];
private const string VALID_REGEX = '/^#[0-9a-f]{6}$/';
public function getRandomColor(): string
{
return self::COLORS[array_rand(self::COLORS)];
}
public function isValid(string $color): bool
{
return preg_match(self::VALID_REGEX, $color) === 1;
}
}

207
app/Service/Import/ImportDatabaseHelper.php Normal file
View File

@@ -0,0 +1,207 @@
<?php
declare(strict_types=1);
namespace App\Service\Import;
use App\Service\Import\Importers\ImportException;
use Closure;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Facades\Validator;
/**
* @template TModel of Model
*/
class ImportDatabaseHelper
{
/**
* @var class-string<TModel>
*/
private string $model;
/**
* @var string[]
*/
private array $identifiers;
/**
* @var array<string, string>|null
*/
private ?array $mapIdentifierToKey = null;
/**
* @var array<string, string>
*/
private array $mapExternalIdentifierToInternalIdentifier = [];
private bool $attachToExisting;
private ?Closure $queryModifier;
private ?Closure $afterCreate;
private int $createdCount;
private array $validate;
/**
* @param class-string<TModel> $model
* @param array<string> $identifiers
*/
public function __construct(string $model, array $identifiers, bool $attachToExisting = false, ?Closure $queryModifier = null, ?Closure $afterCreate = null, array $validate = [])
{
$this->model = $model;
$this->identifiers = $identifiers;
$this->attachToExisting = $attachToExisting;
$this->queryModifier = $queryModifier;
$this->afterCreate = $afterCreate;
$this->createdCount = 0;
$this->validate = $validate;
}
/**
* @return Builder<TModel>
*/
private function getModelInstance(): Builder
{
return (new $this->model)->query();
}
/**
* @param array<string, mixed> $identifierData
* @param array<string, mixed> $createValues
*/
private function createEntity(array $identifierData, array $createValues, ?string $externalIdentifier): string
{
$data = array_merge($identifierData, $createValues);
$validator = Validator::make($data, $this->validate);
if ($validator->fails()) {
throw new ImportException('Invalid data: '.implode(', ', $validator->errors()->all()));
}
$model = new $this->model();
foreach ($data as $key => $value) {
$model->{$key} = $value;
}
$model->save();
if ($this->afterCreate !== null) {
($this->afterCreate)($model);
}
$hash = $this->getHash($identifierData);
$this->mapIdentifierToKey[$hash] = $model->getKey();
$this->createdCount++;
if ($externalIdentifier !== null) {
$this->mapExternalIdentifierToInternalIdentifier[$externalIdentifier] = $hash;
}
return $model->getKey();
}
/**
* @param array<string, mixed> $data
*/
private function getHash(array $data): string
{
$jsonData = json_encode($data);
if ($jsonData === false) {
throw new \RuntimeException('Failed to encode data to JSON');
}
return md5($jsonData);
}
/**
* @param array<string, mixed> $identifierData
* @param array<string, mixed> $createValues
*
* @throws ImportException
*/
public function getKey(array $identifierData, array $createValues = [], ?string $externalIdentifier = null): string
{
$this->checkMap();
$this->validateIdentifierData($identifierData);
$hash = $this->getHash($identifierData);
if ($this->attachToExisting) {
$key = $this->mapIdentifierToKey[$hash] ?? null;
if ($key !== null) {
if ($externalIdentifier !== null) {
$this->mapExternalIdentifierToInternalIdentifier[$externalIdentifier] = $hash;
}
return $key;
}
return $this->createEntity($identifierData, $createValues, $externalIdentifier);
} else {
throw new \RuntimeException('Not implemented');
}
}
/**
* @param array<string, mixed> $identifierData
*
* @throws ImportException
*/
private function validateIdentifierData(array $identifierData): void
{
if (array_keys($identifierData) !== $this->identifiers) {
throw new ImportException('Invalid identifier data');
}
}
public function getKeyByExternalIdentifier(string $externalIdentifier): ?string
{
$hash = $this->mapExternalIdentifierToInternalIdentifier[$externalIdentifier] ?? null;
if ($hash === null) {
return null;
}
return $this->mapIdentifierToKey[$hash] ?? null;
}
/**
* @return array<string>
*/
public function getExternalIds(): array
{
// Note: Otherwise the external ids are integers
return array_map(fn ($value) => (string) $value, array_keys($this->mapExternalIdentifierToInternalIdentifier));
}
private function checkMap(): void
{
if ($this->mapIdentifierToKey === null) {
$select = $this->identifiers;
$select[] = (new $this->model())->getKeyName();
$builder = $this->getModelInstance();
if ($this->queryModifier !== null) {
$builder = ($this->queryModifier)($builder);
}
$databaseEntries = $builder->select($select)
->get();
$this->mapIdentifierToKey = [];
foreach ($databaseEntries as $databaseEntry) {
$identifierData = [];
foreach ($this->identifiers as $identifier) {
$identifierData[$identifier] = $databaseEntry->{$identifier};
}
$hash = $this->getHash($identifierData);
$this->mapIdentifierToKey[$hash] = $databaseEntry->getKey();
}
}
}
public function getCreatedCount(): int
{
return $this->createdCount;
}
}

30
app/Service/Import/ImportService.php Normal file
View File

@@ -0,0 +1,30 @@
<?php
declare(strict_types=1);
namespace App\Service\Import;
use App\Models\Organization;
use App\Service\Import\Importers\ImporterContract;
use App\Service\Import\Importers\ImporterProvider;
use App\Service\Import\Importers\ImportException;
use App\Service\Import\Importers\ReportDto;
use Illuminate\Support\Facades\DB;
class ImportService
{
/**
* @throws ImportException
*/
public function import(Organization $organization, string $importerType, string $data): ReportDto
{
/** @var ImporterContract $importer */
$importer = app(ImporterProvider::class)->getImporter($importerType);
$importer->init($organization);
DB::transaction(function () use (&$importer, &$data) {
$importer->importData($data);
});
return $importer->getReport();
}
}

87
app/Service/Import/Importers/ClockifyProjectsImporter.php Normal file
View File

@@ -0,0 +1,87 @@
<?php
declare(strict_types=1);
namespace App\Service\Import\Importers;
use Exception;
use League\Csv\Exception as CsvException;
use League\Csv\Reader;
class ClockifyProjectsImporter extends DefaultImporter
{
/**
* @throws ImportException
*/
#[\Override]
public function importData(string $data): void
{
try {
$reader = Reader::createFromString($data);
$reader->setHeaderOffset(0);
$reader->setDelimiter(',');
$header = $reader->getHeader();
$this->validateHeader($header);
$records = $reader->getRecords();
foreach ($records as $record) {
$clientId = null;
if ($record['Client'] !== '') {
$clientId = $this->clientImportHelper->getKey([
'name' => $record['Client'],
'organization_id' => $this->organization->id,
]);
}
$projectId = null;
if ($record['Name'] !== '') {
$projectId = $this->projectImportHelper->getKey([
'name' => $record['Name'],
'organization_id' => $this->organization->id,
], [
'client_id' => $clientId,
'color' => $this->colorService->getRandomColor(),
]);
}
if ($record['Tasks'] !== '') {
$tasks = explode(', ', $record['Tasks']);
foreach ($tasks as $task) {
$this->taskImportHelper->getKey([
'name' => $task,
'project_id' => $projectId,
'organization_id' => $this->organization->id,
]);
}
}
}
} catch (ImportException $exception) {
throw $exception;
} catch (CsvException $exception) {
throw new ImportException('Invalid CSV data');
} catch (Exception $exception) {
report($exception);
throw new ImportException('Unknown error');
}
}
/**
* @param array<string> $header
*
* @throws ImportException
*/
private function validateHeader(array $header): void
{
$requiredFields = [
'Name',
'Client',
'Status',
'Visibility',
'Billability',
'Tasks',
];
foreach ($requiredFields as $requiredField) {
if (! in_array($requiredField, $header, true)) {
throw new ImportException('Invalid CSV header, missing field: '.$requiredField);
}
}
}
}

160
app/Service/Import/Importers/ClockifyTimeEntriesImporter.php Normal file
View File

@@ -0,0 +1,160 @@
<?php
declare(strict_types=1);
namespace App\Service\Import\Importers;
use App\Models\TimeEntry;
use Exception;
use Illuminate\Support\Carbon;
use League\Csv\Exception as CsvException;
use League\Csv\Reader;
class ClockifyTimeEntriesImporter extends DefaultImporter
{
/**
* @return array<string>
*
* @throws ImportException
*/
private function getTags(string $tags): array
{
if (trim($tags) === '') {
return [];
}
$tagsParsed = explode(', ', $tags);
$tagIds = [];
foreach ($tagsParsed as $tagParsed) {
$tagId = $this->tagImportHelper->getKey([
'name' => $tagParsed,
'organization_id' => $this->organization->id,
]);
$tagIds[] = $tagId;
}
return $tagIds;
}
/**
* @throws ImportException
*/
#[\Override]
public function importData(string $data): void
{
try {
$reader = Reader::createFromString($data);
$reader->setHeaderOffset(0);
$reader->setDelimiter(',');
$header = $reader->getHeader();
$this->validateHeader($header);
$records = $reader->getRecords();
foreach ($records as $record) {
$userId = $this->userImportHelper->getKey([
'email' => $record['Email'],
], [
'name' => $record['User'],
'is_placeholder' => true,
]);
$clientId = null;
if ($record['Client'] !== '') {
$clientId = $this->clientImportHelper->getKey([
'name' => $record['Client'],
'organization_id' => $this->organization->id,
]);
}
$projectId = null;
if ($record['Project'] !== '') {
$projectId = $this->projectImportHelper->getKey([
'name' => $record['Project'],
'organization_id' => $this->organization->id,
], [
'client_id' => $clientId,
'color' => $this->colorService->getRandomColor(),
]);
}
$taskId = null;
if ($record['Task'] !== '') {
$taskId = $this->taskImportHelper->getKey([
'name' => $record['Task'],
'project_id' => $projectId,
'organization_id' => $this->organization->id,
]);
}
$timeEntry = new TimeEntry();
$timeEntry->user_id = $userId;
$timeEntry->task_id = $taskId;
$timeEntry->project_id = $projectId;
$timeEntry->organization_id = $this->organization->id;
if (strlen($record['Description']) > 500) {
throw new ImportException('Time entry description is too long');
}
$timeEntry->description = $record['Description'];
if (! in_array($record['Billable'], ['Yes', 'No'], true)) {
throw new ImportException('Invalid billable value');
}
$timeEntry->billable = $record['Billable'] === 'Yes';
$timeEntry->tags = $this->getTags($record['Tags']);
// Start
if (preg_match('/^[0-9]{1,2}:[0-9]{1,2} (AM|PM)$/', $record['Start Time']) === 1) {
$start = Carbon::createFromFormat('m/d/Y h:i A', $record['Start Date'].' '.$record['Start Time'], 'UTC');
} else {
$start = Carbon::createFromFormat('m/d/Y H:i:s A', $record['Start Date'].' '.$record['Start Time'], 'UTC');
}
if ($start === false) {
throw new ImportException('Start date ("'.$record['Start Date'].'") or time ("'.$record['Start Time'].'") are invalid');
}
$timeEntry->start = $start;
// End
if (preg_match('/^[0-9]{1,2}:[0-9]{1,2} (AM|PM)$/', $record['End Time']) === 1) {
$end = Carbon::createFromFormat('m/d/Y h:i A', $record['End Date'].' '.$record['End Time'], 'UTC');
} else {
$end = Carbon::createFromFormat('m/d/Y H:i:s A', $record['End Date'].' '.$record['End Time'], 'UTC');
}
if ($end === false) {
throw new ImportException('End date ("'.$record['End Date'].'") or time ("'.$record['End Time'].'") are invalid');
}
$timeEntry->end = $end;
$timeEntry->save();
$this->timeEntriesCreated++;
}
} catch (ImportException $exception) {
throw $exception;
} catch (CsvException $exception) {
throw new ImportException('Invalid CSV data');
} catch (Exception $exception) {
report($exception);
throw new ImportException('Unknown error');
}
}
/**
* @param array<string> $header
*
* @throws ImportException
*/
private function validateHeader(array $header): void
{
$requiredFields = [
'Project',
'Client',
'Description',
'Task',
'User',
'Group',
'Email',
'Tags',
'Billable',
'Start Date',
'Start Time',
'End Date',
'End Time',
];
foreach ($requiredFields as $requiredField) {
if (! in_array($requiredField, $header, true)) {
throw new ImportException('Invalid CSV header, missing field: '.$requiredField);
}
}
}
}

114
app/Service/Import/Importers/DefaultImporter.php Normal file
View File

@@ -0,0 +1,114 @@
<?php
declare(strict_types=1);
namespace App\Service\Import\Importers;
use App\Models\Client;
use App\Models\Organization;
use App\Models\Project;
use App\Models\Tag;
use App\Models\Task;
use App\Models\User;
use App\Service\ColorService;
use App\Service\Import\ImportDatabaseHelper;
use Illuminate\Database\Eloquent\Builder;
abstract class DefaultImporter implements ImporterContract
{
protected Organization $organization;
/**
* @var ImportDatabaseHelper<User>
*/
protected ImportDatabaseHelper $userImportHelper;
/**
* @var ImportDatabaseHelper<Project>
*/
protected ImportDatabaseHelper $projectImportHelper;
/**
* @var ImportDatabaseHelper<Tag>
*/
protected ImportDatabaseHelper $tagImportHelper;
/**
* @var ImportDatabaseHelper<Client>
*/
protected ImportDatabaseHelper $clientImportHelper;
/**
* @var ImportDatabaseHelper<Task>
*/
protected ImportDatabaseHelper $taskImportHelper;
protected int $timeEntriesCreated;
protected ColorService $colorService;
public function init(Organization $organization): void
{
$this->organization = $organization;
$this->userImportHelper = new ImportDatabaseHelper(User::class, ['email'], true, function (Builder $builder) {
/** @var Builder<User> $builder */
return $builder->belongsToOrganization($this->organization);
}, function (User $user) {
$user->organizations()->attach($this->organization, [
'role' => 'placeholder',
]);
}, validate: [
'name' => [
'required',
'max:255',
],
]);
$this->projectImportHelper = new ImportDatabaseHelper(Project::class, ['name', 'organization_id'], true, function (Builder $builder) {
return $builder->where('organization_id', $this->organization->id);
}, validate: [
'name' => [
'required',
'max:255',
],
]);
$this->tagImportHelper = new ImportDatabaseHelper(Tag::class, ['name', 'organization_id'], true, function (Builder $builder) {
return $builder->where('organization_id', $this->organization->id);
}, validate: [
'name' => [
'required',
'max:255',
],
]);
$this->clientImportHelper = new ImportDatabaseHelper(Client::class, ['name', 'organization_id'], true, function (Builder $builder) {
return $builder->where('organization_id', $this->organization->id);
}, validate: [
'name' => [
'required',
'max:255',
],
]);
$this->taskImportHelper = new ImportDatabaseHelper(Task::class, ['name', 'project_id', 'organization_id'], true, function (Builder $builder) {
return $builder->where('organization_id', $this->organization->id);
}, validate: [
'name' => [
'required',
'max:500',
],
]);
$this->timeEntriesCreated = 0;
$this->colorService = app(ColorService::class);
}
#[\Override]
public function getReport(): ReportDto
{
return new ReportDto(
clientsCreated: $this->clientImportHelper->getCreatedCount(),
projectsCreated: $this->projectImportHelper->getCreatedCount(),
tasksCreated: $this->taskImportHelper->getCreatedCount(),
timeEntriesCreated: $this->timeEntriesCreated,
tagsCreated: $this->tagImportHelper->getCreatedCount(),
usersCreated: $this->userImportHelper->getCreatedCount(),
);
}
}

9
app/Service/Import/Importers/ImportException.php Normal file
View File

@@ -0,0 +1,9 @@
<?php
declare(strict_types=1);
namespace App\Service\Import\Importers;
class ImportException extends \Exception
{
}

16
app/Service/Import/Importers/ImporterContract.php Normal file
View File

@@ -0,0 +1,16 @@
<?php
declare(strict_types=1);
namespace App\Service\Import\Importers;
use App\Models\Organization;
interface ImporterContract
{
public function init(Organization $organization): void;
public function importData(string $data): void;
public function getReport(): ReportDto;
}

43
app/Service/Import/Importers/ImporterProvider.php Normal file
View File

@@ -0,0 +1,43 @@
<?php
declare(strict_types=1);
namespace App\Service\Import\Importers;
class ImporterProvider
{
/**
* @var array<string, class-string<ImporterContract>>
*/
private array $importers = [
'toggl_time_entries' => TogglTimeEntriesImporter::class,
'toggl_data_importer' => TogglDataImporter::class,
'clockify_time_entries' => ClockifyTimeEntriesImporter::class,
'clockify_projects' => ClockifyProjectsImporter::class,
];
/**
* @param class-string<ImporterContract> $importer
*/
public function registerImporter(string $type, string $importer): void
{
$this->importers[$type] = $importer;
}
/**
* @return array<string>
*/
public function getImporterKeys(): array
{
return array_keys($this->importers);
}
public function getImporter(string $type): ImporterContract
{
if (! array_key_exists($type, $this->importers)) {
throw new \InvalidArgumentException('Invalid importer type');
}
return new $this->importers[$type];
}
}

76
app/Service/Import/Importers/ReportDto.php Normal file
View File

@@ -0,0 +1,76 @@
<?php
declare(strict_types=1);
namespace App\Service\Import\Importers;
class ReportDto
{
public int $clientsCreated;
public int $projectsCreated;
public int $tasksCreated;
public int $timeEntriesCreated;
public int $tagsCreated;
public int $usersCreated;
public function __construct(int $clientsCreated, int $projectsCreated, int $tasksCreated, int $timeEntriesCreated, int $tagsCreated, int $usersCreated)
{
$this->clientsCreated = $clientsCreated;
$this->projectsCreated = $projectsCreated;
$this->tasksCreated = $tasksCreated;
$this->timeEntriesCreated = $timeEntriesCreated;
$this->tagsCreated = $tagsCreated;
$this->usersCreated = $usersCreated;
}
/**
* @return array{
* clients: array{
* created: int,
* },
* projects: array{
* created: int,
* },
* tasks: array{
* created: int,
* },
* time-entries: array{
* created: int,
* },
* tags: array{
* created: int,
* },
* users: array{
* created: int,
* }
* }
*/
public function toArray(): array
{
return [
'clients' => [
'created' => $this->clientsCreated,
],
'projects' => [
'created' => $this->projectsCreated,
],
'tasks' => [
'created' => $this->tasksCreated,
],
'time-entries' => [
'created' => $this->timeEntriesCreated,
],
'tags' => [
'created' => $this->tagsCreated,
],
'users' => [
'created' => $this->usersCreated,
],
];
}
}

116
app/Service/Import/Importers/TogglDataImporter.php Normal file
View File

@@ -0,0 +1,116 @@
<?php
declare(strict_types=1);
namespace App\Service\Import\Importers;
use Exception;
use Spatie\TemporaryDirectory\TemporaryDirectory;
use ZipArchive;
class TogglDataImporter extends DefaultImporter
{
/**
* @throws ImportException
*/
#[\Override]
public function importData(string $data): void
{
try {
$zip = new ZipArchive();
$temporaryDirectory = TemporaryDirectory::make();
file_put_contents($temporaryDirectory->path('import.zip'), $data);
$zip->open($temporaryDirectory->path('import.zip'), ZipArchive::RDONLY);
$temporaryDirectory = TemporaryDirectory::make();
$zip->extractTo($temporaryDirectory->path());
$zip->close();
$clientsFileContent = file_get_contents($temporaryDirectory->path('clients.json'));
if ($clientsFileContent === false) {
throw new ImportException('File clients.json missing in ZIP');
}
$clients = json_decode($clientsFileContent);
$projectsFileContent = file_get_contents($temporaryDirectory->path('projects.json'));
if ($projectsFileContent === false) {
throw new ImportException('File projects.json missing in ZIP');
}
$projects = json_decode($projectsFileContent);
$tagsFileContent = file_get_contents($temporaryDirectory->path('tags.json'));
if ($tagsFileContent === false) {
throw new ImportException('File tags.json missing in ZIP');
}
$tags = json_decode($tagsFileContent);
$workspaceUsersFileContent = file_get_contents($temporaryDirectory->path('workspace_users.json'));
if ($workspaceUsersFileContent === false) {
throw new ImportException('File workspace_users.json missing in ZIP');
}
$workspaceUsers = json_decode($workspaceUsersFileContent);
foreach ($clients as $client) {
$this->clientImportHelper->getKey([
'name' => $client->name,
'organization_id' => $this->organization->id,
], [], (string) $client->id);
}
foreach ($tags as $tag) {
$this->tagImportHelper->getKey([
'name' => $tag->name,
'organization_id' => $this->organization->id,
], [], (string) $tag->id);
}
foreach ($projects as $project) {
$clientId = null;
if ($project->client_id !== null) {
$clientId = $this->clientImportHelper->getKeyByExternalIdentifier((string) $project->client_id);
if ($clientId === null) {
throw new Exception('Client does not exist');
}
}
if (! $this->colorService->isValid($project->color)) {
throw new ImportException('Invalid color');
}
$this->projectImportHelper->getKey([
'name' => $project->name,
'organization_id' => $this->organization->getKey(),
], [
'client_id' => $clientId,
'color' => $project->color,
], (string) $project->id);
}
foreach ($workspaceUsers as $workspaceUser) {
$this->userImportHelper->getKey([
'email' => $workspaceUser->email,
], [
'name' => $workspaceUser->name,
'is_placeholder' => true,
], (string) $workspaceUser->id);
}
$projectIds = $this->projectImportHelper->getExternalIds();
foreach ($projectIds as $projectIdExternal) {
$tasksFileContent = file_get_contents($temporaryDirectory->path('tasks/'.$projectIdExternal.'.json'));
if ($tasksFileContent === false) {
throw new ImportException('File tasks/'.$projectIdExternal.'.json missing in ZIP');
}
$tasks = json_decode($tasksFileContent);
foreach ($tasks as $task) {
$projectId = $this->projectImportHelper->getKeyByExternalIdentifier((string) $projectIdExternal);
if ($projectId === null) {
throw new Exception('Project does not exist');
}
$this->taskImportHelper->getKey([
'name' => $task->name,
'project_id' => $projectId,
'organization_id' => $this->organization->getKey(),
], [], (string) $task->id);
}
}
} catch (ImportException $exception) {
throw $exception;
} catch (Exception $exception) {
report($exception);
throw new ImportException('Unknown error');
}
}
}

144
app/Service/Import/Importers/TogglTimeEntriesImporter.php Normal file
View File

@@ -0,0 +1,144 @@
<?php
declare(strict_types=1);
namespace App\Service\Import\Importers;
use App\Models\TimeEntry;
use Exception;
use Illuminate\Support\Carbon;
use League\Csv\Exception as CsvException;
use League\Csv\Reader;
class TogglTimeEntriesImporter extends DefaultImporter
{
/**
* @return array<string>
*
* @throws ImportException
*/
private function getTags(string $tags): array
{
if (trim($tags) === '') {
return [];
}
$tagsParsed = explode(', ', $tags);
$tagIds = [];
foreach ($tagsParsed as $tagParsed) {
$tagId = $this->tagImportHelper->getKey([
'name' => $tagParsed,
'organization_id' => $this->organization->id,
]);
$tagIds[] = $tagId;
}
return $tagIds;
}
/**
* @throws ImportException
*/
#[\Override]
public function importData(string $data): void
{
try {
$reader = Reader::createFromString($data);
$reader->setHeaderOffset(0);
$reader->setDelimiter(',');
$header = $reader->getHeader();
$this->validateHeader($header);
$records = $reader->getRecords();
foreach ($records as $record) {
$userId = $this->userImportHelper->getKey([
'email' => $record['Email'],
], [
'name' => $record['User'],
'is_placeholder' => true,
]);
$clientId = null;
if ($record['Client'] !== '') {
$clientId = $this->clientImportHelper->getKey([
'name' => $record['Client'],
'organization_id' => $this->organization->id,
]);
}
$projectId = null;
if ($record['Project'] !== '') {
$projectId = $this->projectImportHelper->getKey([
'name' => $record['Project'],
'organization_id' => $this->organization->id,
], [
'client_id' => $clientId,
'color' => $this->colorService->getRandomColor(),
]);
}
$taskId = null;
if ($record['Task'] !== '') {
$taskId = $this->taskImportHelper->getKey([
'name' => $record['Task'],
'project_id' => $projectId,
'organization_id' => $this->organization->id,
]);
}
$timeEntry = new TimeEntry();
$timeEntry->user_id = $userId;
$timeEntry->task_id = $taskId;
$timeEntry->project_id = $projectId;
$timeEntry->organization_id = $this->organization->id;
$timeEntry->description = $record['Description'];
if (! in_array($record['Billable'], ['Yes', 'No'], true)) {
throw new ImportException('Invalid billable value');
}
$timeEntry->billable = $record['Billable'] === 'Yes';
$timeEntry->tags = $this->getTags($record['Tags']);
$start = Carbon::createFromFormat('Y-m-d H:i:s', $record['Start date'].' '.$record['Start time'], 'UTC');
if ($start === false) {
throw new ImportException('Start date ("'.$record['Start date'].'") or time ("'.$record['Start time'].'") are invalid');
}
$timeEntry->start = $start;
$end = Carbon::createFromFormat('Y-m-d H:i:s', $record['End date'].' '.$record['End time'], 'UTC');
if ($end === false) {
throw new ImportException('End date ("'.$record['End date'].'") or time ("'.$record['End time'].'") are invalid');
}
$timeEntry->end = $end;
$timeEntry->save();
$this->timeEntriesCreated++;
}
} catch (ImportException $exception) {
throw $exception;
} catch (CsvException $exception) {
throw new ImportException('Invalid CSV data');
} catch (Exception $exception) {
report($exception);
throw new ImportException('Unknown error');
}
}
/**
* @param array<string> $header
*
* @throws ImportException
*/
private function validateHeader(array $header): void
{
$requiredFields = [
'User',
'Email',
'Client',
'Project',
'Task',
'Description',
'Billable',
'Start date',
'Start time',
'End date',
'End time',
'Tags',
];
foreach ($requiredFields as $requiredField) {
if (! in_array($requiredField, $header, true)) {
throw new ImportException('Invalid CSV header, missing field: '.$requiredField);
}
}
}
}

23
app/Service/UserService.php Normal file
View File

@@ -0,0 +1,23 @@
<?php
declare(strict_types=1);
namespace App\Service;
use App\Models\Organization;
use App\Models\TimeEntry;
use App\Models\User;
class UserService
{
public function assignOrganizationEntitiesToDifferentUser(Organization $organization, User $fromUser, User $toUser): void
{
// Time entries
TimeEntry::query()
->whereBelongsTo($organization, 'organization')
->whereBelongsTo($fromUser, 'user')
->update([
'user_id' => $toUser->getKey(),
]);
}
}

2
composer.json
View File

@@ -6,6 +6,7 @@
"license": "AGPL-3.0-or-later",
"require": {
"php": "8.3.*",
"ext-zip": "*",
"dedoc/scramble": "^0.8.5",
"filament/filament": "^3.2",
"guzzlehttp/guzzle": "^7.2",
@@ -16,6 +17,7 @@
"laravel/passport": "^11.10.2",
"laravel/tinker": "^2.8",
"pxlrbt/filament-environment-indicator": "^2.0",
"spatie/temporary-directory": "^2.2",
"tightenco/ziggy": "^1.0",
"tpetry/laravel-postgresql-enhanced": "^0.33.0"
},

66
composer.lock generated
View File

@@ -4,7 +4,7 @@
"Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
"This file is @generated automatically"
],
"content-hash": "e83929e68d256367652d91e43a79288e",
"content-hash": "9e9c41ae5787e1aa711b04cc019cb7e7",
"packages": [
{
"name": "anourvalar/eloquent-serialize",
@@ -6542,6 +6542,67 @@
],
"time": "2024-01-11T08:43:00+00:00"
},
{
"name": "spatie/temporary-directory",
"version": "2.2.1",
"source": {
"type": "git",
"url": "https://github.com/spatie/temporary-directory.git",
"reference": "76949fa18f8e1a7f663fd2eaa1d00e0bcea0752a"
},
"dist": {
"type": "zip",
"url": "https://api.github.com/repos/spatie/temporary-directory/zipball/76949fa18f8e1a7f663fd2eaa1d00e0bcea0752a",
"reference": "76949fa18f8e1a7f663fd2eaa1d00e0bcea0752a",
"shasum": ""
},
"require": {
"php": "^8.0"
},
"require-dev": {
"phpunit/phpunit": "^9.5"
},
"type": "library",
"autoload": {
"psr-4": {
"Spatie\\TemporaryDirectory\\": "src"
}
},
"notification-url": "https://packagist.org/downloads/",
"license": [
"MIT"
],
"authors": [
{
"name": "Alex Vanderbist",
"email": "alex@spatie.be",
"homepage": "https://spatie.be",
"role": "Developer"
}
],
"description": "Easily create, use and destroy temporary directories",
"homepage": "https://github.com/spatie/temporary-directory",
"keywords": [
"php",
"spatie",
"temporary-directory"
],
"support": {
"issues": "https://github.com/spatie/temporary-directory/issues",
"source": "https://github.com/spatie/temporary-directory/tree/2.2.1"
},
"funding": [
{
"url": "https://spatie.be/open-source/support-us",
"type": "custom"
},
{
"url": "https://github.com/spatie",
"type": "github"
}
],
"time": "2023-12-25T11:46:58+00:00"
},
{
"name": "symfony/console",
"version": "v6.4.4",
@@ -12424,7 +12485,8 @@
"prefer-stable": true,
"prefer-lowest": false,
"platform": {
"php": "8.3.*"
"php": "8.3.*",
"ext-zip": "*"
},
"platform-dev": [],
"plugin-api-version": "2.6.0"

6
config/filesystems.php
View File

@@ -58,6 +58,12 @@ return [
'throw' => false,
],
'testfiles' => [
'driver' => 'local',
'root' => storage_path('tests'),
'throw' => false,
],
],
/*

3
config/telescope.php
View File

@@ -98,7 +98,6 @@ return [
],
'ignore_paths' => [
'livewire*',
'nova-api*',
'pulse*',
],
@@ -156,7 +155,7 @@ return [
Watchers\LogWatcher::class => [
'enabled' => env('TELESCOPE_LOG_WATCHER', true),
'level' => 'error',
'level' => 'debug',
],
Watchers\MailWatcher::class => env('TELESCOPE_MAIL_WATCHER', true),

4
database/factories/OrganizationFactory.php
View File

@@ -27,10 +27,10 @@ class OrganizationFactory extends Factory
];
}
public function withOwner(): self
public function withOwner(?User $owner = null): self
{
return $this->state(fn (array $attributes) => [
'user_id' => User::factory(),
'user_id' => $owner === null ? User::factory() : $owner,
]);
}
}

3
database/factories/ProjectFactory.php
View File

@@ -7,6 +7,7 @@ namespace Database\Factories;
use App\Models\Client;
use App\Models\Organization;
use App\Models\Project;
use App\Service\ColorService;
use Illuminate\Database\Eloquent\Factories\Factory;
/**
@@ -23,7 +24,7 @@ class ProjectFactory extends Factory
{
return [
'name' => $this->faker->company(),
'color' => $this->faker->hexColor(),
'color' => app(ColorService::class)->getRandomColor(),
'organization_id' => Organization::factory(),
'client_id' => null,
];

10
database/factories/UserFactory.php
View File

@@ -31,9 +31,19 @@ class UserFactory extends Factory
'remember_token' => Str::random(10),
'profile_photo_path' => null,
'current_team_id' => null,
'is_placeholder' => false,
];
}
public function placeholder(bool $placeholder = true): static
{
return $this->state(function (array $attributes) use ($placeholder): array {
return [
'is_placeholder' => $placeholder,
];
});
}
/**
* Indicate that the model's email address should be unverified.
*/

8
database/migrations/2014_10_12_000000_create_users_table.php
View File

@@ -16,13 +16,17 @@ return new class extends Migration
Schema::create('users', function (Blueprint $table) {
$table->uuid('id')->primary();
$table->string('name');
$table->string('email')->unique();
$table->string('email');
$table->timestamp('email_verified_at')->nullable();
$table->string('password');
$table->string('password')->nullable();
$table->rememberToken();
$table->boolean('is_placeholder')->default(false);
$table->foreignUuid('current_team_id')->nullable();
$table->string('profile_photo_path', 2048)->nullable();
$table->timestamps();
$table->uniqueIndex('email')
->where('is_placeholder = false');
});
}

2
database/migrations/2024_01_20_110444_create_tasks_table.php
View File

@@ -15,7 +15,7 @@ return new class extends Migration
{
Schema::create('tasks', function (Blueprint $table) {
$table->uuid('id')->primary();
$table->string('name', 255);
$table->string('name', 500);
$table->uuid('project_id');
$table->foreign('project_id')
->references('id')

2
database/migrations/2024_01_20_110837_create_time_entries_table.php
View File

@@ -15,7 +15,7 @@ return new class extends Migration
{
Schema::create('time_entries', function (Blueprint $table) {
$table->uuid('id')->primary();
$table->string('description', 255);
$table->string('description', 500);
$table->dateTime('start');
$table->dateTime('end')->nullable();
$table->boolean('billable')->default(false);

54
database/seeders/DatabaseSeeder.php
View File

@@ -22,31 +22,57 @@ class DatabaseSeeder extends Seeder
public function run(): void
{
$this->deleteAll();
$organization1 = Organization::factory()->create([
$userAcmeOwner = User::factory()->create([
'name' => 'ACME Admin',
'email' => 'owner@acme.test',
]);
$organizationAcme = Organization::factory()->withOwner($userAcmeOwner)->create([
'name' => 'ACME Corp',
]);
$user1 = User::factory()->withPersonalOrganization()->create([
$userAcmeManager = User::factory()->withPersonalOrganization()->create([
'name' => 'Test User',
'email' => 'test@example.com',
]);
$employee1 = User::factory()->withPersonalOrganization()->create([
'name' => 'Test User',
'email' => 'employee@example.com',
]);
$userAcmeAdmin = User::factory()->create([
$userAcmeAdmin = User::factory()->withPersonalOrganization()->create([
'name' => 'ACME Admin',
'email' => 'admin@acme.test',
]);
$user1->organizations()->attach($organization1, [
$userAcmeEmployee = User::factory()->withPersonalOrganization()->create([
'name' => 'Max Mustermann',
'email' => 'max.mustermann@acme.test',
]);
$userAcmePlaceholder = User::factory()->placeholder()->create([
'name' => 'Old Employee',
'email' => 'old.employee@acme.test',
'password' => null,
]);
$userAcmeManager->organizations()->attach($organizationAcme, [
'role' => 'manager',
]);
$userAcmeAdmin->organizations()->attach($organization1, [
$userAcmeAdmin->organizations()->attach($organizationAcme, [
'role' => 'admin',
]);
$timeEntriesEmployees = TimeEntry::factory()
$userAcmeEmployee->organizations()->attach($organizationAcme, [
'role' => 'employee',
]);
$userAcmePlaceholder->organizations()->attach($organizationAcme, [
'role' => 'employee',
]);
$timeEntriesAcmeAdmin = TimeEntry::factory()
->count(10)
->forUser($employee1)
->forOrganization($organization1)
->forUser($userAcmeAdmin)
->forOrganization($organizationAcme)
->create();
$timeEntriesAcmePlaceholder = TimeEntry::factory()
->count(10)
->forUser($userAcmePlaceholder)
->forOrganization($organizationAcme)
->create();
$timeEntriesAcmePlaceholder = TimeEntry::factory()
->count(10)
->forUser($userAcmeEmployee)
->forOrganization($organizationAcme)
->create();
$client = Client::factory()->create([
'name' => 'Big Company',
@@ -63,11 +89,11 @@ class DatabaseSeeder extends Seeder
$organization2 = Organization::factory()->create([
'name' => 'Rival Corp',
]);
$user1 = User::factory()->withPersonalOrganization()->create([
$userAcmeManager = User::factory()->withPersonalOrganization()->create([
'name' => 'Other User',
'email' => 'test@rival-company.test',
]);
$user1->organizations()->attach($organization2, [
$userAcmeManager->organizations()->attach($organization2, [
'role' => 'admin',
]);
$otherCompanyProject = Project::factory()->forClient($client)->create([

39
docker-compose.yml
View File

@@ -57,10 +57,43 @@ services:
- '${DB_USERNAME}'
retries: 3
timeout: 5s
mailpit:
image: 'axllent/mailpit:latest'
pgsql_test:
image: 'postgres:15'
environment:
PGPASSWORD: '${DB_PASSWORD:-secret}'
POSTGRES_DB: '${DB_DATABASE}'
POSTGRES_USER: '${DB_USERNAME}'
POSTGRES_PASSWORD: '${DB_PASSWORD:-secret}'
volumes:
- 'sail-pgsql-test:/var/lib/postgresql/data'
- './vendor/laravel/sail/database/pgsql/create-testing-database.sql:/docker-entrypoint-initdb.d/10-create-testing-database.sql'
networks:
- sail
healthcheck:
test:
- CMD
- pg_isready
- '-q'
- '-d'
- '${DB_DATABASE}'
- '-U'
- '${DB_USERNAME}'
retries: 3
timeout: 5s
mailpit:
image: 'axllent/mailpit:latest'
labels:
- "traefik.enable=true"
- "traefik.docker.network=${NETWORK_NAME}"
- "traefik.http.routers.solidtime-mailpit.rule=Host(`mail.${NGINX_HOST_NAME}`)"
- "traefik.http.routers.solidtime-mailpit.entrypoints=web"
- "traefik.http.services.solidtime-mailpit.loadbalancer.server.port=8025"
- "traefik.http.routers.solidtime-mailpit-https.rule=Host(`mail.${NGINX_HOST_NAME}`)"
- "traefik.http.routers.solidtime-mailpit-https.entrypoints=websecure"
- "traefik.http.routers.solidtime-mailpit-https.tls=true"
networks:
- sail
- reverse-proxy
playwright:
image: mcr.microsoft.com/playwright:v1.41.1-jammy
command: ['npx', 'playwright', 'test', '--ui-port=8080', '--ui-host=0.0.0.0']
@@ -90,3 +123,5 @@ networks:
volumes:
sail-pgsql:
driver: local
sail-pgsql-test:
driver: local

22
lang/en/auth.php Normal file
View File

@@ -0,0 +1,22 @@
<?php
declare(strict_types=1);
return [
/*
|--------------------------------------------------------------------------
| Authentication Language Lines
|--------------------------------------------------------------------------
|
| The following language lines are used during authentication for various
| messages that we need to display to the user. You are free to modify
| these language lines according to your application's requirements.
|
*/
'failed' => 'These credentials do not match our records.',
'password' => 'The provided password is incorrect.',
'throttle' => 'Too many login attempts. Please try again in :seconds seconds.',
];

13
lang/en/exceptions.php Normal file
View File

@@ -0,0 +1,13 @@
<?php
declare(strict_types=1);
use App\Exceptions\Api\TimeEntryStillRunningApiException;
use App\Exceptions\Api\UserNotPlaceholderApiException;
return [
'api' => [
TimeEntryStillRunningApiException::KEY => 'Time entry is still running',
UserNotPlaceholderApiException::KEY => 'The given user is not a placeholder',
],
];

21
lang/en/pagination.php Normal file
View File

@@ -0,0 +1,21 @@
<?php
declare(strict_types=1);
return [
/*
|--------------------------------------------------------------------------
| Pagination Language Lines
|--------------------------------------------------------------------------
|
| The following language lines are used by the paginator library to build
| the simple pagination links. You are free to change them to anything
| you want to customize your views to better match your application.
|
*/
'previous' => '&laquo; Previous',
'next' => 'Next &raquo;',
];

24
lang/en/passwords.php Normal file
View File

@@ -0,0 +1,24 @@
<?php
declare(strict_types=1);
return [
/*
|--------------------------------------------------------------------------
| Password Reset Language Lines
|--------------------------------------------------------------------------
|
| The following language lines are the default lines which match reasons
| that are given by the password broker for a password update attempt
| has failed, such as for an invalid token or invalid new password.
|
*/
'reset' => 'Your password has been reset.',
'sent' => 'We have emailed your password reset link.',
'throttled' => 'Please wait before retrying.',
'token' => 'This password reset token is invalid.',
'user' => "We can't find a user with that email address.",
];

199
lang/en/validation.php Normal file
View File

@@ -0,0 +1,199 @@
<?php
declare(strict_types=1);
return [
/*
|--------------------------------------------------------------------------
| Validation Language Lines
|--------------------------------------------------------------------------
|
| The following language lines contain the default error messages used by
| the validator class. Some of these rules have multiple versions such
| as the size rules. Feel free to tweak each of these messages here.
|
*/
'accepted' => 'The :attribute field must be accepted.',
'accepted_if' => 'The :attribute field must be accepted when :other is :value.',
'active_url' => 'The :attribute field must be a valid URL.',
'after' => 'The :attribute field must be a date after :date.',
'after_or_equal' => 'The :attribute field must be a date after or equal to :date.',
'alpha' => 'The :attribute field must only contain letters.',
'alpha_dash' => 'The :attribute field must only contain letters, numbers, dashes, and underscores.',
'alpha_num' => 'The :attribute field must only contain letters and numbers.',
'array' => 'The :attribute field must be an array.',
'ascii' => 'The :attribute field must only contain single-byte alphanumeric characters and symbols.',
'before' => 'The :attribute field must be a date before :date.',
'before_or_equal' => 'The :attribute field must be a date before or equal to :date.',
'between' => [
'array' => 'The :attribute field must have between :min and :max items.',
'file' => 'The :attribute field must be between :min and :max kilobytes.',
'numeric' => 'The :attribute field must be between :min and :max.',
'string' => 'The :attribute field must be between :min and :max characters.',
],
'boolean' => 'The :attribute field must be true or false.',
'can' => 'The :attribute field contains an unauthorized value.',
'confirmed' => 'The :attribute field confirmation does not match.',
'current_password' => 'The password is incorrect.',
'date' => 'The :attribute field must be a valid date.',
'date_equals' => 'The :attribute field must be a date equal to :date.',
'date_format' => 'The :attribute field must match the format :format.',
'decimal' => 'The :attribute field must have :decimal decimal places.',
'declined' => 'The :attribute field must be declined.',
'declined_if' => 'The :attribute field must be declined when :other is :value.',
'different' => 'The :attribute field and :other must be different.',
'digits' => 'The :attribute field must be :digits digits.',
'digits_between' => 'The :attribute field must be between :min and :max digits.',
'dimensions' => 'The :attribute field has invalid image dimensions.',
'distinct' => 'The :attribute field has a duplicate value.',
'doesnt_end_with' => 'The :attribute field must not end with one of the following: :values.',
'doesnt_start_with' => 'The :attribute field must not start with one of the following: :values.',
'email' => 'The :attribute field must be a valid email address.',
'ends_with' => 'The :attribute field must end with one of the following: :values.',
'enum' => 'The selected :attribute is invalid.',
'exists' => 'The selected :attribute is invalid.',
'extensions' => 'The :attribute field must have one of the following extensions: :values.',
'file' => 'The :attribute field must be a file.',
'filled' => 'The :attribute field must have a value.',
'gt' => [
'array' => 'The :attribute field must have more than :value items.',
'file' => 'The :attribute field must be greater than :value kilobytes.',
'numeric' => 'The :attribute field must be greater than :value.',
'string' => 'The :attribute field must be greater than :value characters.',
],
'gte' => [
'array' => 'The :attribute field must have :value items or more.',
'file' => 'The :attribute field must be greater than or equal to :value kilobytes.',
'numeric' => 'The :attribute field must be greater than or equal to :value.',
'string' => 'The :attribute field must be greater than or equal to :value characters.',
],
'hex_color' => 'The :attribute field must be a valid hexadecimal color.',
'image' => 'The :attribute field must be an image.',
'in' => 'The selected :attribute is invalid.',
'in_array' => 'The :attribute field must exist in :other.',
'integer' => 'The :attribute field must be an integer.',
'ip' => 'The :attribute field must be a valid IP address.',
'ipv4' => 'The :attribute field must be a valid IPv4 address.',
'ipv6' => 'The :attribute field must be a valid IPv6 address.',
'json' => 'The :attribute field must be a valid JSON string.',
'lowercase' => 'The :attribute field must be lowercase.',
'lt' => [
'array' => 'The :attribute field must have less than :value items.',
'file' => 'The :attribute field must be less than :value kilobytes.',
'numeric' => 'The :attribute field must be less than :value.',
'string' => 'The :attribute field must be less than :value characters.',
],
'lte' => [
'array' => 'The :attribute field must not have more than :value items.',
'file' => 'The :attribute field must be less than or equal to :value kilobytes.',
'numeric' => 'The :attribute field must be less than or equal to :value.',
'string' => 'The :attribute field must be less than or equal to :value characters.',
],
'mac_address' => 'The :attribute field must be a valid MAC address.',
'max' => [
'array' => 'The :attribute field must not have more than :max items.',
'file' => 'The :attribute field must not be greater than :max kilobytes.',
'numeric' => 'The :attribute field must not be greater than :max.',
'string' => 'The :attribute field must not be greater than :max characters.',
],
'max_digits' => 'The :attribute field must not have more than :max digits.',
'mimes' => 'The :attribute field must be a file of type: :values.',
'mimetypes' => 'The :attribute field must be a file of type: :values.',
'min' => [
'array' => 'The :attribute field must have at least :min items.',
'file' => 'The :attribute field must be at least :min kilobytes.',
'numeric' => 'The :attribute field must be at least :min.',
'string' => 'The :attribute field must be at least :min characters.',
],
'min_digits' => 'The :attribute field must have at least :min digits.',
'missing' => 'The :attribute field must be missing.',
'missing_if' => 'The :attribute field must be missing when :other is :value.',
'missing_unless' => 'The :attribute field must be missing unless :other is :value.',
'missing_with' => 'The :attribute field must be missing when :values is present.',
'missing_with_all' => 'The :attribute field must be missing when :values are present.',
'multiple_of' => 'The :attribute field must be a multiple of :value.',
'not_in' => 'The selected :attribute is invalid.',
'not_regex' => 'The :attribute field format is invalid.',
'numeric' => 'The :attribute field must be a number.',
'password' => [
'letters' => 'The :attribute field must contain at least one letter.',
'mixed' => 'The :attribute field must contain at least one uppercase and one lowercase letter.',
'numbers' => 'The :attribute field must contain at least one number.',
'symbols' => 'The :attribute field must contain at least one symbol.',
'uncompromised' => 'The given :attribute has appeared in a data leak. Please choose a different :attribute.',
],
'present' => 'The :attribute field must be present.',
'present_if' => 'The :attribute field must be present when :other is :value.',
'present_unless' => 'The :attribute field must be present unless :other is :value.',
'present_with' => 'The :attribute field must be present when :values is present.',
'present_with_all' => 'The :attribute field must be present when :values are present.',
'prohibited' => 'The :attribute field is prohibited.',
'prohibited_if' => 'The :attribute field is prohibited when :other is :value.',
'prohibited_unless' => 'The :attribute field is prohibited unless :other is in :values.',
'prohibits' => 'The :attribute field prohibits :other from being present.',
'regex' => 'The :attribute field format is invalid.',
'required' => 'The :attribute field is required.',
'required_array_keys' => 'The :attribute field must contain entries for: :values.',
'required_if' => 'The :attribute field is required when :other is :value.',
'required_if_accepted' => 'The :attribute field is required when :other is accepted.',
'required_unless' => 'The :attribute field is required unless :other is in :values.',
'required_with' => 'The :attribute field is required when :values is present.',
'required_with_all' => 'The :attribute field is required when :values are present.',
'required_without' => 'The :attribute field is required when :values is not present.',
'required_without_all' => 'The :attribute field is required when none of :values are present.',
'same' => 'The :attribute field must match :other.',
'size' => [
'array' => 'The :attribute field must contain :size items.',
'file' => 'The :attribute field must be :size kilobytes.',
'numeric' => 'The :attribute field must be :size.',
'string' => 'The :attribute field must be :size characters.',
],
'starts_with' => 'The :attribute field must start with one of the following: :values.',
'string' => 'The :attribute field must be a string.',
'timezone' => 'The :attribute field must be a valid timezone.',
'unique' => 'The :attribute has already been taken.',
'uploaded' => 'The :attribute failed to upload.',
'uppercase' => 'The :attribute field must be uppercase.',
'url' => 'The :attribute field must be a valid URL.',
'ulid' => 'The :attribute field must be a valid ULID.',
'uuid' => 'The :attribute field must be a valid UUID.',
/*
|--------------------------------------------------------------------------
| Custom Validation Language Lines
|--------------------------------------------------------------------------
|
| Here you may specify custom validation messages for attributes using the
| convention "attribute.rule" to name the lines. This makes it quick to
| specify a specific custom language line for a given attribute rule.
|
*/
'custom' => [
'attribute-name' => [
'rule-name' => 'custom-message',
],
],
/*
|--------------------------------------------------------------------------
| Custom Validation Attributes
|--------------------------------------------------------------------------
|
| The following language lines are used to swap our attribute placeholder
| with something more reader friendly such as "E-Mail Address" instead
| of "email". This simply helps us make our message more expressive.
|
*/
'attributes' => [],
/*
* Custom validation rules
*/
'color' => 'The :attribute field must be a valid color.',
];

1
phpunit.xml
View File

@@ -22,6 +22,7 @@
<env name="BCRYPT_ROUNDS" value="4"/>
<env name="CACHE_DRIVER" value="array"/>
<env name="DB_CONNECTION" value="pgsql"/>
<env name="DB_HOST" value="pgsql_test"/>
<env name="MAIL_MAILER" value="array"/>
<env name="PULSE_ENABLED" value="false"/>
<env name="QUEUE_CONNECTION" value="sync"/>

13
routes/api.php
View File

@@ -3,10 +3,12 @@
declare(strict_types=1);
use App\Http\Controllers\Api\V1\ClientController;
use App\Http\Controllers\Api\V1\ImportController;
use App\Http\Controllers\Api\V1\OrganizationController;
use App\Http\Controllers\Api\V1\ProjectController;
use App\Http\Controllers\Api\V1\TagController;
use App\Http\Controllers\Api\V1\TimeEntryController;
use App\Http\Controllers\Api\V1\UserController;
use Illuminate\Support\Facades\Route;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
@@ -28,6 +30,12 @@ Route::middleware('auth:api')->prefix('v1')->name('v1.')->group(static function
Route::put('/organizations/{organization}', [OrganizationController::class, 'update'])->name('update');
});
// User routes
Route::name('users.')->group(static function () {
Route::get('/organizations/{organization}/users', [UserController::class, 'index'])->name('index');
Route::post('/organizations/{organization}/users/{user}/invite-placeholder', [UserController::class, 'invitePlaceholder'])->name('invite-placeholder');
});
// Project routes
Route::name('projects.')->group(static function () {
Route::get('/organizations/{organization}/projects', [ProjectController::class, 'index'])->name('index');
@@ -60,6 +68,11 @@ Route::middleware('auth:api')->prefix('v1')->name('v1.')->group(static function
Route::put('/organizations/{organization}/clients/{client}', [ClientController::class, 'update'])->name('update');
Route::delete('/organizations/{organization}/clients/{client}', [ClientController::class, 'destroy'])->name('destroy');
});
// Import routes
Route::name('import.')->group(static function () {
Route::post('/organizations/{organization}/import', [ImportController::class, 'import'])->name('import');
});
});
/**

3
storage/tests/clockify_projects_import_test_1.csv Normal file
View File

@@ -0,0 +1,3 @@
"Name","Client","Status","Visibility","Billability","Tasks","Tracked (h)","Estimated (h)","Remaining (h)","Overage (h)","Progress(%)","Billable (h)","Non-billable (h)","Billable Rate (USD)","Amount (USD)","Project members","Project manager","Note"
"Project for Big Company","Big Company","Active","Public","Yes","Task 1, Task 2, Task 3","0.00","","","","","0.00","0.00","","0.00","Constantin Graf","",""
"Project without Client","","Active","Public","Yes","","0.00","","","","","0.00","0.00","","0.00","Constantin Graf","",""
1 Name Client Status Visibility Billability Tasks Tracked (h) Estimated (h) Remaining (h) Overage (h) Progress(%) Billable (h) Non-billable (h) Billable Rate (USD) Amount (USD) Project members Project manager Note
2 Project for Big Company Big Company Active Public Yes Task 1, Task 2, Task 3 0.00 0.00 0.00 0.00 Constantin Graf
3 Project without Client Active Public Yes 0.00 0.00 0.00 0.00 Constantin Graf

3
storage/tests/clockify_time_entries_import_test_1.csv Normal file
View File

@@ -0,0 +1,3 @@
"Project","Client","Description","Task","User","Group","Email","Tags","Billable","Start Date","Start Time","End Date","End Time","Duration (h)","Duration (decimal)","Billable Rate (USD)","Billable Amount (USD)"
"Project without Client","","","","Peter Tester","","peter.test@email.test","Development, Backend","No","03/04/2024","10:23:52 AM","03/04/2024","10:23:52 AM","00:00:00","0.00","0.00","0.00"
"Project for Big Company","Big Company","Working hard","Task 1","Peter Tester","","peter.test@email.test","","Yes","03/04/2024","10:23 AM","03/04/2024","11:23:01 AM","01:00:01","0.00","0.00","0.00"
1 Project Client Description Task User Group Email Tags Billable Start Date Start Time End Date End Time Duration (h) Duration (decimal) Billable Rate (USD) Billable Amount (USD)
2 Project without Client Peter Tester peter.test@email.test Development, Backend No 03/04/2024 10:23:52 AM 03/04/2024 10:23:52 AM 00:00:00 0.00 0.00 0.00
3 Project for Big Company Big Company Working hard Task 1 Peter Tester peter.test@email.test Yes 03/04/2024 10:23 AM 03/04/2024 11:23:01 AM 01:00:01 0.00 0.00 0.00

9
storage/tests/toggl_data_import_test_1/clients.json Normal file
View File

@@ -0,0 +1,9 @@
[
{
"archived": false,
"creator_id": 201,
"id": 301,
"name": "Big Company",
"wid": 0
}
]

58
storage/tests/toggl_data_import_test_1/projects.json Normal file
View File

@@ -0,0 +1,58 @@
[
{
"active": true,
"actual_hours": null,
"actual_seconds": null,
"auto_estimates": false,
"billable": true,
"cid": null,
"client_id": null,
"color": "#ef5350",
"currency": "EUR",
"estimated_hours": null,
"estimated_seconds": null,
"fixed_fee": null,
"guid": "",
"id": 401,
"is_private": true,
"name": "Project without Client",
"rate": null,
"rate_last_updated": null,
"recurring": false,
"recurring_parameters": null,
"start_date": "2020-01-01",
"status": "active",
"template": false,
"template_id": null,
"wid": 0,
"workspace_id": 0
},
{
"active": true,
"actual_hours": null,
"actual_seconds": null,
"auto_estimates": false,
"billable": false,
"cid": 301,
"client_id": 301,
"color": "#ec407a",
"currency": null,
"estimated_hours": null,
"estimated_seconds": null,
"fixed_fee": null,
"guid": "",
"id": 402,
"is_private": true,
"name": "Project for Big Company",
"rate": null,
"rate_last_updated": null,
"recurring": false,
"recurring_parameters": null,
"start_date": "2020-01-01",
"status": "active",
"template": false,
"template_id": null,
"wid": 0,
"workspace_id": 0
}
]

14
storage/tests/toggl_data_import_test_1/tags.json Normal file
View File

@@ -0,0 +1,14 @@
[
{
"creator_id": 0,
"id": 501,
"name": "Development",
"workspace_id": 0
},
{
"creator_id": 0,
"id": 502,
"name": "Backend",
"workspace_id": 0
}
]

1
storage/tests/toggl_data_import_test_1/tasks/401.json Normal file
View File

@@ -0,0 +1 @@
[]

13
storage/tests/toggl_data_import_test_1/tasks/402.json Normal file
View File

@@ -0,0 +1,13 @@
[
{
"active": true,
"estimated_seconds": 0,
"id": 601,
"name": "Task 1",
"project_id": 402,
"recurring": false,
"tracked_seconds": 0,
"user_id": null,
"workspace_id": 0
}
]

19
storage/tests/toggl_data_import_test_1/workspace_users.json Normal file
View File

@@ -0,0 +1,19 @@
[
{
"active": true,
"admin": true,
"email": "peter.test@email.test",
"group_ids": [],
"id": 201,
"inactive": false,
"labour_cost": null,
"name": "Peter Tester",
"rate": null,
"rate_last_updated": null,
"role": "admin",
"timezone": "Europe/Vienna",
"uid": 0,
"wid": 0,
"working_hours_in_minutes": null
}
]

3
storage/tests/toggl_time_entries_import_test_1.csv Normal file
View File

@@ -0,0 +1,3 @@
User,Email,Client,Project,Task,Description,Billable,Start date,Start time,End date,End time,Duration,Tags,Amount (EUR)
Peter Tester,peter.test@email.test,,Project without Client,,"",No,2024-03-04,10:23:52,2024-03-04,10:23:52,00:00:00,"Development, Backend",
Peter Tester,peter.test@email.test,Big Company,Project for Big Company,Task 1,Working hard,Yes,2024-03-04,10:23:00,2024-03-04,11:23:01,01:00:01,,111.11
1 User Email Client Project Task Description Billable Start date Start time End date End time Duration Tags Amount (EUR)
2 Peter Tester peter.test@email.test Project without Client No 2024-03-04 10:23:52 2024-03-04 10:23:52 00:00:00 Development, Backend
3 Peter Tester peter.test@email.test Big Company Project for Big Company Task 1 Working hard Yes 2024-03-04 10:23:00 2024-03-04 11:23:01 01:00:01 111.11

138
tests/Feature/InviteTeamMemberTest.php
View File

@@ -4,9 +4,11 @@ declare(strict_types=1);
namespace Tests\Feature;
use App\Models\TimeEntry;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\URL;
use Laravel\Jetstream\Mail\TeamInvitation;
use Tests\TestCase;
@@ -31,6 +33,49 @@ class InviteTeamMemberTest extends TestCase
$this->assertCount(1, $user->currentTeam->fresh()->teamInvitations);
}
public function test_team_member_can_not_be_invited_to_team_if_already_on_team(): void
{
// Arrange
Mail::fake();
$user = User::factory()->withPersonalOrganization()->create();
$existingUser = User::factory()->create();
$user->currentTeam->users()->attach($existingUser, ['role' => 'admin']);
$this->actingAs($user);
// Act
$response = $this->post('/teams/'.$user->currentTeam->id.'/members', [
'email' => $existingUser->email,
'role' => 'admin',
]);
// Assert
$response->assertInvalid(['email'], 'addTeamMember');
Mail::assertNotSent(TeamInvitation::class);
$this->assertCount(0, $user->currentTeam->fresh()->teamInvitations);
}
public function test_team_member_can_be_invited_to_team_if_already_on_team_as_placeholder(): void
{
// Arrange
Mail::fake();
$user = User::factory()->withPersonalOrganization()->create();
$existingUser = User::factory()->create([
'is_placeholder' => true,
]);
$user->currentTeam->users()->attach($existingUser, ['role' => 'employee']);
$this->actingAs($user);
// Act
$response = $this->post('/teams/'.$user->currentTeam->id.'/members', [
'email' => $existingUser->email,
'role' => 'employee',
]);
// Assert
Mail::assertSent(TeamInvitation::class);
$this->assertCount(1, $user->currentTeam->fresh()->teamInvitations);
}
public function test_team_member_invitations_can_be_cancelled(): void
{
// Arrange
@@ -49,4 +94,97 @@ class InviteTeamMemberTest extends TestCase
// Assert
$this->assertCount(0, $user->currentTeam->fresh()->teamInvitations);
}
public function test_team_member_invitations_can_be_accepted(): void
{
// Arrange
Mail::fake();
$owner = User::factory()->withPersonalOrganization()->create();
$user = User::factory()->withPersonalOrganization()->create();
$invitation = $owner->currentTeam->teamInvitations()->create([
'email' => $user->email,
'role' => 'employee',
]);
$this->actingAs($user);
// Act
$acceptUrl = URL::temporarySignedRoute(
'team-invitations.accept',
now()->addMinutes(60),
[$invitation->getKey()]
);
$response = $this->get($acceptUrl);
// Assert
$this->assertCount(0, $owner->currentTeam->fresh()->teamInvitations);
$user->refresh();
$this->assertCount(1, $user->organizations);
$this->assertContains($owner->currentTeam->getKey(), $user->organizations->pluck('id'));
}
public function test_team_member_invitations_of_placeholder_can_be_accepted_and_migrates_date_to_real_user(): void
{
// Arrange
Mail::fake();
$placeholder = User::factory()->withPersonalOrganization()->create([
'is_placeholder' => true,
]);
$owner = User::factory()->withPersonalOrganization()->create();
$owner->currentTeam->users()->attach($placeholder, ['role' => 'employee']);
$timeEntries = TimeEntry::factory()->forOrganization($owner->currentTeam)->forUser($placeholder)->createMany(5);
$user = User::factory()->withPersonalOrganization()->create([
'email' => $placeholder->email,
]);
$invitation = $owner->currentTeam->teamInvitations()->create([
'email' => $user->email,
'role' => 'employee',
]);
$this->actingAs($user);
// Act
$acceptUrl = URL::temporarySignedRoute(
'team-invitations.accept',
now()->addMinutes(60),
[$invitation->getKey()]
);
$response = $this->get($acceptUrl);
// Assert
$user->refresh();
$placeholder->refresh();
$this->assertCount(0, $owner->currentTeam->fresh()->teamInvitations);
$this->assertCount(1, $user->organizations);
$this->assertContains($owner->currentTeam->getKey(), $user->organizations->pluck('id'));
$this->assertCount(5, $user->timeEntries);
$this->assertCount(0, $placeholder->timeEntries);
}
public function test_team_member_accept_fails_if_user_with_that_email_does_not_exist(): void
{
// Arrange
Mail::fake();
$owner = User::factory()->withPersonalOrganization()->create();
$user = User::factory()->withPersonalOrganization()->create();
$invitation = $owner->currentTeam->teamInvitations()->create([
'email' => 'firstname.lastname@mail.test',
'role' => 'employee',
]);
$this->actingAs($user);
// Act
$acceptUrl = URL::temporarySignedRoute(
'team-invitations.accept',
now()->addMinutes(60),
[$invitation->getKey()]
);
$response = $this->get($acceptUrl);
// Assert
$this->assertCount(1, $owner->currentTeam->fresh()->teamInvitations);
$user->refresh();
$this->assertCount(0, $user->organizations);
}
}

44
tests/Feature/RegistrationTest.php
View File

@@ -4,6 +4,7 @@ declare(strict_types=1);
namespace Tests\Feature;
use App\Models\User;
use App\Providers\RouteServiceProvider;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Laravel\Fortify\Features;
@@ -38,10 +39,47 @@ class RegistrationTest extends TestCase
public function test_new_users_can_register(): void
{
if (! Features::enabled(Features::registration())) {
$this->markTestSkipped('Registration support is not enabled.');
}
$response = $this->post('/register', [
'name' => 'Test User',
'email' => 'test@example.com',
'password' => 'password',
'password_confirmation' => 'password',
'terms' => Jetstream::hasTermsAndPrivacyPolicyFeature(),
]);
$this->assertAuthenticated();
$response->assertRedirect(RouteServiceProvider::HOME);
}
public function test_new_users_can_not_register_if_user_with_email_already_exists(): void
{
// Arrange
$user = User::factory()->create([
'email' => 'test@example.com',
]);
// Act
$response = $this->post('/register', [
'name' => 'Test User',
'email' => 'test@example.com',
'password' => 'password',
'password_confirmation' => 'password',
'terms' => Jetstream::hasTermsAndPrivacyPolicyFeature(),
]);
$this->assertFalse($this->isAuthenticated(), 'The user is authenticated');
$response->assertInvalid(['email']);
}
public function test_new_users_can_register_if_placeholder_user_with_email_already_exists(): void
{
// Arrange
$user = User::factory()->create([
'email' => 'test@example.com',
'is_placeholder' => true,
]);
// Act
$response = $this->post('/register', [
'name' => 'Test User',
'email' => 'test@example.com',

88
tests/Unit/Endpoint/Api/V1/ImportEndpointTest.php Normal file
View File

@@ -0,0 +1,88 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Endpoint\Api\V1;
use App\Models\Organization;
use App\Service\Import\Importers\ReportDto;
use App\Service\Import\ImportService;
use Laravel\Passport\Passport;
use Mockery\MockInterface;
class ImportEndpointTest extends ApiEndpointTestAbstract
{
public function test_import_fails_if_user_does_not_have_permission()
{
// Arrange
$data = $this->createUserWithPermission([
]);
Passport::actingAs($data->user);
// Act
$response = $this->postJson(route('api.v1.import.import', ['organization' => $data->organization->id]), [
'type' => 'toggl_time_entries',
'data' => 'some data',
'options' => [],
]);
// Assert
$response->assertStatus(403);
}
public function test_import_calls_import_service_if_user_has_permission(): void
{
// Arrange
$user = $this->createUserWithPermission([
'import',
]);
$this->mock(ImportService::class, function (MockInterface $mock) use (&$user): void {
$mock->shouldReceive('import')
->withArgs(function (Organization $organization, string $importerType, string $data) use (&$user): bool {
return $organization->is($user->organization) && $importerType === 'toggl_time_entries' && $data === 'some data';
})
->andReturn(new ReportDto(
clientsCreated: 1,
projectsCreated: 2,
tasksCreated: 3,
timeEntriesCreated: 4,
tagsCreated: 5,
usersCreated: 6,
))
->once();
});
Passport::actingAs($user->user);
// Act
$response = $this->postJson(route('api.v1.import.import', ['organization' => $user->organization->id]), [
'type' => 'toggl_time_entries',
'data' => 'some data',
]);
// Assert
$response->assertStatus(200);
$response->assertExactJson([
'report' => [
'clients' => [
'created' => 1,
],
'projects' => [
'created' => 2,
],
'tasks' => [
'created' => 3,
],
'time-entries' => [
'created' => 4,
],
'tags' => [
'created' => 5,
],
'users' => [
'created' => 6,
],
],
]);
}
}

85
tests/Unit/Endpoint/Api/V1/UserEndpointTest.php Normal file
View File

@@ -0,0 +1,85 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Endpoint\Api\V1;
use App\Models\Organization;
use App\Models\User;
use Laravel\Passport\Passport;
class UserEndpointTest extends ApiEndpointTestAbstract
{
public function test_index_returns_members_of_organization(): void
{
// Arrange
$data = $this->createUserWithPermission([
'users:view',
]);
Passport::actingAs($data->user);
// Act
$response = $this->getJson(route('api.v1.users.index', $data->organization->id));
// Assert
$response->assertStatus(200);
}
public function test_invite_placeholder_fails_if_user_does_not_have_permission(): void
{
// Arrange
$data = $this->createUserWithPermission([
]);
$user = User::factory()->create([
'is_placeholder' => true,
]);
$data->organization->users()->attach($user);
Passport::actingAs($data->user);
// Act
$response = $this->postJson(route('api.v1.users.invite-placeholder', ['organization' => $data->organization->id, 'user' => $user->id]));
// Assert
$response->assertStatus(403);
}
public function test_invite_placeholder_fails_if_user_is_not_part_of_organization(): void
{
// Arrange
$data = $this->createUserWithPermission([
'users:invite-placeholder',
]);
$otherOrganization = Organization::factory()->create();
$user = User::factory()->create([
'is_placeholder' => true,
]);
$otherOrganization->users()->attach($user);
Passport::actingAs($data->user);
// Act
$response = $this->postJson(route('api.v1.users.invite-placeholder', ['organization' => $data->organization->id, 'user' => $user->id]));
// Assert
$response->assertStatus(403);
}
public function test_invite_placeholder_returns_400_if_user_is_not_placeholder(): void
{
// Arrange
$data = $this->createUserWithPermission([
'users:invite-placeholder',
]);
Passport::actingAs($data->user);
// Act
$response = $this->postJson(route('api.v1.users.invite-placeholder', ['organization' => $data->organization->id, 'user' => $data->user->id]));
// Assert
$response->assertStatus(400);
$response->assertExactJson([
'error' => true,
'key' => 'user_not_placeholder',
'message' => 'The given user is not a placeholder',
]);
}
}

45
tests/Unit/Model/UserModelTest.php
View File

@@ -4,6 +4,8 @@ declare(strict_types=1);
namespace Tests\Unit\Model;
use App\Models\Organization;
use App\Models\TimeEntry;
use App\Models\User;
use App\Providers\Filament\AdminPanelProvider;
use Filament\Panel;
@@ -42,4 +44,47 @@ class UserModelTest extends ModelTestAbstract
// Assert
$this->assertTrue($canAccess);
}
public function test_scope_belongs_to_organization_returns_only_users_of_organization_including_owners(): void
{
// Arrange
$owner = User::factory()->create();
$organization = Organization::factory()->withOwner($owner)->create();
$user = User::factory()->create();
$user->organizations()->attach($organization, [
'role' => 'employee',
]);
$otherOrganization = Organization::factory()->create();
$otherUser = User::factory()->create();
$otherUser->organizations()->attach($otherOrganization, [
'role' => 'employee',
]);
// Act
$users = User::query()
->belongsToOrganization($organization)
->get();
// Assert
$this->assertCount(2, $users);
$userIds = $users->pluck('id')->toArray();
$this->assertContains($user->getKey(), $userIds);
$this->assertContains($owner->getKey(), $userIds);
}
public function test_it_has_many_time_entries(): void
{
// Arrange
$user = User::factory()->create();
$timeEntries = TimeEntry::factory()->forUser($user)->createMany(3);
// Act
$user->refresh();
$timeEntriesRel = $user->timeEntries;
// Assert
$this->assertNotNull($timeEntriesRel);
$this->assertCount(3, $timeEntriesRel);
$this->assertTrue($timeEntriesRel->first()->is($timeEntries->first()));
}
}

66
tests/Unit/Rules/ColorRuleTest.php Normal file
View File

@@ -0,0 +1,66 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Rules;
use App\Rules\ColorRule;
use Illuminate\Support\Facades\Validator;
use Tests\TestCase;
class ColorRuleTest extends TestCase
{
public function test_validation_passes_if_value_is_valid_color(): void
{
// Arrange
$validator = Validator::make([
'color' => '#ef5350',
], [
'color' => [new ColorRule()],
]);
// Act
$isValid = $validator->passes();
$messages = $validator->messages()->toArray();
// Assert
$this->assertTrue($isValid);
$this->assertArrayNotHasKey('color', $messages);
}
public function test_validation_fails_if_value_is_not_a_string(): void
{
// Arrange
$validator = Validator::make([
'color' => true,
], [
'color' => [new ColorRule()],
]);
// Act
$isValid = $validator->passes();
$messages = $validator->messages()->toArray();
// Assert
$this->assertFalse($isValid);
$this->assertEquals('The color field must be a string.', $messages['color'][0]);
}
public function test_validation_fails_if_value_is_not_a_valid_color(): void
{
// Arrange
$validator = Validator::make([
'color' => 'rgb(0,0,0)',
], [
'color' => [new ColorRule()],
]);
// Act
$isValid = $validator->passes();
$messages = $validator->messages()->toArray();
// Assert
$this->assertFalse($isValid);
$this->assertEquals('The color field must be a valid color.', $messages['color'][0]);
}
}

138
tests/Unit/Service/Import/ImportDatabaseHelperTest.php Normal file
View File

@@ -0,0 +1,138 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Service\Import;
use App\Models\Organization;
use App\Models\Project;
use App\Models\User;
use App\Service\Import\ImportDatabaseHelper;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
class ImportDatabaseHelperTest extends TestCase
{
use RefreshDatabase;
public function test_get_key_attach_to_existing_returns_key_for_identifier_without_creating_model(): void
{
// Arrange
$user = User::factory()->create();
$helper = new ImportDatabaseHelper(User::class, ['email'], true);
// Act
$key = $helper->getKey([
'email' => $user->email,
], [
'name' => 'Test',
]);
// Assert
$this->assertSame($user->getKey(), $key);
}
public function test_get_key_attach_to_existing_creates_model_if_not_existing(): void
{
// Arrange
$helper = new ImportDatabaseHelper(User::class, ['email'], true);
// Act
$key = $helper->getKey([
'email' => 'test@mail.test',
], [
'name' => 'Test',
]);
// Assert
$this->assertNotNull($key);
$this->assertDatabaseHas(User::class, [
'email' => 'test@mail.test',
'name' => 'Test',
]);
}
public function test_get_key_not_attach_to_existing_is_not_implemented_yet(): void
{
// Arrange
$project = Project::factory()->create();
$helper = new ImportDatabaseHelper(Project::class, ['name', 'organization_id'], false);
// Act
try {
$key = $helper->getKey([
'name' => $project->name,
'organization_id' => $project->organization_id,
], [
'color' => '#000000',
]);
} catch (\Exception $e) {
$this->assertSame('Not implemented', $e->getMessage());
return;
}
// Assert
$this->fail();
}
public function test_get_key_by_external_identifier_returns_key_for_external_identifier(): void
{
// Arrange
$organization = Organization::factory()->create();
$project = Project::factory()->forOrganization($organization)->create();
$externalIdentifier1 = '12345';
$externalIdentifier2 = '54321';
$helper = new ImportDatabaseHelper(Project::class, ['name', 'organization_id'], true);
$helper->getKey([
'name' => $project->name,
'organization_id' => $organization->getKey(),
], [
'color' => '#000000',
], $externalIdentifier1);
$helper->getKey([
'name' => 'Not existing project',
'organization_id' => $organization->getKey(),
], [
'color' => '#000000',
], $externalIdentifier2);
// Act
$key1 = $helper->getKeyByExternalIdentifier($externalIdentifier1);
$key2 = $helper->getKeyByExternalIdentifier($externalIdentifier2);
// Assert
$this->assertSame($project->getKey(), $key1);
$this->assertSame(Project::where('name', '=', 'Not existing project')->first()->getKey(), $key2);
}
public function test_get_external_ids_returns_all_external_ids_that_were_temporary_stored_via_get_key(): void
{
// Arrange
$organization = Organization::factory()->create();
$project = Project::factory()->forOrganization($organization)->create();
$externalIdentifier1 = '12345';
$externalIdentifier2 = '54321';
$helper = new ImportDatabaseHelper(Project::class, ['name', 'organization_id'], true);
$helper->getKey([
'name' => $project->name,
'organization_id' => $organization->getKey(),
], [
'color' => '#000000',
], $externalIdentifier1);
$helper->getKey([
'name' => 'Not existing project',
'organization_id' => $organization->getKey(),
], [
'color' => '#000000',
], $externalIdentifier2);
// Act
$externalKeys = $helper->getExternalIds();
// Assert
$this->assertCount(2, $externalKeys);
$this->assertContains($externalIdentifier1, $externalKeys);
$this->assertContains($externalIdentifier2, $externalKeys);
}
}

44
tests/Unit/Service/Import/Importer/ClockifyProjectsImporterTest.php Normal file
View File

@@ -0,0 +1,44 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Service\Import\Importer;
use App\Models\Organization;
use App\Service\Import\Importers\ClockifyProjectsImporter;
class ClockifyProjectsImporterTest extends ImporterTestAbstract
{
public function test_import_of_test_file_succeeds(): void
{
// Arrange
$organization = Organization::factory()->create();
$importer = new ClockifyProjectsImporter();
$importer->init($organization);
$data = file_get_contents(storage_path('tests/clockify_projects_import_test_1.csv'));
// Act
$importer->importData($data, []);
// Assert
$this->checkTestScenarioProjectsOnlyAfterImport();
}
public function test_import_of_test_file_twice_succeeds(): void
{
// Arrange
$organization = Organization::factory()->create();
$importer = new ClockifyProjectsImporter();
$importer->init($organization);
$data = file_get_contents(storage_path('tests/clockify_projects_import_test_1.csv'));
$importer->importData($data, []);
$importer = new ClockifyProjectsImporter();
$importer->init($organization);
// Act
$importer->importData($data, []);
// Assert
$this->checkTestScenarioProjectsOnlyAfterImport();
}
}

77
tests/Unit/Service/Import/Importer/ClockifyTimeEntriesImporterTest.php Normal file
View File

@@ -0,0 +1,77 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Service\Import\Importer;
use App\Models\Organization;
use App\Models\TimeEntry;
use App\Service\Import\Importers\ClockifyTimeEntriesImporter;
class ClockifyTimeEntriesImporterTest extends ImporterTestAbstract
{
public function test_import_of_test_file_succeeds(): void
{
// Arrange
$organization = Organization::factory()->create();
$importer = new ClockifyTimeEntriesImporter();
$importer->init($organization);
$data = file_get_contents(storage_path('tests/clockify_time_entries_import_test_1.csv'));
// Act
$importer->importData($data, []);
// Assert
$testScenario = $this->checkTestScenarioAfterImportExcludingTimeEntries();
$timeEntries = TimeEntry::all();
$this->assertCount(2, $timeEntries);
$timeEntry1 = $timeEntries->firstWhere('description', '');
$this->assertNotNull($timeEntry1);
$this->assertSame('', $timeEntry1->description);
$this->assertSame('2024-03-04 10:23:52', $timeEntry1->start->toDateTimeString());
$this->assertSame('2024-03-04 10:23:52', $timeEntry1->end->toDateTimeString());
$this->assertFalse($timeEntry1->billable);
$this->assertSame([$testScenario->tag1->getKey(), $testScenario->tag2->getKey()], $timeEntry1->tags);
$timeEntry2 = $timeEntries->firstWhere('description', 'Working hard');
$this->assertNotNull($timeEntry2);
$this->assertSame('Working hard', $timeEntry2->description);
$this->assertSame('2024-03-04 10:23:00', $timeEntry2->start->toDateTimeString());
$this->assertSame('2024-03-04 11:23:01', $timeEntry2->end->toDateTimeString());
$this->assertTrue($timeEntry2->billable);
$this->assertSame([], $timeEntry2->tags);
}
public function test_import_of_test_file_twice_succeeds(): void
{
// Arrange
$organization = Organization::factory()->create();
$importer = new ClockifyTimeEntriesImporter();
$importer->init($organization);
$data = file_get_contents(storage_path('tests/clockify_time_entries_import_test_1.csv'));
$importer->importData($data, []);
$importer = new ClockifyTimeEntriesImporter();
$importer->init($organization);
// Act
$importer->importData($data, []);
// Assert
$testScenario = $this->checkTestScenarioAfterImportExcludingTimeEntries();
$timeEntries = TimeEntry::all();
$this->assertCount(4, $timeEntries);
$timeEntry1 = $timeEntries->firstWhere('description', '');
$this->assertNotNull($timeEntry1);
$this->assertSame('', $timeEntry1->description);
$this->assertSame('2024-03-04 10:23:52', $timeEntry1->start->toDateTimeString());
$this->assertSame('2024-03-04 10:23:52', $timeEntry1->end->toDateTimeString());
$this->assertFalse($timeEntry1->billable);
$this->assertSame([$testScenario->tag1->getKey(), $testScenario->tag2->getKey()], $timeEntry1->tags);
$timeEntry2 = $timeEntries->firstWhere('description', 'Working hard');
$this->assertNotNull($timeEntry2);
$this->assertSame('Working hard', $timeEntry2->description);
$this->assertSame('2024-03-04 10:23:00', $timeEntry2->start->toDateTimeString());
$this->assertSame('2024-03-04 11:23:01', $timeEntry2->end->toDateTimeString());
$this->assertTrue($timeEntry2->billable);
$this->assertSame([], $timeEntry2->tags);
}
}

99
tests/Unit/Service/Import/Importer/ImporterTestAbstract.php Normal file
View File

@@ -0,0 +1,99 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Service\Import\Importer;
use App\Models\Client;
use App\Models\Project;
use App\Models\Tag;
use App\Models\Task;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
class ImporterTestAbstract extends TestCase
{
use RefreshDatabase;
/**
* @return object{user1: User, project1: Project, project2: Project, tag1: Tag, tag2: Tag}
*/
protected function checkTestScenarioAfterImportExcludingTimeEntries(): object
{
$users = User::all();
$this->assertCount(2, $users);
$user1 = $users->firstWhere('name', 'Peter Tester');
$this->assertNotNull($user1);
$this->assertSame(null, $user1->password);
$this->assertSame('Peter Tester', $user1->name);
$this->assertSame('peter.test@email.test', $user1->email);
$clients = Client::all();
$this->assertCount(1, $clients);
$client1 = $clients->firstWhere('name', 'Big Company');
$this->assertNotNull($client1);
$projects = Project::all();
$this->assertCount(2, $projects);
$project1 = $projects->firstWhere('name', 'Project without Client');
$this->assertNotNull($project1);
$this->assertNull($project1->client_id);
$project2 = $projects->firstWhere('name', 'Project for Big Company');
$this->assertNotNull($project2);
$this->assertSame($client1->getKey(), $project2->client_id);
$tasks = Task::all();
$this->assertCount(1, $tasks);
$task1 = $tasks->firstWhere('name', 'Task 1');
$this->assertNotNull($task1);
$this->assertSame($project2->getKey(), $task1->project_id);
$tags = Tag::all();
$this->assertCount(2, $tags);
$tag1 = $tags->firstWhere('name', 'Development');
$tag2 = $tags->firstWhere('name', 'Backend');
$this->assertNotNull($tag1);
return (object) [
'user1' => $user1,
'project1' => $project1,
'project2' => $project2,
'tag1' => $tag1,
'tag2' => $tag2,
];
}
/**
* @return object{client1: Client, project1: Project, project2: Project, task1: Task}
*/
protected function checkTestScenarioProjectsOnlyAfterImport(): object
{
$clients = Client::all();
$this->assertCount(1, $clients);
$client1 = $clients->firstWhere('name', 'Big Company');
$this->assertNotNull($client1);
$projects = Project::all();
$this->assertCount(2, $projects);
$project1 = $projects->firstWhere('name', 'Project without Client');
$this->assertNotNull($project1);
$this->assertNull($project1->client_id);
$project2 = $projects->firstWhere('name', 'Project for Big Company');
$this->assertNotNull($project2);
$this->assertSame($client1->getKey(), $project2->client_id);
$tasks = Task::all();
$this->assertCount(3, $tasks);
$task1 = $tasks->firstWhere('name', 'Task 1');
$this->assertNotNull($task1);
$this->assertSame($project2->getKey(), $task1->project_id);
$task2 = $tasks->firstWhere('name', 'Task 2');
$this->assertNotNull($task2);
$this->assertSame($project2->getKey(), $task2->project_id);
$task3 = $tasks->firstWhere('name', 'Task 3');
$this->assertNotNull($task3);
$this->assertSame($project2->getKey(), $task3->project_id);
return (object) [
'client1' => $client1,
'project1' => $project1,
'project2' => $project2,
'task1' => $task1,
];
}
}

64
tests/Unit/Service/Import/Importer/TogglDataImporterTest.php Normal file
View File

@@ -0,0 +1,64 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Service\Import\Importer;
use App\Models\Organization;
use App\Service\Import\Importers\TogglDataImporter;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Spatie\TemporaryDirectory\TemporaryDirectory;
use ZipArchive;
class TogglDataImporterTest extends ImporterTestAbstract
{
private function createTestZip(string $folder): string
{
$tempDir = TemporaryDirectory::make();
$zipPath = $tempDir->path('test.zip');
$zip = new ZipArchive();
$zip->open($zipPath, ZipArchive::CREATE);
foreach (Storage::disk('testfiles')->allFiles($folder) as $file) {
$zip->addFile(Storage::disk('testfiles')->path($file), Str::of($file)->after($folder.'/')->value());
}
$zip->close();
return $zipPath;
}
public function test_import_of_test_file_succeeds(): void
{
// Arrange
$zipPath = $this->createTestZip('toggl_data_import_test_1');
$organization = Organization::factory()->create();
$importer = new TogglDataImporter();
$importer->init($organization);
$data = file_get_contents($zipPath);
// Act
$importer->importData($data);
// Assert
$this->checkTestScenarioAfterImportExcludingTimeEntries();
}
public function test_import_of_test_file_twice_succeeds(): void
{
// Arrange
$zipPath = $this->createTestZip('toggl_data_import_test_1');
$organization = Organization::factory()->create();
$importer = new TogglDataImporter();
$importer->init($organization);
$data = file_get_contents($zipPath);
$importer->importData($data);
$importer = new TogglDataImporter();
$importer->init($organization);
// Act
$importer->importData($data);
// Assert
$this->checkTestScenarioAfterImportExcludingTimeEntries();
}
}

77
tests/Unit/Service/Import/Importer/TogglTimeEntriesImporterTest.php Normal file
View File

@@ -0,0 +1,77 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Service\Import\Importer;
use App\Models\Organization;
use App\Models\TimeEntry;
use App\Service\Import\Importers\TogglTimeEntriesImporter;
class TogglTimeEntriesImporterTest extends ImporterTestAbstract
{
public function test_import_of_test_file_succeeds(): void
{
// Arrange
$organization = Organization::factory()->create();
$importer = new TogglTimeEntriesImporter();
$importer->init($organization);
$data = file_get_contents(storage_path('tests/toggl_time_entries_import_test_1.csv'));
// Act
$importer->importData($data, []);
// Assert
$testScenario = $this->checkTestScenarioAfterImportExcludingTimeEntries();
$timeEntries = TimeEntry::all();
$this->assertCount(2, $timeEntries);
$timeEntry1 = $timeEntries->firstWhere('description', '');
$this->assertNotNull($timeEntry1);
$this->assertSame('', $timeEntry1->description);
$this->assertSame('2024-03-04 10:23:52', $timeEntry1->start->toDateTimeString());
$this->assertSame('2024-03-04 10:23:52', $timeEntry1->end->toDateTimeString());
$this->assertFalse($timeEntry1->billable);
$this->assertSame([$testScenario->tag1->getKey(), $testScenario->tag2->getKey()], $timeEntry1->tags);
$timeEntry2 = $timeEntries->firstWhere('description', 'Working hard');
$this->assertNotNull($timeEntry2);
$this->assertSame('Working hard', $timeEntry2->description);
$this->assertSame('2024-03-04 10:23:00', $timeEntry2->start->toDateTimeString());
$this->assertSame('2024-03-04 11:23:01', $timeEntry2->end->toDateTimeString());
$this->assertTrue($timeEntry2->billable);
$this->assertSame([], $timeEntry2->tags);
}
public function test_import_of_test_file_twice_succeeds(): void
{
// Arrange
$organization = Organization::factory()->create();
$importer = new TogglTimeEntriesImporter();
$importer->init($organization);
$data = file_get_contents(storage_path('tests/toggl_time_entries_import_test_1.csv'));
$importer->importData($data, []);
$importer = new TogglTimeEntriesImporter();
$importer->init($organization);
// Act
$importer->importData($data, []);
// Assert
$testScenario = $this->checkTestScenarioAfterImportExcludingTimeEntries();
$timeEntries = TimeEntry::all();
$this->assertCount(4, $timeEntries);
$timeEntry1 = $timeEntries->firstWhere('description', '');
$this->assertNotNull($timeEntry1);
$this->assertSame('', $timeEntry1->description);
$this->assertSame('2024-03-04 10:23:52', $timeEntry1->start->toDateTimeString());
$this->assertSame('2024-03-04 10:23:52', $timeEntry1->end->toDateTimeString());
$this->assertFalse($timeEntry1->billable);
$this->assertSame([$testScenario->tag1->getKey(), $testScenario->tag2->getKey()], $timeEntry1->tags);
$timeEntry2 = $timeEntries->firstWhere('description', 'Working hard');
$this->assertNotNull($timeEntry2);
$this->assertSame('Working hard', $timeEntry2->description);
$this->assertSame('2024-03-04 10:23:00', $timeEntry2->start->toDateTimeString());
$this->assertSame('2024-03-04 11:23:01', $timeEntry2->end->toDateTimeString());
$this->assertTrue($timeEntry2->billable);
$this->assertSame([], $timeEntry2->tags);
}
}

37
tests/Unit/Service/UserServiceTest.php Normal file
View File

@@ -0,0 +1,37 @@
<?php
declare(strict_types=1);
namespace Tests\Unit\Service;
use App\Models\Organization;
use App\Models\TimeEntry;
use App\Models\User;
use App\Service\UserService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
class UserServiceTest extends TestCase
{
use RefreshDatabase;
public function test_assign_organization_entities_to_different_user(): void
{
// Arrange
$organization = Organization::factory()->create();
$otherUser = User::factory()->create();
$fromUser = User::factory()->create();
$toUser = User::factory()->create();
TimeEntry::factory()->forOrganization($organization)->forUser($otherUser)->createMany(3);
TimeEntry::factory()->forOrganization($organization)->forUser($fromUser)->createMany(3);
// Act
$userService = app(UserService::class);
$userService->assignOrganizationEntitiesToDifferentUser($organization, $fromUser, $toUser);
// Assert
$this->assertSame(3, TimeEntry::query()->whereBelongsTo($toUser, 'user')->count());
$this->assertSame(3, TimeEntry::query()->whereBelongsTo($otherUser, 'user')->count());
$this->assertSame(0, TimeEntry::query()->whereBelongsTo($fromUser, 'user')->count());
}
}