Xây dựng lớp CarRepository.java - Ví lập trình android quản lý car

package com.vantinviet.adayroionline.repository.car;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;

import com.vantinviet.adayroionline.ApiResponse.ApiResponseGetCarList;
import com.vantinviet.adayroionline.ApiResponse.ApiResponseGetCar;
import com.vantinviet.adayroionline.ApiResponse.ApiResponseGetDeleteCar;
import com.vantinviet.adayroionline.ApiResponse.ApiResponseUser;
import com.vantinviet.adayroionline.AppExecutors;
import com.vantinviet.adayroionline.Lib.Factory;
import com.vantinviet.adayroionline.api.ApiResponse;
import com.vantinviet.adayroionline.api.PSApiService;
import com.vantinviet.adayroionline.db.CarDao;
import com.vantinviet.adayroionline.db.PSCoreDb;
import com.vantinviet.adayroionline.repository.common.NetworkBoundResource;
import com.vantinviet.adayroionline.repository.common.PSRepository;
import com.vantinviet.adayroionline.utils.AbsentLiveData;
import com.vantinviet.adayroionline.utils.Utils;
import com.vantinviet.adayroionline.viewobject.Car;
import com.vantinviet.adayroionline.viewobject.User;
import com.vantinviet.adayroionline.viewobject.UserLogin;
import com.vantinviet.adayroionline.viewobject.common.Resource;

import java.io.IOException;
import java.util.List;

import javax.inject.Inject;
import javax.inject.Singleton;

import retrofit2.Response;

@Singleton
public class CarRepository extends PSRepository {

    //region variable
    private final CarDao carDao;
    //end region

    //region constructor
    @Inject
    CarRepository(PSApiService psApiService, AppExecutors appExecutors, PSCoreDb db, CarDao carDao) {
        super(psApiService, appExecutors, db);
        this.carDao = carDao;
    }


    //region User Repository Functions for ViewModel
    public LiveData<Resource<List<Car>>> getAllCar(String limit, String offset) {

        final MutableLiveData<Resource<List<Car>>> statusLiveData = new MutableLiveData<>(); // To update the status to the listener

        appExecutors.networkIO().execute(() -> {

            try {

                // Call the API Service
                Response<ApiResponseGetCarList> response =
                        psApiService.getAllCar(limit,offset).execute();
                // Wrap with APIResponse Class
                ApiResponse<ApiResponseGetCarList> apiResponseGetCarList = new ApiResponse<>(response);
                Utils.psLog("apiResponseGetCarList",apiResponseGetCarList.toString());
                if(apiResponseGetCarList.body.code.equals("101")){
                    statusLiveData.postValue(Resource.error(apiResponseGetCarList.body.errorMessage, null));
                    return;
                }
                // If response is successful
                if (apiResponseGetCarList.isSuccessful()) {

                    db.beginTransaction();

                    try {
                        List<Car> carList=apiResponseGetCarList.body.carList;
                        carDao.deleteAll();
                        carDao.insertAll(carList);
                        db.setTransactionSuccessful();

                    } catch (Exception e) {
                        Utils.psErrorLog("Error in doing car of recent car list.", e);
                    } finally {
                        db.endTransaction();
                    }
                    statusLiveData.postValue(Resource.success(apiResponseGetCarList.body.carList));
                } else {
                    statusLiveData.postValue(Resource.error(apiResponseGetCarList.errorMessage, null));
                }

            } catch (IOException e) {
                statusLiveData.postValue(Resource.error(e.getMessage(), null));
            }

        });
        return statusLiveData;

    }




    // Get next page transaction list
    public LiveData<Resource<Boolean>> getNextPageCarList(String limit,String offset) {

        final MutableLiveData<Resource<Boolean>> statusLiveData = new MutableLiveData<>(); // To update the status to the listener

        appExecutors.networkIO().execute(() -> {

            try {

                // Call the API Service
                Response<ApiResponseGetCarList> response =
                        psApiService.getAllCar(limit,offset).execute();


                // Wrap with APIResponse Class
                ApiResponse<ApiResponseGetCarList> apiResponseGetCarList = new ApiResponse<>(response);
                if(apiResponseGetCarList.body.code.equals("101")){
                    statusLiveData.postValue(Resource.error(apiResponseGetCarList.body.errorMessage, null));
                    return;
                }
                // If response is successful
                if (apiResponseGetCarList.isSuccessful()) {

                    db.beginTransaction();

                    try {

                        carDao.deleteAll();
                        carDao.insertAll(apiResponseGetCarList.body.carList);
                        db.setTransactionSuccessful();

                    } catch (Exception e) {
                        Utils.psErrorLog("Error in doing transaction of recent car list.", e);
                    } finally {
                        db.endTransaction();
                    }
                } else {
                    statusLiveData.postValue(Resource.error(apiResponseGetCarList.errorMessage, null));
                }

            } catch (IOException e) {
                statusLiveData.postValue(Resource.error(e.getMessage(), null));
            }

        });
        return statusLiveData;

    }
    public LiveData<Resource<Car>> getCarById(String carId) {

        return new NetworkBoundResource<Car, ApiResponseGetCar>(appExecutors) {

            @Override
            protected void saveCallResult(@NonNull ApiResponseGetCar apiResponseGetCar) {
                Utils.psLog("SaveCallResult of recent car.");

                db.beginTransaction();

                try {

                    carDao.deleteCarById(carId);
                    carDao.insert(apiResponseGetCar.car);
                    db.setTransactionSuccessful();

                } catch (Exception e) {
                    Utils.psErrorLog("Error in doing car of list.", e);
                } finally {
                    db.endTransaction();
                }
            }

            @Override
            protected boolean shouldFetch(@Nullable Car data) {

                // Recent news always load from server
                return connectivity.isConnected();

            }

            @NonNull
            @Override
            protected LiveData<Car> loadFromDb() {
                Utils.psLog("Load car From Db");

                return carDao.getCarById(carId);

            }

            @NonNull
            @Override
            protected LiveData<ApiResponse<ApiResponseGetCar>> createCall() {
                Utils.psLog("Call API Service to get car by id.");

                return psApiService.getCarById(carId);

            }

            @Override
            protected void onFetchFailed(String message) {
                Utils.psLog("Fetch Failed (getCar) : " + message);
            }

        }.asLiveData();
    }
    public LiveData<Resource<ApiResponseGetCar>> updateCar(Car car) {

        return new NetworkBoundResource<ApiResponseGetCar, ApiResponseGetCar>(appExecutors) {

            String carId = "";
            private ApiResponseGetCar resultsDb;

            @Override
            protected void saveCallResult(@NonNull ApiResponseGetCar apiResponseGetCar) {
                Utils.psLog("SaveCallResult of update car.");

                db.beginTransaction();
                try {

                    if(apiResponseGetCar.result.equals("success")) {

                        // set User id
                        carId = apiResponseGetCar.car.id;

                        // update car data
                        carDao.update(apiResponseGetCar.car);

                       

                        db.setTransactionSuccessful();

                    }
                    resultsDb = apiResponseGetCar;

                } catch (Exception e) {
                    Utils.psErrorLog("Error in doing transaction of update car.", e);
                } finally {
                    db.endTransaction();
                }
            }

            @Override
            protected boolean shouldFetch(@Nullable ApiResponseGetCar data) {
                // for car update, always should fetch
                return connectivity.isConnected();
            }

            @NonNull
            @Override
            protected LiveData<ApiResponseGetCar> loadFromDb() {
                if(carId == null || carId.equals("")) {
                    return AbsentLiveData.create();
                }

                return new LiveData<ApiResponseGetCar>() {
                    @Override
                    protected void onActive() {
                        super.onActive();
                        setValue(resultsDb);
                    }
                };
            }

            @NonNull
            @Override
            protected LiveData<ApiResponse<ApiResponseGetCar>> createCall() {
                Utils.psLog("Call API Service to update car.");
                if (car.id != null && !car.id.isEmpty()) {
                    return psApiService.updateCar(car.id, car.carName, car.carColor, car.carModel, car.carDescription);
                }else {
                    return psApiService.insertCar(car.carName, car.carColor, car.carModel, car.carDescription);
                }
            }

            @Override
            protected void onFetchFailed(String message) {

                Utils.psLog("Fetch Failed (updateUser)." + message);
            }
        }.asLiveData();
    }
    public LiveData<Resource<Boolean>> getCarDelete(String carId)  {

        final MutableLiveData<Resource<Boolean>> statusLiveData = new MutableLiveData<>();

        appExecutors.networkIO().execute(() -> {

            Response<ApiResponseGetDeleteCar> response;

            try {

                response = psApiService.getDeleteCar(carId).execute();

                ApiResponse<ApiResponseGetDeleteCar> apiResponse = new ApiResponse<>(response);

                if (apiResponse.isSuccessful() && apiResponse.body.code.equals("200")) {
                    statusLiveData.postValue(Resource.success(true));
                } else {
                    statusLiveData.postValue(Resource.error(apiResponse.body.errorMessage, null));
                }

            } catch (IOException e) {
                statusLiveData.postValue(Resource.error(e.getMessage(), null));
            }

        });

        return statusLiveData;

    }


}