RXSwift объединяет наблюдателей в цепочку и отлавливает ошибки - PullRequest
Новая
       48

RXSwift объединяет наблюдателей в цепочку и отлавливает ошибки

2 голосов
/ 17 июня 2020

У меня есть код, который должен ожидать завершения некоторых наблюдаемых операций, но у меня проблемы с его написанием наиболее оптимальным способом.

Важно, чтобы окончательный результат подписки был событием, и что updateEvent запускается последним.

Вот мой код: 

/// Update Event
///
/// Updates an event and invites or removes any members from the event before updating the actual event information. This ensures newly updated event to contain the updated list of attendes
///
/// - Parameters:
///   - event: The event to update
///   - group: The group that the event belongs to
///   - newMembers: A list of new group members that should be invited to the invited
///   - removeMembers: A list of event attendees that should be removed from the event
func updateEvent(_ event: EventModel, _ group: GroupModel, newMembers: [MemberModel], removeMembers: [AttendanceModel]) {

    let updateEventObserver = self.repository.updateEvent(group, event)
    var memberObservers: [Observable<AttendanceModel>] = []

    if newMembers.count > 0 {
        memberObservers.append(contentsOf: newMembers.map { (member) in
            return self.repository.inviteToEvent(member: member, event: event, group: group)
        })
    }

    if removeMembers.count > 0 {
        memberObservers.append(contentsOf: removeMembers.map { (member) in
            return self.repository.removeFromEvent(member: member, event: event, group: group)
        })
    }

    if memberObservers.count > 0 {

        Observable
            .zip(memberObservers)
            .subscribe(onNext: { (_) in
                updateEventObserver
                    .subscribe(onNext: { event in
                        self.presenter.eventSuccessfullyUpdated(event)
                    }, onError: { error in
                        self.presenter.failedWithError(error)
                    }).disposed(by: self.disposeBag)
            }, onError: { (error) in
                self.presenter.failedWithError(error)
            }).disposed(by: self.disposeBag)
    } else {
        updateEventObserver
            .subscribe(onNext: { event in
                self.presenter.eventSuccessfullyUpdated(event)
            }, onError: { error in
                self.presenter.failedWithError(error)
            }).disposed(by: self.disposeBag)
    }

}

Я думаю, что мой код «уродливый», и я чувствую, что есть способ получше. Спасибо!

1 Ответ

0 голосов
/ 18 июня 2020

Ну, это немного чище: 

func updateEvent(_ event: EventModel, _ group: GroupModel, newMembers: [MemberModel], removeMembers: [AttendanceModel]) {

    let invitedResults = newMembers
        .compactMap { [repository] member in
            repository?.inviteToEvent(member: member, event: event, group: group)
        }

    let removedResults = removeMembers
        .compactMap { [repository] member in
            repository?.removeFromEvent(member: member, event: event, group: group)
        }

    Observable.zip(invitedResults + removedResults)
        .flatMap { [repository] _ in repository?.updateEvent(group, event) ?? .empty() }
        .subscribe(
            onNext: { [presenter] event in
                presenter?.eventSuccessfullyUpdated(event)
            },
            onError: { [presenter] error in
                presenter?.failedWithError(error)
            }
        )
        .disposed(by: disposeBag)
}

Это позволяет избежать захвата себя и, по крайней мере, создать цикл сохранения. Но если любой приглашает или удаляет ошибку, это может оставить вашу систему в недопустимом состоянии ...

...