AbstractGhantChartManagerImpl.java

  1. /*
  2.  * Copyright 2010-2025 James Pether Sörling
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *   http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  *
  16.  *  $Id$
  17.  *  $HeadURL$
  18. */
  19. package com.hack23.cia.web.impl.ui.application.views.common.chartfactory.impl;

  21. import java.util.Collection;
  22. import java.util.Collections;
  23. import java.util.Comparator;
  24. import java.util.Date;
  25. import java.util.List;
  26. import java.util.Map;
  27. import java.util.Map.Entry;
  28. import java.util.SortedSet;
  29. import java.util.TreeMap;
  30. import java.util.TreeSet;
  31. import java.util.function.Function;
  32. import java.util.stream.Collectors;

  34. import org.joda.time.DateTime;
  35. import org.tltv.gantt.Gantt;
  36. import org.tltv.gantt.client.shared.AbstractStep.CaptionMode;
  37. import org.tltv.gantt.client.shared.Resolution;
  38. import org.tltv.gantt.client.shared.Step;
  39. import org.tltv.gantt.client.shared.SubStep;

  41. import com.hack23.cia.web.impl.ui.application.views.common.sizing.ContentRatio;
  42. import com.vaadin.server.Sizeable.Unit;
  43. import com.vaadin.ui.AbstractOrderedLayout;

  45. /**
  46.  * The Class AbstractGhantChartManagerImpl.
  47.  *
  48.  * @param <T>
  49.  *            the generic type
  50.  */
  51. public abstract class AbstractGhantChartManagerImpl<T extends Object> {

  53.     /** The Constant CONTENT_SEPARATOR. */
  54.     private static final char CONTENT_SEPARATOR = ' ';

  56.     /** The Constant FILTER_DATA_BEFORE_YEAR. */
  57.     private static final int FILTER_DATA_BEFORE_YEAR = 2000;

  59.     /** The Constant PARTY_END_TAG. */
  60.     private static final char PARTY_END_TAG = ')';

  62.     /** The Constant PARTY_START_TAG. */
  63.     private static final String PARTY_START_TAG = " (";

  65.     /**
  66.      * Instantiates a new abstract ghant chart manager impl.
  67.      */
  68.     public AbstractGhantChartManagerImpl() {
  69.         super();
  70.     }

  72.     /**
  73.      * Creates the gantt.
  74.      *
  75.      * @return the gantt
  76.      */
  77.     private static final Gantt createGantt() {
  78.         final Gantt gantt = new Gantt();
  79.         gantt.setSizeFull();
  80.         gantt.setWidth(100, Unit.PERCENTAGE);
  81.         gantt.setHeight(100, Unit.PERCENTAGE);
  82.         gantt.setResizableSteps(false);
  83.         gantt.setMovableSteps(false);
  84.         gantt.setResolution(Resolution.Week);
  85.         return gantt;
  86.     }

  88.     /**
  89.      * Strip dates after current date.
  90.      *
  91.      * @param toDate
  92.      *            the to date
  93.      * @return the date
  94.      */
  95.     private static final Date stripDatesAfterCurrentDate(final Date toDate) {
  96.         return DateUtils.stripDatesAfterCurrentDate(toDate);
  97.     }

  99.     /**
  100.      * Adds the view generic role member to step.
  101.      *
  102.      * @param roleName
  103.      *            the role name
  104.      * @param step
  105.      *            the step
  106.      * @param roleAssignments
  107.      *            the role assignments
  108.      * @param stepMapping
  109.      *            the step mapping
  110.      */
  111.     private void addViewGenericRoleMemberToStep(final String roleName, final Step step, final List<T> roleAssignments,
  112.             final StepMapping<T> stepMapping) {

  114.         for (final T roleMember : roleAssignments) {

  116.             String subStepName = "";

  118.             if (stepMapping.getRoleCode(roleMember) != null) {
  119.                 subStepName = new StringBuilder().append(stepMapping.getFirstName(roleMember))
  120.                         .append(CONTENT_SEPARATOR).append(stepMapping.getLastName(roleMember))
  121.                         .append(PARTY_START_TAG).append(stepMapping.getParty(roleMember)).append(PARTY_END_TAG)
  122.                         .toString();
  123.             }

  125.             final SubStep sameRoleSubStep = new SubStep(roleName + '.' + subStepName,CaptionMode.HTML);
  126.             sameRoleSubStep.setDescription(roleName + '.' + subStepName);
  127.             sameRoleSubStep.setBackgroundColor(stepMapping.getBackgroundColor(roleMember));

  129.             sameRoleSubStep.setStartDate(stepMapping.getFromDate(roleMember).getTime());
  130.             sameRoleSubStep.setEndDate(stripDatesAfterCurrentDate(stepMapping.getToDate(roleMember)).getTime());

  132.             step.addSubStep(sameRoleSubStep);
  133.         }
  134.     }

  136.     /**
  137.      * Creates the generic gantt.
  138.      *
  139.      * @param assignmentList
  140.      *            the assignment list
  141.      * @param roleMapping
  142.      *            the role mapping
  143.      * @param stepMapping
  144.      *            the step mapping
  145.      * @return the gantt
  146.      */
  147.     private Gantt createGenericGantt(final List<T> assignmentList, final Function<T, String> roleMapping,
  148.             final StepMapping<T> stepMapping) {

  150.         final Map<String, List<T>> assignmentListMap = assignmentList.stream()
  151.                 .collect(Collectors.groupingBy(roleMapping, TreeMap::new, Collectors.toList()));

  153.         final Gantt gantt = createGantt();

  155.         if (!assignmentList.isEmpty()) {

  157.             gantt.setStartDate(stepMapping.getFromDate(assignmentList.get(0)));
  158.             gantt.setEndDate(
  159.                     stripDatesAfterCurrentDate(stepMapping.getToDate(assignmentList.get(assignmentList.size() - 1))));

  161.             for (final Entry<String, List<T>> entry : entriesSortedByValues(assignmentListMap, stepMapping)) {

  163.                 final String stepName = entry.getKey();

  165.                 final Step step = new Step(stepName,CaptionMode.HTML);
  166.                 step.setDescription(stepName);

  168.                 final List<T> assignments = entry.getValue();

  170.                 Collections.sort(assignments, getComparator());

  172.                 addViewGenericRoleMemberToStep(stepName, step, assignments, stepMapping);

  174.                 gantt.addStep(step);
  175.             }
  176.         }

  178.         return gantt;
  179.     }


  182.     /**
  183.      * Creates the role ghant.
  184.      *
  185.      * @param roleSummaryLayoutTabsheet the role summary layout tabsheet
  186.      * @param assignmentList            the assignment list
  187.      */
  188.     public final void createRoleGhant(final AbstractOrderedLayout roleSummaryLayoutTabsheet, final Collection<T> assignmentList) {

  190.         final List<T> list = filterAndSortAssignments(assignmentList);

  192.         final Gantt createGantt = createGenericGantt(list, getRoleMapping(), getStepMapping());
  193.         roleSummaryLayoutTabsheet.addComponent(createGantt);
  194.         roleSummaryLayoutTabsheet.setExpandRatio(createGantt, ContentRatio.GRID);

  196.     }

  198.     /**
  199.      * Filter and sort assignments.
  200.      *
  201.      * @param assignmentList
  202.      *            the assignment list
  203.      * @return the list
  204.      */
  205.     private List<T> filterAndSortAssignments(final Collection<T> assignmentList) {
  206.         final Comparator<T> compare = getComparator();

  208.         final List<T> list = assignmentList.stream().filter(
  209.                 (final T x) -> new DateTime(getStepMapping().getFromDate(x).getTime()).getYear() > FILTER_DATA_BEFORE_YEAR)
  210.                 .collect(Collectors.toList());

  212.         Collections.sort(list, compare);
  213.         return list;
  214.     }

  216.     /**
  217.      * Entries sorted by values.
  218.      *
  219.      * @param map
  220.      *            the map
  221.      * @param stepMapping
  222.      *            the step mapping
  223.      * @return the sorted set
  224.      */
  225.     private SortedSet<Map.Entry<String, List<T>>> entriesSortedByValues(final Map<String, List<T>> map,
  226.             final StepMapping<T> stepMapping) {
  227.         final Comparator<? super Entry<String, List<T>>> compare = (o1, o2) -> {

  229.             final Comparator<T> compare1 = (o11, o21) -> {
  230.                 final int compareDate = stepMapping.getFromDate(o11).compareTo(stepMapping.getFromDate(o21));
  231.                 if (compareDate == 0) {
  232.                     final int compareType = stepMapping.getRoleCode(o11).compareTo(stepMapping.getRoleCode(o21));
  233.                     if (compareType == 0) {
  234.                         return stepMapping.getOrg(o11).compareTo(stepMapping.getOrg(o21));
  235.                     } else {
  236.                         return compareType;
  237.                     }
  238.                 }

  240.                 return compareDate;
  241.             };

  243.             Collections.sort(o1.getValue(), compare1);
  244.             Collections.sort(o2.getValue(), compare1);

  246.             return compare1.compare(o1.getValue().get(0), o2.getValue().get(0));
  247.         };

  249.         final SortedSet<Map.Entry<String, List<T>>> sortedEntries = new TreeSet<>(compare);
  250.         sortedEntries.addAll(map.entrySet());
  251.         return sortedEntries;
  252.     }

  254.     /**
  255.      * Gets the comparator.
  256.      *
  257.      * @return the comparator
  258.      */
  259.     protected abstract Comparator<T> getComparator();

  261.     /**
  262.      * Gets the role mapping.
  263.      *
  264.      * @return the role mapping
  265.      */
  266.     protected abstract Function<T, String> getRoleMapping();

  268.     /**
  269.      * Gets the step mapping.
  270.      *
  271.      * @return the step mapping
  272.      */
  273.     protected abstract StepMapping<T> getStepMapping();

  275.     /**
  276.      * The Interface StepMapping.
  277.      *
  278.      * @param <T>
  279.      *            the generic type
  280.      */
  281.     public interface StepMapping<T> {

  283.         /**
  284.          * Gets the background color.
  285.          *
  286.          * @param t
  287.          *            the t
  288.          * @return the background color
  289.          */
  290.         String getBackgroundColor(T t);

  292.         /**
  293.          * Gets the first name.
  294.          *
  295.          * @param assignmentData
  296.          *            the assignment data
  297.          * @return the first name
  298.          */
  299.         Object getFirstName(T assignmentData);

  301.         /**
  302.          * Gets the from date.
  303.          *
  304.          * @param t
  305.          *            the t
  306.          * @return the from date
  307.          */
  308.         Date getFromDate(T t);

  310.         /**
  311.          * Gets the last name.
  312.          *
  313.          * @param assignmentData
  314.          *            the assignment data
  315.          * @return the last name
  316.          */
  317.         Object getLastName(T assignmentData);

  319.         /**
  320.          * Gets the org.
  321.          *
  322.          * @param t
  323.          *            the t
  324.          * @return the org
  325.          */
  326.         String getOrg(T t);

  328.         /**
  329.          * Gets the party.
  330.          *
  331.          * @param t
  332.          *            the t
  333.          * @return the party
  334.          */
  335.         String getParty(T t);

  337.         /**
  338.          * Gets the role code.
  339.          *
  340.          * @param t
  341.          *            the t
  342.          * @return the role code
  343.          */
  344.         String getRoleCode(T t);

  346.         /**
  347.          * Gets the to date.
  348.          *
  349.          * @param t the t
  350.          * @return the to date
  351.          */
  352.         Date getToDate(T t);

  354.     }

  356. }
Created with JaCoCo 0.8.12.202403310830