private async Task <SuccessOrError <Unit> > HandleInternal(PatchConferenceRequest request,
                                                                   CancellationToken cancellationToken)
        {
            var(conferenceId, patch) = request;

            cancellationToken.ThrowIfCancellationRequested();

            var conference = await _conferenceRepo.FindById(conferenceId);

            if (conference == null)
            {
                return(ConferenceError.ConferenceNotFound);
            }

            var config = ConferenceData.FromConference(conference);

            try
            {
                patch.ApplyTo(config);
            }
            catch (Exception e)
            {
                _logger.LogWarning(e, "Json patch failed for conference {conferenceId}", conference.ConferenceId);
                return(new FieldValidationError("patch", "An error occurred applying the json patch"));
            }

            var validationResult = new ConferenceDataValidator().Validate(config);

            if (!validationResult.IsValid)
            {
                return(validationResult.ToError());
            }

            conference.Configuration = config.Configuration;
            conference.Permissions   = config.Permissions;

            _logger.LogDebug("Json patch succeeded for conference {conferenceId}. Save to database...",
                             conference.ConferenceId);

            var result = await _conferenceRepo.Update(conference);

            if (result == OptimisticUpdateResult.Ok)
            {
                await _mediator.Publish(new ConferencePatchedNotification(conferenceId));
            }

            return(result switch
            {
                OptimisticUpdateResult.ConcurrencyException => CommonError.ConcurrencyError,
                OptimisticUpdateResult.DeletedException => ConferenceError.ConferenceNotFound,
                _ => Unit.Value,
            });