475 lines
15 KiB
Java
475 lines
15 KiB
Java
/**
|
|
*
|
|
*/
|
|
package org.gcube.portlets.user.performfishanalytics.server.util.database;
|
|
|
|
import java.io.File;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
|
|
import javax.persistence.EntityManagerFactory;
|
|
import javax.servlet.ServletContext;
|
|
|
|
import org.gcube.portlets.user.performfishanalytics.client.PerformFishAnalyticsConstant;
|
|
import org.gcube.portlets.user.performfishanalytics.server.persistence.GenericPersistenceDaoBuilder;
|
|
import org.gcube.portlets.user.performfishanalytics.server.util.csv.CSVReader;
|
|
import org.gcube.portlets.user.performfishanalytics.server.util.database.data.AreaData;
|
|
import org.gcube.portlets.user.performfishanalytics.server.util.database.data.KPIBatchTypeData;
|
|
import org.gcube.portlets.user.performfishanalytics.server.util.database.data.PeriodData;
|
|
import org.gcube.portlets.user.performfishanalytics.server.util.database.data.QuarterData;
|
|
import org.gcube.portlets.user.performfishanalytics.server.util.database.data.SpeciesData;
|
|
import org.gcube.portlets.user.performfishanalytics.server.util.database.data.YearData;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.Area;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.KPI;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.Period;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.Population;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.PopulationType;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.Quarter;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.Species;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.Year;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.csv.CSVFile;
|
|
import org.gcube.portlets.user.performfishanalytics.shared.csv.CSVRow;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
|
|
/**
|
|
* The Class FillDatabasePerBatchType.
|
|
*
|
|
* @author Francesco Mangiacrapa at ISTI-CNR (francesco.mangiacrapa@isti.cnr.it)
|
|
* Feb 27, 2019
|
|
*/
|
|
public class FillDatabasePerBatchType {
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public static final String RELATIVE_PATH_TO_BATCH_KPI = "BATCH/KPI";
|
|
public static final String RELATIVE_PATH_TO_FARM_KPI = "FARM/KPI";
|
|
protected static Logger log = LoggerFactory.getLogger(FillDatabasePerBatchType.class);
|
|
|
|
/**
|
|
* Prints the database data.
|
|
*
|
|
* @param entityManagerFactory the entity manager factory
|
|
* @throws Exception the exception
|
|
*/
|
|
public static void printDatabaseData(EntityManagerFactory entityManagerFactory) throws Exception {
|
|
|
|
GenericPersistenceDaoBuilder<Population> builderPopulation = new GenericPersistenceDaoBuilder<Population>(entityManagerFactory, "Population");
|
|
|
|
for(Population population: builderPopulation.getPersistenceEntity().getList()){
|
|
log.debug("\n\n#### Population: "+population.getName());
|
|
for (PopulationType populationType : population.getListPopulationType()) {
|
|
log.debug("\t{} Type: {}",populationType.getName(),populationType.getType());
|
|
|
|
log.debug("\t**has Species: "+populationType.getListSpecies().size());
|
|
for (Species species : populationType.getListSpecies()) {
|
|
log.debug("\t\t"+species.getName());
|
|
}
|
|
|
|
log.debug("\t**has Quarter: "+populationType.getListQuarter().size());
|
|
for (Quarter quarter : populationType.getListQuarter()) {
|
|
log.debug("\t\t"+quarter.getName());
|
|
}
|
|
|
|
log.debug("\t**has Area: "+populationType.getListArea().size());
|
|
for (Area area : populationType.getListArea()) {
|
|
log.debug("\t\t"+area.getName());
|
|
}
|
|
|
|
log.debug("\t**has Period: "+populationType.getListPeriod().size());
|
|
for (Period period : populationType.getListPeriod()) {
|
|
log.debug("\t\t"+period.getName());
|
|
}
|
|
|
|
log.debug("\t**has Years: "+populationType.getListYears().size());
|
|
for (Year year : populationType.getListYears()) {
|
|
log.debug("\t\t"+year.getValue());
|
|
}
|
|
|
|
log.debug("\t**has KPIs: "+populationType.getListKPI().size());
|
|
for (KPI kpi : populationType.getListKPI()) {
|
|
printKPIs(kpi);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints the kp is.
|
|
*
|
|
* @param kpi the kpi
|
|
* @param level the level
|
|
*/
|
|
public static void printKPIs(KPI kpi, int level){
|
|
if(kpi==null)
|
|
return;
|
|
|
|
log.debug(String.format("\t%"+level*5+"d|KPI: %s, %s",level, kpi.getCode(), kpi.getName()));
|
|
//log.debug("LIST KPI ARE: "+listKPI);
|
|
level++;
|
|
if(kpi.getListKPI()==null){
|
|
//log.debug("[LEAF: "+kpi.getName()+"]");
|
|
//I'm a LEAF
|
|
return;
|
|
}
|
|
for (KPI kpiChild : kpi.getListKPI()) {
|
|
printKPIs(kpiChild, kpiChild.getDeepIndex());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Prints the kp is.
|
|
*
|
|
* @param kpi the kpi
|
|
*/
|
|
public static void printKPIs(KPI kpi){
|
|
if(kpi==null || kpi.getListKPI()==null)
|
|
return;
|
|
|
|
log.debug(String.format("\t%"+kpi.getDeepIndex()*5+"d|KPI: %s, %s",kpi.getDeepIndex(), kpi.getCode(), kpi.getName()));
|
|
for (KPI kpiChild : kpi.getListKPI()) {
|
|
printKPIs(kpiChild, kpiChild.getDeepIndex());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Fill database.
|
|
*
|
|
* @param entityManagerFactory the entity manager factory
|
|
* @param context the context
|
|
* @throws Exception the exception
|
|
*/
|
|
public static void fillDatabase(EntityManagerFactory entityManagerFactory, ServletContext context) throws Exception{
|
|
|
|
//INSERT LEVEL OF KIND 'BATCH'
|
|
Population batchPopulation = new Population(java.util.UUID.randomUUID().toString(), "BATCH", "BATCH", "BATCH Description", null);
|
|
|
|
List<PopulationType> listBatchLevels = loadKPIForBatchLevelFromResource(context, RELATIVE_PATH_TO_BATCH_KPI);
|
|
|
|
//FILLING BATCH LEVEL/POPULATIONS
|
|
for (PopulationType batchType : listBatchLevels) {
|
|
|
|
batchType.setPopulation(batchPopulation);
|
|
|
|
if(batchType.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.PRE_ONGROWING.name()) || batchType.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.PRE_ONGROWING_CLOSED_BATCHES.name())){
|
|
|
|
//Species
|
|
batchType.setListSpecies(SpeciesData.getListSpecies(batchType));
|
|
//Areas
|
|
batchType.setListArea(AreaData.getListArea(batchType));
|
|
//Periods
|
|
batchType.setListPeriod(PeriodData.getListPeriods(batchType));
|
|
|
|
}else if(batchType.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.HATCHERY_INDIVIDUAL.name()) || batchType.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.HATCHERY_INDIVIDUAL_CLOSED_BATCHES.name())){
|
|
|
|
//Species
|
|
batchType.setListSpecies(SpeciesData.getListSpecies(batchType));
|
|
//Periods
|
|
batchType.setListPeriod(PeriodData.getListPeriods(batchType));
|
|
|
|
}else if(batchType.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.GROW_OUT_INDIVIDUAL.name()) || batchType.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.GROW_OUT_INDIVIDUAL_CLOSED_BATCHES.name())){
|
|
|
|
//Species
|
|
batchType.setListSpecies(SpeciesData.getListSpecies(batchType));
|
|
//Quarters
|
|
batchType.setListQuarter(QuarterData.getListQuarter(batchType));
|
|
//Areas
|
|
batchType.setListArea(AreaData.getListArea(batchType));
|
|
|
|
}else if(batchType.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.GROW_OUT_AGGREGATED_CLOSED_BATCHES.name())){
|
|
|
|
//Species
|
|
batchType.setListSpecies(SpeciesData.getListSpecies(batchType));
|
|
//Quarters
|
|
batchType.setListQuarter(QuarterData.getListQuarter(batchType));
|
|
//Areas
|
|
batchType.setListArea(AreaData.getListArea(batchType));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//INSERTING BATCH LEVEL/POPULATIONS
|
|
GenericPersistenceDaoBuilder<Population> builderPopulation = new GenericPersistenceDaoBuilder<Population>(entityManagerFactory, "Population");
|
|
batchPopulation.setListPopulationType(new ArrayList<PopulationType>(listBatchLevels));
|
|
builderPopulation.getPersistenceEntity().insert(batchPopulation);
|
|
|
|
|
|
//INSERT LEVEL OF KIND 'FARM'
|
|
Population farmPopulation = new Population(java.util.UUID.randomUUID().toString(), "FARM", "FARM", "FARM Description", null);
|
|
List<PopulationType> listFarmLevels = loadKPIForBatchLevelFromResource(context, RELATIVE_PATH_TO_FARM_KPI);
|
|
//FILLING BATCH LEVEL/POPULATIONS
|
|
|
|
log.info("FARM batch types are: "+listBatchLevels);
|
|
for (PopulationType batchTypeFarm : listFarmLevels) {
|
|
|
|
batchTypeFarm.setPopulation(farmPopulation);
|
|
|
|
if(batchTypeFarm.getName().equals(PerformFishAnalyticsConstant.BATCH_LEVEL.GROW_OUT_AGGREGATED_CLOSED_BATCHES.name())){
|
|
//Years
|
|
batchTypeFarm.setListYears(YearData.getListYears(batchTypeFarm));
|
|
}
|
|
}
|
|
|
|
//INSERTING BATCH LEVEL/POPULATIONS
|
|
farmPopulation.setListPopulationType(new ArrayList<PopulationType>(listFarmLevels));
|
|
builderPopulation.getPersistenceEntity().insert(farmPopulation);
|
|
|
|
}
|
|
|
|
/**
|
|
* Builds the populations.
|
|
*
|
|
* @return the list
|
|
*/
|
|
public static List<Population> buildPopulations(){
|
|
Population popFarm = new Population(java.util.UUID.randomUUID().toString(), "FARM", "FARM", "FARM Description", null);
|
|
Population popBatch = new Population(java.util.UUID.randomUUID().toString(), "BATCH", "BATCH", "BATCH Description", null);
|
|
return Arrays.asList(popFarm, popBatch);
|
|
}
|
|
|
|
|
|
/**
|
|
* Builds the population type.
|
|
*
|
|
* @param type the type
|
|
* @param description the description
|
|
* @param poulation the poulation
|
|
* @return the population type
|
|
*/
|
|
public static PopulationType buildPopulationType(String type, String description, Population poulation){
|
|
|
|
return new PopulationType(java.util.UUID.randomUUID().toString(), type, type, description, poulation);
|
|
}
|
|
|
|
|
|
/**
|
|
* Creates the batch type.
|
|
*
|
|
* @param fileName the file name
|
|
* @param reader the reader
|
|
* @return the population type
|
|
* @throws Exception the exception
|
|
*/
|
|
private static PopulationType createBatchType(String fileName, CSVReader reader) throws Exception{
|
|
|
|
Population batchPopulation = null;
|
|
String batchTypeName = fileName.substring(0, fileName.lastIndexOf("."));
|
|
PopulationType batchType = buildPopulationType(batchTypeName, batchTypeName+" description", batchPopulation);
|
|
|
|
CSVFile csvFile = reader.getCsvFile();
|
|
List<KPI> rootListKPI = new ArrayList<KPI>();
|
|
//Map<String, KPI> kpiMap = new HashMap<String, KPI>();
|
|
int rowIndex = 0;
|
|
//KPI[] lastDeepLevel = new KPI[10];
|
|
// lastDeepLevel[0] = null;
|
|
for (CSVRow csvRow : csvFile.getValueRows()) {
|
|
List<String> rowValues = csvRow.getListValues();
|
|
String kpiCode = "";
|
|
int levelIndex = 0;
|
|
String kpiName = null;
|
|
log.trace("Reading row values: {} ",rowValues);
|
|
log.trace("Row index: {} ",rowIndex);
|
|
//Looping on row values
|
|
for (int j = 0; j < rowValues.size(); j++) {
|
|
String value = rowValues.get(j);
|
|
log.trace("\tColumn index: {} ",j);
|
|
//first column I'm expecting the KPI code if exists
|
|
if(j==0){
|
|
kpiCode = value;
|
|
log.trace("\tKPI code: {} ",kpiCode);
|
|
}else if(value!=null && !value.isEmpty()){
|
|
levelIndex = j;
|
|
kpiName = value;
|
|
}
|
|
}
|
|
|
|
|
|
PopulationType populationType = null;
|
|
ArrayList<KPI> descendants = null;
|
|
//DIRECT CHILD OF POPULATION (i.e. "BATCH")
|
|
if(levelIndex==1){
|
|
populationType = batchType;
|
|
}
|
|
|
|
KPI toAdd = KPIBatchTypeData.buildKPI(kpiCode, kpiName, kpiName + " description", descendants, populationType, levelIndex);
|
|
log.debug("\t Created: {} ",toAdd);
|
|
//lastDeepLevel[levelIndex-1] = toAdd;
|
|
|
|
if(levelIndex==1){
|
|
//ADDING TO ROOT LIST
|
|
rootListKPI.add(toAdd);
|
|
// }
|
|
// else if(levelIndex==2){
|
|
// //ADDING TO SECOND LEVEL
|
|
// KPI lastRootKPI = rootListKPI.get(rootListKPI.size()-1);
|
|
// addAsDescendant(lastRootKPI, toAdd);
|
|
}else{
|
|
KPI lastRootKPI = rootListKPI.get(rootListKPI.size()-1);
|
|
//ADDING TO 3 LEVEL onwards
|
|
KPI lastDescendant = getLastDescendantAtIndex(lastRootKPI, levelIndex-1);
|
|
addAsDescendant(lastDescendant, toAdd);
|
|
}
|
|
|
|
rowIndex++;
|
|
}
|
|
|
|
batchType.setListKPI(rootListKPI);
|
|
|
|
return batchType;
|
|
}
|
|
|
|
/**
|
|
* Gets the last descendant at index.
|
|
*
|
|
* @param kpi the kpi
|
|
* @param levelIndex the level index
|
|
* @return the last descendant at index
|
|
*/
|
|
private static KPI getLastDescendantAtIndex(KPI kpi, int levelIndex){
|
|
|
|
if(kpi.getDeepIndex()==levelIndex)
|
|
return kpi;
|
|
|
|
KPI lastKPI = kpi.getListKPI().get(kpi.getListKPI().size()-1);
|
|
return getLastDescendantAtIndex(lastKPI, levelIndex);
|
|
|
|
}
|
|
|
|
/**
|
|
* Adds the as descendant.
|
|
*
|
|
* @param parent the parent
|
|
* @param toAdd the to add
|
|
* @return the kpi
|
|
*/
|
|
private static KPI addAsDescendant(KPI parent, KPI toAdd){
|
|
if(parent==null){
|
|
return null;
|
|
}
|
|
List<KPI> asDescendants = parent.getListKPI();
|
|
if(asDescendants==null){
|
|
asDescendants = new ArrayList<KPI>();
|
|
}
|
|
asDescendants.add(toAdd);
|
|
parent.setListKPI(asDescendants);
|
|
return parent;
|
|
}
|
|
|
|
/**
|
|
* List files for folder.
|
|
*
|
|
* @param folder the folder
|
|
* @param files the files
|
|
*/
|
|
private static void listFilesForFolder(final File folder, List<File> files) {
|
|
for (final File fileEntry : folder.listFiles()) {
|
|
if (fileEntry.isDirectory()) {
|
|
listFilesForFolder(fileEntry, files);
|
|
} else {
|
|
files.add(fileEntry);
|
|
System.out.println(fileEntry.getName());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Load kpi for batch level from resource.
|
|
*
|
|
* @param context the context
|
|
* @return the list
|
|
*/
|
|
private static List<PopulationType> loadKPIForBatchLevelFromResource(ServletContext context, String pathToCSVKPI){
|
|
|
|
String kpiFolder = null;
|
|
List<PopulationType> batchTypes = null;
|
|
try{
|
|
|
|
String relKPIFolder = String.format("/WEB-INF/classes/%s", pathToCSVKPI);
|
|
|
|
if(context==null){
|
|
log.warn("ECLIPSE MODE ACTIVES ADDING USER DIRECTORY");
|
|
String workingDir = System.getProperty("user.dir");
|
|
kpiFolder = String.format(workingDir+"/%s/%s", "src/main/resources", pathToCSVKPI);
|
|
}else{
|
|
log.info("Getting real path of {}",relKPIFolder);
|
|
kpiFolder = context.getRealPath(relKPIFolder);
|
|
}
|
|
|
|
log.info("KPI base folder is: {}",kpiFolder);
|
|
List<File> listFile = new ArrayList<File>();
|
|
listFilesForFolder(new File(kpiFolder), listFile);
|
|
log.info("### Loading KPIs from path: {}",kpiFolder);
|
|
batchTypes = new ArrayList<PopulationType>();
|
|
for (File file : listFile) {
|
|
try{
|
|
log.info("Reading the csv: "+file.getName());
|
|
CSVReader reader = new CSVReader(file);
|
|
batchTypes.add(createBatchType(file.getName(), reader));
|
|
}catch(Exception e){
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
if(log.isDebugEnabled()){
|
|
for (PopulationType populationType : batchTypes) {
|
|
log.info("****{} {}",PopulationType.class.getSimpleName(),populationType);
|
|
log.debug("\t**has KPIs: "+populationType.getListKPI().size());
|
|
for (KPI kpi : populationType.getListKPI()) {
|
|
printKPIs(kpi);
|
|
}
|
|
}
|
|
}
|
|
|
|
log.info("### Procedure to load the KPIs from path "+kpiFolder+" terminated correctly");
|
|
}catch(Exception e){
|
|
log.error("Error on loading KPI from path: {}",kpiFolder, e);
|
|
}
|
|
|
|
return batchTypes;
|
|
}
|
|
|
|
/**
|
|
* The main method.
|
|
*
|
|
* @param args the arguments
|
|
*/
|
|
public static void main(String[] args) {
|
|
|
|
try{
|
|
String kpiFolder = String.format("%s/src/main/resources/BATCH/KPI", System.getProperty("user.dir"));
|
|
log.info("KPI base folder is: {}",kpiFolder);
|
|
List<File> listFile = new ArrayList<File>();
|
|
listFilesForFolder(new File(kpiFolder), listFile);
|
|
log.info("### Starting populating the DB: ");
|
|
List<PopulationType> batchTypes = new ArrayList<PopulationType>();
|
|
for (File file : listFile) {
|
|
try{
|
|
log.info("Reading the csv: "+file.getName());
|
|
CSVReader reader = new CSVReader(file);
|
|
batchTypes.add(createBatchType(file.getName(), reader));
|
|
}catch(Exception e){
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
for (PopulationType populationType : batchTypes) {
|
|
log.info("****Batch {}",populationType);
|
|
log.debug("\t**has KPIs: "+populationType.getListKPI().size());
|
|
for (KPI kpi : populationType.getListKPI()) {
|
|
printKPIs(kpi);
|
|
}
|
|
}
|
|
|
|
log.info("### Procedure to populate the DB terminated");
|
|
}catch(Exception e){
|
|
}
|
|
}
|
|
|
|
}
|