StatementRepositoryImpl.Java

gistfile1.txt

package ua.ibox.app.repository;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;

import io.reactivex.Completable;
import io.reactivex.Single;
import ua.ibox.app.api.Api;
import ua.ibox.app.api.request.StatementRequest;
import ua.ibox.app.api.response.statement.StatementResponseBody;
import ua.ibox.app.api.response.statement.StatementSummaryBody;
import ua.ibox.app.model.Cursor;
import ua.ibox.app.model.statements.Category;
import ua.ibox.app.model.statements.Partner;
import ua.ibox.app.model.statements.Statement;
import ua.ibox.app.model.statements.SummaryCategory;
import ua.ibox.app.model.statements.SummaryStatement;
import ua.ibox.app.storage.abstraction.Query;
import ua.ibox.app.storage.abstraction.Sort;
import ua.ibox.app.storage.abstraction.Storage;
import ua.ibox.app.storage.realm.query.statement.StatementById;
import ua.ibox.app.storage.realm.query.statement.StatementCardSearchQuery;
import ua.ibox.app.storage.realm.query.statement.StatementSearch;

/**
 * Statement repository implementation.
 * <p>
 * Created by alexander on 3/17/17.
 */
public class StatementRepositoryImpl implements StatementRepository {

    private static final int PAGE_SIZE = 100;

    private boolean mIsLoaded;

    private Storage<Statement> mStorage;
    private Api mApi;

    public StatementRepositoryImpl(Api api, Storage<Statement> storage) {
        mApi = api;
        mStorage = storage;
    }

    @Override
    public Completable fetch(String cardId) {
        applyStorageSort();
        Statement topStatement = mStorage.getFirst();
        StatementRequest request = new StatementRequest(topStatement, true, PAGE_SIZE);
        return saveStatement(mApi.loadStatement(cardId, request),
                true,
                topStatement == null);
    }

    @Override
    public Completable fetchMore(String cardId) {
        applyStorageSort();
        StatementRequest request = new StatementRequest(mStorage.getLast(), false, PAGE_SIZE);
        return saveStatement(mApi.loadStatement(cardId, request),
                false,
                false);
    }

    private Completable saveStatement(Single<StatementResponseBody> observable,
                                      boolean top,
                                      boolean firstLoad) {
        return observable.flatMapCompletable(response -> {
            if (top && !firstLoad) {
                if (!response.isFullStatement) {
                    mStorage.deleteAll();
                    mIsLoaded = false;
                }
            } else {
                mIsLoaded = response.isFullStatement;
            }

            for (Statement statementItem : response.statementItems) {
                if (statementItem.getPartner() != null) {
                    statementItem.getPartner().generateFilter();
                }
            }

            mStorage.insert(response.statementItems);

            return Completable.complete();
        });
    }

    @Override
    public boolean isLoaded() {
        return mIsLoaded;
    }

    @Override
    public void clearRepository() {
        mStorage.deleteAll();
    }

    @Override
    public Cursor<Statement> filter(String[] filterWords) {
        applyStorageSort();

        if (filterWords == null) {
            return mStorage.cursor();
        }

        Query[] query = new StatementSearch[filterWords.length];
        for (int i = 0; i < filterWords.length; i++) {
            query[i] = new StatementSearch(filterWords[i]);
        }
        return mStorage.cursor(query);
    }

    private void applyStorageSort() {
        mStorage.withSort(new Sort(Statement.DATE, true));
        mStorage.withSort(new Sort(Statement.ID, true));
    }

    @Override
    public Single<List<Partner>> findCardToCard(String query) {
        return Single.fromCallable(() -> {
            applyStorageSort();
            Query cardSearchQuery = new StatementCardSearchQuery(query);
            List<Partner> result = new ArrayList<>();
            for (Statement statement : mStorage.list(cardSearchQuery)) {
                if (!result.contains(statement.getPartner())) {
                    result.add(statement.getPartner());
                }
            }
            return result;
        });
    }

    @Override
    public Statement loadItem(String statementId) {
        return mStorage.getFirst(new StatementById(statementId));
    }

    @Override
    public Single<SummaryStatement> fetchSummaryStatement(String cardId, Date start, Date end) {
        return mApi.loadSummaryStatement(cardId, start, end)
                .map(summaryBody -> new SummaryStatement(summaryBody.total, summaryBody.full, parseCategoryItems(summaryBody)));
    }

    private List<SummaryCategory> parseCategoryItems(StatementSummaryBody summary) {
        List<Integer> categories = new ArrayList<>(summary.categories.keySet());
        List<Integer> groupCategories = null;
        if (summary.groups != null && summary.groups.values().size() > 0) {
            int firstKey = summary.groups.keySet().iterator().next();
            groupCategories = summary.groups.get(firstKey);
            categories.removeAll(groupCategories);
        }

        List<SummaryCategory> result = new ArrayList<>();
        for (Integer category : categories) {
            double amount = summary.categories.get(category);
            float weight = getWeight(summary.total, amount);
            result.add(new SummaryCategory(category, amount, category, weight));
        }

        if (groupCategories != null) {
            double amount = 0;
            for (Integer category : groupCategories) {
                amount += summary.categories.get(category);
            }
            float weight = getWeight(summary.total, amount);
            result.add(new SummaryCategory(Category.OTHER, amount, groupCategories, weight));
        }

        Collections.sort(result, (o1, o2) -> Double.compare(o2.amount, o1.amount));

        return result;
    }

    private float getWeight(double total, double amount) {
        double weight = amount / total;
        return Math.round(weight * 100) / 100f;
    }

    @Override
    public Single<List<Statement>> fetchStatementByCategory(String cardId, List<Integer> categories, Date start, Date end) {
        return mApi.loadStatementByCategory(cardId, categories, start, end)
                .map(response -> response.statementItems);
    }
}