From a706b6531caf3c0e9bf5fee6a8d8d046e36e0352 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Thu, 17 Oct 2024 21:06:08 +0200 Subject: [PATCH 01/31] OM-344: Group of Worker feature - backend --- worker_voucher/apps.py | 8 ++ worker_voucher/gql_mutations.py | 94 ++++++++++++++- worker_voucher/gql_queries.py | 27 ++++- ...kergroup_historicalworkergroup_and_more.py | 111 ++++++++++++++++++ ...calworkergroup_date_valid_from_and_more.py | 45 +++++++ ...012_groupofworker_policyholder_and_more.py | 25 ++++ .../0013_alter_groupofworker_name_and_more.py | 23 ++++ worker_voucher/models.py | 25 +++- worker_voucher/schema.py | 47 +++++++- worker_voucher/services.py | 108 ++++++++++++++++- 10 files changed, 504 insertions(+), 9 deletions(-) create mode 100644 worker_voucher/migrations/0010_groupofworker_workergroup_historicalworkergroup_and_more.py create mode 100644 worker_voucher/migrations/0011_historicalworkergroup_date_valid_from_and_more.py create mode 100644 worker_voucher/migrations/0012_groupofworker_policyholder_and_more.py create mode 100644 worker_voucher/migrations/0013_alter_groupofworker_name_and_more.py diff --git a/worker_voucher/apps.py b/worker_voucher/apps.py index 901dec3..3a597ef 100644 --- a/worker_voucher/apps.py +++ b/worker_voucher/apps.py @@ -11,6 +11,10 @@ "gql_worker_voucher_acquire_unassigned_perms": ["204006"], "gql_worker_voucher_acquire_assigned_perms": ["204007"], "gql_worker_voucher_assign_vouchers_perms": ["204008"], + "gql_group_of_worker_search_perms": ["205001"], + "gql_group_of_worker_create_perms": ["205002"], + "gql_group_of_worker_update_perms": ["205003"], + "gql_group_of_worker_delete_perms": ["205004"], "unassigned_voucher_enabled": True, "price_per_voucher": "100.00", "max_generic_vouchers": 1000, @@ -42,6 +46,10 @@ class WorkerVoucherConfig(AppConfig, ConfigUtilMixin): gql_worker_voucher_acquire_unassigned_perms = None gql_worker_voucher_acquire_assigned_perms = None gql_worker_voucher_assign_vouchers_perms = None + gql_group_of_worker_search_perms = None + gql_group_of_worker_create_perms = None + gql_group_of_worker_update_perms = None + gql_group_of_worker_delete_perms = None unassigned_voucher_enabled = None price_per_voucher = None diff --git a/worker_voucher/gql_mutations.py b/worker_voucher/gql_mutations.py index 7a3e22c..a5d5a83 100644 --- a/worker_voucher/gql_mutations.py +++ b/worker_voucher/gql_mutations.py @@ -16,7 +16,7 @@ from policyholder.services import PolicyHolderInsuree as PolicyHolderInsureeService from worker_voucher.apps import WorkerVoucherConfig from worker_voucher.models import WorkerVoucher -from worker_voucher.services import WorkerVoucherService, validate_acquire_unassigned_vouchers, \ +from worker_voucher.services import WorkerVoucherService, GroupOfWorkerService, validate_acquire_unassigned_vouchers, \ validate_acquire_assigned_vouchers, validate_assign_vouchers, create_assigned_voucher, create_voucher_bill, \ create_unassigned_voucher, assign_voucher, economic_unit_user_filter, check_existing_active_vouchers @@ -379,3 +379,95 @@ def _mutate(cls, user, count=None, economic_unit_code=None, workers=None, date_r class Input(AssignVouchersMutationInput): pass + + +class CreateOrUpdateGroupOfWorkerMutation(BaseMutation): + """ + Create a new group of worker or update existing group + """ + _mutation_module = "worker_voucher" + _mutation_class = "CreateOrUpdateGroupOfWorkerMutation" + + class Input(OpenIMISMutation.Input): + id = graphene.UUID(required=False) + name = graphene.String(required=True, max_length=50) + economic_unit_code = graphene.String(required=True) + insurees_chf_id = graphene.List(graphene.String, required=True) + + @classmethod + def _validate_mutation(cls, user, **data): + if type(user) is AnonymousUser or not user.id or not user.has_perms( + WorkerVoucherConfig.gql_worker_voucher_acquire_assigned_perms): + raise ValidationError("mutation.authentication_required") + + @classmethod + def _mutate(cls, user, **data): + try: + data.pop('client_mutation_id', None) + data.pop('client_mutation_label', None) + eu_code = data.pop('economic_unit_code', None) + eu_uuid = (PolicyHolder.objects + .filter(economic_unit_user_filter(user), code=eu_code) + .values_list('uuid', flat=True) + .first()) + if not eu_uuid: + return [{"message": _("worker_voucher.validation.economic_unit_not_exists")}] + with transaction.atomic(): + data['policyholder_id'] = eu_uuid + service = GroupOfWorkerService(user) + result = service.create_or_update(data, eu_code) + if not result.get("success"): + return result + return None + except Exception as exc: + return [ + { + 'message': "worker_voucher.mutation.failed_to_create_or_update_group_of_worker", + 'detail': str(exc) + }] + + +class DeleteGroupOfWorkerMutation(BaseMutation): + """ + Delete a chosen group of worker + """ + _mutation_module = "core" + _mutation_class = "DeleteGroupOfWorkerMutation" + + class Input(OpenIMISMutation.Input): + uuid = graphene.String(required=False) + uuids = graphene.List(graphene.String, required=False) + economic_unit_code = graphene.String(required=True) + + @classmethod + def _validate_mutation(cls, user, **data): + if type(user) is AnonymousUser or not user.id or not user.has_perms( + WorkerVoucherConfig.gql_group_of_worker_delete_perms): + raise ValidationError("mutation.authentication_required") + + @classmethod + def _mutate(cls, user, uuid=None, uuids=None, economic_unit_code=None, **data): + uuids_to_delete = [uuid] if uuid else uuids + if not uuids_to_delete: + return [{"message": _("workers.validation.no_group_of_workers_to_delete")}] + + eu_uuid = (PolicyHolder.objects + .filter(economic_unit_user_filter(user), code=economic_unit_code) + .values_list('uuid', flat=True) + .first()) + + if not eu_uuid: + return [{"message": _("worker_voucher.validation.economic_unit_not_exists")}] + + errors = [] + service = GroupOfWorkerService(user) + try: + with transaction.atomic(): + for group_id in uuids_to_delete: + errors += service.delete(group_id, eu_uuid) + if errors: + raise ValueError("Errors during mutation") + except ValueError: + pass + + return errors diff --git a/worker_voucher/gql_queries.py b/worker_voucher/gql_queries.py index 9195592..5f3cbb4 100644 --- a/worker_voucher/gql_queries.py +++ b/worker_voucher/gql_queries.py @@ -6,7 +6,7 @@ from insuree.models import Insuree from invoice.models import Bill from policyholder.gql import PolicyHolderGQLType -from worker_voucher.models import WorkerVoucher +from worker_voucher.models import WorkerVoucher, GroupOfWorker, WorkerGroup from worker_voucher.services import get_worker_yearly_voucher_count_counts @@ -89,3 +89,28 @@ class OnlineWorkerDataGQLType(graphene.ObjectType): other_names = graphene.String() last_name = graphene.String() photo = graphene.String() + + +class GroupOfWorkerGQLType(DjangoObjectType): + + class Meta: + model = GroupOfWorker + interfaces = (graphene.relay.Node,) + filter_fields = { + "id": ["exact"], + "name": ["exact", "istartswith", "icontains", "iexact"], + **prefix_filterset("policyholder__", PolicyHolderGQLType._meta.filter_fields), + } + connection_class = ExtendedConnection + + +class WorkerGroupGQLType(DjangoObjectType): + class Meta: + model = WorkerGroup + interfaces = (graphene.relay.Node,) + filter_fields = { + "id": ["exact"], + "insuree_id": ["exact"], + **prefix_filterset("group__", GroupOfWorkerGQLType._meta.filter_fields), + } + connection_class = ExtendedConnection diff --git a/worker_voucher/migrations/0010_groupofworker_workergroup_historicalworkergroup_and_more.py b/worker_voucher/migrations/0010_groupofworker_workergroup_historicalworkergroup_and_more.py new file mode 100644 index 0000000..635f2d4 --- /dev/null +++ b/worker_voucher/migrations/0010_groupofworker_workergroup_historicalworkergroup_and_more.py @@ -0,0 +1,111 @@ +# Generated by Django 4.2.15 on 2024-10-15 13:05 + +import core.fields +import datetime +import dirtyfields.dirtyfields +from django.conf import settings +from django.db import migrations, models +import django.db.models.deletion +import simple_history.models + + +class Migration(migrations.Migration): + + dependencies = [ + migrations.swappable_dependency(settings.AUTH_USER_MODEL), + ('insuree', '0023_alter_family_head_insuree'), + ('worker_voucher', '0009_alter_historicalworkerupload_status_and_more'), + ] + + operations = [ + migrations.CreateModel( + name='GroupOfWorker', + fields=[ + ('id', models.UUIDField(db_column='UUID', default=None, editable=False, primary_key=True, serialize=False)), + ('is_deleted', models.BooleanField(db_column='isDeleted', default=False)), + ('json_ext', models.JSONField(blank=True, db_column='Json_ext', null=True)), + ('date_created', core.fields.DateTimeField(db_column='DateCreated', default=datetime.datetime.now, null=True)), + ('date_updated', core.fields.DateTimeField(db_column='DateUpdated', default=datetime.datetime.now, null=True)), + ('version', models.IntegerField(default=1)), + ('name', models.CharField(max_length=50)), + ('user_created', models.ForeignKey(db_column='UserCreatedUUID', on_delete=django.db.models.deletion.DO_NOTHING, related_name='%(class)s_user_created', to=settings.AUTH_USER_MODEL)), + ('user_updated', models.ForeignKey(db_column='UserUpdatedUUID', on_delete=django.db.models.deletion.DO_NOTHING, related_name='%(class)s_user_updated', to=settings.AUTH_USER_MODEL)), + ], + options={ + 'abstract': False, + }, + bases=(dirtyfields.dirtyfields.DirtyFieldsMixin, models.Model), + ), + migrations.CreateModel( + name='WorkerGroup', + fields=[ + ('id', models.UUIDField(db_column='UUID', default=None, editable=False, primary_key=True, serialize=False)), + ('is_deleted', models.BooleanField(db_column='isDeleted', default=False)), + ('json_ext', models.JSONField(blank=True, db_column='Json_ext', null=True)), + ('date_created', core.fields.DateTimeField(db_column='DateCreated', default=datetime.datetime.now, null=True)), + ('date_updated', core.fields.DateTimeField(db_column='DateUpdated', default=datetime.datetime.now, null=True)), + ('version', models.IntegerField(default=1)), + ('group', models.ForeignKey(on_delete=django.db.models.deletion.DO_NOTHING, related_name='group_workers', to='worker_voucher.groupofworker')), + ('insuree', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.DO_NOTHING, to='insuree.insuree')), + ('user_created', models.ForeignKey(db_column='UserCreatedUUID', on_delete=django.db.models.deletion.DO_NOTHING, related_name='%(class)s_user_created', to=settings.AUTH_USER_MODEL)), + ('user_updated', models.ForeignKey(db_column='UserUpdatedUUID', on_delete=django.db.models.deletion.DO_NOTHING, related_name='%(class)s_user_updated', to=settings.AUTH_USER_MODEL)), + ], + options={ + 'abstract': False, + }, + bases=(dirtyfields.dirtyfields.DirtyFieldsMixin, models.Model), + ), + migrations.CreateModel( + name='HistoricalWorkerGroup', + fields=[ + ('id', models.UUIDField(db_column='UUID', db_index=True, default=None, editable=False)), + ('is_deleted', models.BooleanField(db_column='isDeleted', default=False)), + ('json_ext', models.JSONField(blank=True, db_column='Json_ext', null=True)), + ('date_created', core.fields.DateTimeField(db_column='DateCreated', default=datetime.datetime.now, null=True)), + ('date_updated', core.fields.DateTimeField(db_column='DateUpdated', default=datetime.datetime.now, null=True)), + ('version', models.IntegerField(default=1)), + ('history_id', models.AutoField(primary_key=True, serialize=False)), + ('history_date', models.DateTimeField(db_index=True)), + ('history_change_reason', models.CharField(max_length=100, null=True)), + ('history_type', models.CharField(choices=[('+', 'Created'), ('~', 'Changed'), ('-', 'Deleted')], max_length=1)), + ('group', models.ForeignKey(blank=True, db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to='worker_voucher.groupofworker')), + ('history_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to=settings.AUTH_USER_MODEL)), + ('insuree', models.ForeignKey(blank=True, db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to='insuree.insuree')), + ('user_created', models.ForeignKey(blank=True, db_column='UserCreatedUUID', db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to=settings.AUTH_USER_MODEL)), + ('user_updated', models.ForeignKey(blank=True, db_column='UserUpdatedUUID', db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to=settings.AUTH_USER_MODEL)), + ], + options={ + 'verbose_name': 'historical worker group', + 'verbose_name_plural': 'historical worker groups', + 'ordering': ('-history_date', '-history_id'), + 'get_latest_by': ('history_date', 'history_id'), + }, + bases=(simple_history.models.HistoricalChanges, models.Model), + ), + migrations.CreateModel( + name='HistoricalGroupOfWorker', + fields=[ + ('id', models.UUIDField(db_column='UUID', db_index=True, default=None, editable=False)), + ('is_deleted', models.BooleanField(db_column='isDeleted', default=False)), + ('json_ext', models.JSONField(blank=True, db_column='Json_ext', null=True)), + ('date_created', core.fields.DateTimeField(db_column='DateCreated', default=datetime.datetime.now, null=True)), + ('date_updated', core.fields.DateTimeField(db_column='DateUpdated', default=datetime.datetime.now, null=True)), + ('version', models.IntegerField(default=1)), + ('name', models.CharField(max_length=50)), + ('history_id', models.AutoField(primary_key=True, serialize=False)), + ('history_date', models.DateTimeField(db_index=True)), + ('history_change_reason', models.CharField(max_length=100, null=True)), + ('history_type', models.CharField(choices=[('+', 'Created'), ('~', 'Changed'), ('-', 'Deleted')], max_length=1)), + ('history_user', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='+', to=settings.AUTH_USER_MODEL)), + ('user_created', models.ForeignKey(blank=True, db_column='UserCreatedUUID', db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to=settings.AUTH_USER_MODEL)), + ('user_updated', models.ForeignKey(blank=True, db_column='UserUpdatedUUID', db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to=settings.AUTH_USER_MODEL)), + ], + options={ + 'verbose_name': 'historical group of worker', + 'verbose_name_plural': 'historical group of workers', + 'ordering': ('-history_date', '-history_id'), + 'get_latest_by': ('history_date', 'history_id'), + }, + bases=(simple_history.models.HistoricalChanges, models.Model), + ), + ] diff --git a/worker_voucher/migrations/0011_historicalworkergroup_date_valid_from_and_more.py b/worker_voucher/migrations/0011_historicalworkergroup_date_valid_from_and_more.py new file mode 100644 index 0000000..f2b45e6 --- /dev/null +++ b/worker_voucher/migrations/0011_historicalworkergroup_date_valid_from_and_more.py @@ -0,0 +1,45 @@ +# Generated by Django 4.2.15 on 2024-10-15 14:30 + +import core.fields +import datetime +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('worker_voucher', '0010_groupofworker_workergroup_historicalworkergroup_and_more'), + ] + + operations = [ + migrations.AddField( + model_name='historicalworkergroup', + name='date_valid_from', + field=core.fields.DateTimeField(db_column='DateValidFrom', default=datetime.datetime.now), + ), + migrations.AddField( + model_name='historicalworkergroup', + name='date_valid_to', + field=core.fields.DateTimeField(blank=True, db_column='DateValidTo', null=True), + ), + migrations.AddField( + model_name='historicalworkergroup', + name='replacement_uuid', + field=models.UUIDField(blank=True, db_column='ReplacementUUID', null=True), + ), + migrations.AddField( + model_name='workergroup', + name='date_valid_from', + field=core.fields.DateTimeField(db_column='DateValidFrom', default=datetime.datetime.now), + ), + migrations.AddField( + model_name='workergroup', + name='date_valid_to', + field=core.fields.DateTimeField(blank=True, db_column='DateValidTo', null=True), + ), + migrations.AddField( + model_name='workergroup', + name='replacement_uuid', + field=models.UUIDField(blank=True, db_column='ReplacementUUID', null=True), + ), + ] diff --git a/worker_voucher/migrations/0012_groupofworker_policyholder_and_more.py b/worker_voucher/migrations/0012_groupofworker_policyholder_and_more.py new file mode 100644 index 0000000..b9fae2a --- /dev/null +++ b/worker_voucher/migrations/0012_groupofworker_policyholder_and_more.py @@ -0,0 +1,25 @@ +# Generated by Django 4.2.15 on 2024-10-17 09:25 + +from django.db import migrations, models +import django.db.models.deletion + + +class Migration(migrations.Migration): + + dependencies = [ + ('policyholder', '0018_alter_historicalpolicyholder_date_created_and_more'), + ('worker_voucher', '0011_historicalworkergroup_date_valid_from_and_more'), + ] + + operations = [ + migrations.AddField( + model_name='groupofworker', + name='policyholder', + field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.DO_NOTHING, to='policyholder.policyholder'), + ), + migrations.AddField( + model_name='historicalgroupofworker', + name='policyholder', + field=models.ForeignKey(blank=True, db_constraint=False, null=True, on_delete=django.db.models.deletion.DO_NOTHING, related_name='+', to='policyholder.policyholder'), + ), + ] diff --git a/worker_voucher/migrations/0013_alter_groupofworker_name_and_more.py b/worker_voucher/migrations/0013_alter_groupofworker_name_and_more.py new file mode 100644 index 0000000..be6f138 --- /dev/null +++ b/worker_voucher/migrations/0013_alter_groupofworker_name_and_more.py @@ -0,0 +1,23 @@ +# Generated by Django 4.2.15 on 2024-10-17 17:20 + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('worker_voucher', '0012_groupofworker_policyholder_and_more'), + ] + + operations = [ + migrations.AlterField( + model_name='groupofworker', + name='name', + field=models.CharField(max_length=50, unique=True), + ), + migrations.AlterField( + model_name='historicalgroupofworker', + name='name', + field=models.CharField(db_index=True, max_length=50), + ), + ] diff --git a/worker_voucher/models.py b/worker_voucher/models.py index c2fb623..4e3eb50 100644 --- a/worker_voucher/models.py +++ b/worker_voucher/models.py @@ -1,7 +1,7 @@ from django.db import models from django.conf import settings from django.utils.translation import gettext_lazy as _ -from core.models import HistoryModel +from core.models import HistoryModel, HistoryBusinessModel from core import fields from insuree.models import Insuree from policyholder.models import PolicyHolder @@ -51,3 +51,26 @@ class Status(models.TextChoices): status = models.CharField(max_length=255, choices=Status.choices, default=Status.TRIGGERED) error = models.JSONField(blank=True, default=dict) file_name = models.CharField(max_length=255, null=True, blank=True) + + +class GroupOfWorker(HistoryModel): + name = models.CharField(max_length=50, unique=True) + policyholder = models.ForeignKey(PolicyHolder, models.DO_NOTHING, null=True, blank=True) + + @classmethod + def get_queryset(cls, queryset, user): + from worker_voucher.services import get_voucher_user_filters + + queryset = cls.filter_queryset(queryset) + if isinstance(user, ResolveInfo): + user = user.context.user + if settings.ROW_SECURITY: + if user.is_anonymous: + queryset = queryset.filter(id=None) + queryset = queryset.filter(*get_voucher_user_filters(user)) + return queryset + + +class WorkerGroup(HistoryBusinessModel): + group = models.ForeignKey(GroupOfWorker, related_name="group_workers", on_delete=models.DO_NOTHING) + insuree = models.ForeignKey(Insuree, null=True, blank=True, on_delete=models.DO_NOTHING) diff --git a/worker_voucher/schema.py b/worker_voucher/schema.py index 1f24098..72e2661 100644 --- a/worker_voucher/schema.py +++ b/worker_voucher/schema.py @@ -16,13 +16,21 @@ from policyholder.models import PolicyHolder from worker_voucher.apps import WorkerVoucherConfig from worker_voucher.gql_queries import WorkerVoucherGQLType, AcquireVouchersValidationSummaryGQLType, WorkerGQLType, \ - OnlineWorkerDataGQLType + OnlineWorkerDataGQLType, GroupOfWorkerGQLType, WorkerGroupGQLType from worker_voucher.gql_mutations import CreateWorkerVoucherMutation, UpdateWorkerVoucherMutation, \ DeleteWorkerVoucherMutation, AcquireUnassignedVouchersMutation, AcquireAssignedVouchersMutation, \ - DateRangeInclusiveInputType, AssignVouchersMutation, CreateWorkerMutation, DeleteWorkerMutation -from worker_voucher.models import WorkerVoucher -from worker_voucher.services import get_voucher_worker_enquire_filters, validate_acquire_unassigned_vouchers, \ - validate_acquire_assigned_vouchers, validate_assign_vouchers, economic_unit_user_filter, worker_user_filter + DateRangeInclusiveInputType, AssignVouchersMutation, CreateWorkerMutation, DeleteWorkerMutation, \ + CreateOrUpdateGroupOfWorkerMutation, DeleteGroupOfWorkerMutation +from worker_voucher.models import WorkerVoucher, GroupOfWorker, WorkerGroup +from worker_voucher.services import ( + get_voucher_worker_enquire_filters, + validate_acquire_unassigned_vouchers, + validate_acquire_assigned_vouchers, + validate_assign_vouchers, + economic_unit_user_filter, + worker_user_filter, + get_group_worker_user_filters +) class Query(ExportableQueryMixin, graphene.ObjectType): @@ -80,6 +88,21 @@ class Query(ExportableQueryMixin, graphene.ObjectType): economic_unit_code=graphene.ID(), ) + group_of_worker = OrderedDjangoFilterConnectionField( + GroupOfWorkerGQLType, + orderBy=graphene.List(of_type=graphene.String), + is_system=graphene.Boolean(), + insuree_id=graphene.Int(), + system_role_id=graphene.Int(), + client_mutation_id=graphene.String(), + str=graphene.String(description="Text search on any field") + ) + + worker_group = OrderedDjangoFilterConnectionField( + WorkerGroupGQLType, + orderBy=graphene.List(of_type=graphene.String), + ) + def resolve_worker(self, info, client_mutation_id=None, economic_unit_code=None, **kwargs): Query._check_permissions(info.context.user, InsureeConfig.gql_query_insurees_perms) filters = filter_validity(**kwargs) @@ -204,6 +227,17 @@ def resolve_online_worker_data(self, info, national_id=None, economic_unit_code= photo=online_result["data"]["Photo"] ) + def resolve_group_of_worker(self, info, **kwargs): + if not info.context.user.has_perms(WorkerVoucherConfig.gql_group_of_worker_search_perms): + raise PermissionError("Unauthorized") + filters = [] + query = GroupOfWorker.objects + client_mutation_id = kwargs.get("client_mutation_id", None) + if client_mutation_id: + filters.append(Q(mutations__mutation__client_mutation_id=client_mutation_id)) + filters.extend(get_group_worker_user_filters(info.context.user)) + return gql_optimizer.query(query.filter(*filters), info) + @staticmethod def _check_permissions(user, perms): if type(user) is AnonymousUser or not user.id or not user.has_perms(perms): @@ -221,3 +255,6 @@ class Mutation(graphene.ObjectType): acquire_unassigned_vouchers = AcquireUnassignedVouchersMutation.Field() acquire_assigned_vouchers = AcquireAssignedVouchersMutation.Field() assign_vouchers = AssignVouchersMutation.Field() + + create_or_update_group_of_workers = CreateOrUpdateGroupOfWorkerMutation.Field() + delete_group_of_workers = DeleteGroupOfWorkerMutation.Field() diff --git a/worker_voucher/services.py b/worker_voucher/services.py index 0ddfad0..fb4ee9d 100644 --- a/worker_voucher/services.py +++ b/worker_voucher/services.py @@ -13,6 +13,11 @@ from core import datetime from core.models import InteractiveUser, User from core.services import BaseService +from core.services.utils import ( + output_exception, + model_representation, + output_result_success +) from core.signals import register_service_signal from insuree.models import Insuree from insuree.gql_mutations import update_or_create_insuree @@ -22,7 +27,7 @@ from policyholder.services import PolicyHolderInsuree as PolicyHolderInsureeService from msystems.services.mconnect_worker_service import MConnectWorkerService from worker_voucher.apps import WorkerVoucherConfig -from worker_voucher.models import WorkerVoucher +from worker_voucher.models import WorkerVoucher, GroupOfWorker, WorkerGroup from worker_voucher.validation import WorkerVoucherValidation logger = logging.getLogger(__name__) @@ -75,6 +80,16 @@ def get_voucher_user_filters(user: InteractiveUser) -> Iterable[Q]: )] if not user.user.has_perms(WorkerVoucherConfig.gql_worker_voucher_search_all_perms) else [] +def get_group_worker_user_filters(user: InteractiveUser) -> Iterable[Q]: + return [Q( + policyholder__policyholderuser__user__i_user=user.i_user, + policyholder__is_deleted=False, + policyholder__policyholderuser__is_deleted=False, + policyholder__policyholderuser__user__validity_to__isnull=True, + policyholder__policyholderuser__user__i_user__validity_to__isnull=True, + )] if user.has_perms(WorkerVoucherConfig.gql_group_of_worker_search_perms) else [] + + def validate_acquire_unassigned_vouchers(user: User, eu_code: str, count: Union[int, str]) -> Dict: try: price_per_voucher = Decimal(WorkerVoucherConfig.price_per_voucher) @@ -552,6 +567,97 @@ def _add_worker_to_system(self, chf_id, economic_unit, data_from_mconnect, error return errors +class GroupOfWorkerService(BaseService): + OBJECT_TYPE = GroupOfWorker + + def __init__(self, user, validation_class=None): + super().__init__(user, validation_class) + + @register_service_signal('group_of_worker_service.create_or_update') + def create_or_update(self, obj_data, eu_code): + try: + with transaction.atomic(): + import datetime + now = datetime.datetime.now() + group_id = obj_data.pop('id') if 'id' in obj_data else None + insurees_chf_id = obj_data.pop('insurees_chf_id') if "insurees_chf_id" in obj_data else None + insurees = _check_insurees(insurees_chf_id, eu_code, self.user) + if group_id: + group = GroupOfWorker.objects.get(id=group_id) + [setattr(group, k, v) for k, v in obj_data.items()] + group.save(user=self.user) + if insurees is not None: + worker_group_currently_assigned = WorkerGroup.objects.filter(group=group_id) + worker_group_currently_assigned.update(date_valid_to=now, is_deleted=True) + worker_group_currently_assigned = worker_group_currently_assigned.values_list( + 'insuree__chf_id', + flat=True + ) + for insuree in insurees: + if insuree.chf_id not in worker_group_currently_assigned: + worker_group = WorkerGroup( + group_id=group_id, + insuree_id=insuree.id, + ) + worker_group.save(user=self.user) + else: + role_right = WorkerGroup.objects.get(Q(group_id=group.id, insuree_id=insuree.id)) + role_right.date_valid_to = None + role_right.is_deleted = False + role_right.save(user=self.user) + else: + group = GroupOfWorker(**obj_data) + group.save(user=self.user) + if insurees: + for insuree in insurees: + worker_group = WorkerGroup( + **{ + "group_id": group.id, + "insuree_id": insuree.id + } + ) + worker_group.save(user=self.user) + dict_repr = model_representation(group) + return output_result_success(dict_representation=dict_repr) + except Exception as exc: + return output_exception(model_name=self.OBJECT_TYPE.__name__, method="create_or_update", exception=exc) + + @register_service_signal('group_of_worker_service.create') + def create(self, obj_data): + raise NotImplementedError() + + @register_service_signal('group_of_worker_service.update') + def update(self, obj_data): + raise NotImplementedError() + + @register_service_signal('group_of_worker_service.delete') + def delete(self, group_id, eu_uuid): + try: + with transaction.atomic(): + import datetime + now = datetime.datetime.now() + gow = GroupOfWorker.objects.filter( + id=group_id, + policy_holder__uuid=eu_uuid, + policy_holder__is_deleted=False, + is_deleted=False, + ).first() + + if not gow: + return [{"message": _("worker_voucher.validation.group_of_worker_not_exists"), "detail": group_id}] + + worker_group = WorkerGroup.objects.filter( + group_of_worker__id=group_id, + group_of_worker__policy_holder__uuid=eu_uuid, + policy_holder__is_deleted=False, + is_deleted=False, + ) + worker_group.delete() + gow.delete(user=self.user) + except Exception as exc: + return output_exception(model_name=self.OBJECT_TYPE.__name__, method="delete", exception=exc) + + def worker_voucher_bill_user_filter(qs: QuerySet, user: User) -> QuerySet: if user.is_imis_admin: return qs From 96f0cafab550e854577214538093989b97af0665 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Thu, 17 Oct 2024 21:09:44 +0200 Subject: [PATCH 02/31] OM-344: fixing typos --- worker_voucher/schema.py | 7 ------- worker_voucher/services.py | 8 ++++---- 2 files changed, 4 insertions(+), 11 deletions(-) diff --git a/worker_voucher/schema.py b/worker_voucher/schema.py index 72e2661..4daf139 100644 --- a/worker_voucher/schema.py +++ b/worker_voucher/schema.py @@ -93,14 +93,7 @@ class Query(ExportableQueryMixin, graphene.ObjectType): orderBy=graphene.List(of_type=graphene.String), is_system=graphene.Boolean(), insuree_id=graphene.Int(), - system_role_id=graphene.Int(), client_mutation_id=graphene.String(), - str=graphene.String(description="Text search on any field") - ) - - worker_group = OrderedDjangoFilterConnectionField( - WorkerGroupGQLType, - orderBy=graphene.List(of_type=graphene.String), ) def resolve_worker(self, info, client_mutation_id=None, economic_unit_code=None, **kwargs): diff --git a/worker_voucher/services.py b/worker_voucher/services.py index fb4ee9d..fb259e1 100644 --- a/worker_voucher/services.py +++ b/worker_voucher/services.py @@ -601,10 +601,10 @@ def create_or_update(self, obj_data, eu_code): ) worker_group.save(user=self.user) else: - role_right = WorkerGroup.objects.get(Q(group_id=group.id, insuree_id=insuree.id)) - role_right.date_valid_to = None - role_right.is_deleted = False - role_right.save(user=self.user) + worker_group = WorkerGroup.objects.get(Q(group_id=group.id, insuree_id=insuree.id)) + worker_group.date_valid_to = None + worker_group.is_deleted = False + worker_group.save(user=self.user) else: group = GroupOfWorker(**obj_data) group.save(user=self.user) From 2167333f13975823b8bffdec1590d869b687459b Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Thu, 17 Oct 2024 21:13:05 +0200 Subject: [PATCH 03/31] OM-344: added uuid not encoded in graphqql --- worker_voucher/gql_queries.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/worker_voucher/gql_queries.py b/worker_voucher/gql_queries.py index 5f3cbb4..fb9f46e 100644 --- a/worker_voucher/gql_queries.py +++ b/worker_voucher/gql_queries.py @@ -92,6 +92,7 @@ class OnlineWorkerDataGQLType(graphene.ObjectType): class GroupOfWorkerGQLType(DjangoObjectType): + uuid = graphene.String(source='uuid') class Meta: model = GroupOfWorker @@ -105,6 +106,8 @@ class Meta: class WorkerGroupGQLType(DjangoObjectType): + uuid = graphene.String(source='uuid') + class Meta: model = WorkerGroup interfaces = (graphene.relay.Node,) From 97a1c0c1eed456d6a36851611d39c9902645ab50 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Thu, 17 Oct 2024 21:34:35 +0200 Subject: [PATCH 04/31] OM-344: improving cherry pick of workers in update mode of group --- worker_voucher/services.py | 26 +++++++------------------- 1 file changed, 7 insertions(+), 19 deletions(-) diff --git a/worker_voucher/services.py b/worker_voucher/services.py index fb259e1..4a09b2b 100644 --- a/worker_voucher/services.py +++ b/worker_voucher/services.py @@ -581,30 +581,18 @@ def create_or_update(self, obj_data, eu_code): now = datetime.datetime.now() group_id = obj_data.pop('id') if 'id' in obj_data else None insurees_chf_id = obj_data.pop('insurees_chf_id') if "insurees_chf_id" in obj_data else None - insurees = _check_insurees(insurees_chf_id, eu_code, self.user) + insurees = _check_insurees(insurees_chf_id, eu_code, self.user) if len(insurees_chf_id) > 0 else set() if group_id: group = GroupOfWorker.objects.get(id=group_id) - [setattr(group, k, v) for k, v in obj_data.items()] - group.save(user=self.user) if insurees is not None: worker_group_currently_assigned = WorkerGroup.objects.filter(group=group_id) - worker_group_currently_assigned.update(date_valid_to=now, is_deleted=True) - worker_group_currently_assigned = worker_group_currently_assigned.values_list( - 'insuree__chf_id', - flat=True - ) + worker_group_currently_assigned.delete() for insuree in insurees: - if insuree.chf_id not in worker_group_currently_assigned: - worker_group = WorkerGroup( - group_id=group_id, - insuree_id=insuree.id, - ) - worker_group.save(user=self.user) - else: - worker_group = WorkerGroup.objects.get(Q(group_id=group.id, insuree_id=insuree.id)) - worker_group.date_valid_to = None - worker_group.is_deleted = False - worker_group.save(user=self.user) + worker_group = WorkerGroup( + group_id=group_id, + insuree_id=insuree.id, + ) + worker_group.save(user=self.user) else: group = GroupOfWorker(**obj_data) group.save(user=self.user) From 80c90e74fa4386dc7539b475fb00b10ff573e300 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Thu, 17 Oct 2024 21:56:56 +0200 Subject: [PATCH 05/31] OM-344: improvements in delete group mutation --- worker_voucher/gql_mutations.py | 2 +- .../0014_alter_groupofworker_name_and_more.py | 23 +++++++++++++++++++ worker_voucher/models.py | 2 +- worker_voucher/services.py | 15 ++++++------ 4 files changed, 33 insertions(+), 9 deletions(-) create mode 100644 worker_voucher/migrations/0014_alter_groupofworker_name_and_more.py diff --git a/worker_voucher/gql_mutations.py b/worker_voucher/gql_mutations.py index a5d5a83..839be3a 100644 --- a/worker_voucher/gql_mutations.py +++ b/worker_voucher/gql_mutations.py @@ -431,7 +431,7 @@ class DeleteGroupOfWorkerMutation(BaseMutation): """ Delete a chosen group of worker """ - _mutation_module = "core" + _mutation_module = "worker_voucher" _mutation_class = "DeleteGroupOfWorkerMutation" class Input(OpenIMISMutation.Input): diff --git a/worker_voucher/migrations/0014_alter_groupofworker_name_and_more.py b/worker_voucher/migrations/0014_alter_groupofworker_name_and_more.py new file mode 100644 index 0000000..ee9952b --- /dev/null +++ b/worker_voucher/migrations/0014_alter_groupofworker_name_and_more.py @@ -0,0 +1,23 @@ +# Generated by Django 4.2.15 on 2024-10-17 19:53 + +from django.db import migrations, models + + +class Migration(migrations.Migration): + + dependencies = [ + ('worker_voucher', '0013_alter_groupofworker_name_and_more'), + ] + + operations = [ + migrations.AlterField( + model_name='groupofworker', + name='name', + field=models.CharField(max_length=50), + ), + migrations.AlterField( + model_name='historicalgroupofworker', + name='name', + field=models.CharField(max_length=50), + ), + ] diff --git a/worker_voucher/models.py b/worker_voucher/models.py index 4e3eb50..59b96fc 100644 --- a/worker_voucher/models.py +++ b/worker_voucher/models.py @@ -54,7 +54,7 @@ class Status(models.TextChoices): class GroupOfWorker(HistoryModel): - name = models.CharField(max_length=50, unique=True) + name = models.CharField(max_length=50) policyholder = models.ForeignKey(PolicyHolder, models.DO_NOTHING, null=True, blank=True) @classmethod diff --git a/worker_voucher/services.py b/worker_voucher/services.py index 4a09b2b..86084e8 100644 --- a/worker_voucher/services.py +++ b/worker_voucher/services.py @@ -622,12 +622,10 @@ def update(self, obj_data): def delete(self, group_id, eu_uuid): try: with transaction.atomic(): - import datetime - now = datetime.datetime.now() gow = GroupOfWorker.objects.filter( id=group_id, - policy_holder__uuid=eu_uuid, - policy_holder__is_deleted=False, + policyholder__uuid=eu_uuid, + policyholder__is_deleted=False, is_deleted=False, ).first() @@ -635,14 +633,17 @@ def delete(self, group_id, eu_uuid): return [{"message": _("worker_voucher.validation.group_of_worker_not_exists"), "detail": group_id}] worker_group = WorkerGroup.objects.filter( - group_of_worker__id=group_id, - group_of_worker__policy_holder__uuid=eu_uuid, - policy_holder__is_deleted=False, + group__id=group_id, + group__policyholder__uuid=eu_uuid, + group__policyholder__is_deleted=False, is_deleted=False, ) + print(worker_group) worker_group.delete() gow.delete(user=self.user) + return [] except Exception as exc: + print(exc) return output_exception(model_name=self.OBJECT_TYPE.__name__, method="delete", exception=exc) From 7f40eaaeabb5edb64d0767b21bc1439bb06b3e30 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 12:08:07 +0200 Subject: [PATCH 06/31] OM-344: added improvements after review from frontend perspective --- worker_voucher/gql_queries.py | 8 ++++++++ worker_voucher/schema.py | 7 +++---- worker_voucher/services.py | 8 ++++++++ 3 files changed, 19 insertions(+), 4 deletions(-) diff --git a/worker_voucher/gql_queries.py b/worker_voucher/gql_queries.py index fb9f46e..8427c27 100644 --- a/worker_voucher/gql_queries.py +++ b/worker_voucher/gql_queries.py @@ -101,6 +101,10 @@ class Meta: "id": ["exact"], "name": ["exact", "istartswith", "icontains", "iexact"], **prefix_filterset("policyholder__", PolicyHolderGQLType._meta.filter_fields), + + "date_created": ["exact", "lt", "lte", "gt", "gte"], + "date_updated": ["exact", "lt", "lte", "gt", "gte"], + "is_deleted": ["exact"], } connection_class = ExtendedConnection @@ -115,5 +119,9 @@ class Meta: "id": ["exact"], "insuree_id": ["exact"], **prefix_filterset("group__", GroupOfWorkerGQLType._meta.filter_fields), + + "date_created": ["exact", "lt", "lte", "gt", "gte"], + "date_updated": ["exact", "lt", "lte", "gt", "gte"], + "is_deleted": ["exact"], } connection_class = ExtendedConnection diff --git a/worker_voucher/schema.py b/worker_voucher/schema.py index 4daf139..5f4e95e 100644 --- a/worker_voucher/schema.py +++ b/worker_voucher/schema.py @@ -91,8 +91,7 @@ class Query(ExportableQueryMixin, graphene.ObjectType): group_of_worker = OrderedDjangoFilterConnectionField( GroupOfWorkerGQLType, orderBy=graphene.List(of_type=graphene.String), - is_system=graphene.Boolean(), - insuree_id=graphene.Int(), + economic_unit_code=graphene.String(), client_mutation_id=graphene.String(), ) @@ -220,7 +219,7 @@ def resolve_online_worker_data(self, info, national_id=None, economic_unit_code= photo=online_result["data"]["Photo"] ) - def resolve_group_of_worker(self, info, **kwargs): + def resolve_group_of_worker(self, info, economic_unit_code=None, **kwargs): if not info.context.user.has_perms(WorkerVoucherConfig.gql_group_of_worker_search_perms): raise PermissionError("Unauthorized") filters = [] @@ -229,7 +228,7 @@ def resolve_group_of_worker(self, info, **kwargs): if client_mutation_id: filters.append(Q(mutations__mutation__client_mutation_id=client_mutation_id)) filters.extend(get_group_worker_user_filters(info.context.user)) - return gql_optimizer.query(query.filter(*filters), info) + return gql_optimizer.query(query.filter(*filters, policyholder__code=economic_unit_code), info) @staticmethod def _check_permissions(user, perms): diff --git a/worker_voucher/services.py b/worker_voucher/services.py index 86084e8..7fb1ea5 100644 --- a/worker_voucher/services.py +++ b/worker_voucher/services.py @@ -5,6 +5,7 @@ from typing import Iterable, Dict, Union, List from uuid import uuid4 +from django.core.exceptions import ValidationError from django.db import transaction from django.db.models import Q, QuerySet, UUIDField, Count from django.db.models.functions import Cast @@ -584,6 +585,11 @@ def create_or_update(self, obj_data, eu_code): insurees = _check_insurees(insurees_chf_id, eu_code, self.user) if len(insurees_chf_id) > 0 else set() if group_id: group = GroupOfWorker.objects.get(id=group_id) + if group.name != obj_data['name']: + if GroupOfWorker.objects.filter(name=obj_data['name'], is_deleted=False).count() > 0: + raise ValidationError(_("This name for group already exists.")) + [setattr(group, k, v) for k, v in obj_data.items()] + group.save(user=self.user) if insurees is not None: worker_group_currently_assigned = WorkerGroup.objects.filter(group=group_id) worker_group_currently_assigned.delete() @@ -594,6 +600,8 @@ def create_or_update(self, obj_data, eu_code): ) worker_group.save(user=self.user) else: + if GroupOfWorker.objects.filter(name=obj_data['name'], is_deleted=False).count() > 0: + raise ValidationError(_("This name for group already exists.")) group = GroupOfWorker(**obj_data) group.save(user=self.user) if insurees: From 8276ff3b2a0d1f4761974c3b1424f93a680948db Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 12:19:47 +0200 Subject: [PATCH 07/31] OM-344: added rights for employer and admin --- .../migrations/0015_group_of_worker_rights.py | 46 +++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 worker_voucher/migrations/0015_group_of_worker_rights.py diff --git a/worker_voucher/migrations/0015_group_of_worker_rights.py b/worker_voucher/migrations/0015_group_of_worker_rights.py new file mode 100644 index 0000000..aa081e4 --- /dev/null +++ b/worker_voucher/migrations/0015_group_of_worker_rights.py @@ -0,0 +1,46 @@ +from django.db import migrations + +rights = ['205001', '205002', '205003', '205004'] +roles = ['Employer', 'IMIS Administrator'] + + +def add_rights(role_name, role_model, role_right_model): + role = role_model.objects.get(name=role_name, validity_to__isnull=True) + for right_id in rights: + if not role_right_model.objects.filter(validity_to__isnull=True, role=role, right_id=right_id).exists(): + _add_right_for_role(role, right_id, role_right_model) + + +def _add_right_for_role(role, right_id, role_right_model): + role_right_model.objects.create(role=role, right_id=right_id, audit_user_id=1) + + +def remove_rights(role_id, role_right_model): + role_right_model.objects.filter( + role__is_system=role_id, + right_id__in=rights, + validity_to__isnull=True + ).delete() + + +def on_migration(apps, schema_editor): + role_model = apps.get_model("core", "role") + role_right_model = apps.get_model("core", "roleright") + for role in roles: + add_rights(role, role_model, role_right_model) + + +def on_reverse_migration(apps, schema_editor): + role_right_model = apps.get_model("core", "roleright") + for role in roles: + remove_rights(role, role_right_model) + + +class Migration(migrations.Migration): + dependencies = [ + ('worker_voucher', '0014_alter_groupofworker_name_and_more'), + ] + + operations = [ + migrations.RunPython(on_migration, on_reverse_migration), + ] From 3a544777bbefe5ac46b4550f98ffe6331b34b8ed Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 15:12:19 +0200 Subject: [PATCH 08/31] OM-344: added test for creation of group of worker --- worker_voucher/tests/data/gql_payloads.py | 27 +++++ .../tests/test_gql_group_of_worker_create.py | 111 ++++++++++++++++++ 2 files changed, 138 insertions(+) create mode 100644 worker_voucher/tests/test_gql_group_of_worker_create.py diff --git a/worker_voucher/tests/data/gql_payloads.py b/worker_voucher/tests/data/gql_payloads.py index 02a01f3..e996f6a 100644 --- a/worker_voucher/tests/data/gql_payloads.py +++ b/worker_voucher/tests/data/gql_payloads.py @@ -73,3 +73,30 @@ } } """ + +gql_mutation_create_group_of_worker = """ +mutation addGroupOfWorker { + createOrUpdateGroupOfWorkers(input: { + insureesChfId: "%s", + economicUnitCode: "%s", + name: "%s", + clientMutationId: "%s" + }) { + clientMutationId + } +} +""" + +gql_mutation_update_group_of_worker = """ +mutation updateGroupOfWorker { + createOrUpdateGroupOfWorkers(input: { + id: "%s", + insureesChfId: "%s", + economicUnitCode: "%s", + name: "%s", + clientMutationId: "%s" + }) { + clientMutationId + } +} +""" diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py new file mode 100644 index 0000000..2acc6ad --- /dev/null +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -0,0 +1,111 @@ +from django.test import TestCase +from core.models import MutationLog, Role +from graphene import Schema +from graphene.test import Client +from core.test_helpers import create_test_interactive_user +from worker_voucher.models import GroupOfWorker, WorkerGroup +from insuree.test_helpers import generate_random_insuree_number +from insuree.apps import InsureeConfig +from worker_voucher.schema import Query, Mutation +from worker_voucher.tests.data.gql_payloads import gql_mutation_create_group_of_worker +from worker_voucher.tests.util import create_test_eu_for_user, create_test_worker + + +class GQLGroupOfWorkerCreateTestCase(TestCase): + class GQLContext: + def __init__(self, user): + self.user = user + + user = None + eu = None + chf_id = None + insurees_chf_id = None + name = None + + @classmethod + def setUpClass(cls): + super(GQLGroupOfWorkerCreateTestCase, cls).setUpClass() + role_employer = Role.objects.get(name='Employer', validity_to__isnull=True) + cls.user = create_test_interactive_user(username='VoucherTestUser1', roles=[role_employer.id]) + cls.eu = create_test_eu_for_user(cls.user) + cls.chf_id = F"{generate_random_insuree_number()}" + cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") + cls.name = 'Group Test' + cls.insurees_chf_id = [cls.chf_id] + + gql_schema = Schema( + query=Query, + mutation=Mutation + ) + + cls.gql_client = Client(gql_schema) + cls.gql_context = cls.GQLContext(cls.user) + + def test_create_group_of_worker_success(self): + InsureeConfig.reset_validation_settings() + mutation_id = "93g453h5g77h04gh35" + payload = gql_mutation_create_group_of_worker % ( + self.insurees_chf_id, + self.eu.code, + self.name, + mutation_id + ) + + _ = self.gql_client.execute(payload, context=self.gql_context) + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertFalse(mutation_log.error) + group = GroupOfWorker.objects.filter(name=self.name) + workers_group = WorkerGroup.objects.filter(group=group) + self.assertEquals(group.count(), 1) + self.assertEquals(workers_group.count(), 1) + + def test_create_group_of_worker_empty_success(self): + InsureeConfig.reset_validation_settings() + mutation_id = "39g453h5g92h74klj78" + payload = gql_mutation_create_group_of_worker % ( + [], + self.eu.code, + self.name, + mutation_id + ) + + _ = self.gql_client.execute(payload, context=self.gql_context) + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertFalse(mutation_log.error) + group = GroupOfWorker.objects.filter(name=self.name) + workers_group = WorkerGroup.objects.filter(group=group) + self.assertEquals(group.count(), 1) + self.assertEquals(workers_group.count(), 0) + + def test_create_worker_false_not_existing_economic_unit(self): + InsureeConfig.reset_validation_settings() + mutation_id = "39g453h5g92h04gh36" + payload = gql_mutation_create_group_of_worker % ( + self.insurees_chf_id, + 'NOT-EXISTS', + self.name, + mutation_id + ) + + _ = self.gql_client.execute(payload, context=self.gql_context) + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertTrue(mutation_log.error) + group = GroupOfWorker.objects.filter(name=self.name) + self.assertEquals(group.count(), 0) + + def test_create_group_of_worker_insuree_not_exist(self): + InsureeConfig.reset_validation_settings() + mutation_id = "19g453h5g92h04gh99" + national_id = F"{generate_random_insuree_number()}" + payload = gql_mutation_create_group_of_worker % ( + [national_id], + self.eu.code, + self.name, + mutation_id + ) + + _ = self.gql_client.execute(payload, context=self.gql_context) + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertTrue(mutation_log.error) + group = GroupOfWorker.objects.filter(name=self.name) + self.assertEquals(group.count(), 0) From 5fce587e75a0aa8aedddbc4e9f1614a4b3eefc12 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 15:15:43 +0200 Subject: [PATCH 09/31] OM-344: fixed test for creation of workers --- worker_voucher/tests/test_gql_group_of_worker_create.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index 2acc6ad..e4b2d31 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -31,7 +31,7 @@ def setUpClass(cls): cls.chf_id = F"{generate_random_insuree_number()}" cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") cls.name = 'Group Test' - cls.insurees_chf_id = [cls.chf_id] + cls.insurees_chf_id = [cls.existing_worker.chf_id] gql_schema = Schema( query=Query, @@ -77,7 +77,7 @@ def test_create_group_of_worker_empty_success(self): self.assertEquals(group.count(), 1) self.assertEquals(workers_group.count(), 0) - def test_create_worker_false_not_existing_economic_unit(self): + def test_create_group_of_worker_false_not_existing_economic_unit(self): InsureeConfig.reset_validation_settings() mutation_id = "39g453h5g92h04gh36" payload = gql_mutation_create_group_of_worker % ( @@ -93,7 +93,7 @@ def test_create_worker_false_not_existing_economic_unit(self): group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 0) - def test_create_group_of_worker_insuree_not_exist(self): + def test_create_group_of_worker_false_insuree_not_exist(self): InsureeConfig.reset_validation_settings() mutation_id = "19g453h5g92h04gh99" national_id = F"{generate_random_insuree_number()}" From 7f40274f5f81a86c456e25ce5fcfdf3cd11d6ee2 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 15:28:36 +0200 Subject: [PATCH 10/31] OM-344: fixed value of array not under quotation marks --- worker_voucher/tests/data/gql_payloads.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/worker_voucher/tests/data/gql_payloads.py b/worker_voucher/tests/data/gql_payloads.py index e996f6a..d1442aa 100644 --- a/worker_voucher/tests/data/gql_payloads.py +++ b/worker_voucher/tests/data/gql_payloads.py @@ -77,7 +77,7 @@ gql_mutation_create_group_of_worker = """ mutation addGroupOfWorker { createOrUpdateGroupOfWorkers(input: { - insureesChfId: "%s", + insureesChfId: %s, economicUnitCode: "%s", name: "%s", clientMutationId: "%s" @@ -91,7 +91,7 @@ mutation updateGroupOfWorker { createOrUpdateGroupOfWorkers(input: { id: "%s", - insureesChfId: "%s", + insureesChfId: %s, economicUnitCode: "%s", name: "%s", clientMutationId: "%s" From 6366493c49dc0f4e526641836a0eb09056751eef Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 15:43:18 +0200 Subject: [PATCH 11/31] OM-344: fixed create tests --- .../tests/test_gql_group_of_worker_create.py | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index e4b2d31..1e3d906 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -52,8 +52,6 @@ def test_create_group_of_worker_success(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) - mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) - self.assertFalse(mutation_log.error) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group) self.assertEquals(group.count(), 1) @@ -70,8 +68,6 @@ def test_create_group_of_worker_empty_success(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) - mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) - self.assertFalse(mutation_log.error) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group) self.assertEquals(group.count(), 1) @@ -88,8 +84,6 @@ def test_create_group_of_worker_false_not_existing_economic_unit(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) - mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) - self.assertTrue(mutation_log.error) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 0) @@ -104,8 +98,6 @@ def test_create_group_of_worker_false_insuree_not_exist(self): mutation_id ) - _ = self.gql_client.execute(payload, context=self.gql_context) - mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) - self.assertTrue(mutation_log.error) + _ = self.gql_client.execute(payload, context=self.gql_context)) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 0) From d34a0fac7db1060abc7a66dc0e0ad2848265438d Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 15:44:49 +0200 Subject: [PATCH 12/31] OM-344: fixed typo --- worker_voucher/tests/test_gql_group_of_worker_create.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index 1e3d906..c558655 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -98,6 +98,6 @@ def test_create_group_of_worker_false_insuree_not_exist(self): mutation_id ) - _ = self.gql_client.execute(payload, context=self.gql_context)) + _ = self.gql_client.execute(payload, context=self.gql_context) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 0) From 92585ca672b89880a9a4149370816ec522cbbaa2 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 16:31:03 +0200 Subject: [PATCH 13/31] OM-344: fixed worker group count --- worker_voucher/tests/test_gql_group_of_worker_create.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index c558655..c3006aa 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -53,7 +53,7 @@ def test_create_group_of_worker_success(self): _ = self.gql_client.execute(payload, context=self.gql_context) group = GroupOfWorker.objects.filter(name=self.name) - workers_group = WorkerGroup.objects.filter(group=group) + workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) self.assertEquals(workers_group.count(), 1) @@ -69,7 +69,7 @@ def test_create_group_of_worker_empty_success(self): _ = self.gql_client.execute(payload, context=self.gql_context) group = GroupOfWorker.objects.filter(name=self.name) - workers_group = WorkerGroup.objects.filter(group=group) + workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) self.assertEquals(workers_group.count(), 0) From 988af2c048ec0e236e876e6ee3364d56b849a6e1 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 16:44:02 +0200 Subject: [PATCH 14/31] OM-344: added update tests --- .../tests/test_gql_group_of_worker_create.py | 2 +- .../tests/test_gql_group_of_worker_update.py | 164 ++++++++++++++++++ worker_voucher/tests/util.py | 10 ++ 3 files changed, 175 insertions(+), 1 deletion(-) create mode 100644 worker_voucher/tests/test_gql_group_of_worker_update.py diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index c3006aa..8d6ff70 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -31,7 +31,7 @@ def setUpClass(cls): cls.chf_id = F"{generate_random_insuree_number()}" cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") cls.name = 'Group Test' - cls.insurees_chf_id = [cls.existing_worker.chf_id] + cls.insurees_chf_id = [f"{cls.existing_worker.chf_id}"] gql_schema = Schema( query=Query, diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py new file mode 100644 index 0000000..3af3967 --- /dev/null +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -0,0 +1,164 @@ +from django.test import TestCase +from core.models import MutationLog, Role +from graphene import Schema +from graphene.test import Client +from core.test_helpers import create_test_interactive_user +from worker_voucher.models import GroupOfWorker, WorkerGroup +from insuree.test_helpers import generate_random_insuree_number +from insuree.apps import InsureeConfig +from worker_voucher.schema import Query, Mutation +from worker_voucher.tests.data.gql_payloads import ( + gql_mutation_update_group_of_worker, + gql_mutation_create_group_of_worker +) +from worker_voucher.tests.util import create_test_eu_for_user, create_test_worker + + +class GQLGroupOfWorkerUpdateTestCase(TestCase): + class GQLContext: + def __init__(self, user): + self.user = user + + user = None + eu = None + chf_id = None + insurees_chf_id = None + name = None + + @classmethod + def setUpClass(cls): + super(GQLGroupOfWorkerUpdateTestCase, cls).setUpClass() + role_employer = Role.objects.get(name='Employer', validity_to__isnull=True) + cls.user = create_test_interactive_user(username='VoucherTestUser1', roles=[role_employer.id]) + cls.eu = create_test_eu_for_user(cls.user) + cls.chf_id = F"{generate_random_insuree_number()}" + cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") + cls.existing_worker2 = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") + cls.name = 'Group Test' + cls.insurees_chf_id = [ + f"{cls.existing_worker.chf_id}", + f"{cls.existing_worker2.chf_id}" + ] + + gql_schema = Schema( + query=Query, + mutation=Mutation + ) + + cls.gql_client = Client(gql_schema) + cls.gql_context = cls.GQLContext(cls.user) + cls.group = cls.create_test_group_of_worker(cls.user, cls.eu, cls.name) + + def test_update_group_of_worker_success(self): + InsureeConfig.reset_validation_settings() + mutation_id = "93g453h5g77h04gh01" + payload = gql_mutation_update_group_of_worker % ( + self.group.id, + self.insurees_chf_id, + self.eu.code, + self.name, + mutation_id + ) + + workers_group = WorkerGroup.objects.filter(group=self.group) + self.assertEquals(workers_group.count(), 0) + _ = self.gql_client.execute(payload, context=self.gql_context) + group = GroupOfWorker.objects.filter(name=self.name) + workers_group = WorkerGroup.objects.filter(group=group.first()) + self.assertEquals(group.count(), 1) + self.assertEquals(group.first().name, self.name) + self.assertEquals(workers_group.count(), 2) + + def test_update_group_of_worker_change_name_success(self): + InsureeConfig.reset_validation_settings() + mutation_id = "93g453h5g77h04gh00" + changed_name = 'ChangedName' + payload = gql_mutation_update_group_of_worker % ( + self.group.id, + [], + self.eu.code, + changed_name, + mutation_id + ) + + workers_group = WorkerGroup.objects.filter(group=self.group) + self.assertEquals(workers_group.count(), 0) + _ = self.gql_client.execute(payload, context=self.gql_context) + group = GroupOfWorker.objects.filter(name=self.name) + workers_group = WorkerGroup.objects.filter(group=group.first()) + self.assertEquals(group.count(), 1) + self.assertEquals(group.first().name, changed_name) + self.assertEquals(workers_group.count(), 0) + + def test_update_group_of_worker_remove_one_of_worker_success(self): + InsureeConfig.reset_validation_settings() + mutation_id = "93g453h5g77h04gh01" + payload = gql_mutation_create_group_of_worker % ( + self.insurees_chf_id, + self.eu.code, + self.name, + mutation_id + ) + + workers_group = WorkerGroup.objects.filter(group=self.group) + self.assertEquals(workers_group.count(), 0) + _ = self.gql_client.execute(payload, context=self.gql_context) + group = GroupOfWorker.objects.filter(name=self.name) + workers_group = WorkerGroup.objects.filter(group=group.first()) + self.assertEquals(group.count(), 1) + self.assertEquals(group.first().name, self.name) + self.assertEquals(workers_group.count(), 2) + + mutation_id = "93g453h5g77h04gh09" + payload = gql_mutation_update_group_of_worker % ( + self.group.id, + [self.existing_worker.chf_id], + self.eu.code, + self.name, + mutation_id + ) + + _ = self.gql_client.execute(payload, context=self.gql_context) + group = GroupOfWorker.objects.filter(name=self.name) + workers_group = WorkerGroup.objects.filter(group=group.first()) + self.assertEquals(group.count(), 1) + self.assertEquals(group.first().name, self.name) + self.assertEquals(workers_group.count(), 1) + self.assertEquals(workers_group.first().insuree.chf_id, self.existing_worker.chf_id) + + def test_update_group_of_worker_false_not_existing_economic_unit(self): + InsureeConfig.reset_validation_settings() + mutation_id = "39g453h5g92h04gh03" + payload = gql_mutation_update_group_of_worker % ( + self.group.id, + self.insurees_chf_id, + 'NOT-EXISTS', + self.name, + mutation_id + ) + + _ = self.gql_client.execute(payload, context=self.gql_context) + group = GroupOfWorker.objects.filter(name=self.name) + self.assertEquals(group.count(), 1) + workers_group = WorkerGroup.objects.filter(group=group.first()) + self.assertEquals(group.first().name, self.name) + self.assertEquals(workers_group.count(), 0) + + def test_update_group_of_worker_insuree_not_exist(self): + InsureeConfig.reset_validation_settings() + mutation_id = "19g453h5g92h04gh04" + national_id = F"{generate_random_insuree_number()}" + payload = gql_mutation_update_group_of_worker % ( + self.group.id, + [national_id], + self.eu.code, + self.name, + mutation_id + ) + + _ = self.gql_client.execute(payload, context=self.gql_context) + group = GroupOfWorker.objects.filter(name=self.name) + self.assertEquals(group.count(), 1) + workers_group = WorkerGroup.objects.filter(group=group.first()) + self.assertEquals(group.first().name, self.name) + self.assertEquals(workers_group.count(), 0) diff --git a/worker_voucher/tests/util.py b/worker_voucher/tests/util.py index 583f496..5787e13 100644 --- a/worker_voucher/tests/util.py +++ b/worker_voucher/tests/util.py @@ -6,6 +6,7 @@ from insuree.models import Insuree from policyholder.models import PolicyHolder, PolicyHolderUser, PolicyHolderInsuree +from worker_voucher.models import GroupOfWorker def create_test_eu(user, code='test_eu'): @@ -96,3 +97,12 @@ def __enter__(self): def __exit__(self, exc_type, exc_val, exc_tb): for key in self.original_config: setattr(self.config_class, key, self.original_config[key]) + + +def create_test_group_of_worker(user, eu, name): + group = GroupOfWorker( + name=name, + eu=eu, + ) + group.save(user=user) + return group From 6e68fee0c51dba13ae8beb00c5115410b80fcc50 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 16:54:54 +0200 Subject: [PATCH 15/31] OM-344: improved create and update tests --- worker_voucher/tests/data/gql_payloads.py | 33 +++++++++++++++-- .../tests/test_gql_group_of_worker_create.py | 13 +++---- .../tests/test_gql_group_of_worker_update.py | 35 ++++++++++--------- 3 files changed, 55 insertions(+), 26 deletions(-) diff --git a/worker_voucher/tests/data/gql_payloads.py b/worker_voucher/tests/data/gql_payloads.py index d1442aa..9d294b4 100644 --- a/worker_voucher/tests/data/gql_payloads.py +++ b/worker_voucher/tests/data/gql_payloads.py @@ -77,7 +77,7 @@ gql_mutation_create_group_of_worker = """ mutation addGroupOfWorker { createOrUpdateGroupOfWorkers(input: { - insureesChfId: %s, + insureesChfId: ["%s"], economicUnitCode: "%s", name: "%s", clientMutationId: "%s" @@ -87,11 +87,38 @@ } """ -gql_mutation_update_group_of_worker = """ +gql_mutation_create_group_of_worker_empty = """ +mutation addGroupOfWorker { + createOrUpdateGroupOfWorkers(input: { + insureesChfId: [], + economicUnitCode: "%s", + name: "%s", + clientMutationId: "%s" + }) { + clientMutationId + } +} +""" + +gql_mutation_update_group_of_worker_multiple = """ +mutation updateGroupOfWorker { + createOrUpdateGroupOfWorkers(input: { + id: "%s", + insureesChfId: ["%s", "%s"], + economicUnitCode: "%s", + name: "%s", + clientMutationId: "%s" + }) { + clientMutationId + } +} +""" + +gql_mutation_update_group_of_worker_single = """ mutation updateGroupOfWorker { createOrUpdateGroupOfWorkers(input: { id: "%s", - insureesChfId: %s, + insureesChfId: ["%s", "%s"], economicUnitCode: "%s", name: "%s", clientMutationId: "%s" diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index 8d6ff70..14e723d 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -7,7 +7,10 @@ from insuree.test_helpers import generate_random_insuree_number from insuree.apps import InsureeConfig from worker_voucher.schema import Query, Mutation -from worker_voucher.tests.data.gql_payloads import gql_mutation_create_group_of_worker +from worker_voucher.tests.data.gql_payloads import ( + gql_mutation_create_group_of_worker, + gql_mutation_create_group_of_worker_empty +) from worker_voucher.tests.util import create_test_eu_for_user, create_test_worker @@ -31,7 +34,6 @@ def setUpClass(cls): cls.chf_id = F"{generate_random_insuree_number()}" cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") cls.name = 'Group Test' - cls.insurees_chf_id = [f"{cls.existing_worker.chf_id}"] gql_schema = Schema( query=Query, @@ -45,7 +47,7 @@ def test_create_group_of_worker_success(self): InsureeConfig.reset_validation_settings() mutation_id = "93g453h5g77h04gh35" payload = gql_mutation_create_group_of_worker % ( - self.insurees_chf_id, + self.existing_worker.chf_id, self.eu.code, self.name, mutation_id @@ -60,8 +62,7 @@ def test_create_group_of_worker_success(self): def test_create_group_of_worker_empty_success(self): InsureeConfig.reset_validation_settings() mutation_id = "39g453h5g92h74klj78" - payload = gql_mutation_create_group_of_worker % ( - [], + payload = gql_mutation_create_group_of_worker_empty % ( self.eu.code, self.name, mutation_id @@ -92,7 +93,7 @@ def test_create_group_of_worker_false_insuree_not_exist(self): mutation_id = "19g453h5g92h04gh99" national_id = F"{generate_random_insuree_number()}" payload = gql_mutation_create_group_of_worker % ( - [national_id], + national_id, self.eu.code, self.name, mutation_id diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index 3af3967..3157c63 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -8,8 +8,8 @@ from insuree.apps import InsureeConfig from worker_voucher.schema import Query, Mutation from worker_voucher.tests.data.gql_payloads import ( - gql_mutation_update_group_of_worker, - gql_mutation_create_group_of_worker + gql_mutation_update_group_of_worker_single, + gql_mutation_update_group_of_worker_multiple ) from worker_voucher.tests.util import create_test_eu_for_user, create_test_worker @@ -35,10 +35,6 @@ def setUpClass(cls): cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") cls.existing_worker2 = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") cls.name = 'Group Test' - cls.insurees_chf_id = [ - f"{cls.existing_worker.chf_id}", - f"{cls.existing_worker2.chf_id}" - ] gql_schema = Schema( query=Query, @@ -52,8 +48,10 @@ def setUpClass(cls): def test_update_group_of_worker_success(self): InsureeConfig.reset_validation_settings() mutation_id = "93g453h5g77h04gh01" - payload = gql_mutation_update_group_of_worker % ( + payload = gql_mutation_update_group_of_worker_multiple % ( self.group.id, + self.existing_worker.chf_id, + self.existing_worker2.chf_id, self.insurees_chf_id, self.eu.code, self.name, @@ -73,9 +71,10 @@ def test_update_group_of_worker_change_name_success(self): InsureeConfig.reset_validation_settings() mutation_id = "93g453h5g77h04gh00" changed_name = 'ChangedName' - payload = gql_mutation_update_group_of_worker % ( + payload = gql_mutation_update_group_of_worker_multiple % ( self.group.id, - [], + self.existing_worker.chf_id, + self.existing_worker2.chf_id, self.eu.code, changed_name, mutation_id @@ -93,8 +92,10 @@ def test_update_group_of_worker_change_name_success(self): def test_update_group_of_worker_remove_one_of_worker_success(self): InsureeConfig.reset_validation_settings() mutation_id = "93g453h5g77h04gh01" - payload = gql_mutation_create_group_of_worker % ( - self.insurees_chf_id, + payload = gql_mutation_update_group_of_worker_multiple % ( + self.group.id, + self.existing_worker.chf_id, + self.existing_worker2.chf_id, self.eu.code, self.name, mutation_id @@ -110,9 +111,9 @@ def test_update_group_of_worker_remove_one_of_worker_success(self): self.assertEquals(workers_group.count(), 2) mutation_id = "93g453h5g77h04gh09" - payload = gql_mutation_update_group_of_worker % ( + payload = gql_mutation_update_group_of_worker_single % ( self.group.id, - [self.existing_worker.chf_id], + self.existing_worker.chf_id, self.eu.code, self.name, mutation_id @@ -129,9 +130,9 @@ def test_update_group_of_worker_remove_one_of_worker_success(self): def test_update_group_of_worker_false_not_existing_economic_unit(self): InsureeConfig.reset_validation_settings() mutation_id = "39g453h5g92h04gh03" - payload = gql_mutation_update_group_of_worker % ( + payload = gql_mutation_update_group_of_worker_single % ( self.group.id, - self.insurees_chf_id, + self.existing_worker.chf_id, 'NOT-EXISTS', self.name, mutation_id @@ -148,9 +149,9 @@ def test_update_group_of_worker_insuree_not_exist(self): InsureeConfig.reset_validation_settings() mutation_id = "19g453h5g92h04gh04" national_id = F"{generate_random_insuree_number()}" - payload = gql_mutation_update_group_of_worker % ( + payload = gql_mutation_update_group_of_worker_single % ( self.group.id, - [national_id], + national_id, self.eu.code, self.name, mutation_id From 3cd49c844d373838b45e603ec9b8404c57a93384 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 17:16:17 +0200 Subject: [PATCH 16/31] OM-344: fixed tests --- worker_voucher/tests/test_gql_group_of_worker_create.py | 7 +++---- worker_voucher/tests/test_gql_group_of_worker_update.py | 7 +++---- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index 14e723d..5c08046 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -22,15 +22,14 @@ def __init__(self, user): user = None eu = None chf_id = None - insurees_chf_id = None name = None @classmethod def setUpClass(cls): super(GQLGroupOfWorkerCreateTestCase, cls).setUpClass() role_employer = Role.objects.get(name='Employer', validity_to__isnull=True) - cls.user = create_test_interactive_user(username='VoucherTestUser1', roles=[role_employer.id]) - cls.eu = create_test_eu_for_user(cls.user) + cls.user = create_test_interactive_user(username='VoucherTestUser2', roles=[role_employer.id]) + cls.eu = create_test_eu_for_user(cls.user, code='test_eu2') cls.chf_id = F"{generate_random_insuree_number()}" cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") cls.name = 'Group Test' @@ -78,7 +77,7 @@ def test_create_group_of_worker_false_not_existing_economic_unit(self): InsureeConfig.reset_validation_settings() mutation_id = "39g453h5g92h04gh36" payload = gql_mutation_create_group_of_worker % ( - self.insurees_chf_id, + self.chf_id, 'NOT-EXISTS', self.name, mutation_id diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index 3157c63..082753b 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -29,12 +29,12 @@ def __init__(self, user): def setUpClass(cls): super(GQLGroupOfWorkerUpdateTestCase, cls).setUpClass() role_employer = Role.objects.get(name='Employer', validity_to__isnull=True) - cls.user = create_test_interactive_user(username='VoucherTestUser1', roles=[role_employer.id]) - cls.eu = create_test_eu_for_user(cls.user) + cls.user = create_test_interactive_user(username='VoucherTestUser3', roles=[role_employer.id]) + cls.eu = create_test_eu_for_user(cls.user, code='test_eu3') cls.chf_id = F"{generate_random_insuree_number()}" cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") cls.existing_worker2 = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") - cls.name = 'Group Test' + cls.name = 'Group Test Update' gql_schema = Schema( query=Query, @@ -52,7 +52,6 @@ def test_update_group_of_worker_success(self): self.group.id, self.existing_worker.chf_id, self.existing_worker2.chf_id, - self.insurees_chf_id, self.eu.code, self.name, mutation_id From 183ee8d8dadf85b9396fff5ee67cd55bebd6da74 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 17:23:46 +0200 Subject: [PATCH 17/31] OM-344: fixed update test import --- worker_voucher/tests/test_gql_group_of_worker_update.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index 082753b..d76f28d 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -11,7 +11,11 @@ gql_mutation_update_group_of_worker_single, gql_mutation_update_group_of_worker_multiple ) -from worker_voucher.tests.util import create_test_eu_for_user, create_test_worker +from worker_voucher.tests.util import ( + create_test_eu_for_user, + create_test_worker, + create_test_group_of_worker +) class GQLGroupOfWorkerUpdateTestCase(TestCase): @@ -43,7 +47,7 @@ def setUpClass(cls): cls.gql_client = Client(gql_schema) cls.gql_context = cls.GQLContext(cls.user) - cls.group = cls.create_test_group_of_worker(cls.user, cls.eu, cls.name) + cls.group = create_test_group_of_worker(cls.user, cls.eu, cls.name) def test_update_group_of_worker_success(self): InsureeConfig.reset_validation_settings() From 6526a1e7ee87b65557de26297fc19b2ad1acb9d8 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 17:31:01 +0200 Subject: [PATCH 18/31] OM-344: fixed utils test helper for group of workers --- worker_voucher/tests/util.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/worker_voucher/tests/util.py b/worker_voucher/tests/util.py index 5787e13..7b8d98e 100644 --- a/worker_voucher/tests/util.py +++ b/worker_voucher/tests/util.py @@ -102,7 +102,7 @@ def __exit__(self, exc_type, exc_val, exc_tb): def create_test_group_of_worker(user, eu, name): group = GroupOfWorker( name=name, - eu=eu, + policyholder=eu, ) group.save(user=user) return group From e7945c835d2c7fb570f36b6168c5a1cb99630ca2 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 17:45:19 +0200 Subject: [PATCH 19/31] OM-344: fixed utils test helper for group of workers part 2 --- worker_voucher/tests/data/gql_payloads.py | 2 +- worker_voucher/tests/test_gql_group_of_worker_create.py | 6 +++++- worker_voucher/tests/test_gql_group_of_worker_update.py | 9 ++++++++- 3 files changed, 14 insertions(+), 3 deletions(-) diff --git a/worker_voucher/tests/data/gql_payloads.py b/worker_voucher/tests/data/gql_payloads.py index 9d294b4..cb2e71a 100644 --- a/worker_voucher/tests/data/gql_payloads.py +++ b/worker_voucher/tests/data/gql_payloads.py @@ -118,7 +118,7 @@ mutation updateGroupOfWorker { createOrUpdateGroupOfWorkers(input: { id: "%s", - insureesChfId: ["%s", "%s"], + insureesChfId: ["%s"], economicUnitCode: "%s", name: "%s", clientMutationId: "%s" diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index 5c08046..8c984a3 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -51,9 +51,13 @@ def test_create_group_of_worker_success(self): self.name, mutation_id ) - + print(payload) _ = self.gql_client.execute(payload, context=self.gql_context) + print(_) + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + print(mutation_log) group = GroupOfWorker.objects.filter(name=self.name) + print(group) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) self.assertEquals(workers_group.count(), 1) diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index d76f28d..f855547 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -82,10 +82,13 @@ def test_update_group_of_worker_change_name_success(self): changed_name, mutation_id ) - + print(payload) workers_group = WorkerGroup.objects.filter(group=self.group) self.assertEquals(workers_group.count(), 0) _ = self.gql_client.execute(payload, context=self.gql_context) + print(_) + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + print(mutation_log) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -107,6 +110,8 @@ def test_update_group_of_worker_remove_one_of_worker_success(self): workers_group = WorkerGroup.objects.filter(group=self.group) self.assertEquals(workers_group.count(), 0) _ = self.gql_client.execute(payload, context=self.gql_context) + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + print(mutation_log) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -123,6 +128,8 @@ def test_update_group_of_worker_remove_one_of_worker_success(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + print(mutation_log) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) From 621de8142b6b6920e0645dffa144ca8a082a7b4c Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 18:03:49 +0200 Subject: [PATCH 20/31] OM-344: fixed utils test helper for group of workers part 3 --- worker_voucher/tests/test_gql_group_of_worker_create.py | 2 ++ worker_voucher/tests/test_gql_group_of_worker_update.py | 6 ++++++ 2 files changed, 8 insertions(+) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index 8c984a3..bb14c7e 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -56,6 +56,8 @@ def test_create_group_of_worker_success(self): print(_) mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) print(mutation_log) + print(mutation_log.error) + print(mutation_log.status) group = GroupOfWorker.objects.filter(name=self.name) print(group) workers_group = WorkerGroup.objects.filter(group=group.first()) diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index f855547..623c590 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -89,6 +89,8 @@ def test_update_group_of_worker_change_name_success(self): print(_) mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) print(mutation_log) + print(mutation_log.error) + print(mutation_log.status) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -112,6 +114,8 @@ def test_update_group_of_worker_remove_one_of_worker_success(self): _ = self.gql_client.execute(payload, context=self.gql_context) mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) print(mutation_log) + print(mutation_log.error) + print(mutation_log.status) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -130,6 +134,8 @@ def test_update_group_of_worker_remove_one_of_worker_success(self): _ = self.gql_client.execute(payload, context=self.gql_context) mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) print(mutation_log) + print(mutation_log.error) + print(mutation_log.status) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) From 134a86b70f9c10d369d2cfafdc2221e3d9b5dd0b Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 18:15:26 +0200 Subject: [PATCH 21/31] OM-344: fixed utils test helper for group of workers part 4 --- worker_voucher/tests/test_gql_group_of_worker_create.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index bb14c7e..d2515c1 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -32,6 +32,7 @@ def setUpClass(cls): cls.eu = create_test_eu_for_user(cls.user, code='test_eu2') cls.chf_id = F"{generate_random_insuree_number()}" cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") + print(cls.existing_worker, 'xxxxxx') cls.name = 'Group Test' gql_schema = Schema( @@ -45,6 +46,7 @@ def setUpClass(cls): def test_create_group_of_worker_success(self): InsureeConfig.reset_validation_settings() mutation_id = "93g453h5g77h04gh35" + print(self.existing_worker, 'yyyyy') payload = gql_mutation_create_group_of_worker % ( self.existing_worker.chf_id, self.eu.code, From 55cf8929e3c378ce610ce0bbbcb591a1c9047b4a Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 18:17:00 +0200 Subject: [PATCH 22/31] OM-344: added missing properties in test class --- worker_voucher/tests/test_gql_group_of_worker_create.py | 1 + worker_voucher/tests/test_gql_group_of_worker_update.py | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index d2515c1..cb9e5cb 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -23,6 +23,7 @@ def __init__(self, user): eu = None chf_id = None name = None + existing_worker = None @classmethod def setUpClass(cls): diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index 623c590..cb4a2b6 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -26,8 +26,9 @@ def __init__(self, user): user = None eu = None chf_id = None - insurees_chf_id = None name = None + existing_worker = None + existing_worker2 = None @classmethod def setUpClass(cls): From 41f8e02462925be5a4548bac46239046f54bc842 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 18:18:13 +0200 Subject: [PATCH 23/31] OM-344: added missing properties in test class - group --- worker_voucher/tests/test_gql_group_of_worker_update.py | 1 + 1 file changed, 1 insertion(+) diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index cb4a2b6..f0b0e5e 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -29,6 +29,7 @@ def __init__(self, user): name = None existing_worker = None existing_worker2 = None + group = None @classmethod def setUpClass(cls): From ed4680b1fb2e958c67fa351bd2ef16411938ec57 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 18:31:07 +0200 Subject: [PATCH 24/31] OM-344: added relationship with EU in test helpers --- worker_voucher/tests/test_gql_group_of_worker_create.py | 7 +++++-- worker_voucher/tests/test_gql_group_of_worker_update.py | 6 +++--- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index cb9e5cb..2d0135f 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -11,7 +11,10 @@ gql_mutation_create_group_of_worker, gql_mutation_create_group_of_worker_empty ) -from worker_voucher.tests.util import create_test_eu_for_user, create_test_worker +from worker_voucher.tests.util import ( + create_test_eu_for_user, + create_test_worker_for_eu +) class GQLGroupOfWorkerCreateTestCase(TestCase): @@ -32,7 +35,7 @@ def setUpClass(cls): cls.user = create_test_interactive_user(username='VoucherTestUser2', roles=[role_employer.id]) cls.eu = create_test_eu_for_user(cls.user, code='test_eu2') cls.chf_id = F"{generate_random_insuree_number()}" - cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") + cls.existing_worker = create_test_worker_for_eu(cls.user, cls.eu, chf_id=F"{generate_random_insuree_number()}") print(cls.existing_worker, 'xxxxxx') cls.name = 'Group Test' diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index f0b0e5e..6d454fd 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -13,7 +13,7 @@ ) from worker_voucher.tests.util import ( create_test_eu_for_user, - create_test_worker, + create_test_worker_for_eu, create_test_group_of_worker ) @@ -38,8 +38,8 @@ def setUpClass(cls): cls.user = create_test_interactive_user(username='VoucherTestUser3', roles=[role_employer.id]) cls.eu = create_test_eu_for_user(cls.user, code='test_eu3') cls.chf_id = F"{generate_random_insuree_number()}" - cls.existing_worker = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") - cls.existing_worker2 = create_test_worker(cls.user, chf_id=F"{generate_random_insuree_number()}") + cls.existing_worker = create_test_worker_for_eu(cls.user, cls.eu, chf_id=F"{generate_random_insuree_number()}") + cls.existing_worker2 = create_test_worker_for_eu(cls.user, cls.eu, chf_id=F"{generate_random_insuree_number()}") cls.name = 'Group Test Update' gql_schema = Schema( From d2ce5123199fbda7e021e591e6eb882d90c4e321 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 18:47:53 +0200 Subject: [PATCH 25/31] OM-344: cleaned code after debugging and checks --- .../tests/test_gql_group_of_worker_create.py | 9 --------- .../tests/test_gql_group_of_worker_update.py | 14 -------------- 2 files changed, 23 deletions(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index 2d0135f..6540059 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -36,7 +36,6 @@ def setUpClass(cls): cls.eu = create_test_eu_for_user(cls.user, code='test_eu2') cls.chf_id = F"{generate_random_insuree_number()}" cls.existing_worker = create_test_worker_for_eu(cls.user, cls.eu, chf_id=F"{generate_random_insuree_number()}") - print(cls.existing_worker, 'xxxxxx') cls.name = 'Group Test' gql_schema = Schema( @@ -50,22 +49,14 @@ def setUpClass(cls): def test_create_group_of_worker_success(self): InsureeConfig.reset_validation_settings() mutation_id = "93g453h5g77h04gh35" - print(self.existing_worker, 'yyyyy') payload = gql_mutation_create_group_of_worker % ( self.existing_worker.chf_id, self.eu.code, self.name, mutation_id ) - print(payload) _ = self.gql_client.execute(payload, context=self.gql_context) - print(_) - mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) - print(mutation_log) - print(mutation_log.error) - print(mutation_log.status) group = GroupOfWorker.objects.filter(name=self.name) - print(group) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) self.assertEquals(workers_group.count(), 1) diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index 6d454fd..92c988e 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -84,15 +84,9 @@ def test_update_group_of_worker_change_name_success(self): changed_name, mutation_id ) - print(payload) workers_group = WorkerGroup.objects.filter(group=self.group) self.assertEquals(workers_group.count(), 0) _ = self.gql_client.execute(payload, context=self.gql_context) - print(_) - mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) - print(mutation_log) - print(mutation_log.error) - print(mutation_log.status) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -114,10 +108,6 @@ def test_update_group_of_worker_remove_one_of_worker_success(self): workers_group = WorkerGroup.objects.filter(group=self.group) self.assertEquals(workers_group.count(), 0) _ = self.gql_client.execute(payload, context=self.gql_context) - mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) - print(mutation_log) - print(mutation_log.error) - print(mutation_log.status) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -134,10 +124,6 @@ def test_update_group_of_worker_remove_one_of_worker_success(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) - mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) - print(mutation_log) - print(mutation_log.error) - print(mutation_log.status) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) From 9a93d6016babce370dadffe1bc6e6c2131417200 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 19:00:59 +0200 Subject: [PATCH 26/31] OM-344: fixed update name test --- .../tests/test_gql_group_of_worker_create.py | 15 +++++++++++++++ .../tests/test_gql_group_of_worker_update.py | 17 ++++++++++++++++- 2 files changed, 31 insertions(+), 1 deletion(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index 6540059..1c38c7d 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -56,6 +56,7 @@ def test_create_group_of_worker_success(self): mutation_id ) _ = self.gql_client.execute(payload, context=self.gql_context) + self._assert_mutation_success(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -71,6 +72,7 @@ def test_create_group_of_worker_empty_success(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) + self._assert_mutation_success(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -87,6 +89,7 @@ def test_create_group_of_worker_false_not_existing_economic_unit(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) + self._assert_mutation_false(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 0) @@ -102,5 +105,17 @@ def test_create_group_of_worker_false_insuree_not_exist(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) + self._assert_mutation_false(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 0) + + + def _assert_mutation_success(self, mutation_id): + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertEquals(mutation_log.status, 2) + self.assertFalse(mutation_log.error) + + def _assert_mutation_failed(self, mutation_id): + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertEquals(mutation_log.status, 1) + self.assertTrue(mutation_log.error) diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index 92c988e..ea3d7cf 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -66,6 +66,7 @@ def test_update_group_of_worker_success(self): workers_group = WorkerGroup.objects.filter(group=self.group) self.assertEquals(workers_group.count(), 0) _ = self.gql_client.execute(payload, context=self.gql_context) + self._assert_mutation_success(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -87,7 +88,8 @@ def test_update_group_of_worker_change_name_success(self): workers_group = WorkerGroup.objects.filter(group=self.group) self.assertEquals(workers_group.count(), 0) _ = self.gql_client.execute(payload, context=self.gql_context) - group = GroupOfWorker.objects.filter(name=self.name) + self._assert_mutation_success(mutation_id) + group = GroupOfWorker.objects.filter(name=changed_name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) self.assertEquals(group.first().name, changed_name) @@ -124,6 +126,7 @@ def test_update_group_of_worker_remove_one_of_worker_success(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) + self._assert_mutation_success(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) @@ -143,6 +146,7 @@ def test_update_group_of_worker_false_not_existing_economic_unit(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) + self._assert_mutation_false(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 1) workers_group = WorkerGroup.objects.filter(group=group.first()) @@ -162,8 +166,19 @@ def test_update_group_of_worker_insuree_not_exist(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) + self._assert_mutation_false(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 1) workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.first().name, self.name) self.assertEquals(workers_group.count(), 0) + + def _assert_mutation_success(self, mutation_id): + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertEquals(mutation_log.status, 2) + self.assertFalse(mutation_log.error) + + def _assert_mutation_failed(self, mutation_id): + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertEquals(mutation_log.status, 1) + self.assertTrue(mutation_log.error) From 3c6a1157e8f119c1628ba71e03a58a8b1b2d9986 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 19:26:03 +0200 Subject: [PATCH 27/31] OM-344: added tests for delete --- worker_voucher/tests/data/gql_payloads.py | 12 ++ .../tests/test_gql_group_of_worker_create.py | 5 +- .../tests/test_gql_group_of_worker_delete.py | 108 ++++++++++++++++++ .../tests/test_gql_group_of_worker_update.py | 6 +- worker_voucher/tests/util.py | 11 +- 5 files changed, 135 insertions(+), 7 deletions(-) create mode 100644 worker_voucher/tests/test_gql_group_of_worker_delete.py diff --git a/worker_voucher/tests/data/gql_payloads.py b/worker_voucher/tests/data/gql_payloads.py index cb2e71a..d2ebab0 100644 --- a/worker_voucher/tests/data/gql_payloads.py +++ b/worker_voucher/tests/data/gql_payloads.py @@ -127,3 +127,15 @@ } } """ + +gql_mutation_group_of_worker_delete = """ +mutation deleteGroupOfWorker { + deleteGroupOfWorkers(input: { + uuid: "%s" + economicUnitCode: "%s" + clientMutationId: "%s" + }) { + clientMutationId + } +} +""" diff --git a/worker_voucher/tests/test_gql_group_of_worker_create.py b/worker_voucher/tests/test_gql_group_of_worker_create.py index 1c38c7d..283a27d 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_create.py +++ b/worker_voucher/tests/test_gql_group_of_worker_create.py @@ -89,7 +89,7 @@ def test_create_group_of_worker_false_not_existing_economic_unit(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) - self._assert_mutation_false(mutation_id) + self._assert_mutation_failed(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 0) @@ -105,11 +105,10 @@ def test_create_group_of_worker_false_insuree_not_exist(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) - self._assert_mutation_false(mutation_id) + self._assert_mutation_failed(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 0) - def _assert_mutation_success(self, mutation_id): mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) self.assertEquals(mutation_log.status, 2) diff --git a/worker_voucher/tests/test_gql_group_of_worker_delete.py b/worker_voucher/tests/test_gql_group_of_worker_delete.py new file mode 100644 index 0000000..7f828a8 --- /dev/null +++ b/worker_voucher/tests/test_gql_group_of_worker_delete.py @@ -0,0 +1,108 @@ +from uuid import uuid4 + +from django.test import TestCase +from core.models import MutationLog, Role +from graphene import Schema +from graphene.test import Client +from core.test_helpers import create_test_interactive_user +from insuree.test_helpers import generate_random_insuree_number +from insuree.apps import InsureeConfig +from worker_voucher.schema import Query, Mutation +from worker_voucher.tests.data.gql_payloads import gql_mutation_group_of_worker_delete +from worker_voucher.tests.util import ( + create_test_eu_for_user, + create_test_worker_for_eu, + create_test_group_of_worker, + create_test_worker_group +) +from worker_voucher.models import GroupOfWorker, WorkerGroup + + +class GQLGroupOfWorkerDeleteTestCase(TestCase): + class GQLContext: + def __init__(self, user): + self.user = user + + user = None + user2 = None + eu = None + existing_worker = None + existing_worker2 = None + existing_worker3 = None + group = None + + @classmethod + def setUpClass(cls): + super(GQLGroupOfWorkerDeleteTestCase, cls).setUpClass() + role_employer = Role.objects.get(name='Employer', validity_to__isnull=True) + cls.user = create_test_interactive_user(username='VoucherTestUser4', roles=[role_employer.id]) + cls.eu = create_test_eu_for_user(cls.user, code="ECTest2") + cls.existing_worker = create_test_worker_for_eu(cls.user, cls.eu, chf_id=F"{generate_random_insuree_number()}") + cls.existing_worker2 = create_test_worker_for_eu(cls.user, cls.eu, chf_id=F"{generate_random_insuree_number()}") + cls.existing_worker3 = create_test_worker_for_eu(cls.user, cls.eu, chf_id=F"{generate_random_insuree_number()}") + cls.name = 'Test Group to Delete' + gql_schema = Schema( + query=Query, + mutation=Mutation + ) + + cls.gql_client = Client(gql_schema) + cls.gql_context = cls.GQLContext(cls.user) + cls.group = create_test_group_of_worker(cls.user, cls.eu, cls.name) + create_test_worker_group(cls.user, cls.existing_worker, cls.group) + create_test_worker_group(cls.user, cls.existing_worker2, cls.group) + create_test_worker_group(cls.user, cls.existing_worker3, cls.group) + + def test_delete_group_of_worker_success(self): + InsureeConfig.reset_validation_settings() + group = GroupOfWorker.objects.filter(id=self.group.id, is_deleted=False) + workers_group = WorkerGroup.objects.filter(group__id=self.group.id) + self.assertEquals(group.count(), 1) + self.assertEquals(workers_group.count(), 3) + + mutation_id = uuid4() + mutation = gql_mutation_group_of_worker_delete % ( + self.group.uuid, + self.eu.code, + mutation_id + ) + + self.gql_client.execute(mutation, context=self.gql_context) + self._assert_mutation_success(mutation_id) + + group = GroupOfWorker.objects.filter(id=self.group.id, is_deleted=False) + workers_group = WorkerGroup.objects.filter(group__id=self.group.id) + self.assertEquals(group.count(), 0) + self.assertEquals(workers_group.count(), 0) + + def test_delete_worker_failed_economic_unit_not_exist(self): + InsureeConfig.reset_validation_settings() + group = GroupOfWorker.objects.filter(id=self.group.id, is_deleted=False) + workers_group = WorkerGroup.objects.filter(group__id=self.group.id) + self.assertEquals(group.count(), 1) + self.assertEquals(workers_group.count(), 3) + + mutation_id = uuid4() + mutation = gql_mutation_group_of_worker_delete % ( + self.worker.uuid, + 'NOT-EXIST', + mutation_id + ) + + self.gql_client.execute(mutation, context=self.gql_context2) + self._assert_mutation_failed(mutation_id) + + group = GroupOfWorker.objects.filter(id=self.group.id, is_deleted=False) + workers_group = WorkerGroup.objects.filter(group__id=self.group.id) + self.assertEquals(group.count(), 1) + self.assertEquals(workers_group.count(), 3) + + def _assert_mutation_success(self, mutation_id): + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertEquals(mutation_log.status, 2) + self.assertFalse(mutation_log.error) + + def _assert_mutation_failed(self, mutation_id): + mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) + self.assertEquals(mutation_log.status, 1) + self.assertTrue(mutation_log.error) diff --git a/worker_voucher/tests/test_gql_group_of_worker_update.py b/worker_voucher/tests/test_gql_group_of_worker_update.py index ea3d7cf..c21177f 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_update.py +++ b/worker_voucher/tests/test_gql_group_of_worker_update.py @@ -93,7 +93,7 @@ def test_update_group_of_worker_change_name_success(self): workers_group = WorkerGroup.objects.filter(group=group.first()) self.assertEquals(group.count(), 1) self.assertEquals(group.first().name, changed_name) - self.assertEquals(workers_group.count(), 0) + self.assertEquals(workers_group.count(), 2) def test_update_group_of_worker_remove_one_of_worker_success(self): InsureeConfig.reset_validation_settings() @@ -146,7 +146,7 @@ def test_update_group_of_worker_false_not_existing_economic_unit(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) - self._assert_mutation_false(mutation_id) + self._assert_mutation_failed(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 1) workers_group = WorkerGroup.objects.filter(group=group.first()) @@ -166,7 +166,7 @@ def test_update_group_of_worker_insuree_not_exist(self): ) _ = self.gql_client.execute(payload, context=self.gql_context) - self._assert_mutation_false(mutation_id) + self._assert_mutation_failed(mutation_id) group = GroupOfWorker.objects.filter(name=self.name) self.assertEquals(group.count(), 1) workers_group = WorkerGroup.objects.filter(group=group.first()) diff --git a/worker_voucher/tests/util.py b/worker_voucher/tests/util.py index 7b8d98e..2ff6352 100644 --- a/worker_voucher/tests/util.py +++ b/worker_voucher/tests/util.py @@ -6,7 +6,7 @@ from insuree.models import Insuree from policyholder.models import PolicyHolder, PolicyHolderUser, PolicyHolderInsuree -from worker_voucher.models import GroupOfWorker +from worker_voucher.models import GroupOfWorker, WorkerGroup def create_test_eu(user, code='test_eu'): @@ -106,3 +106,12 @@ def create_test_group_of_worker(user, eu, name): ) group.save(user=user) return group + + +def create_test_worker_group(user, insuree, group): + worker_group = WorkerGroup( + group=group, + insuree=insuree, + ) + worker_group.save(user=user) + return worker_group From b3eb05d521a50e21bad92e0666377b45082938d6 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 19:32:55 +0200 Subject: [PATCH 28/31] OM-344: fixed delete tests --- worker_voucher/tests/test_gql_group_of_worker_delete.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_delete.py b/worker_voucher/tests/test_gql_group_of_worker_delete.py index 7f828a8..9466958 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_delete.py +++ b/worker_voucher/tests/test_gql_group_of_worker_delete.py @@ -84,7 +84,7 @@ def test_delete_worker_failed_economic_unit_not_exist(self): mutation_id = uuid4() mutation = gql_mutation_group_of_worker_delete % ( - self.worker.uuid, + self.group.uuid, 'NOT-EXIST', mutation_id ) From bcd701c8762454d8a0bf39cc908dfb676666bc23 Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 19:38:37 +0200 Subject: [PATCH 29/31] OM-344: removing prints --- worker_voucher/services.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/worker_voucher/services.py b/worker_voucher/services.py index 7fb1ea5..15d6322 100644 --- a/worker_voucher/services.py +++ b/worker_voucher/services.py @@ -646,12 +646,10 @@ def delete(self, group_id, eu_uuid): group__policyholder__is_deleted=False, is_deleted=False, ) - print(worker_group) worker_group.delete() gow.delete(user=self.user) return [] except Exception as exc: - print(exc) return output_exception(model_name=self.OBJECT_TYPE.__name__, method="delete", exception=exc) From 1d3c6390903f8816ae2a1bd34de46d536f96af7e Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Fri, 18 Oct 2024 19:43:49 +0200 Subject: [PATCH 30/31] OM-344: added additional test in delete to increase coverage --- .../tests/test_gql_group_of_worker_delete.py | 29 ++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/worker_voucher/tests/test_gql_group_of_worker_delete.py b/worker_voucher/tests/test_gql_group_of_worker_delete.py index 9466958..27be27a 100644 --- a/worker_voucher/tests/test_gql_group_of_worker_delete.py +++ b/worker_voucher/tests/test_gql_group_of_worker_delete.py @@ -89,13 +89,40 @@ def test_delete_worker_failed_economic_unit_not_exist(self): mutation_id ) - self.gql_client.execute(mutation, context=self.gql_context2) + self.gql_client.execute(mutation, context=self.gql_context) + self._assert_mutation_failed(mutation_id) + + group = GroupOfWorker.objects.filter(id=self.group.id, is_deleted=False) + workers_group = WorkerGroup.objects.filter(group__id=self.group.id) + self.assertEquals(group.count(), 1) + self.assertEquals(workers_group.count(), 3) + + def test_delete_worker_failed_no_group_not_exist(self): + InsureeConfig.reset_validation_settings() + group = GroupOfWorker.objects.filter(id=self.group.id, is_deleted=False) + workers_group = WorkerGroup.objects.filter(group__id=self.group.id) + self.assertEquals(group.count(), 1) + self.assertEquals(workers_group.count(), 3) + uuid_group_not_exist = "b47356b5-1423-4ca6-99e8-3b4b4642a640" + group2 = GroupOfWorker.objects.filter(id=uuid_group_not_exist, is_deleted=False) + self.assertEquals(group2.count(), 0) + + mutation_id = uuid4() + mutation = gql_mutation_group_of_worker_delete % ( + uuid_group_not_exist, + self.eu.code, + mutation_id + ) + + self.gql_client.execute(mutation, context=self.gql_context) self._assert_mutation_failed(mutation_id) group = GroupOfWorker.objects.filter(id=self.group.id, is_deleted=False) workers_group = WorkerGroup.objects.filter(group__id=self.group.id) self.assertEquals(group.count(), 1) self.assertEquals(workers_group.count(), 3) + group2 = GroupOfWorker.objects.filter(id=uuid_group_not_exist, is_deleted=False) + self.assertEquals(group2.count(), 0) def _assert_mutation_success(self, mutation_id): mutation_log = MutationLog.objects.get(client_mutation_id=mutation_id) From b806958b64941e4400704d1e92dc855d29e7a4ae Mon Sep 17 00:00:00 2001 From: sniedzielski Date: Mon, 21 Oct 2024 20:18:05 +0200 Subject: [PATCH 31/31] OM-344: fixed broken test by adjusting assigned date --- worker_voucher/services.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/worker_voucher/services.py b/worker_voucher/services.py index 15d6322..9992f17 100644 --- a/worker_voucher/services.py +++ b/worker_voucher/services.py @@ -66,7 +66,7 @@ def get_voucher_worker_enquire_filters(national_id: str) -> Iterable[Q]: policyholder__is_deleted=False, is_deleted=False, status=WorkerVoucher.Status.ASSIGNED, - assigned_date=today, + assigned_date__date=today, expiry_date__gte=today, )]