Mercurial > dive4elements > river

view artifacts/src/main/java/org/dive4elements/river/artifacts/states/minfo/DifferencesState.java @ 6665:b7945db8a43b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
issue1413: Only show unknown sediment loads of selected unit type. Therefore, adjusted the factory to take the units name. Unfortunately, names in db do not match values of data items. Thus do manual replacing. In Facet and Calculate, take the chosen unit via access and to the string replacement. In Facet, do not transform data (we assume it comes in unit as labeled in the db), and removed the possibility of m3/a-data of unknown yields in a t/a diagram and vice versa.
author Felix Wolfsteller <felix.wolfsteller@intevation.de>
date Thu, 25 Jul 2013 15:08:13 +0200
parents 1994d064ebb1
children 7b81b3c3c0fa
line wrap: on
line source
/* Copyright (C) 2011, 2012, 2013 by Bundesanstalt für Gewässerkunde
 * Software engineering by Intevation GmbH
 *
 * This file is Free Software under the GNU AGPL (>=v3)
 * and comes with ABSOLUTELY NO WARRANTY! Check out the
 * documentation coming with Dive4Elements River for details.
 */

package org.dive4elements.river.artifacts.states.minfo;

import java.text.DateFormat;
import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;

import org.dive4elements.artifactdatabase.state.Facet;
import org.dive4elements.artifactdatabase.state.FacetActivity;
import org.dive4elements.artifacts.Artifact;
import org.dive4elements.artifacts.CallContext;
import org.dive4elements.artifacts.CallMeta;
import org.dive4elements.river.artifacts.D4EArtifact;
import org.dive4elements.river.artifacts.access.BedDifferencesAccess;
import org.dive4elements.river.artifacts.model.CalculationResult;
import org.dive4elements.river.artifacts.model.DataFacet;
import org.dive4elements.river.artifacts.model.FacetTypes;
import org.dive4elements.river.artifacts.model.minfo.BedDiffCalculation;
import org.dive4elements.river.artifacts.model.minfo.BedDiffEpochFacet;
import org.dive4elements.river.artifacts.model.minfo.BedDiffEpochFilterFacet;
import org.dive4elements.river.artifacts.model.minfo.BedDiffEpochResult;
import org.dive4elements.river.artifacts.model.minfo.BedDiffYearFacet;
import org.dive4elements.river.artifacts.model.minfo.BedDiffYearFilterFacet;
import org.dive4elements.river.artifacts.model.minfo.BedDiffYearResult;
import org.dive4elements.river.artifacts.model.minfo.BedDifferencesResult;
import org.dive4elements.river.artifacts.resources.Resources;
import org.dive4elements.river.artifacts.states.DefaultState;
import org.dive4elements.river.utils.Formatter;

/**
 * State for BedDifferences.
 * @author <a href="mailto:raimund.renkert@intevation.de">Raimund Renkert</a>
 */
public class DifferencesState
extends DefaultState
implements FacetTypes
{
    /** The logger used in this class. */
    private static Logger logger = Logger.getLogger(DifferencesState.class);
    public static final String I18N_DIFF_YEAR = "beddifference.year";
    public static final String I18N_DIFF_EPOCH = "beddifference.epoch";

    public static final String I18N_FACET_BED_DIFF_YEAR = "facet.bedheight.diff.year";
    public static final String I18N_FACET_BED_DIFF_YEAR_RAW = "facet.bedheight.diff.year.raw";
    public static final String I18N_FACET_BED_DIFF_ABSOLUTE = "facet.bedheight.diff.absolute";
    public static final String I18N_FACET_BED_DIFF_ABSOLUTE_RAW = "facet.bedheight.diff.absolute.raw";
    public static final String I18N_FACET_BED_DIFF_MORPH = "facet.bedheight.diff.morph";
    public static final String I18N_FACET_BED_DIFF_EPOCH = "facet.bedheight.diff.epoch";
    public static final String I18N_FACET_BED_DIFF_EPOCH_RAW = "facet.bedheight.diff.epoch.raw";
    public static final String I18N_FACET_BED_DIFF_HEIGHT1 = "facet.bedheight.diff.height1";
    public static final String I18N_FACET_BED_DIFF_HEIGHT1_RAW = "facet.bedheight.diff.height1.raw";
    public static final String I18N_FACET_BED_DIFF_HEIGHT2 = "facet.bedheight.diff.height2";
    public static final String I18N_FACET_BED_DIFF_HEIGHT2_RAW = "facet.bedheight.diff.height2.raw";

    public static final String I18N_FACET_BED_DIFF_HEIGHT_RAW = "facet.bedheight.diff.height.raw";

    public DifferencesState() {
    }

    @Override
    public Object computeAdvance(D4EArtifact artifact, String hash,
        CallContext context, List<Facet> facets, Object old) {
        logger.debug("DifferencesState.computeAdvance");

        List<Facet> newFacets = new ArrayList<Facet>();

        BedDifferencesAccess access = new BedDifferencesAccess(artifact);

        CalculationResult res = old instanceof CalculationResult
            ? (CalculationResult)old
            : new BedDiffCalculation().calculate(access, context);

        if (facets == null || res == null) {
            return res;
        }

        BedDifferencesResult[] results = (BedDifferencesResult[]) res.getData();

        if (results == null || results.length == 0) {
            logger.warn("Calculation computed no results!");
            return res;
        }

        generateFacets(context, newFacets, results, getID(), hash);
        logger.debug("Created " + newFacets.size() + " new Facets.");

        facets.addAll(newFacets);

        return res;
    }

    protected void generateFacets(CallContext context, List<Facet> newFacets,
        BedDifferencesResult[] results, String stateId, String hash) {
        logger.debug("DifferencesState.generateFacets");

        CallMeta meta = context.getMeta();

        newFacets.add(new DataFacet(CSV, "CSV data", ComputeType.ADVANCE, hash, id));
        newFacets.add(new DataFacet(PDF, "PDF data", ComputeType.ADVANCE, hash, id));
        for (int idx = 0; idx < results.length; idx++) {
            if (results[idx] instanceof BedDiffYearResult) {
                newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_YEAR,
                    createBedDiffYearDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        true),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_MORPH_WIDTH,
                    createBedDiffMorphDescription(
                        meta,
                        (BedDiffYearResult)results[idx]),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_YEAR_HEIGHT1,
                    createBedDiffHeightDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        0,
                        true),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                 newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_YEAR_HEIGHT2,
                    createBedDiffHeightDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        1,
                        true),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffYearFacet(
                    idx,
                    BED_DIFFERENCE_HEIGHT_YEAR,
                    createBedDiffAbsoluteDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        true),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffYearFilterFacet(
                    idx,
                    BED_DIFFERENCE_YEAR_FILTERED,
                    createBedDiffYearDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        false),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffYearFilterFacet(
                    idx,
                    BED_DIFFERENCE_YEAR_HEIGHT1_FILTERED,
                    createBedDiffHeightDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        0,
                        false),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                 newFacets.add(new BedDiffYearFilterFacet(
                    idx,
                    BED_DIFFERENCE_YEAR_HEIGHT2_FILTERED,
                    createBedDiffHeightDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        1,
                        false),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffYearFilterFacet(
                    idx,
                    BED_DIFFERENCE_HEIGHT_YEAR_FILTERED,
                    createBedDiffAbsoluteDescription(
                        meta,
                        (BedDiffYearResult)results[idx],
                        false),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
            }
            if (results[idx] instanceof BedDiffEpochResult) {
                newFacets.add(new BedDiffEpochFacet(
                    idx,
                    BED_DIFFERENCE_EPOCH,
                    createBedDiffEpochDescription(
                        meta,
                        (BedDiffEpochResult)results[idx],
                        true),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffEpochFacet(
                    idx,
                    BED_DIFFERENCE_EPOCH_HEIGHT1,
                    createBedDiffHeightEpochDescription(
                        meta,
                        (BedDiffEpochResult)results[idx],
                        0,
                        true),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffEpochFacet(
                    idx,
                    BED_DIFFERENCE_EPOCH_HEIGHT2,
                    createBedDiffHeightEpochDescription(
                        meta,
                        (BedDiffEpochResult)results[idx],
                        1,
                        true),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffEpochFilterFacet(
                    idx,
                    BED_DIFFERENCE_EPOCH_FILTERED,
                    createBedDiffEpochDescription(
                        meta,
                        (BedDiffEpochResult)results[idx],
                        false),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffEpochFilterFacet(
                    idx,
                    BED_DIFFERENCE_EPOCH_HEIGHT1_FILTERED,
                    createBedDiffHeightEpochDescription(
                        meta,
                        (BedDiffEpochResult)results[idx],
                        0,
                        false),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
                newFacets.add(new BedDiffEpochFilterFacet(
                    idx,
                    BED_DIFFERENCE_EPOCH_HEIGHT2_FILTERED,
                    createBedDiffHeightEpochDescription(
                        meta,
                        (BedDiffEpochResult)results[idx],
                        1,
                        false),
                    ComputeType.ADVANCE,
                    stateId,
                    hash));
            }
        }
    }

    private String createBedDiffHeightDescription(
        CallMeta meta,
        BedDiffYearResult result,
        int ndx,
        boolean raw
    ) {
        if (raw && ndx == 0) {
            return Resources.getMsg(meta, I18N_FACET_BED_DIFF_HEIGHT_RAW,
                I18N_FACET_BED_DIFF_HEIGHT_RAW, new Object[] {result.getNameFirst()});
        }
        if (raw && ndx == 1) {
            return Resources.getMsg(meta, I18N_FACET_BED_DIFF_HEIGHT_RAW,
                I18N_FACET_BED_DIFF_HEIGHT_RAW, new Object[] {result.getNameSecond()});
        }
        if (ndx == 0) {
            return result.getNameFirst();
        }
        else {
            return result.getNameSecond();
        }
    }

    private String createBedDiffHeightEpochDescription(
        CallMeta meta,
        BedDiffEpochResult result,
        int ndx,
        boolean raw
    ) {
        DateFormat df = Formatter.getDateFormatter(meta, "yyyy");
        String range =
            df.format(result.getStart())
            + " - " +
            df.format(result.getEnd());

        String i18nHeight1 = I18N_FACET_BED_DIFF_HEIGHT1;
        String i18nHeight2 = I18N_FACET_BED_DIFF_HEIGHT2;
        if (raw) {
            i18nHeight1 = I18N_FACET_BED_DIFF_HEIGHT1_RAW;
            i18nHeight2 = I18N_FACET_BED_DIFF_HEIGHT2_RAW;
        }
        if (ndx == 0) {
            return Resources.getMsg(meta, i18nHeight1,
                i18nHeight1, new Object[] { range });
        }
        else {
            return Resources.getMsg(meta, i18nHeight2,
                i18nHeight2, new Object[] {range});
        }
    }

    protected String createBedDiffYearDescription(
        CallMeta meta,
        BedDiffYearResult result,
        boolean raw
    ) {
        String range = result.getStart() + " - " + result.getEnd();

        String i18n = I18N_FACET_BED_DIFF_YEAR;
        if (raw) {
            i18n = I18N_FACET_BED_DIFF_YEAR_RAW;
        }
        return Resources.getMsg(meta, i18n, i18n, new Object[] { range });
    }

    protected String createBedDiffMorphDescription(
        CallMeta meta,
        BedDiffYearResult result) {
        String range = result.getStart() + " - " + result.getEnd();

        return Resources.getMsg(meta, I18N_FACET_BED_DIFF_MORPH,
            I18N_FACET_BED_DIFF_MORPH, new Object[] { range });
    }

    protected String createBedDiffAbsoluteDescription(
        CallMeta meta,
        BedDiffYearResult result,
        boolean raw
    ) {
        String range = result.getStart() + " - " + result.getEnd();

        String i18n = I18N_FACET_BED_DIFF_ABSOLUTE;
        if (raw) {
            i18n = I18N_FACET_BED_DIFF_ABSOLUTE_RAW;
        }
        return Resources.getMsg(meta, i18n, i18n, new Object[] { range });
    }

    protected String createBedDiffEpochDescription(
        CallMeta meta,
        BedDiffEpochResult result,
        boolean raw) {
        DateFormat df = Formatter.getDateFormatter(meta, "yyyy");
        String range =
            df.format(result.getStart())
            + " - " +
            df.format(result.getEnd());

        String i18n = I18N_FACET_BED_DIFF_EPOCH;
        if (raw) {
            i18n = I18N_FACET_BED_DIFF_EPOCH_RAW;
        }
        return Resources.getMsg(meta, i18n, i18n, new Object[] { range });
    }

    static {
        // Active/deactivate facets.
        FacetActivity.Registry.getInstance().register(
            "minfo",
            new FacetActivity() {
                @Override
                public Boolean isInitialActive(
                    Artifact artifact,
                    Facet    facet,
                    String   output
                ) {
                    String name = facet.getName();
                    if (name.equals(BED_DIFFERENCE_EPOCH) ||
                        name.equals(BED_DIFFERENCE_EPOCH_HEIGHT1) ||
                        name.equals(BED_DIFFERENCE_EPOCH_HEIGHT2) ||
                        name.equals(BED_DIFFERENCE_EPOCH_HEIGHT1_FILTERED) ||
                        name.equals(BED_DIFFERENCE_EPOCH_HEIGHT2_FILTERED) ||
                        name.equals(BED_DIFFERENCE_HEIGHT_YEAR) ||
                        name.equals(BED_DIFFERENCE_YEAR) ||
                        name.equals(BED_DIFFERENCE_YEAR_HEIGHT1) ||
                        name.equals(BED_DIFFERENCE_YEAR_HEIGHT2) ||
                        name.equals(BED_DIFFERENCE_YEAR_HEIGHT1_FILTERED) ||
                        name.equals(BED_DIFFERENCE_YEAR_HEIGHT2_FILTERED)){
                        return Boolean.FALSE;
                    }
                    else if (name.equals(BED_DIFFERENCE_MORPH_WIDTH) ||
                        name.equals(BED_DIFFERENCE_EPOCH_FILTERED) ||
                        name.equals(BED_DIFFERENCE_HEIGHT_YEAR_FILTERED) ||
                        name.equals(BED_DIFFERENCE_YEAR_FILTERED)) {
                        return Boolean.TRUE;
                    }
                    else {
                        return null;
                    }
                }
            });
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf-8 :
http://dive4elements.wald.intevation.org