UserRepositoryImpl.java

package com.booklava.booklava.data.repository.impl;

import com.booklava.booklava.data.cache.UserDataCache;
import com.booklava.booklava.data.model.request.LoginRequest;
import com.booklava.booklava.data.model.request.SignUpRequest;
import com.booklava.booklava.data.model.request.SocialSignInRequest;
import com.booklava.booklava.data.model.request.UserRequest;
import com.booklava.booklava.data.model.transformer.ProfileTransformer;
import com.booklava.booklava.data.model.transformer.UserTransform;
import com.booklava.booklava.data.network.UserApiService;
import com.booklava.booklava.data.repository.UserRepository;
import com.booklava.booklava.domain.entity.User;
import com.booklava.core.data.utils.RxUtils;
import com.booklava.core.domain.repository.DefaultNetworkErrorHandler;

import java.util.Date;

import okhttp3.MultipartBody;
import rx.Observable;


public final class UserRepositoryImpl implements UserRepository {

    private final UserApiService mUserApiService;
    private final UserDataCache mUserDataCache;
    private final UserTransform mUserTransform;

    public UserRepositoryImpl(final UserApiService userApiService,
                              final UserDataCache userDataCache) {
        mUserApiService = userApiService;
        mUserDataCache = userDataCache;
        mUserTransform = new UserTransform();
    }

    @Override
    public Observable<User> login(final String userName,
                                  final String password,
                                  final String token,
                                  final String device) {
        return mUserApiService.login(new LoginRequest(userName, password, device, token))
                .compose(mUserTransform)
                .flatMap(mUserDataCache::storeOrUpdateUser);
    }

    @Override
    public Observable<User> linkedInLogin(final String accessToken,
                                          final String email,
                                          final String token,
                                          final String device) {
        return mUserApiService.linkedInSignIn(new SocialSignInRequest(accessToken, email, token, device))
                .compose(mUserTransform)
                .flatMap(mUserDataCache::storeOrUpdateUser);
    }

    @Override
    public Observable<Void> signUp(final String userName,
                                   final String email,
                                   final String password,
                                   final String confirmPassword,
                                   final String token,
                                   final String device) {
        return mUserApiService.signUp(new SignUpRequest(userName, email, password, confirmPassword, token, device));
    }

    @Override
    public Observable<User> facebookSignIn(final String facebookToken,
                                           final String email,
                                           final String token,
                                           final String device) {
        return mUserApiService.facebookLogin(new SocialSignInRequest(facebookToken, email, device, token))
                .compose(mUserTransform)
                .flatMap(mUserDataCache::storeOrUpdateUser);
    }

    @Override
    public Observable<Void> logout() {
        return mUserApiService.logoutUser()
                .flatMap(aVoid -> mUserDataCache.removeCurrentUser())
                .onErrorResumeNext(new LogoutErrorHandler());
    }

    @Override
    public Observable<Void> forgotPassword(final String email) {
        return mUserApiService.forgotPassword(email);
    }

    @Override
    public Observable<User> profile(final boolean fromDB) {
        if (fromDB) {
            return mUserDataCache.getCurrentUser()
                    .compose(RxUtils.applyAsyncSchedulers());
        } else {
            return mUserApiService.getProfile()
                    .compose(new ProfileTransformer())
                    .flatMap(mUserDataCache::updateProfile)
                    .onErrorResumeNext(new CurrentUserErrorHandler());
        }
    }

    @Override
    public Observable<User> updateProfile(final String email, final String name,
                                          final String credit, final String gender,
                                          final String countryCode, final Date dateOfBirth,
                                          final String language, final String password,
                                          final String currentPassword) {
        return mUserApiService.updateUser(new UserRequest(email, name, credit, gender, countryCode, dateOfBirth, language, password, currentPassword))
                .map(profileResponse -> profileResponse)
                .compose(new ProfileTransformer())
                .flatMap(mUserDataCache::updateProfile);
    }

    @Override
    public Observable<User> updateAvatar(final MultipartBody.Part avatar) {
        return mUserApiService.updateAvatar(avatar)
                .compose(new ProfileTransformer())
                .flatMap(mUserDataCache::updateProfile);
    }

    @Override
    public Observable<User> getCurrentUser() {
        return mUserDataCache.getCurrentUser();
    }

    @Override
    public Observable<Void> verifyEmail(final String code) {
        return mUserApiService.verifyUser(code)
                .flatMap(aVoid -> mUserDataCache.verifyUser(true));
    }

    @Override
    public Observable<Void> resendVerificationCode(final String email) {
        return mUserApiService.resendVerificationCode(email);
    }


    private class LogoutErrorHandler extends DefaultNetworkErrorHandler<Void> {

        @Override
        public Observable<Void> getNetworkErrorHandlerObservable(final Throwable throwable) {
            return mUserDataCache.removeCurrentUser();
        }
    }

    private class CurrentUserErrorHandler extends DefaultNetworkErrorHandler<User> {

        @Override
        public Observable<User> getNetworkErrorHandlerObservable(final Throwable throwable) {
            return mUserDataCache.getCurrentUser();
        }
    }
}