file_name stringlengths 6 86 | file_path stringlengths 45 249 | content stringlengths 47 6.26M | file_size int64 47 6.26M | language stringclasses 1 value | extension stringclasses 1 value | repo_name stringclasses 767 values | repo_stars int64 8 14.4k | repo_forks int64 0 1.17k | repo_open_issues int64 0 788 | repo_created_at stringclasses 767 values | repo_pushed_at stringclasses 767 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
KNProcessPlans.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/drt/KNProcessPlans.java | package org.matsim.legacy.run.drt;
import org.matsim.api.core.v01.population.Activity;
import org.matsim.api.core.v01.population.Leg;
import org.matsim.api.core.v01.population.Person;
import org.matsim.api.core.v01.population.Plan;
import org.matsim.api.core.v01.population.PlanElement;
import org.matsim.api.core.v01.population.Population;
import org.matsim.contrib.drt.routing.DrtRoute;
import org.matsim.contrib.drt.routing.DrtRouteFactory;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.gbl.MatsimRandom;
import org.matsim.core.population.PopulationUtils;
import org.matsim.core.router.MainModeIdentifier;
import org.matsim.core.router.StageActivityTypeIdentifier;
import org.matsim.core.router.TripStructureUtils;
import java.util.ArrayList;
import java.util.List;
import static org.matsim.core.router.TripStructureUtils.StageActivityHandling.StagesAsNormalActivities;
class KNProcessPlans {
public static void main( String[] args ) {
Population pop = PopulationUtils.createPopulation( ConfigUtils.createConfig() ) ;
pop.getFactory().getRouteFactories().setRouteFactory( DrtRoute.class, new DrtRouteFactory() );
// PopulationUtils .readPopulation( pop,"berlin-drt-v5.5-1pct_drt-114/berlin-drt-v5.5-1pct_drt-114.output_plans.xml.gz" ) ;
// PopulationUtils .readPopulation( pop,"/Users/kainagel/mnt/mathe/ils3/leich/open-berlin/output/berlin-drt-v5.5-1pct_drt-132/berlin-drt-v5.5-1pct_drt-132.output_plans.xml.gz" ) ;
// PopulationUtils .readPopulation( pop,"/Users/kainagel/mnt/mathe/ils3/leich/open-berlin/output/berlin-drt-v5.5-1pct_drt-143/berlin-drt-v5.5-1pct_drt-143.output_plans.xml.gz") ;
PopulationUtils.readPopulation( pop,
"/Users/kainagel/mnt/mathe/ils3/kaddoura/avoev-intermodal-routing/output/output-i58/ITERS/it.450/i58.450.plans.xml.gz" );
// for ( final Person person : pop.getPersons().values() ) {
// person.getPlans().removeIf( (plan) -> !plan.equals( person.getSelectedPlan() ) ) ;
// }
// PopulationUtils.writePopulation( pop, "popWOnlySelectedPlans.xml.gz" );
// only keep persons who use drt:
// pop.getPersons().values().removeIf( (person) -> !selectedPlanContainsDrtAndPt( person ) ) ;
// only keep persons who use nonpt:
pop.getPersons().values().removeIf( (person) -> selectedPlanContainsPt( person ) ) ;
// remove persons who do not have pt in unselected plans
pop.getPersons().values().removeIf( (person) -> !unSelectedPlanContainsPt( person ) ) ;
// make easier to read:
for ( final Person person : pop.getPersons().values() ) {
for ( final Plan plan : person.getPlans() ) {
for ( final Leg leg : TripStructureUtils.getLegs( plan ) ) {
leg.getAttributes().clear();
}
TripStructureUtils.getActivities( plan, StagesAsNormalActivities ).forEach( (act) -> act.getAttributes().clear() );
plan.getPlanElements().removeIf( (pe) -> pe instanceof Activity && StageActivityTypeIdentifier.isStageActivity( ((Activity)pe).getType() ) );
}
}
PopulationUtils.writePopulation( pop, "popCar.xml.gz" );
// // of filtered plans, only write 1%:
// {
// Population popSel = PopulationUtils.createPopulation( ConfigUtils.createConfig() );
// for ( final Person person : pop.getPersons().values() ) {
// if ( MatsimRandom.getRandom().nextDouble() < 0.01 ) {
// final Person newPerson = popSel.getFactory().createPerson( person.getId() );
// for ( final Plan plan : person.getPlans() ) {
// Plan newPlan = PopulationUtils.createPlan();
// PopulationUtils.copyFromTo( plan, newPlan );
// newPlan.getPlanElements().removeIf( (pe) -> ( pe instanceof Activity && ((Activity)pe).getType().endsWith( "interaction" ) ) ) ;
// for ( final PlanElement planElement : newPlan.getPlanElements() ) {
// planElement.getAttributes().clear() ;
// }
// newPerson.addPlan( newPlan );
// if ( person.getSelectedPlan() == plan ) {
// newPerson.setSelectedPlan( newPlan );
// }
// }
// popSel.addPerson( newPerson );
// }
// }
// PopulationUtils.writePopulation( popSel, "popDrtAndPtReduced.xml.gz" );
// }
// // of filtered plans, only write selected plans:
// {
// Population popSel = PopulationUtils.createPopulation( ConfigUtils.createConfig() );
// for ( final Person person : pop.getPersons().values() ) {
// final Person newPerson = popSel.getFactory().createPerson( person.getId() );
// Plan newPlan = PopulationUtils.createPlan();
// PopulationUtils.copyFromTo( person.getSelectedPlan(), newPlan );
// newPerson.addPlan( newPlan );
// popSel.addPerson( newPerson );
// }
// PopulationUtils.writePopulation( popSel, "popDrtAndPtSel.xml.gz" );
// }
// {
// List<Population> pops = new ArrayList<>() ;
// for ( int ii=0 ; ii<5 ; ii++ ) {
// pops.add( PopulationUtils.createPopulation( ConfigUtils.createConfig() ) ) ;
// }
// for ( final Person person : pop.getPersons().values() ) {
// int ii=-1 ;
// for ( final Plan plan : person.getPlans() ) {
// if ( plan==person.getSelectedPlan() ) {
// continue ;
// }
// ii++ ;
// Population pop2 = pops.get( ii ) ;
//
// final Person newPerson = pop2.getFactory().createPerson( person.getId() );
// Plan newPlan = PopulationUtils.createPlan();
//
// PopulationUtils.copyFromTo( plan, newPlan );
// newPerson.addPlan( newPlan );
// pop2.addPerson( newPerson );
// }
//
// }
// int jj = 1 ;
// for ( final Population population : pops ) {
// jj++ ;
// PopulationUtils.writePopulation( population, "pop" + jj + ".xml.gz" );
// }
// }
}
private static boolean selectedPlanContainsDrtAndPt( final Person person ) {
boolean containsDrt = false ;
boolean containsPt = false ;
Plan plan = person.getSelectedPlan() ;
for ( final Leg leg : TripStructureUtils.getLegs( plan ) ) {
if ( leg.getMode().contains( "drt" ) ) {
containsDrt = true ;
}
if ( leg.getMode().contains( "pt" ) ) {
containsPt = true ;
}
}
return containsDrt && containsPt ;
}
private static boolean selectedPlanContainsNonPt( final Person person ) {
boolean containsNonPt = false ;
Plan plan = person.getSelectedPlan() ;
for ( final Leg leg : TripStructureUtils.getLegs( plan ) ) {
if ( leg.getMode().contains( "car" ) || leg.getMode().contains( "bike" ) ) {
containsNonPt = true ;
}
}
return containsNonPt ;
}
private static boolean selectedPlanContainsPt( final Person person ) {
boolean containsPt = false ;
Plan plan = person.getSelectedPlan() ;
for ( final Leg leg : TripStructureUtils.getLegs( plan ) ) {
if ( leg.getMode().contains( "pt" ) ) {
containsPt = true ;
}
}
return containsPt ;
}
private static boolean unSelectedPlanContainsPt( final Person person ) {
boolean containsPt = false ;
for ( final Plan plan : person.getPlans() ) {
for ( final Leg leg : TripStructureUtils.getLegs( plan ) ) {
if ( leg.getMode().contains( "pt" ) ) {
containsPt = true;
}
}
}
return containsPt ;
}
}
| 6,990 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
BerlinShpUtils.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/drt/BerlinShpUtils.java | /* *********************************************************************** *
* project: org.matsim.*
* *
* *********************************************************************** *
* *
* copyright : (C) 2017 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.run.drt;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import org.geotools.data.FileDataStore;
import org.geotools.data.FileDataStoreFinder;
import org.geotools.data.simple.SimpleFeatureIterator;
import org.geotools.data.simple.SimpleFeatureSource;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.Point;
import org.matsim.api.core.v01.Coord;
import org.matsim.core.utils.geometry.geotools.MGC;
import org.matsim.core.utils.gis.ShapeFileReader;
import org.opengis.feature.simple.SimpleFeature;
/**
* @author ikaddoura
*/
public final class BerlinShpUtils {
private Map<Integer, Geometry> serviceAreaGeometries;
private Map<Double, Map<Integer, Geometry>> serviceAreaGeometriesWithBuffer = new HashMap<>();
public BerlinShpUtils(String drtServiceAreaShapeFile) {
if (drtServiceAreaShapeFile != null && drtServiceAreaShapeFile != "" && drtServiceAreaShapeFile != "null" ) {
this.serviceAreaGeometries = loadShapeFile(drtServiceAreaShapeFile);
}
}
private Map<Integer, Geometry> loadShapeFile(String shapeFile) {
Map<Integer, Geometry> geometries = new HashMap<>();
Collection<SimpleFeature> features = null;
if (!shapeFile.startsWith("http")) {
features = ShapeFileReader.getAllFeatures(shapeFile);
} else {
try {
features = getAllFeatures(new URL(shapeFile));
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
if (features == null) throw new RuntimeException("Aborting...");
int featureCounter = 0;
for (SimpleFeature feature : features) {
geometries.put(featureCounter, (Geometry) feature.getDefaultGeometry());
featureCounter++;
}
return geometries;
}
public boolean isCoordInDrtServiceArea(Coord coord) {
return isCoordInArea(coord, serviceAreaGeometries);
}
public boolean isCoordInDrtServiceAreaWithBuffer(Coord coord, double buffer) {
if (!serviceAreaGeometriesWithBuffer.containsKey(buffer)) {
serviceAreaGeometriesWithBuffer.put(buffer, prepareAndSaveGeometriesWithBuffer(serviceAreaGeometries, buffer));
}
return isCoordInArea(coord, serviceAreaGeometriesWithBuffer.get(buffer));
}
private Map<Integer, Geometry> prepareAndSaveGeometriesWithBuffer(Map<Integer, Geometry> geometries, double buffer) {
Map<Integer, Geometry> geometriesWithBuffer = new HashMap<>();
for (Map.Entry<Integer, Geometry> entry: geometries.entrySet()) {
geometriesWithBuffer.put(entry.getKey(), entry.getValue().buffer(buffer));
}
return geometriesWithBuffer;
}
private boolean isCoordInArea(Coord coord, Map<Integer, Geometry> areaGeometries) {
boolean coordInArea = false;
for (Geometry geometry : areaGeometries.values()) {
Point p = MGC.coord2Point(coord);
if (p.within(geometry)) {
coordInArea = true;
}
}
return coordInArea;
}
static Collection<SimpleFeature> getAllFeatures(final URL url) {
try {
FileDataStore store = FileDataStoreFinder.getDataStore(url);
SimpleFeatureSource featureSource = store.getFeatureSource();
SimpleFeatureIterator it = featureSource.getFeatures().features();
List<SimpleFeature> featureSet = new ArrayList<SimpleFeature>();
while (it.hasNext()) {
SimpleFeature ft = it.next();
featureSet.add(ft);
}
it.close();
store.dispose();
return featureSet;
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
public Point getRandomPointInServiceArea(Random random) {
return getRandomPointInFeature(random, serviceAreaGeometries.get(random.nextInt(serviceAreaGeometries.size())));
}
private static Point getRandomPointInFeature(Random rnd, Geometry g)
{
Point p = null;
double x, y;
do {
x = g.getEnvelopeInternal().getMinX() + rnd.nextDouble()
* (g.getEnvelopeInternal().getMaxX() - g.getEnvelopeInternal().getMinX());
y = g.getEnvelopeInternal().getMinY() + rnd.nextDouble()
* (g.getEnvelopeInternal().getMaxY() - g.getEnvelopeInternal().getMinY());
p = MGC.xy2Point(x, y);
}
while (!g.contains(p));
return p;
}
}
| 5,680 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunDrtOpenBerlinScenarioWithOptDrt.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/drt/RunDrtOpenBerlinScenarioWithOptDrt.java | /* *********************************************************************** *
* project: org.matsim.*
* *
* *********************************************************************** *
* *
* copyright : (C) 2017 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.run.drt;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.population.Person;
import org.matsim.contrib.drt.run.DrtConfigGroup;
import org.matsim.contrib.drt.run.MultiModeDrtConfigGroup;
import org.matsim.contrib.drt.speedup.DrtSpeedUpParams;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.controler.Controler;
import org.matsim.optDRT.MultiModeOptDrtConfigGroup;
import org.matsim.optDRT.OptDrt;
/**
* @author ikaddoura
*/
public class RunDrtOpenBerlinScenarioWithOptDrt {
private static final Logger log = LogManager.getLogger(RunDrtOpenBerlinScenarioWithOptDrt.class);
public static void main(String[] args) {
for (String arg : args) {
log.info(arg);
}
if (args.length == 0) {
args = new String[] { "scenarios/berlin-v5.5-1pct/input/drt/berlin-drt-v5.5-1pct.config.xml" };
}
Config config = RunDrtOpenBerlinScenario.prepareConfig(args, new MultiModeOptDrtConfigGroup());
for (DrtConfigGroup drtCfg : MultiModeDrtConfigGroup.get(config).getModalElements()) {
if (drtCfg.getDrtSpeedUpParams().isEmpty()) {
drtCfg.addParameterSet(new DrtSpeedUpParams());
}
}
Scenario scenario = RunDrtOpenBerlinScenario.prepareScenario(config);
for (Person person : scenario.getPopulation().getPersons().values()) {
person.getPlans().removeIf((plan) -> plan != person.getSelectedPlan());
}
Controler controler = RunDrtOpenBerlinScenario.prepareControler(scenario);
OptDrt.addAsOverridingModule(controler,
ConfigUtils.addOrGetModule(scenario.getConfig(), MultiModeOptDrtConfigGroup.class));
controler.run() ;
// RunBerlinScenario.runAnalysis(controler);
}
}
| 3,133 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunBerlinScenarioWithBicycles.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/bicycle/RunBerlinScenarioWithBicycles.java | /* *********************************************************************** *
* project: org.matsim.*
* *
* *********************************************************************** *
* *
* copyright : (C) 2017 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.run.bicycle;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Scenario;
import org.matsim.contrib.bicycle.BicycleConfigGroup;
import org.matsim.contrib.bicycle.BicycleModule;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigGroup;
import org.matsim.core.controler.Controler;
import org.matsim.legacy.run.RunBerlinScenario;
/**
* @author dziemke
*/
public final class RunBerlinScenarioWithBicycles {
private static final Logger log = LogManager.getLogger(RunBerlinScenarioWithBicycles.class);
public static void main(String[] args) {
for (String arg : args) {
log.info( arg );
}
if ( args.length==0 ) {
throw new IllegalArgumentException("Config file needs to be provided.");
}
Config config = prepareConfig( args ) ;
Scenario scenario = RunBerlinScenario.prepareScenario( config ) ;
Controler controler = prepareControler( scenario ) ;
controler.run() ;
}
public static Controler prepareControler( Scenario scenario ) {
Controler controler = RunBerlinScenario.prepareControler( scenario ) ;
// Add bicycle module
controler.addOverridingModule(new BicycleModule());
return controler;
}
public static Config prepareConfig( String [] args, ConfigGroup... customModules) {
BicycleConfigGroup bicycleConfigGroup = new BicycleConfigGroup();
bicycleConfigGroup.setBicycleMode("bicycle");
ConfigGroup[] customModulesToAdd = new ConfigGroup[]{bicycleConfigGroup};
ConfigGroup[] customModulesAll = new ConfigGroup[customModules.length + customModulesToAdd.length];
int counter = 0;
for (ConfigGroup customModule : customModules) {
customModulesAll[counter] = customModule;
counter++;
}
for (ConfigGroup customModule : customModulesToAdd) {
customModulesAll[counter] = customModule;
counter++;
}
Config config = RunBerlinScenario.prepareConfig( args, customModulesAll ) ;
config.routing().removeModeRoutingParams("bicycle");
//
config.controller().setLastIteration(0);
//
return config ;
}
}
| 3,430 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
DynamicShutdownControlerListenerImpl.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/dynamicShutdown/DynamicShutdownControlerListenerImpl.java | package org.matsim.legacy.run.dynamicShutdown;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.analysis.ModeStatsControlerListener;
import org.matsim.analysis.ScoreStats;
import org.matsim.analysis.ScoreStatsControlerListener.ScoreItem;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.population.Person;
import org.matsim.api.core.v01.population.Plan;
import org.matsim.core.config.groups.ControllerConfigGroup;
import org.matsim.core.config.groups.ScoringConfigGroup;
import org.matsim.core.config.groups.ReplanningConfigGroup;
import org.matsim.core.controler.OutputDirectoryHierarchy;
import org.matsim.core.controler.events.IterationStartsEvent;
import org.matsim.core.controler.events.ShutdownEvent;
import org.matsim.core.controler.events.StartupEvent;
import org.matsim.core.controler.listener.IterationStartsListener;
import org.matsim.core.controler.listener.ShutdownListener;
import org.matsim.core.controler.listener.StartupListener;
import org.matsim.core.replanning.GenericPlanStrategy;
import org.matsim.core.replanning.PlanStrategyImpl;
import org.matsim.core.replanning.ReplanningUtils;
import org.matsim.core.replanning.StrategyManager;
import org.matsim.core.utils.io.IOUtils;
import javax.inject.Inject;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.*;
/**
* Initiats dynamic shutdown when a when the MATSim run has stabilized: 1) Turns off innovation in next iteration and
* 2) informs TerminateDynamically Module of the iteration at which MATSim should shut down.
*
* The simulation is deemed stable, when a group of metrics converge; currently, this includes score, mode stats,
* and mode choice coverage. A metric converges when the slope of the metric consistently lies below a user-specified
* threshold for number of iterations (default=50).
*
* @author jakobrehmann
*/
public class DynamicShutdownControlerListenerImpl implements IterationStartsListener, StartupListener, ShutdownListener, DynamicShutdownControlerListener {
private static final Logger log = LogManager.getLogger(StrategyManager.class);
private final ControllerConfigGroup controlerConfigGroup;
private final ScoreStats scoreStats;
private final ScoringConfigGroup scoreConfig;
private final ReplanningConfigGroup strategyConfigGroup;
private final ModeStatsControlerListener modeStatsControlerListener;
private final ModeChoiceCoverageControlerListener modeChoiceCoverageControlerListener;
private final Scenario scenario;
private final StrategyManager strategyManager;
private final DynamicShutdownConfigGroup cfg;
private final String outputFileName;
private final BufferedWriter slopesOut ;
private final int globalInnovationDisableAfter;
private int dynamicShutdownIteration;
private boolean dynamicShutdownInitiated;
private int dynamicInnovationDisableIteration;
private static final Map<String, Map<Integer,Double>> slopesScore = new HashMap<>();
private static final Map<String, Map<Integer,Double>> slopesMode = new HashMap<>();
private static final Map<String, Map<Integer,Double>> slopesModeChoiceCoverage = new HashMap<>();
private static final Map<String, Map<Integer,Integer>> convergenceScore = new HashMap<>();
private static final Map<String, Map<Integer,Integer>> convergenceMode = new HashMap<>();
private static final Map<String, Map<Integer,Integer>> convergenceModeCC = new HashMap<>();
private List<String> activeMetricsScore = new ArrayList<>();
private List<String> activeMetricsMode = new ArrayList<>();
private List<String> activeMetricsModeCC = new ArrayList<>();
@Inject
DynamicShutdownControlerListenerImpl(ControllerConfigGroup controlerConfigGroup, ScoreStats scoreStats,
ModeStatsControlerListener modeStatsControlerListener, StrategyManager strategyManager,
ReplanningConfigGroup strategyConfigGroup, Scenario scenario, OutputDirectoryHierarchy controlerIO,
ScoringConfigGroup scoreConfig,
ModeChoiceCoverageControlerListener modeChoiceCoverageControlerListener) {
this.scenario = scenario;
this.scoreStats = scoreStats;
this.strategyManager = strategyManager;
this.strategyConfigGroup = strategyConfigGroup;
this.controlerConfigGroup = controlerConfigGroup ;
this.modeStatsControlerListener = modeStatsControlerListener ;
this.outputFileName = controlerIO.getOutputFilename("dynShutdown_");
this.modeChoiceCoverageControlerListener = modeChoiceCoverageControlerListener;
this.cfg = (DynamicShutdownConfigGroup) scenario.getConfig().getModules().get(DynamicShutdownConfigGroup.GROUP_NAME);
this.globalInnovationDisableAfter = (int) ((controlerConfigGroup.getLastIteration() - controlerConfigGroup.getFirstIteration())
* strategyConfigGroup.getFractionOfIterationsToDisableInnovation() + controlerConfigGroup.getFirstIteration());
this.slopesOut = IOUtils.getBufferedWriter(this.outputFileName + "allMetrics.txt");
this.scoreConfig = scoreConfig;
}
@Override
public int getDynamicShutdownIteration() {
return dynamicShutdownIteration;
}
@Override
public boolean isDynamicShutdownInitiated() {
return dynamicShutdownInitiated;
}
@Override
public void notifyStartup(StartupEvent startupEvent) {
dynamicShutdownInitiated = false ;
dynamicShutdownIteration = Integer.MAX_VALUE;
dynamicInnovationDisableIteration = Integer.MAX_VALUE;
generateMetricLists(scoreConfig);
try {
this.slopesOut.write("Iteration");
for ( String scoreType : activeMetricsScore) {
this.slopesOut.write("\tscore-" + scoreType+ "\tconverged");
}
for ( String mode : activeMetricsMode) {
this.slopesOut.write("\tmode-" + mode+ "\tconverged");
}
for ( String mode : activeMetricsModeCC) {
this.slopesOut.write("\tmodeCC-" + mode + "\tconverged");
}
this.slopesOut.write("\tnotes");
this.slopesOut.flush();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
}
@Override
public void notifyIterationStarts(IterationStartsEvent iterationStartsEvent) {
int iteration = iterationStartsEvent.getIteration();
int prevIteration = iteration - 1;
if (cfg.isDynamicShutdownModuleActive()== DynamicShutdownConfigGroup.dynamicShutdownOptions.OFF) {
log.warn("Dynamic shutdown module not active");
}
if (activeMetricsScore.isEmpty() && activeMetricsMode.isEmpty() && activeMetricsModeCC.isEmpty()) {
log.warn("No criteria specified for dynamic shutdown module");
return;
}
if (iteration < cfg.getIterationToStartFindingSlopes()) {
return;
}
try {
this.slopesOut.write("\n" + prevIteration);
} catch (IOException e) {
e.printStackTrace();
}
boolean scoreConverged = false;
if (!activeMetricsScore.isEmpty()) {
String metricType = "score";
Map<ScoreItem, Map<Integer, Double>> scoreHistory = scoreStats.getScoreHistory();
Map<String, Map<Integer, Double>> scoreHistoryMod = new HashMap<>();
for (ScoreItem scoreItem : scoreHistory.keySet()) {
scoreHistoryMod.put(scoreItem.name(), scoreHistory.get(scoreItem));
}
bestFitLineGeneric(prevIteration, scoreHistoryMod, slopesScore, activeMetricsScore);
produceDynShutdownGraphs(scoreHistoryMod, slopesScore, metricType, activeMetricsScore, cfg.getScoreThreshold(), iteration);
scoreConverged = metricTypeConverges(slopesScore, convergenceScore, activeMetricsScore, cfg.getScoreThreshold(), prevIteration);
writeSlopeAndConvergence(slopesScore, convergenceScore, activeMetricsScore, prevIteration);
}
boolean modeConverged = false;
if (!activeMetricsMode.isEmpty()) {
String metricType = "mode";
if (true)
throw new RuntimeException(" modeStatsControlerListener.getModeHistories() not implemented anymore. Check if this is still needed.");
Map<String, Map<Integer, Double>> modeHistories =null;
bestFitLineGeneric(prevIteration, modeHistories, slopesMode, activeMetricsMode);
produceDynShutdownGraphs(modeHistories, slopesMode, metricType, activeMetricsMode, cfg.getModeThreshold(), iteration);
modeConverged = metricTypeConverges(slopesMode, convergenceMode, activeMetricsMode, cfg.getModeThreshold(), prevIteration);
writeSlopeAndConvergence(slopesMode, convergenceMode, activeMetricsMode, prevIteration);
}
boolean modeCCConverged = false;
if (!activeMetricsModeCC.isEmpty()) {
String metricType = "modeChoiceCoverage";
int mCCLimit = 1;
Map<String, Map<Integer, Double>> mCCHistory = modeChoiceCoverageControlerListener.getModeChoiceCoverageHistory().get(mCCLimit);
bestFitLineGeneric(prevIteration, mCCHistory, slopesModeChoiceCoverage, activeMetricsModeCC);
produceDynShutdownGraphs(mCCHistory,slopesModeChoiceCoverage, metricType, activeMetricsModeCC, cfg.getModeChoiceCoverageThreshold(),iteration);
modeCCConverged = metricTypeConverges(slopesModeChoiceCoverage, convergenceModeCC, activeMetricsModeCC, cfg.getModeChoiceCoverageThreshold(), prevIteration);
writeSlopeAndConvergence(slopesModeChoiceCoverage, convergenceModeCC, activeMetricsModeCC, prevIteration);
}
try {
if (iteration == dynamicInnovationDisableIteration) {
this.slopesOut.write("\tNOTE: innovation turned off");
}
} catch (IOException e) {
e.printStackTrace();
}
if (cfg.isDynamicShutdownModuleActive() == DynamicShutdownConfigGroup.dynamicShutdownOptions.ON_ANALYSIS_ONLY) {
return;
}
if (dynamicShutdownInitiated) {
log.info("Dynamic shutdown was previously initiated");
return;
}
if (iteration < cfg.getMinimumIteration()) {
return ;
}
if (iteration >= globalInnovationDisableAfter) {
return;
}
if (!activeMetricsScore.isEmpty() && !scoreConverged) {
return;
}
if (!activeMetricsMode.isEmpty() && !modeConverged) {
return;
}
if (!activeMetricsModeCC.isEmpty() && !modeCCConverged) {
return;
}
shutdownInnovation(iteration);
}
private void writeSlopeAndConvergence(Map<String, Map<Integer, Double>> slopesMap,
Map<String, Map<Integer, Integer>> convergenceMap,
List<String> metricsToInclude,int prevIteration) {
try{
for (String metric : metricsToInclude) {
Double slope = slopesMap.get(metric).get(prevIteration);
int convCnt = convergenceMap.get(metric).get(prevIteration);
String convStr;
if (convCnt >= cfg.getIterationsInZoneToConverge()) {
convStr = "true";
} else {
convStr = convCnt + "/" + cfg.getIterationsInZoneToConverge();
}
this.slopesOut.write("\t"+ slope + "\t" + convStr);
}
this.slopesOut.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
private boolean metricTypeConverges(Map<String, Map<Integer, Double>> slopesMap,
Map<String, Map<Integer, Integer>> convergenceMap,
List<String> metricsToInclude,
double threshold,
int prevIteration) {
if (slopesMap.isEmpty()) {
return false;
}
for (String metric : metricsToInclude) {
Map<Integer,Integer> convergenceCntPerMetric = convergenceMap.computeIfAbsent(metric, v -> new HashMap<>());
Double slope = slopesMap.get(metric).get(prevIteration);
if (slope > -1 * threshold && slope < threshold) {
int convergenceCountSoFar = convergenceCntPerMetric.getOrDefault(prevIteration - 1, 0);
convergenceCntPerMetric.put(prevIteration, convergenceCountSoFar + 1);
} else {
convergenceCntPerMetric.put(prevIteration, 0);
}
}
for (String metric : metricsToInclude) {
if (convergenceMap.get(metric).get(prevIteration) < cfg.getIterationsInZoneToConverge()) {
return false;
}
}
return true;
}
private void bestFitLineGeneric(int prevIteration,
Map<String, Map<Integer, Double>> history,
Map<String, Map<Integer, Double>> slopes,
List<String> metricsToInclude) {
for (Map.Entry<String, Map<Integer, Double>> entry : history.entrySet()) {
String metricName = entry.getKey();
if (!metricsToInclude.isEmpty() && !metricsToInclude.contains(metricName)) {
continue;
}
double slope = computeLineSlope(entry.getValue());
Map<Integer,Double> slopesForMetric = slopes.computeIfAbsent(metricName, v -> new HashMap<>());
slopesForMetric.put(prevIteration,slope);
}
}
private double computeLineSlope(Map<Integer,Double> inputMap) {
int currentIter = Collections.max(inputMap.keySet());
int startIteration = currentIter - cfg.getMinimumWindowSize() + 1; // fixed window
int startIterationExpanding = (int) ((1.0 - cfg.getExpandingWindowPctRetention()) * currentIter + 1); // expanding window
if (cfg.getSlopeWindowPolicy() == DynamicShutdownConfigGroup.slopeWindowOption.EXPANDING && startIterationExpanding < startIteration) {
startIteration = startIterationExpanding;
}
ArrayList<Integer> x = new ArrayList<>();
ArrayList<Double> y = new ArrayList<>();
for (Integer it : inputMap.keySet()) {
if (it >= startIteration) {
x.add(it);
y.add(inputMap.get(it));
}
}
if (x.size() != y.size()) {
throw new IllegalArgumentException("array lengths are not equal");
}
int n = x.size();
double sumX = 0.0;
double sumY = 0.0;
for (int i = 0; i < n; i++) {
sumX += x.get(i);
sumY += y.get(i);
}
double xBar = sumX / n;
double yBar = sumY / n;
double xxBar = 0.0;
double xyBar = 0.0;
for (int i = 0; i < n; i++) {
xxBar += (x.get(i) - xBar) * (x.get(i) - xBar);
xyBar += (x.get(i) - xBar) * (y.get(i) - yBar);
}
return xyBar / xxBar;
}
private void produceDynShutdownGraphs(Map<String, Map<Integer, Double>> history,
Map<String, Map<Integer, Double>> slopes,
String metricType,
List<String> metricsToInclude,
double convergenceThreshold,
int iteration) {
if (iteration <= cfg.getMinIterationForGraphics()) {
return;
}
for (String metricName : metricsToInclude) {
try {
XYLineChartDualYAxis chart = new XYLineChartDualYAxis("Convergence of " + metricType + "-" + metricName, "iteration", metricType + " : " + metricName, "slope of " + metricName);
chart.addSeries(metricName, history.get(metricName));
chart.addSeries2("slope of " + metricName, slopes.get(metricName));
chart.addVerticalRange(-convergenceThreshold, convergenceThreshold);
chart.addMatsimLogo();
chart.saveAsPng(outputFileName + metricType + "_" + metricName + ".png", 800, 600);
} catch (NullPointerException e) {
log.error("Too early to produce Could not produce Dynamic Shutdown Graphs (probably too early)");
}
}
}
private void shutdownInnovation(int iteration) {
dynamicInnovationDisableIteration = iteration + 1; // New weights are in effect in following iteration.
double innoPct = strategyConfigGroup.getFractionOfIterationsToDisableInnovation();
int firstIter = controlerConfigGroup.getFirstIteration();
dynamicShutdownIteration = (int) ((dynamicInnovationDisableIteration - firstIter) / innoPct) + firstIter;
dynamicShutdownInitiated = true;
Set<String> subpopulations = new HashSet<>();
for (ReplanningConfigGroup.StrategySettings setting : this.scenario.getConfig().replanning().getStrategySettings()) {
subpopulations.add(setting.getSubpopulation());
if (subpopulations.size() == 0) subpopulations.add(null);
}
for (String subpopulation : subpopulations) {
for (GenericPlanStrategy<Plan, Person> planStrategy : strategyManager.getStrategies(subpopulation)) {
PlanStrategyImpl planStrategyImpl = (PlanStrategyImpl) planStrategy;
if (!(ReplanningUtils.isOnlySelector(planStrategyImpl))) { // if (innovation strategy)
strategyManager.addChangeRequest(dynamicInnovationDisableIteration, planStrategyImpl, subpopulation, 0.);
}
}
}
log.info("********** DYNAMIC SHUTDOWN INITIATED ***********");
log.info("Innovation strategies deactivated in iteration " + (dynamicInnovationDisableIteration));
log.info("Full shutdown will occur in iteration " + dynamicShutdownIteration);
try {
this.slopesOut.write("\tNOTE: dynamic shutdown initiated");
} catch (IOException e) {
e.printStackTrace();
}
}
private void generateMetricLists(ScoringConfigGroup scoreConfig) {
switch (cfg.getScorePolicyChosen()) {
case ON_FULL:
activeMetricsScore = new ArrayList<>(Arrays.asList(
ScoreItem.executed.name(),
ScoreItem.average.name(),
ScoreItem.best.name(),
ScoreItem.worst.name()));
break;
case ON_EXECUTED_ONLY:
activeMetricsScore.add(ScoreItem.executed.name());
break;
case OFF:
break;
default:
break;
}
switch (cfg.getModePolicyChosen()) {
case ON_FULL:
activeMetricsMode.addAll(scoreConfig.getAllModes());
break;
case OFF:
activeMetricsMode.clear();
break;
default:
activeMetricsMode.clear();
break;
}
switch (cfg.getModeCCPolicyChosen()) {
case ON_FULL:
activeMetricsModeCC.addAll(scoreConfig.getAllModes());
break;
case OFF:
activeMetricsModeCC.clear();
break;
default:
activeMetricsModeCC.clear();
break;
}
}
@Override
public void notifyShutdown(ShutdownEvent shutdownEvent) {
try {
this.slopesOut.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
| 20,258 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
DynamicShutdownModule.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/dynamicShutdown/DynamicShutdownModule.java | package org.matsim.legacy.run.dynamicShutdown;
import com.google.inject.Singleton;
import org.matsim.core.controler.AbstractModule;
import org.matsim.core.controler.TerminationCriterion;
public class DynamicShutdownModule extends AbstractModule {
/**
* Adds all necessary GUICE bindings for Dynamic Shutdown to work.
*
* @author jakobrehmann
*/
@Override
public void install() {
this.bind(ModeChoiceCoverageControlerListener.class).in(Singleton.class);
this.addControlerListenerBinding().to(ModeChoiceCoverageControlerListener.class);
this.bind(DynamicShutdownControlerListenerImpl.class).in(Singleton.class);
this.addControlerListenerBinding().to(DynamicShutdownControlerListenerImpl.class);
this.bind(TerminateDynamically.class).in(Singleton.class);
this.bind(TerminationCriterion.class).to(TerminateDynamically.class);
}
}
| 919 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
DynamicShutdownControlerListener.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/dynamicShutdown/DynamicShutdownControlerListener.java | package org.matsim.legacy.run.dynamicShutdown;
/**
*
* @author jakobrehmann
*/
public interface DynamicShutdownControlerListener {
int getDynamicShutdownIteration();
boolean isDynamicShutdownInitiated();
}
| 222 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
XYLineChartDualYAxis.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/dynamicShutdown/XYLineChartDualYAxis.java | /* *********************************************************************** *
* project: org.matsim.*
* BarChart.java
* *
* *********************************************************************** *
* *
* copyright : (C) 2007 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.run.dynamicShutdown;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.LogarithmicAxis;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.plot.IntervalMarker;
import org.jfree.chart.plot.Marker;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYAreaRenderer;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.chart.renderer.xy.XYSplineRenderer;
import org.jfree.chart.ui.RectangleAnchor;
import org.jfree.chart.ui.RectangleInsets;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.matsim.core.utils.charts.ChartUtil;
import javax.swing.*;
import java.awt.*;
import java.util.Map;
import java.util.Map.Entry;
/**
* Creates a new XYLineChart with dual Y axes
*
* @author jakobrehmann
* adapted from mrieser
*/
public class XYLineChartDualYAxis extends ChartUtil {
private final XYSeriesCollection dataset1;
private final XYSeriesCollection dataset2;
public XYLineChartDualYAxis(final String title, final String xAxisLabel,
final String yAxisLabel, final String yAxisLabel2) {
super(title, xAxisLabel, yAxisLabel);
this.dataset1 = new XYSeriesCollection();
this.dataset2 = new XYSeriesCollection();
this.chart = createChart(title, xAxisLabel, yAxisLabel, this.dataset1, yAxisLabel2, dataset2);
addDefaultFormatting();
}
@Override
public JFreeChart getChart() {
return this.chart;
}
private JFreeChart createChart(final String title, final String categoryAxisLabel, final String yAxisLabel, final XYSeriesCollection dataset1,
final String yAxisLabel2, final XYSeriesCollection dataset2) {
XYPlot plot = new XYPlot();
plot.setDataset(1, dataset1);
plot.setDataset(0, dataset2);
XYLineAndShapeRenderer renderer1 = new XYLineAndShapeRenderer(true, false);
renderer1.setSeriesFillPaint(0,Color.YELLOW);
plot.setRenderer(1, renderer1);//use default fill paint for first series
XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer(true, false);
renderer.setSeriesFillPaint(0, Color.GREEN);
plot.setRenderer(0, renderer);
plot.setRangeAxis(1, new NumberAxis(yAxisLabel));
plot.setRangeAxis(0, new NumberAxis(yAxisLabel2));
plot.setDomainAxis(new NumberAxis(categoryAxisLabel));
//Map the data to the appropriate axis
plot.mapDatasetToRangeAxis(0, 0);
plot.mapDatasetToRangeAxis(1, 1);
JFreeChart chart = new JFreeChart(title, null, plot, true);
chart.setBackgroundPaint(Color.WHITE);
return chart;
}
public void addVerticalRange(double botLimit, double topLimit) {
XYPlot plot = this.chart.getXYPlot();
IntervalMarker marker = new IntervalMarker(botLimit, topLimit);
marker.setPaint(Color.PINK);
marker.setLabel("CovergenceZone");
marker.setLabelAnchor(RectangleAnchor.TOP);
plot.addRangeMarker(marker);
}
/**
* Adds a new data series to the chart with the specified title.
* <code>xs<code> and <code>ys</code> should have the same length. If not, only as many items
* are shown as the shorter array contains.
*
* @param title
* @param xs The x values.
* @param ys The y values.
*/
public final void addSeries(final String title, final double[] xs, final double[] ys) {
XYSeries series = new XYSeries(title, false, true);
for (int i = 0, n = Math.min(xs.length, ys.length); i < n; i++) {
series.add(xs[i], ys[i]);
}
this.dataset1.addSeries(series);
}
public final void addSeries(String title, Map<Integer, Double> map) {
XYSeries series = new XYSeries(title, false, true);
for ( Entry<Integer,Double> entry : map.entrySet() ) {
series.add(entry.getKey(), entry.getValue() );
}
this.dataset1.addSeries(series);
}
public final void addSeries2(String title, Map<Integer, Double> map) {
XYSeries series = new XYSeries(title, false, true);
for ( Entry<Integer,Double> entry : map.entrySet() ) {
series.add(entry.getKey(), entry.getValue() );
}
this.dataset2.addSeries(series);
}
}
| 5,461 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
TerminateDynamically.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/dynamicShutdown/TerminateDynamically.java |
/* *********************************************************************** *
* project: org.matsim.*
* TerminateAtFixedIterationNumber.java
* *
* *********************************************************************** *
* *
* copyright : (C) 2019 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.run.dynamicShutdown;
import org.matsim.core.config.groups.ControllerConfigGroup;
import org.matsim.core.controler.TerminationCriterion;
import javax.inject.Inject;
/**
* Shuts down MATSim, when one of two criteria are satisfied: a) the lastIteration specified in the config file is reached or b) dynamic lastIteration, which can be
* retrieved from the DynamicShutdownControlerListener is reached (if dynamic shutdown is even initiated).
*
* @author jakobrehmann
*/
public class TerminateDynamically implements TerminationCriterion {
private final int lastIteration;
private final DynamicShutdownControlerListenerImpl convergenceDynamicShutdown;
@Inject
TerminateDynamically(ControllerConfigGroup controlerConfigGroup, DynamicShutdownControlerListenerImpl convergenceDynamicShutdown) {
this.lastIteration = controlerConfigGroup.getLastIteration();
this.convergenceDynamicShutdown = convergenceDynamicShutdown;
}
//FIXME
@Override
public boolean mayTerminateAfterIteration(int iteration) {
if (convergenceDynamicShutdown.isDynamicShutdownInitiated()) {
int lastIterationDynamic = convergenceDynamicShutdown.getDynamicShutdownIteration();
return (iteration >= lastIteration || iteration >= lastIterationDynamic);
}
return iteration >= lastIteration ;
}
@Override
public boolean doTerminate(int i) {
if (convergenceDynamicShutdown.isDynamicShutdownInitiated()) {
int lastIterationDynamic = convergenceDynamicShutdown.getDynamicShutdownIteration();
return (i >= lastIteration || i >= lastIterationDynamic);
}
return i >= lastIteration ;
}
}
| 2,995 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
DynamicShutdownConfigGroup.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/dynamicShutdown/DynamicShutdownConfigGroup.java | package org.matsim.legacy.run.dynamicShutdown;
import org.matsim.core.config.ReflectiveConfigGroup;
/**
*
* Allows users to set and get parameters for DynamicShutdownControlerListener. Defaults are included for all parameters.
*
* @author jakobrehmann
*/
public class DynamicShutdownConfigGroup extends ReflectiveConfigGroup {
public static final String GROUP_NAME = "dynamicShutdown";
private static final String MINIMUM_ITERATION_FOR_SHUTDOWN = "minIterationForShutdown";
private static final String ITERATION_TO_START_FINDING_SLOPES = "iterationToStartFindingSlopes";
private static final String SLOPE_WINDOW_POLICY = "slopeWindowPolicy";
private static final String MINIMUM_WINDOW_SIZE = "minWindowSize";
private static final String EXPANDING_WINDOW_PCT_RETENTION = "expandingWindowPctRetention";
private static final String ITERATIONS_IN_ZONE_TO_CONVERGE = "iterationsInZoneToConverge";
private static final String MIN_ITERATIONS_FOR_GRAPHS = "minIterationForGraphs";
private static final String SCORE_POLICY_CHOSEN = "scorePolicyChosen";
private static final String MODE_POLICY_CHOSEN = "modePolicyChosen";
private static final String MODE_CHOICE_COVERAGE_POLICY_CHOSEN = "modeChoiceCoveragePolicyChosen";
private static final String SCORE_THRESHOLD = "scoreConvergenceThreshold";
private static final String MODE_THRESHOLD= "modeConvergenceThreshold";
private static final String MODE_CHOICE_COVERAGE_THRESHOLD= "modeChoiceCoverageConvergenceThreshold";
private static final String DYNAMIC_SHUTDOWN_MODULE_ACTIVE = "dynamicShutdownModuleActive";
public enum dynamicShutdownOptions { ON_FULL , ON_ANALYSIS_ONLY , OFF }
public enum scorePolicyOptions { ON_FULL , ON_EXECUTED_ONLY , OFF }
public enum modePolicyOptions { ON_FULL , OFF }
public enum modeCCPolicyOptions { ON_FULL, OFF }
public enum slopeWindowOption { FIXED , EXPANDING }
private dynamicShutdownOptions dynamicShutdownModuleActive = dynamicShutdownOptions.OFF;
private int minimumIteration = 0;
private int iterationToStartFindingSlopes = 50;
private slopeWindowOption slopeWindowPolicy = slopeWindowOption.EXPANDING;
private int minimumWindowSize = 50;
private double expandingWindowPctRetention = 0.25;
private int iterationsInZoneToConverge = 50;
private int minIterationForGraphics = 50;
private scorePolicyOptions scorePolicyChosen = scorePolicyOptions.ON_EXECUTED_ONLY;
private double scoreThreshold = 0.001;
private modePolicyOptions modePolicyChosen = modePolicyOptions.ON_FULL;
private double modeThreshold = 0.00003;
private modeCCPolicyOptions modeCCPolicyChosen = modeCCPolicyOptions.ON_FULL;
private double modechoicecoverageThreshold = 0.0001;
public DynamicShutdownConfigGroup() {
super(GROUP_NAME);
}
@StringGetter(DYNAMIC_SHUTDOWN_MODULE_ACTIVE)
public dynamicShutdownOptions isDynamicShutdownModuleActive() {
return dynamicShutdownModuleActive;
}
@StringSetter(DYNAMIC_SHUTDOWN_MODULE_ACTIVE)
public void setDynamicShutdownModuleActive(final dynamicShutdownOptions dynamicShutdownModuleActive) {
this.dynamicShutdownModuleActive = dynamicShutdownModuleActive;
}
@StringGetter( MINIMUM_ITERATION_FOR_SHUTDOWN )
public int getMinimumIteration() {
return this.minimumIteration;
}
@StringSetter(MINIMUM_ITERATION_FOR_SHUTDOWN)
public void setMinimumIteration(final int minimumIteration) {
this.minimumIteration = minimumIteration;
}
@StringGetter(ITERATION_TO_START_FINDING_SLOPES)
public int getIterationToStartFindingSlopes() {
return iterationToStartFindingSlopes;
}
@StringSetter(ITERATION_TO_START_FINDING_SLOPES)
public void setIterationToStartFindingSlopes(final int iterationToStartFindingSlopes) {
this.iterationToStartFindingSlopes = iterationToStartFindingSlopes;
}
@StringGetter(SLOPE_WINDOW_POLICY)
public slopeWindowOption getSlopeWindowPolicy() {
return slopeWindowPolicy;
}
@StringSetter(SLOPE_WINDOW_POLICY)
public void setSlopeWindowPolicy(final slopeWindowOption slopeWindowPolicy) {
this.slopeWindowPolicy = slopeWindowPolicy;
}
@StringGetter(MINIMUM_WINDOW_SIZE)
public int getMinimumWindowSize() {
return minimumWindowSize;
}
@StringSetter(MINIMUM_WINDOW_SIZE)
public void setMinimumWindowSize(final int minimumWindowSize) {
this.minimumWindowSize = minimumWindowSize;
}
@StringGetter(EXPANDING_WINDOW_PCT_RETENTION)
public double getExpandingWindowPctRetention() {
return expandingWindowPctRetention;
}
@StringSetter(EXPANDING_WINDOW_PCT_RETENTION)
public void setExpandingWindowPctRetention(final double expandingWindowPctRetention) {
this.expandingWindowPctRetention = expandingWindowPctRetention;
}
@StringGetter(ITERATIONS_IN_ZONE_TO_CONVERGE)
public int getIterationsInZoneToConverge() {
return iterationsInZoneToConverge;
}
@StringSetter(ITERATIONS_IN_ZONE_TO_CONVERGE)
public void setIterationsInZoneToConverge(final int iterationsInZoneToConverge) {
this.iterationsInZoneToConverge = iterationsInZoneToConverge;
}
@StringGetter(MIN_ITERATIONS_FOR_GRAPHS)
public int getMinIterationForGraphics() {
return minIterationForGraphics;
}
@StringSetter(MIN_ITERATIONS_FOR_GRAPHS)
public void setMinIterationForGraphics(final int minIterationForGraphics) {
this.minIterationForGraphics = minIterationForGraphics;
}
@StringGetter(SCORE_POLICY_CHOSEN)
public scorePolicyOptions getScorePolicyChosen() {
return scorePolicyChosen;
}
@StringSetter(SCORE_POLICY_CHOSEN)
public void setScorePolicyChosen(final scorePolicyOptions scorePolicyChosen) {
this.scorePolicyChosen = scorePolicyChosen;
}
@StringGetter(SCORE_THRESHOLD)
public double getScoreThreshold() {
return scoreThreshold;
}
@StringSetter(SCORE_THRESHOLD)
public void setScoreThreshold(final double scoreThreshold) {
this.scoreThreshold = scoreThreshold;
}
@StringGetter(MODE_POLICY_CHOSEN)
public modePolicyOptions getModePolicyChosen() {
return modePolicyChosen;
}
@StringSetter(MODE_POLICY_CHOSEN)
public void setModePolicyChosen(final modePolicyOptions modePolicyChosen) {
this.modePolicyChosen = modePolicyChosen;
}
@StringGetter(MODE_THRESHOLD)
public double getModeThreshold() {
return modeThreshold;
}
@StringSetter(MODE_THRESHOLD)
public void setModeThreshold(final double modeThreshold) {
this.modeThreshold = modeThreshold;
}
@StringGetter(MODE_CHOICE_COVERAGE_POLICY_CHOSEN)
public modeCCPolicyOptions getModeCCPolicyChosen() {
return modeCCPolicyChosen;
}
@StringSetter(MODE_CHOICE_COVERAGE_POLICY_CHOSEN)
public void setModeCCPolicyChosen(final modeCCPolicyOptions modeCCPolicyChosen) {
this.modeCCPolicyChosen = modeCCPolicyChosen;
}
@StringGetter(MODE_CHOICE_COVERAGE_THRESHOLD)
public double getModeChoiceCoverageThreshold() {
return modechoicecoverageThreshold;
}
@StringSetter(MODE_CHOICE_COVERAGE_THRESHOLD)
public void setModechoicecoverageThreshold(final double modechoicecoverageThreshold) {
this.modechoicecoverageThreshold = modechoicecoverageThreshold;
}
}
| 7,477 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
ModeChoiceCoverageControlerListener.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/dynamicShutdown/ModeChoiceCoverageControlerListener.java | package org.matsim.legacy.run.dynamicShutdown;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.population.Person;
import org.matsim.api.core.v01.population.Plan;
import org.matsim.api.core.v01.population.Population;
import org.matsim.core.config.groups.ControllerConfigGroup;
import org.matsim.core.config.groups.ScoringConfigGroup;
import org.matsim.core.controler.OutputDirectoryHierarchy;
import org.matsim.core.controler.events.IterationEndsEvent;
import org.matsim.core.controler.events.ShutdownEvent;
import org.matsim.core.controler.events.StartupEvent;
import org.matsim.core.controler.listener.IterationEndsListener;
import org.matsim.core.controler.listener.ShutdownListener;
import org.matsim.core.controler.listener.StartupListener;
import org.matsim.core.router.AnalysisMainModeIdentifier;
import org.matsim.core.router.MainModeIdentifier;
import org.matsim.core.router.TripStructureUtils;
import org.matsim.core.router.TripStructureUtils.Trip;
import org.matsim.core.utils.charts.XYLineChart;
import org.matsim.core.utils.io.IOUtils;
import javax.inject.Inject;
import java.io.BufferedWriter;
import java.io.IOException;
import java.util.*;
import java.util.Map.Entry;
/**
* Calculates mode choice coverage at the end of each iteration, based on the main mode identifier of a trip chain.
* Mode choice coverage percentage of trips have used a certain mode at least once (or 5x, 10x, โฆ) in previous iterations.
*
* FIXME: This class was copied to matsim-libs. To be removed. The rest of Dynamic Shutdown currently needs this class though.
*
* @author jakobrehmann
*/
public class ModeChoiceCoverageControlerListener implements StartupListener, IterationEndsListener,
ShutdownListener {
private final static Logger log = LogManager.getLogger(org.matsim.analysis.ModeStatsControlerListener.class);
private final Map<Integer, BufferedWriter> modeOutMap = new HashMap<>();
private final Population population;
private final String modeFileName;
private final boolean createPNG;
private final ControllerConfigGroup controlerConfigGroup;
private final MainModeIdentifier mainModeIdentifier;
private int minIteration = 0;
private int firstIteration = -1;
private final Integer[] limits = new Integer[]{1, 5, 10};
private final Map<Integer, Map<String, Map<Integer, Double>>> modeCCHistory = new HashMap<>();
// Map<Iter , Map<Mode , Map<Limit , Pct >>>
private final Map<Id<Person>, Map<Integer, Map<String, Integer>>> modesUsedPerPersonTrip = new LinkedHashMap<>();
// Map<Person , Map<Trip # , Map<Mode , Count >>>
private static final String FILENAME_MODESTATS = "modeChoiceCoverage";
// Keep all modes encountered so far in a sorted set to ensure output is written for modes sorted by mode.
private final Set<String> modes;
@Inject
ModeChoiceCoverageControlerListener(ControllerConfigGroup controlerConfigGroup, Population population1, OutputDirectoryHierarchy controlerIO,
ScoringConfigGroup scoreConfig, AnalysisMainModeIdentifier mainModeIdentifier) {
this.controlerConfigGroup = controlerConfigGroup;
this.population = population1;
this.modeFileName = controlerIO.getOutputFilename(FILENAME_MODESTATS);
// this.createPNG = controlerConfigGroup.isCreateGraphs();
this.createPNG = true;
this.modes = new TreeSet<>();
// this.modes.addAll(scoreConfig.getAllModes());
this.mainModeIdentifier = mainModeIdentifier;
}
@Override
public void notifyStartup(final StartupEvent event) {
this.minIteration = controlerConfigGroup.getFirstIteration();
}
@Override
public void notifyIterationEnds(final IterationEndsEvent event) {
if (firstIteration < 0) {
firstIteration = event.getIteration();
}
/*
* modesUsedPerPersonTrip: for each person-trip, how many times (iterations) was each mode used. The following code adds the
* mode information from the current iteration to the modesUsedPerPersonTrip.
*/
updateModesUsedPerPerson();
/*
* Looks through modesUsedPerPersonTrip at each person-trip. How many of those person trips have used each mode more than the
* predefined limits.
*/
int totalPersonTripCount = 0;
Map<Integer, Map<String, Double>> modeCountCurrentIteration = new TreeMap<>();
//Map<Limit, Map<Mode , TotalTripCount >>
for (Map<Integer, Map<String, Integer>> mapForPerson : modesUsedPerPersonTrip.values()) {
//Map<Trip # , Map<Mode , Count >>
for (Map<String, Integer> mapForPersonTrip : mapForPerson.values()) {
//Map<Mode , Count >
totalPersonTripCount++;
for (String mode : mapForPersonTrip.keySet()) {
Integer realCount = mapForPersonTrip.get(mode);
for (Integer limit : limits) {
Map<String, Double> modeCountMap = modeCountCurrentIteration.computeIfAbsent(limit, k -> new TreeMap<>());
Double modeCount = modeCountMap.computeIfAbsent(mode, k -> 0.);
if (realCount >= limit) {
modeCount++;
}
modeCountMap.put(mode, modeCount);
modeCountCurrentIteration.put(limit, modeCountMap);
}
}
}
}
// Calculates mcc share for each mode in current iteration, and updates modeCCHistory accordingly
for (Integer limit : limits) {
Map<String, Double> modeCnt = modeCountCurrentIteration.get(limit);
this.modes.addAll(modeCnt.keySet()); // potentially adds new modes to setthat just showed up in current iter
Map<String, Map<Integer, Double>> modeIterationShareMap = modeCCHistory.computeIfAbsent(limit, k -> new HashMap<>());
for (String mode : modes) {
Double cnt = modeCnt.get(mode);
double share = 0.;
if (cnt != null) {
share = cnt / totalPersonTripCount;
}
log.info("-- mode choice coverage (" + limit + "x) of mode " + mode + " = " + share);
Map<Integer, Double> iterationShareMap = modeIterationShareMap.get(mode);
// If this is the first iteration where the mode shows up, add zeros to all previous iterations in history
if (iterationShareMap == null) {
iterationShareMap = new TreeMap<>();
for (int iter = firstIteration; iter < event.getIteration(); iter++) {
iterationShareMap.put(iter, 0.0);
}
modeIterationShareMap.put(mode, iterationShareMap);
}
iterationShareMap.put(event.getIteration(), share);
}
}
// Print MCC Stats to output file
for (Integer limit : limits) {
Map<String, Map<Integer, Double>> modeIterationShareMap = modeCCHistory.get(limit);
BufferedWriter modeOut = IOUtils.getBufferedWriter(this.modeFileName + limit + "x.txt");
try {
modeOut.write("Iteration");
for (String mode : modes) {
modeOut.write("\t" + mode);
}
modeOut.write("\n");
for (int iter = firstIteration; iter <= event.getIteration(); iter++) {
modeOut.write(String.valueOf(iter));
for (String mode : modes) {
modeOut.write("\t" + modeIterationShareMap.get(mode).get(iter));
}
modeOut.write("\n");
}
modeOut.flush();
modeOut.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// Produce Graphs
if (this.createPNG && event.getIteration() > this.minIteration) {
produceGraphs();
}
}
private void updateModesUsedPerPerson() {
for (Person person : this.population.getPersons().values()) {
Map<Integer, Map<String, Integer>> mapForPerson = modesUsedPerPersonTrip.computeIfAbsent(person.getId(), v -> new LinkedHashMap<>());
Plan plan = person.getSelectedPlan();
Integer tripNumber = 0;
for (Trip trip : TripStructureUtils.getTrips(plan)) {
tripNumber++;
String mode = this.mainModeIdentifier.identifyMainMode(trip.getTripElements());
Map<String, Integer> mapForPersonTrip = mapForPerson.computeIfAbsent(tripNumber, v -> new HashMap<>());
Integer modeCount = mapForPersonTrip.getOrDefault(mode, 0);
mapForPersonTrip.put(mode, modeCount + 1);
}
}
}
private void produceGraphs() {
for (Integer limit : limits) {
XYLineChart chart = new XYLineChart("Mode Choice Coverage (Mode Used >= " + limit + "x per trip)", "iteration", "mode choice coverage");
for (Entry<String, Map<Integer, Double>> entry : modeCCHistory.get(limit).entrySet()) {
String mode = entry.getKey();
Map<Integer, Double> history = entry.getValue();
chart.addSeries(mode, history);
}
chart.addMatsimLogo();
chart.saveAsPng(this.modeFileName + limit + "x" + ".png", 800, 600);
}
}
@Override
public void notifyShutdown(final ShutdownEvent controlerShudownEvent) {
// for (BufferedWriter modeOut : modeOutMap.values()) {
// try {
// modeOut.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
}
public final Map<Integer, Map<String, Map<Integer, Double>>> getModeChoiceCoverageHistory() {
return Collections.unmodifiableMap(modeCCHistory);
}
}
| 10,342 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunBerlinScenarioWithAccessibilities.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/accessibility/RunBerlinScenarioWithAccessibilities.java | /* *********************************************************************** *
* project: org.matsim.*
* *
* *********************************************************************** *
* *
* copyright : (C) 2017 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.run.accessibility;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.locationtech.jts.geom.Envelope;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.TransportMode;
import org.matsim.contrib.accessibility.*;
import org.matsim.contrib.accessibility.utils.VisualizationUtils;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigGroup;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.controler.AbstractModule;
import org.matsim.core.controler.Controler;
import org.matsim.facilities.ActivityFacilities;
import org.matsim.legacy.run.RunBerlinScenario;
import java.io.File;
import java.util.Arrays;
import java.util.List;
/**
* @author dziemke
*/
public final class RunBerlinScenarioWithAccessibilities {
private static final Logger log = LogManager.getLogger(RunBerlinScenarioWithAccessibilities.class);
// Accessibility configurations
private static final boolean push2Geoserver = false; // Set true for run on server
private static final boolean createQGisOutput = true; // Set false for run on server
private static final List<String> activityTypes = Arrays.asList(new String[]{FacilityTypes.SCHOOL});
private static final Envelope envelope = new Envelope(4574000, 4620000, 5802000, 5839000); // Berlin; notation: minX, maxX, minY, maxY
public static void main(String[] args) {
for (String arg : args) {
log.info( arg );
}
if ( args.length==0 ) {
args = new String[] {"scenarios/berlin-v5.5-1pct/input/berlin-v5.5-1pct.config.xml"};
}
Config config = prepareConfig( args ) ;
Scenario scenario = RunBerlinScenario.prepareScenario( config ) ;
Controler controler = prepareControler( scenario ) ;
controler.run() ;
if (createQGisOutput) {createQGisOutput(config);}
}
public static Config prepareConfig( String [] args, ConfigGroup... customModules) {
ConfigGroup[] customModulesToAdd = new ConfigGroup[]{new AccessibilityConfigGroup()};
ConfigGroup[] customModulesAll = new ConfigGroup[customModules.length + customModulesToAdd.length];
int counter = 0;
for (ConfigGroup customModule : customModules) {
customModulesAll[counter] = customModule;
counter++;
}
for (ConfigGroup customModule : customModulesToAdd) {
customModulesAll[counter] = customModule;
counter++;
}
Config config = RunBerlinScenario.prepareConfig(args, customModulesAll);
config.controller().setOutputDirectory("../../shared-svn/projects/accessibility-berlin/output/v4/5000_8h05_school/");
File opportunitiesFile = new File("../../shared-svn/projects/accessibility-berlin/osm/berlin/amenities/2018-05-30/facilities_classified.xml");
config.facilities().setInputFile(opportunitiesFile.getAbsolutePath());
ConfigUtils.setVspDefaults(config);
AccessibilityConfigGroup acg = ConfigUtils.addOrGetModule(config, AccessibilityConfigGroup.class);
acg.setTimeOfDay((8*60.+5.)*60.);
acg.setAreaOfAccessibilityComputation(AccessibilityConfigGroup.AreaOfAccesssibilityComputation.fromShapeFile);
acg.setShapeFileCellBasedAccessibility("../../shared-svn/studies/countries/de/open_berlin_scenario/input/shapefiles/2013/Berlin_DHDN_GK4.shp");
acg.setTileSize_m(5000);
acg.setComputingAccessibilityForMode(Modes4Accessibility.freespeed, false);
acg.setComputingAccessibilityForMode(Modes4Accessibility.car, false);
acg.setComputingAccessibilityForMode(Modes4Accessibility.pt, true);
acg.setOutputCrs(config.global().getCoordinateSystem());
config.controller().setLastIteration(0);
return config ;
}
public static Controler prepareControler( Scenario scenario ) {
Controler controler = RunBerlinScenario.prepareControler( scenario ) ;
final ActivityFacilities densityFacilities = AccessibilityUtils.createFacilityForEachLink(Labels.DENSITIY, scenario.getNetwork()); // will be aggregated in downstream code!
// Use the (congested) car travel time for the teleported ride mode
controler.addOverridingModule(new AbstractModule(){
@Override
public void install() {
addTravelTimeBinding(TransportMode.ride).to(networkTravelTime());
addTravelDisutilityFactoryBinding(TransportMode.ride).to(carTravelDisutilityFactoryKey());
}
});
// Accessibility module
for (String activityType : activityTypes) {
AccessibilityModule module = new AccessibilityModule();
module.setConsideredActivityType(activityType);
module.addAdditionalFacilityData(densityFacilities);
module.setPushing2Geoserver(push2Geoserver);
module.setCreateQGisOutput(createQGisOutput);
controler.addOverridingModule(module);
}
return controler;
}
private static void createQGisOutput(Config config) {
// final boolean includeDensityLayer = true;
final Integer range = 9; // In the current implementation, this must always be 9
final Double lowerBound = -3.5; // (upperBound - lowerBound) ideally nicely divisible by (range - 2)
final Double upperBound = 3.5;
// final int populationThreshold = (50 / (1000/tileSize_m * 1000/tileSize_m)); // / by zero
final int populationThreshold = 0;
String osName = System.getProperty("os.name");
String workingDirectory = config.controller().getOutputDirectory();
for (String actType : activityTypes) {
String actSpecificWorkingDirectory = workingDirectory + actType + "/";
for (Modes4Accessibility mode : ((AccessibilityConfigGroup) config.getModules().get(AccessibilityConfigGroup.GROUP_NAME)).getIsComputingMode()) {
VisualizationUtils.createQGisOutputRuleBasedStandardColorRange(actType, mode.toString(), envelope , workingDirectory,
config.global().getCoordinateSystem(), lowerBound, upperBound, range, populationThreshold);
// VisualizationUtils.createQGisOutputGraduatedStandardColorRange(actType, mode.toString(), envelope, workingDirectory,
// scenarioCRS, includeDensityLayer, lowerBound, upperBound, range, tileSize_m, populationThreshold);
VisualizationUtils.createSnapshot(actSpecificWorkingDirectory, mode.toString(), osName);
}
}
}
}
| 7,731 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
AbfallChessboardUtils.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/wasteCollection/AbfallChessboardUtils.java | package org.matsim.legacy.run.wasteCollection;
import java.util.HashMap;
import java.util.Map;
import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.network.Link;
import org.matsim.freight.carriers.*;
import org.matsim.vehicles.Vehicle;
public class AbfallChessboardUtils {
static String linkChessboardDump = "j(0,9)R";
static String linkChessboardDepot = "j(0,7)R";
static Carrier carrierChessboard = CarrierImpl.newInstance(Id.create("Carrier_Chessboard", Carrier.class));
/**
* Creates shipments for the chessboard network with the input of the volume
* [kg] garbageToCollect.
*
* @param
*/
static void createShipmentsForChessboardI(HashMap<String, Carrier> carrierMap, int garbageToCollect,
Map<Id<Link>, ? extends Link> allLinks, double volumeBigDustbin, double serviceTimePerBigTrashcan,
Scenario scenario, Carriers carriers) {
Map<Id<Link>, Link> garbageLinks = new HashMap<Id<Link>, Link>();
carrierMap.clear();
carrierMap.put("carrierChessboard", carrierChessboard);
double distanceWithShipments = 0;
for (Link link : allLinks.values()) {
if (link.getFreespeed() < 13.9) {
garbageLinks.put(link.getId(), link);
distanceWithShipments = distanceWithShipments + link.getLength();
}
}
Id<Link> linkDumpId = Id.createLinkId(linkChessboardDump);
throw new UnsupportedOperationException("These lines below have not been updated to the new API.");
// AbfallUtils.createShipmentsForCarrierII(garbageToCollect, volumeBigDustbin, serviceTimePerBigTrashcan,
// distanceWithShipments, garbageLinks, scenario, carrierChessboard, linkDumpId );
// AbfallUtils.districtsWithShipments.add("Chessboard");
// carriers.addCarrier(carrierChessboard);
}
/**
* Creates shipments for the chessboard network with the input of the volume
* [kg] garbagePerMeterToCollect. So every meter of the network gets this volume
* of the garbage.
*
* @param
*/
static void createShipmentsForChessboardII(HashMap<String, Carrier> carrierMap, double garbagePerMeterToCollect,
Map<Id<Link>, ? extends Link> allLinks, double volumeBigDustbin, double serviceTimePerBigTrashcan,
Scenario scenario, Carriers carriers) {
Map<Id<Link>, Link> garbageLinks = new HashMap<Id<Link>, Link>();
carrierMap.clear();
carrierMap.put("carrierChessboard", carrierChessboard);
double distanceWithShipments = 0;
for (Link link : allLinks.values()) {
if (link.getFreespeed() < 12) {
garbageLinks.put(link.getId(), link);
distanceWithShipments = distanceWithShipments + link.getLength();
}
}
Id<Link> linkDumpId = Id.createLinkId(linkChessboardDump);
throw new UnsupportedOperationException("These lines below have not been updated to the new API.");
// AbfallUtils.createShipmentsForCarrierI(garbagePerMeterToCollect, volumeBigDustbin, serviceTimePerBigTrashcan,
// garbageLinks, scenario, carrierChessboard, linkDumpId, carriers);
// AbfallUtils.districtsWithShipments.add("Chessboard");
// carriers.addCarrier(carrierChessboard);
}
/**
* Creates the vehicle at the depot, ads this vehicle to the carriers and sets
* the capabilities. This method is for the Chessboard network with one depot.
*
* @param
*/
static void createCarriersForChessboard(Carriers carriers, CarrierCapabilities.FleetSize fleetSize, CarrierVehicleTypes carrierVehicleTypes) {
String vehicleName = "TruckChessboard";
double earliestStartingTime = 6 * 3600;
double latestFinishingTime = 14 * 3600;
CarrierVehicle newCarrierVehicle = CarrierVehicle.Builder
.newInstance(Id.create(vehicleName, Vehicle.class), Id.createLinkId(linkChessboardDepot),
carrierVehicleTypes.getVehicleTypes().get(carrierVehicleTypes.getVehicleTypes().values().iterator().next().getId()))
.setEarliestStart(earliestStartingTime).setLatestEnd(latestFinishingTime)
.build();
// AbfallUtils.createGarbageTruck(vehicleName, linkChessboardDepot, earliestStartingTime, latestFinishingTime);
// define Carriers
throw new UnsupportedOperationException("These lines below have not been updated to the new API.");
// defineCarriersChessboard(carriers, newCarrierVehicle, fleetSize, carrierVehicleTypes);
}
/**
* Defines and sets the Capabilities of the Carrier, including the vehicleTypes
* for the carriers for the Chessboard network
*
* @param
*
*/
private static void defineCarriersChessboard(Carriers carriers, CarrierVehicle vehicleDepot, CarrierCapabilities.FleetSize fleetSize, CarrierVehicleTypes carrierVehicleTypes) {
CarrierCapabilities carrierCapabilities = CarrierCapabilities.Builder.newInstance()
.addType(carrierVehicleTypes.getVehicleTypes().values().iterator().next()).addVehicle(vehicleDepot).setFleetSize(fleetSize).build();
carrierChessboard.setCarrierCapabilities(carrierCapabilities);
// Fahrzeugtypen den Anbietern zuordenen
new CarrierVehicleTypeLoader(carriers).loadVehicleTypes(carrierVehicleTypes);
}
}
| 5,034 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
AbfallUtils.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/wasteCollection/AbfallUtils.java | package org.matsim.legacy.run.wasteCollection;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.Point;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.network.Link;
import org.matsim.api.core.v01.network.Network;
import org.matsim.api.core.v01.population.Leg;
import org.matsim.api.core.v01.population.Person;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.config.groups.ControllerConfigGroup;
import org.matsim.core.controler.AbstractModule;
import org.matsim.core.controler.Controler;
import org.matsim.core.controler.OutputDirectoryHierarchy;
import org.matsim.core.controler.OutputDirectoryHierarchy.OverwriteFileSetting;
import org.matsim.core.population.routes.NetworkRoute;
import org.matsim.core.population.routes.RouteUtils;
import org.matsim.core.utils.geometry.geotools.MGC;
import org.matsim.core.utils.geometry.transformations.TransformationFactory;
import org.matsim.freight.carriers.*;
import org.matsim.freight.carriers.Tour.TourElement;
import org.matsim.freight.carriers.controler.CarrierModule;
import org.matsim.freight.carriers.jsprit.MatsimJspritFactory;
import org.matsim.freight.carriers.jsprit.NetworkBasedTransportCosts;
import org.matsim.freight.carriers.jsprit.NetworkRouter;
import org.matsim.vehicles.VehicleType;
import org.opengis.feature.simple.SimpleFeature;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import com.graphhopper.jsprit.analysis.toolbox.Plotter;
import com.graphhopper.jsprit.core.algorithm.VehicleRoutingAlgorithm;
import com.graphhopper.jsprit.core.algorithm.box.SchrimpfFactory;
import com.graphhopper.jsprit.core.problem.VehicleRoutingProblem;
import com.graphhopper.jsprit.core.problem.solution.VehicleRoutingProblemSolution;
import com.graphhopper.jsprit.core.util.Solutions;
/**
* @author Ricardo Ewert
*
*/
class AbfallUtils {
static final Logger log = LogManager.getLogger(AbfallUtils.class);
static int amountOfCollectedDustbins;
static int matsimIterations;
static int jspritIterations;
static double costsJsprit = 0;
static int noPickup = 0;
static int allGarbage = 0;
static int numberOfShipments = 0;
static int garbageRuhleben = 0;
static int garbagePankow = 0;
static int garbageReinickenD = 0;
static int garbageGradestr = 0;
static int garbageGruenauerStr = 0;
static String linkMhkwRuhleben = "142010";
static String linkMpsPankow = "145812";
static String linkMpsReinickendorf = "59055";
static String linkUmladestationGradestrasse = "71781";
static String linkGruenauerStr = "97944";
static List<String> districtsWithShipments = new ArrayList<>();
static List<String> districtsWithNoShipments = new ArrayList<>();
static HashMap<String, String> dataEnt = new HashMap<>();
static Multimap<String, String> linksInDistricts;
static boolean streetAlreadyInGarbageLinks = false;
/**
* Creates a map for getting the name of the attribute, where you can find the
* dump for the selected day of pickup.
*/
private static void createMapEnt() {
dataEnt.put("MO", "Mo-Ent");
dataEnt.put("DI", "Di-Ent");
dataEnt.put("MI", "Mi-Ent");
dataEnt.put("DO", "Do-Ent");
dataEnt.put("FR", "Fr-Ent");
}
/**
* Creates a map with the 4 depots in Berlin as 4 different carrier.
*
* @return carrierMap
*/
static HashMap<String, Carrier> createCarrier(Carriers carriers) {
HashMap<String, Carrier> carrierMap = new HashMap<>();
carrierMap.put("Nordring", carriers.getCarriers().get(Id.create("BSR_Nordring", Carrier.class)));
carrierMap.put("MalmoeerStr", carriers.getCarriers().get(Id.create("BSR_MalmoeerStr", Carrier.class)));
carrierMap.put("Forckenbeck", carriers.getCarriers().get(Id.create("BSR_Forckenbeck", Carrier.class)));
carrierMap.put("Gradestrasse", carriers.getCarriers().get(Id.create("BSR_Gradestrasse", Carrier.class)));
return carrierMap;
}
/**
* Creates a multimap where you can find behind every district every link
* containing this district.
*
*/
static void createMapWithLinksInDistricts(Collection<SimpleFeature> districts,
Map<Id<Link>, ? extends Link> allLinks) {
linksInDistricts = ArrayListMultimap.create();
double x, y, xCoordFrom, xCoordTo, yCoordFrom, yCoordTo;
Point p;
log.info("Started creating Multimap with all links of each district...");
for (Link link : allLinks.values()) {
xCoordFrom = link.getFromNode().getCoord().getX();
xCoordTo = link.getToNode().getCoord().getX();
yCoordFrom = link.getFromNode().getCoord().getY();
yCoordTo = link.getToNode().getCoord().getY();
if (xCoordFrom > xCoordTo)
x = xCoordFrom - ((xCoordFrom - xCoordTo) / 2);
else
x = xCoordTo - ((xCoordTo - xCoordFrom) / 2);
if (yCoordFrom > yCoordTo)
y = yCoordFrom - ((yCoordFrom - yCoordTo) / 2);
else
y = yCoordTo - ((yCoordTo - yCoordFrom) / 2);
p = MGC.xy2Point(x, y);
for (SimpleFeature district : districts) {
if (((Geometry) district.getDefaultGeometry()).contains(p)) {
linksInDistricts.put(district.getAttribute("Ortsteil").toString(), link.getId().toString());
}
}
}
log.info("Finished creating Multimap with all links of each district!");
}
/**
* Creates a Map with the 5 dumps in Berlin.
*
*/
static HashMap<String, Id<Link>> createDumpMap() {
HashMap<String, Id<Link>> garbageDumps = new HashMap<>();
garbageDumps.put("Ruhleben", Id.createLinkId(linkMhkwRuhleben));
garbageDumps.put("Pankow", Id.createLinkId(linkMpsPankow));
garbageDumps.put("Gradestr", Id.createLinkId(linkUmladestationGradestrasse));
garbageDumps.put("ReinickenD", Id.createLinkId(linkMpsReinickendorf));
garbageDumps.put("GruenauerStr", Id.createLinkId(linkGruenauerStr));
return garbageDumps;
}
/**
* Deletes the existing output file and sets the number of the last iteration
*
*/
static Config prepareConfig(Config config, int lastIteration, String inputVehicleTypes, String inputCarriers) {
config.controller().setOverwriteFileSetting(OverwriteFileSetting.deleteDirectoryIfExists);
new OutputDirectoryHierarchy(config.controller().getOutputDirectory(), config.controller().getRunId(),
config.controller().getOverwriteFileSetting(), ControllerConfigGroup.CompressionType.gzip);
config.controller().setOverwriteFileSetting(OverwriteFileSetting.overwriteExistingFiles);
config.controller().setLastIteration(lastIteration);
matsimIterations = lastIteration + 1;
config.global().setRandomSeed(4177);
config.controller().setOverwriteFileSetting(OverwriteFileSetting.overwriteExistingFiles);
config.global().setCoordinateSystem(TransformationFactory.GK4);
FreightCarriersConfigGroup freightConfigGroup = ConfigUtils.addOrGetModule(config, FreightCarriersConfigGroup.class);
freightConfigGroup.setCarriersFile(inputCarriers);
freightConfigGroup.setCarriersVehicleTypesFile(inputVehicleTypes);
freightConfigGroup.setTravelTimeSliceWidth(1800);
freightConfigGroup.setTimeWindowHandling(FreightCarriersConfigGroup.TimeWindowHandling.enforceBeginnings);
return config;
}
/**
* Creates Shipments for the selected areas for the selected weekday. The needed
* data is part of the read shapefile. There are information about the volume
* of garbageToCollect for every day and the dump where the garbage have to
* bring to.
*
*/
static void createShipmentsForSelectedArea(Collection<SimpleFeature> districtsWithGarbage,
List<String> districtsForShipments, String day, HashMap<String, Id<Link>> garbageDumps, Scenario scenario,
Carriers carriers, HashMap<String, Carrier> carrierMap, Map<Id<Link>, ? extends Link> allLinks,
double volumeBigDustbin, double serviceTimePerBigTrashcan) {
Id<Link> dumpId = null;
double distanceWithShipments = 0;
int garbageToCollect = 0;
String depot = null;
Map<Id<Link>, Link> garbageLinks = new HashMap<>();
createMapEnt();
for (String districtToCollect : districtsForShipments) {
for (SimpleFeature districtInformation : districtsWithGarbage) {
if (districtInformation.getAttribute("Ortsteil").equals(districtToCollect)) {
if ((double) districtInformation.getAttribute(day) > 0) {
garbageToCollect = (int) ((double) districtInformation.getAttribute(day) * 1000);
dumpId = garbageDumps.get(districtInformation.getAttribute(dataEnt.get(day)));
depot = districtInformation.getAttribute("Depot").toString();
for (Link link : allLinks.values()) {
for (String linkInDistrict : linksInDistricts.get(districtToCollect)) {
if (Id.createLinkId(linkInDistrict) == link.getId()) {
if (link.getFreespeed() < 14 && link.getAllowedModes().contains("car")) {
for (Link garbageLink : garbageLinks.values()) {
if (link.getFromNode() == garbageLink.getToNode()
&& link.getToNode() == garbageLink.getFromNode())
streetAlreadyInGarbageLinks = true;
}
if (! streetAlreadyInGarbageLinks) {
garbageLinks.put(link.getId(), link);
distanceWithShipments = distanceWithShipments + link.getLength();
}
streetAlreadyInGarbageLinks = false;
}
}
}
}
} else {
log.warn("At District " + districtInformation.getAttribute("Ortsteil").toString()
+ " no garbage will be collected at " + day);
districtsWithNoShipments.add(districtToCollect);
}
}
}
if (garbageLinks.size() != 0) {
districtsWithShipments.add(districtToCollect);
createShipmentsForCarrierII(garbageToCollect, volumeBigDustbin, serviceTimePerBigTrashcan,
distanceWithShipments, garbageLinks, scenario, carrierMap.get(depot), dumpId, carriers);
}
distanceWithShipments = 0;
garbageLinks.clear();
}
for (Carrier carrier : carrierMap.values())
carriers.addCarrier(carrier);
}
/**
* Creates Shipments for the selected areas for the selected weekday. You have
* to select the areas and for every area the garbage volume per meter street.
* The information about the dump is given in the shapefile.
*
*/
static void createShipmentsWithGarbagePerMeter(Collection<SimpleFeature> districtsWithGarbage,
HashMap<String, Double> areasForShipmentPerMeterMap, String day, HashMap<String, Id<Link>> garbageDumps,
Scenario scenario, Carriers carriers, HashMap<String, Carrier> carrierMap,
Map<Id<Link>, ? extends Link> allLinks, double volumeBigDustbin, double serviceTimePerBigTrashcan) {
Id<Link> dumpId = null;
double distanceWithShipments = 0;
String depot = null;
Map<Id<Link>, Link> garbageLinks = new HashMap<>();
createMapEnt();
for (String districtToCollect : areasForShipmentPerMeterMap.keySet()) {
for (SimpleFeature districtInformation : districtsWithGarbage) {
if (districtInformation.getAttribute("Ortsteil").equals(districtToCollect)) {
if ((double) districtInformation.getAttribute(day) > 0) {
dumpId = garbageDumps.get(districtInformation.getAttribute(dataEnt.get(day)));
depot = districtInformation.getAttribute("Depot").toString();
for (Link link : allLinks.values()) {
for (String linkInDistrict : linksInDistricts.get(districtToCollect)) {
if (Id.createLinkId(linkInDistrict) == link.getId()) {
if (link.getFreespeed() < 14 && link.getAllowedModes().contains("car")) {
for (Link garbageLink : garbageLinks.values()) {
if (link.getFromNode() == garbageLink.getToNode()
&& link.getToNode() == garbageLink.getFromNode())
streetAlreadyInGarbageLinks = true;
}
if (!streetAlreadyInGarbageLinks) {
garbageLinks.put(link.getId(), link);
distanceWithShipments = distanceWithShipments + link.getLength();
}
streetAlreadyInGarbageLinks = false;
}
}
}
}
} else {
log.warn("At District " + districtInformation.getAttribute("Ortsteil").toString()
+ " no garbage will be collected at " + day);
districtsWithNoShipments.add(districtToCollect);
}
}
}
if (garbageLinks.size() != 0)
districtsWithShipments.add(districtToCollect);
double garbagePerMeterToCollect = areasForShipmentPerMeterMap.get(districtToCollect);
createShipmentsForCarrierI(garbagePerMeterToCollect, volumeBigDustbin, serviceTimePerBigTrashcan,
garbageLinks, scenario, carrierMap.get(depot), dumpId, carriers);
distanceWithShipments = 0;
garbageLinks.clear();
}
for (Carrier carrier : carrierMap.values())
carriers.addCarrier(carrier);
}
/**
* Creates Shipments for Berlin for the selected weekday. You have to select the
* areas and for every area the garbage volume which should be select in this
* area. The information about the dump is given in the shapefile.
*
*/
static void createShipmentsGarbagePerVolume(Collection<SimpleFeature> districtsWithGarbage,
HashMap<String, Integer> areasForShipmentPerVolumeMap, String day, HashMap<String, Id<Link>> garbageDumps,
Scenario scenario, Carriers carriers, HashMap<String, Carrier> carrierMap,
Map<Id<Link>, ? extends Link> allLinks, double volumeBigDustbin, double serviceTimePerBigTrashcan) {
Id<Link> dumpId = null;
double distanceWithShipments = 0;
String depot = null;
Map<Id<Link>, Link> garbageLinks = new HashMap<>();
createMapEnt();
for (String districtToCollect : areasForShipmentPerVolumeMap.keySet()) {
for (SimpleFeature districtInformation : districtsWithGarbage) {
if (districtInformation.getAttribute("Ortsteil").equals(districtToCollect)) {
if ((double) districtInformation.getAttribute(day) > 0) {
dumpId = garbageDumps.get(districtInformation.getAttribute(dataEnt.get(day)));
depot = districtInformation.getAttribute("Depot").toString();
for (Link link : allLinks.values()) {
for (String linkInDistrict : linksInDistricts.get(districtToCollect)) {
if (Id.createLinkId(linkInDistrict) == link.getId()) {
if (link.getFreespeed() < 14 && link.getAllowedModes().contains("car")) {
for (Link garbageLink : garbageLinks.values()) {
if (link.getFromNode() == garbageLink.getToNode()
&& link.getToNode() == garbageLink.getFromNode())
streetAlreadyInGarbageLinks = true;
}
if (!streetAlreadyInGarbageLinks) {
garbageLinks.put(link.getId(), link);
distanceWithShipments = distanceWithShipments + link.getLength();
}
streetAlreadyInGarbageLinks = false;
}
}
}
}
} else {
log.warn("At District " + districtInformation.getAttribute("Ortsteil").toString()
+ " no garbage will be collected at " + day);
districtsWithNoShipments.add(districtToCollect);
}
}
}
if (garbageLinks.size() != 0)
districtsWithShipments.add(districtToCollect);
int garbageVolumeToCollect = areasForShipmentPerVolumeMap.get(districtToCollect);
createShipmentsForCarrierII(garbageVolumeToCollect, volumeBigDustbin, serviceTimePerBigTrashcan,
distanceWithShipments, garbageLinks, scenario, carrierMap.get(depot), dumpId, carriers);
distanceWithShipments = 0;
garbageLinks.clear();
}
for (Carrier carrier : carrierMap.values())
carriers.addCarrier(carrier);
}
/**
* Creates the shipments for all districts where the garbage will be picked up
* at the selected day.
*
*/
static void createShipmentsForSelectedDay(Collection<SimpleFeature> districtsWithGarbage, String day,
HashMap<String, Id<Link>> garbageDumps, Scenario scenario, Carriers carriers,
HashMap<String, Carrier> carrierMap, Map<Id<Link>, ? extends Link> allLinks, double volumeBigTrashcan,
double serviceTimePerBigDustbin, boolean oneCarrierForEachDistrict) {
Id<Link> dumpId = null;
double distanceWithShipments = 0;
int garbageToCollect = 0;
String usedCarrier = null;
String district = null;
Map<Id<Link>, Link> garbageLinks = new HashMap<>();
createMapEnt();
// carrierMap.clear();
for (SimpleFeature districtInformation : districtsWithGarbage) {
if ((double) districtInformation.getAttribute(day) > 0) {
garbageToCollect = (int) ((double) districtInformation.getAttribute(day) * 1000);
dumpId = garbageDumps.get(districtInformation.getAttribute(dataEnt.get(day)));
usedCarrier = districtInformation.getAttribute("Depot").toString();
if (oneCarrierForEachDistrict) {
district = districtInformation.getAttribute("Ortsteil").toString();
Carrier newCarrier = createSingleCarrier(usedCarrier, carrierMap, district);
carrierMap.put(district, newCarrier);
usedCarrier = district;
}
for (Link link : allLinks.values()) {
for (String linkInDistrict : linksInDistricts
.get(districtInformation.getAttribute("Ortsteil").toString())) {
if (Id.createLinkId(linkInDistrict) == link.getId()) {
if (link.getFreespeed() < 14 && link.getAllowedModes().contains("car")) {
for (Link garbageLink : garbageLinks.values()) {
if (link.getFromNode() == garbageLink.getToNode()
&& link.getToNode() == garbageLink.getFromNode())
streetAlreadyInGarbageLinks = true;
}
if (!streetAlreadyInGarbageLinks) {
garbageLinks.put(link.getId(), link);
distanceWithShipments = distanceWithShipments + link.getLength();
}
streetAlreadyInGarbageLinks = false;
}
}
}
}
} else {
log.warn("At District " + districtInformation.getAttribute("Ortsteil").toString()
+ " no garbage will be collected at " + day);
}
if (garbageLinks.size() != 0) {
districtsWithShipments.add(districtInformation.getAttribute("Ortsteil").toString());
createShipmentsForCarrierII(garbageToCollect, volumeBigTrashcan, serviceTimePerBigDustbin,
distanceWithShipments, garbageLinks, scenario,
carrierMap.get(usedCarrier), dumpId, carriers);
}
distanceWithShipments = 0;
garbageLinks.clear();
}
if (oneCarrierForEachDistrict) {
carrierMap.remove("Nordring");
carrierMap.remove("MalmoeerStr");
carrierMap.remove("Forckenbeck");
carrierMap.remove("Gradestrasse");
}
carriers.getCarriers().clear();
for (Carrier carrier : carrierMap.values()) {
carriers.addCarrier(carrier);
}
}
private static Carrier createSingleCarrier(String depot, HashMap<String, Carrier> carrierMap, String district) {
Carrier newCarrier = CarriersUtils.createCarrier(Id.create("Carrier " + district, Carrier.class));
for (Carrier originalCarrier : carrierMap.values()) {
if (originalCarrier.getId().toString().contains(depot)) {
newCarrier.getCarrierCapabilities()
.setFleetSize(originalCarrier.getCarrierCapabilities().getFleetSize());
newCarrier.getCarrierCapabilities().getCarrierVehicles()
.putAll(originalCarrier.getCarrierCapabilities().getCarrierVehicles());
newCarrier.getCarrierCapabilities().getVehicleTypes()
.addAll(originalCarrier.getCarrierCapabilities().getVehicleTypes());
}
}
return newCarrier;
}
/**
* Creates a Shipment for every garbagelink and ads all shipments to myCarrier.
* The volumeGarbage is in garbage per meter. So the volumeGarbage of every
* shipment depends on the input garbagePerMeterToCollect.
*
*/
static void createShipmentsForCarrierI(double garbagePerMeterToCollect, double volumeBigDustbin,
double serviceTimePerBigTrashcan, Map<Id<Link>, Link> garbageLinks, Scenario scenario, Carrier thisCarrier,
Id<Link> dumpId, Carriers carriers) {
for (Link link : garbageLinks.values()) {
double maxWeightBigDustbin = volumeBigDustbin * 0.1; // Umrechnung von Volumen [l] in Masse[kg]
int volumeGarbage = (int) Math.ceil(link.getLength() * garbagePerMeterToCollect);
amountOfCollectedDustbins = amountOfCollectedDustbins
+ (int) Math.ceil(((double) volumeGarbage) / maxWeightBigDustbin);
double serviceTime = Math.ceil(((double) volumeGarbage) / maxWeightBigDustbin) * serviceTimePerBigTrashcan;
// double deliveryTime = ((double) volumeGarbage / capacityTruck) * 45 * 60;
double deliveryTime = ((double) volumeGarbage / 11000) * 45 * 60;
CarrierShipment shipment = CarrierShipment.Builder
.newInstance(Id.create("Shipment_" + link.getId(), CarrierShipment.class), link.getId(), (dumpId),
volumeGarbage)
.setPickupServiceTime(serviceTime).setPickupTimeWindow(TimeWindow.newInstance(6 * 3600, 14 * 3600))
.setDeliveryTimeWindow(TimeWindow.newInstance(6 * 3600, 14 * 3600))
.setDeliveryServiceTime(deliveryTime).build();
thisCarrier.getShipments().put(shipment.getId(), shipment);
countingGarbage(dumpId, volumeGarbage);
}
numberOfShipments = numberOfShipments + garbageLinks.size();
}
/**
* Creates a Shipment for every link, ads all shipments to myCarrier and ads
* myCarrier to carriers. The volumeGarbage is in garbageToCollect [kg]. So the
* volumeGarbage of every shipment depends on the sum of all lengths from links
* with shipments.
*
*/
static void createShipmentsForCarrierII(int garbageToCollect, double volumeBigDustbin,
double serviceTimePerBigTrashcan, double distanceWithShipments, Map<Id<Link>, Link> garbageLinks,
Scenario scenario, Carrier thisCarrier, Id<Link> garbageDumpId, Carriers carriers) {
int count = 1;
int garbageCount = 0;
double roundingError = 0;
for (Link link : garbageLinks.values()) {
double maxWeightBigDustbin = volumeBigDustbin * 0.1; // Umrechnung von Volumen [l] in Masse[kg]
int volumeGarbage;
if (count == garbageLinks.size()) {
volumeGarbage = garbageToCollect - garbageCount;
} else {
volumeGarbage = (int) Math.ceil(link.getLength() / distanceWithShipments * garbageToCollect);
roundingError = roundingError
+ (volumeGarbage - (link.getLength() / distanceWithShipments * garbageToCollect));
if (roundingError > 1) {
volumeGarbage = volumeGarbage - 1;
roundingError = roundingError - 1;
}
count++;
}
amountOfCollectedDustbins = amountOfCollectedDustbins
+ (int) Math.ceil(((double) volumeGarbage) / maxWeightBigDustbin);
double serviceTime = Math.ceil(((double) volumeGarbage) / maxWeightBigDustbin) * serviceTimePerBigTrashcan;
// double deliveryTime = ((double) volumeGarbage / capacityTruck) * 45 * 60;
double deliveryTime = ((double) volumeGarbage / 11000) * 45 * 60;
CarrierShipment shipment = CarrierShipment.Builder
.newInstance(Id.create("Shipment_" + link.getId(), CarrierShipment.class), link.getId(),
garbageDumpId, volumeGarbage)
.setPickupServiceTime(serviceTime).setPickupTimeWindow(TimeWindow.newInstance(6 * 3600, 14 * 3600))
.setDeliveryTimeWindow(TimeWindow.newInstance(6 * 3600, 14 * 3600))
.setDeliveryServiceTime(deliveryTime).build();
thisCarrier.getShipments().put(shipment.getId(), shipment);
garbageCount = garbageCount + volumeGarbage;
countingGarbage(garbageDumpId, volumeGarbage);
}
numberOfShipments = numberOfShipments + garbageLinks.size();
}
/**
* This method is counting the garbage for every different dump and the total
* volume of garbage, which has to be collected.
*
*/
private static void countingGarbage(Id<Link> garbageDumpId, int volumeGarbage) {
allGarbage = allGarbage + volumeGarbage;
if (garbageDumpId.equals(Id.createLinkId(linkGruenauerStr)))
garbageGruenauerStr = garbageGruenauerStr + volumeGarbage;
if (garbageDumpId.equals(Id.createLinkId(linkMhkwRuhleben)))
garbageRuhleben = garbageRuhleben + volumeGarbage;
if (garbageDumpId.equals(Id.createLinkId(linkMpsPankow)))
garbagePankow = garbagePankow + volumeGarbage;
if (garbageDumpId.equals(Id.createLinkId(linkMpsReinickendorf)))
garbageReinickenD = garbageReinickenD + volumeGarbage;
if (garbageDumpId.equals(Id.createLinkId(linkUmladestationGradestrasse)))
garbageGradestr = garbageGradestr + volumeGarbage;
}
/**
* Solves with jsprit and gives a xml output of the plans and a plot of the
* solution
*
*/
static void solveWithJsprit(Scenario scenario, Carriers carriers, HashMap<String, Carrier> carrierMap,
int jspritIteration) {
int carrierCount = 1;
CarrierVehicleTypes vehicleTypes = (CarrierVehicleTypes) scenario.getScenarioElement("carrierVehicleTypes");
Network network = scenario.getNetwork();
NetworkBasedTransportCosts.Builder netBuilder = NetworkBasedTransportCosts.Builder.newInstance(network,
vehicleTypes.getVehicleTypes().values());
final NetworkBasedTransportCosts netBasedCosts = netBuilder.build();
netBuilder.setTimeSliceWidth(1800);
for (Carrier singleCarrier : carrierMap.values()) {
// Build jsprit, solve and route VRP for carrierService only -> need solution to
// convert Services to Shipments
VehicleRoutingProblem.Builder vrpBuilder = MatsimJspritFactory.createRoutingProblemBuilder(singleCarrier,
network);
vrpBuilder.setRoutingCost(netBasedCosts);
VehicleRoutingProblem problem = vrpBuilder.build();
// get the algorithm out-of-the-box, search solution and get the best one.
VehicleRoutingAlgorithm algorithm = new SchrimpfFactory().createAlgorithm(problem);
log.info("Creating solution for carrier " + carrierCount + " of " + carrierMap.size() + " Carriers");
algorithm.setMaxIterations(jspritIterations = jspritIteration);
Collection<VehicleRoutingProblemSolution> solutions = algorithm.searchSolutions();
VehicleRoutingProblemSolution bestSolution = Solutions.bestOf(solutions);
costsJsprit = costsJsprit + bestSolution.getCost();
// Routing bestPlan to Network
CarrierPlan carrierPlanServices = MatsimJspritFactory.createPlan(singleCarrier, bestSolution);
NetworkRouter.routePlan(carrierPlanServices, netBasedCosts);
singleCarrier.setSelectedPlan(carrierPlanServices);
noPickup = noPickup + bestSolution.getUnassignedJobs().size();
carrierCount++;
if (singleCarrier.getId() == Id.create("Carrier_Chessboard", Carrier.class))
new Plotter(problem, bestSolution).plot(
scenario.getConfig().controller().getOutputDirectory() + "/jsprit_CarrierPlans_Test01.png",
"bestSolution");
}
new CarrierPlanXmlWriterV2(carriers)
.write(scenario.getConfig().controller().getOutputDirectory() + "/jsprit_CarrierPlans.xml");
}
// /**
// * @param
// */
// static void scoringAndManagerFactory(Scenario scenario, final Controler controller) {
// controller.addOverridingModule(new CarrierModule());
// controller.addOverridingModule(new AbstractModule() {
// @Override
// public void install() {
// bind(CarrierScoringFunctionFactory.class).toInstance(createMyScoringFunction2(scenario));
// bind(CarrierPlanStrategyManagerFactory.class).toInstance(createMyStrategymanager());
// }
// });
// }
static Controler prepareControler(Scenario scenario) {
Controler controler = new Controler(scenario);
controler.addOverridingModule( new CarrierModule() );
controler.addOverridingModule(new AbstractModule() {
@Override
public void install() {
// bind(CarrierPlanStrategyManagerFactory.class).toInstance( null );
// bind(CarrierScoringFunctionFactory.class).toInstance(null );
}
});
return controler;
}
// /**
// * @param scenario
// * @return
// */
// private static CarrierScoringFunctionFactoryImpl createMyScoringFunction2(final Scenario scenario) {
//
// return new CarrierScoringFunctionFactoryImpl(scenario.getNetwork());
// return new CarrierScoringFunctionFactoryImpl (scenario, scenario.getConfig().controler().getOutputDirectory()) {
//
// public ScoringFunction createScoringFunction(final Carrier carrier){
// SumScoringFunction sumSf = new SumScoringFunction() ;
//
// VehicleFixCostScoring fixCost = new VehicleFixCostScoring(carrier);
// sumSf.addScoringFunction(fixCost);
//
// LegScoring legScoring = new LegScoring(carrier);
// sumSf.addScoringFunction(legScoring);
//
// //Score Activity w/o correction of waitingTime @ 1st Service.
// // ActivityScoring actScoring = new ActivityScoring(carrier);
// // sumSf.addScoringFunction(actScoring);
//
// //Alternativ:
// //Score Activity with correction of waitingTime @ 1st Service.
// ActivityScoringWithCorrection actScoring = new ActivityScoringWithCorrection(carrier);
// sumSf.addScoringFunction(actScoring);
//
// return sumSf;
// }
// };
// }
// /**
// * @return
// */
// private static CarrierPlanStrategyManagerFactory createMyStrategymanager() {
// return new CarrierPlanStrategyManagerFactory() {
// @Override
// public GenericStrategyManager<CarrierPlan, Carrier> createStrategyManager() {
// return null;
// }
// };
// }
/**
* Gives an output of a .txt file with some important information
*
*/
static void outputSummary(Collection<SimpleFeature> districtsWithGarbage, Scenario scenario,
HashMap<String, Carrier> carrierMap, String day, double volumeDustbin,
double secondsServiceTimePerDustbin) {
int vehiclesForckenbeck = 0;
int vehiclesMalmoeer = 0;
int vehiclesNordring = 0;
int vehiclesGradestrasse = 0;
int vehiclesChessboard = 0;
int numberVehicles = 0;
int sizeForckenbeck = 0;
int sizeMalmooer = 0;
int sizeNordring = 0;
int sizeGradestrasse = 0;
int sizeChessboard = 0;
int allCollectedGarbage = 0;
int sizeRuhleben = 0;
int sizePankow = 0;
int sizeReinickendorf = 0;
int sizeUmladestationGradestrasse = 0;
int sizeGruenauerStr = 0;
int sizeChessboardDelivery = 0;
double distanceTour;
double powerConsumptionTour;
int sizeTour;
int carrierWithShipments = 0;
double matsimCosts = 0;
List<Double> tourDistancesNordring = new ArrayList<>();
List<Double> tourDistancesForckenbeck = new ArrayList<>();
List<Double> tourDistancesMalmoeerStr = new ArrayList<>();
List<Double> tourDistancesGradestrasse = new ArrayList<>();
List<Double> tourDistancesChessboard = new ArrayList<>();
List<Double> powerConsumptionTourNordring = new ArrayList<>();
List<Double> powerConsumptionTourForckenbeck = new ArrayList<>();
List<Double> powerConsumptionTourMalmoeerStr = new ArrayList<>();
List<Double> powerConsumptionTourGradestrasse = new ArrayList<>();
List<Double> powerConsumptionTourChessboard = new ArrayList<>();
double maxTourForckenbeck = 0;
double minTourForckenbeck = 0;
double distanceToursForckenbeck = 0;
double averageTourDistanceForckenbeck = 0;
double maxTourNordring = 0;
double minTourNordring = 0;
double distanceToursNordring = 0;
double averageTourDistanceNordring = 0;
double maxTourMalmoeerStr = 0;
double minTourMalmoeerStr = 0;
double distanceToursMalmoeerStr = 0;
double averageTourDistanceMalmoeerStr = 0;
double maxTourGradestrasse = 0;
double minTourGradestrasse = 0;
double distanceToursGradestrasse = 0;
double averageTourDistanceGradestrasse = 0;
double maxPowerConsumptionForckenbeck = 0;
double minPowerConsumptionForckenbeck = 0;
double averagePowerConsumptionForckenbeck = 0;
double powerConsumptionForckenbeck = 0;
double maxPowerConsumptionNordring = 0;
double minPowerConsumptionNordring = 0;
double averagePowerConsumptionNordring = 0;
double powerConsumptionNordring = 0;
double maxPowerConsumptionMalmoeerStr = 0;
double minPowerConsumptionMalmoeerStr = 0;
double averagePowerConsumptionMalmoeerStr = 0;
double powerConsumptionMalmoeerStr = 0;
double maxPowerConsumptionGradestrasse = 0;
double minPowerConsumptionGradestrasse = 0;
double averagePowerConsumptionGradestrasse = 0;
double powerConsumptionGradestrasse = 0;
double tourDistanceChessboard = 0;
double powerConsumptionChessboard = 0;
boolean electricCar = false;
double capacityTruck = 0;
String vehicleTypeId = null;
double energyConsumptionPerDistance = 0;
double energyConsumptionPerWeight = 0;
Carriers allCarriers = (Carriers) scenario.getScenarioElement("carriers");
Carrier testCarrier = allCarriers.getCarriers().values().iterator().next();
for (VehicleType usedType : testCarrier.getCarrierCapabilities().getVehicleTypes()) {
if (usedType.getEngineInformation().getAttributes().getAttribute("fuelType").equals("electric")) {
electricCar = true;
energyConsumptionPerDistance = (double) usedType.getEngineInformation().getAttributes()
.getAttribute("engeryConsumptionPerKm");
energyConsumptionPerWeight = 1.4;
}
capacityTruck = usedType.getCapacity().getOther();
vehicleTypeId = usedType.getId().toString();
}
for (Carrier thisCarrier : carrierMap.values()) {
Collection<ScheduledTour> tours = thisCarrier.getSelectedPlan().getScheduledTours();
Map<Id<CarrierShipment>, CarrierShipment> shipments = thisCarrier.getShipments();
HashMap<String, Integer> shipmentSizes = new HashMap<>();
matsimCosts = matsimCosts + thisCarrier.getSelectedPlan().getScore();
for (Entry<Id<CarrierShipment>, CarrierShipment> entry : shipments.entrySet()) {
String shipmentId = entry.getKey().toString();
int shipmentSize = entry.getValue().getSize();
shipmentSizes.put(shipmentId, shipmentSize);
}
for (ScheduledTour scheduledTour : tours) {
distanceTour = 0;
// powerConsumptionTour = 0;
sizeTour = 0;
List<TourElement> elements = scheduledTour.getTour().getTourElements();
for (TourElement element : elements) {
if (element instanceof Tour.Pickup pickupElement) {
String pickupShipmentId = pickupElement.getShipment().getId().toString();
if (scheduledTour.getVehicle().getId().toString().contains("TruckForckenbeck")) {
sizeForckenbeck = sizeForckenbeck + (shipmentSizes.get(pickupShipmentId));
sizeTour = sizeTour + (shipmentSizes.get(pickupShipmentId));
}
if (scheduledTour.getVehicle().getId().toString().contains("TruckMalmoeer")) {
sizeMalmooer = sizeMalmooer + (shipmentSizes.get(pickupShipmentId));
sizeTour = sizeTour + (shipmentSizes.get(pickupShipmentId));
}
if (scheduledTour.getVehicle().getId().toString().contains("TruckNordring")) {
sizeNordring = sizeNordring + (shipmentSizes.get(pickupShipmentId));
sizeTour = sizeTour + (shipmentSizes.get(pickupShipmentId));
}
if (scheduledTour.getVehicle().getId().toString().contains("TruckGradestrasse")) {
sizeGradestrasse = sizeGradestrasse + (shipmentSizes.get(pickupShipmentId));
sizeTour = sizeTour + (shipmentSizes.get(pickupShipmentId));
}
if (scheduledTour.getVehicle().getId().toString().contains("TruckChessboard")) {
sizeChessboard = sizeChessboard + (shipmentSizes.get(pickupShipmentId));
sizeTour = sizeTour + (shipmentSizes.get(pickupShipmentId));
}
}
if (element instanceof Tour.Delivery deliveryElement) {
String deliveryShipmentId = deliveryElement.getShipment().getId().toString();
if (deliveryElement.getLocation() == Id.createLinkId(linkMhkwRuhleben)) {
sizeRuhleben = sizeRuhleben + (shipmentSizes.get(deliveryShipmentId));
}
if (deliveryElement.getLocation() == Id.createLinkId(linkMpsPankow)) {
sizePankow = sizePankow + (shipmentSizes.get(deliveryShipmentId));
}
if (deliveryElement.getLocation() == Id.createLinkId(linkMpsReinickendorf)) {
sizeReinickendorf = sizeReinickendorf + (shipmentSizes.get(deliveryShipmentId));
}
if (deliveryElement.getLocation() == Id.createLinkId(linkUmladestationGradestrasse)) {
sizeUmladestationGradestrasse = sizeUmladestationGradestrasse
+ (shipmentSizes.get(deliveryShipmentId));
}
if (deliveryElement.getLocation() == Id.createLinkId(linkGruenauerStr)) {
sizeGruenauerStr = sizeGruenauerStr + (shipmentSizes.get(deliveryShipmentId));
}
if (scheduledTour.getVehicle().getId() == Id.createVehicleId("TruckChessboard")) {
sizeChessboardDelivery = sizeChessboardDelivery + (shipmentSizes.get(deliveryShipmentId));
}
}
if (element instanceof Tour.Leg legElement) {
if (legElement.getRoute().getDistance() != 0)
distanceTour = distanceTour + RouteUtils.calcDistance((NetworkRoute) legElement.getRoute(),
0, 0, scenario.getNetwork());
}
}
allCollectedGarbage = sizeForckenbeck + sizeMalmooer + sizeNordring + sizeGradestrasse + sizeChessboard;
powerConsumptionTour = (distanceTour / 1000) * energyConsumptionPerDistance
+ (double) (sizeTour / 1000) * energyConsumptionPerWeight;
if (scheduledTour.getVehicle().getId().toString().contains("TruckForckenbeck")) {
tourDistancesForckenbeck.add(vehiclesForckenbeck, (double) Math.round(distanceTour / 1000));
powerConsumptionTourForckenbeck.add(vehiclesForckenbeck, (double) Math.round(powerConsumptionTour));
vehiclesForckenbeck++;
}
if (scheduledTour.getVehicle().getId().toString().contains("TruckMalmoeer")) {
tourDistancesMalmoeerStr.add(vehiclesMalmoeer, (double) Math.round(distanceTour / 1000));
powerConsumptionTourMalmoeerStr.add(vehiclesMalmoeer, (double) Math.round(powerConsumptionTour));
vehiclesMalmoeer++;
}
if (scheduledTour.getVehicle().getId().toString().contains("TruckNordring")) {
tourDistancesNordring.add(vehiclesNordring, (double) Math.round(distanceTour / 1000));
powerConsumptionTourNordring.add(vehiclesNordring, (double) Math.round(powerConsumptionTour));
vehiclesNordring++;
}
if (scheduledTour.getVehicle().getId().toString().contains("TruckGradestrasse")) {
tourDistancesGradestrasse.add(vehiclesGradestrasse, (double) Math.round(distanceTour / 1000));
powerConsumptionTourGradestrasse.add(vehiclesGradestrasse,
(double) Math.round(powerConsumptionTour));
vehiclesGradestrasse++;
}
if (scheduledTour.getVehicle().getId().toString().contains("TruckChessboard")) {
tourDistancesChessboard.add(vehiclesChessboard, (double) Math.round(distanceTour / 1000));
tourDistanceChessboard = tourDistanceChessboard + tourDistancesChessboard.get(vehiclesChessboard);
powerConsumptionTourChessboard.add(vehiclesChessboard, (double) Math.round(powerConsumptionTour));
powerConsumptionChessboard = powerConsumptionChessboard
+ powerConsumptionTourChessboard.get(vehiclesChessboard);
vehiclesChessboard++;
}
numberVehicles = vehiclesForckenbeck + vehiclesMalmoeer + vehiclesNordring + vehiclesGradestrasse
+ vehiclesChessboard;
}
if (thisCarrier.getShipments().size() > 0)
carrierWithShipments++;
}
if (vehiclesForckenbeck > 0) {
maxTourForckenbeck = tourDistancesForckenbeck.get(0);
minTourForckenbeck = tourDistancesForckenbeck.get(0);
distanceToursForckenbeck = tourDistancesForckenbeck.get(0);
maxPowerConsumptionForckenbeck = powerConsumptionTourForckenbeck.get(0);
minPowerConsumptionForckenbeck = powerConsumptionTourForckenbeck.get(0);
powerConsumptionForckenbeck = powerConsumptionTourForckenbeck.get(0);
for (int index = 1; index < tourDistancesForckenbeck.size(); index++) {
if (tourDistancesForckenbeck.get(index) > maxTourForckenbeck)
maxTourForckenbeck = tourDistancesForckenbeck.get(index);
if (tourDistancesForckenbeck.get(index) < minTourForckenbeck)
minTourForckenbeck = tourDistancesForckenbeck.get(index);
if (powerConsumptionTourForckenbeck.get(index) > maxPowerConsumptionForckenbeck)
maxPowerConsumptionForckenbeck = powerConsumptionTourForckenbeck.get(index);
if (powerConsumptionTourForckenbeck.get(index) < minPowerConsumptionForckenbeck)
minPowerConsumptionForckenbeck = powerConsumptionTourForckenbeck.get(index);
distanceToursForckenbeck = distanceToursForckenbeck + tourDistancesForckenbeck.get(index);
powerConsumptionForckenbeck = powerConsumptionForckenbeck + powerConsumptionTourForckenbeck.get(index);
}
averageTourDistanceForckenbeck = distanceToursForckenbeck / vehiclesForckenbeck;
averagePowerConsumptionForckenbeck = powerConsumptionForckenbeck / vehiclesForckenbeck;
}
if (vehiclesMalmoeer > 0) {
maxTourMalmoeerStr = tourDistancesMalmoeerStr.get(0);
minTourMalmoeerStr = tourDistancesMalmoeerStr.get(0);
distanceToursMalmoeerStr = tourDistancesMalmoeerStr.get(0);
maxPowerConsumptionMalmoeerStr = powerConsumptionTourMalmoeerStr.get(0);
minPowerConsumptionMalmoeerStr = powerConsumptionTourMalmoeerStr.get(0);
powerConsumptionMalmoeerStr = powerConsumptionTourMalmoeerStr.get(0);
for (int index = 1; index < tourDistancesMalmoeerStr.size(); index++) {
if (tourDistancesMalmoeerStr.get(index) > maxTourMalmoeerStr)
maxTourMalmoeerStr = tourDistancesMalmoeerStr.get(index);
if (tourDistancesMalmoeerStr.get(index) < minTourMalmoeerStr)
minTourMalmoeerStr = tourDistancesMalmoeerStr.get(index);
if (powerConsumptionTourMalmoeerStr.get(index) > maxPowerConsumptionMalmoeerStr)
maxPowerConsumptionMalmoeerStr = powerConsumptionTourMalmoeerStr.get(index);
if (powerConsumptionTourMalmoeerStr.get(index) < minPowerConsumptionMalmoeerStr)
minPowerConsumptionMalmoeerStr = powerConsumptionTourMalmoeerStr.get(index);
distanceToursMalmoeerStr = distanceToursMalmoeerStr + tourDistancesMalmoeerStr.get(index);
powerConsumptionMalmoeerStr = powerConsumptionMalmoeerStr + powerConsumptionTourMalmoeerStr.get(index);
}
averageTourDistanceMalmoeerStr = distanceToursMalmoeerStr / vehiclesMalmoeer;
averagePowerConsumptionMalmoeerStr = powerConsumptionMalmoeerStr / vehiclesMalmoeer;
}
if (vehiclesNordring > 0) {
maxTourNordring = tourDistancesNordring.get(0);
minTourNordring = tourDistancesNordring.get(0);
distanceToursNordring = tourDistancesNordring.get(0);
maxPowerConsumptionNordring = powerConsumptionTourNordring.get(0);
minPowerConsumptionNordring = powerConsumptionTourNordring.get(0);
powerConsumptionNordring = powerConsumptionTourNordring.get(0);
for (int index = 1; index < tourDistancesNordring.size(); index++) {
if (tourDistancesNordring.get(index) > maxTourNordring)
maxTourNordring = tourDistancesNordring.get(index);
if (tourDistancesNordring.get(index) < minTourNordring)
minTourNordring = tourDistancesNordring.get(index);
if (powerConsumptionTourNordring.get(index) > maxPowerConsumptionNordring)
maxPowerConsumptionNordring = powerConsumptionTourNordring.get(index);
if (powerConsumptionTourNordring.get(index) < minPowerConsumptionNordring)
minPowerConsumptionNordring = powerConsumptionTourNordring.get(index);
distanceToursNordring = distanceToursNordring + tourDistancesNordring.get(index);
powerConsumptionNordring = powerConsumptionNordring + powerConsumptionTourNordring.get(index);
}
averageTourDistanceNordring = distanceToursNordring / vehiclesNordring;
averagePowerConsumptionNordring = powerConsumptionNordring / vehiclesNordring;
}
if (vehiclesGradestrasse > 0) {
maxTourGradestrasse = tourDistancesGradestrasse.get(0);
minTourGradestrasse = tourDistancesForckenbeck.get(0);
distanceToursGradestrasse = tourDistancesGradestrasse.get(0);
maxPowerConsumptionGradestrasse = powerConsumptionTourGradestrasse.get(0);
minPowerConsumptionGradestrasse = powerConsumptionTourGradestrasse.get(0);
powerConsumptionGradestrasse = powerConsumptionTourGradestrasse.get(0);
for (int index = 1; index < tourDistancesGradestrasse.size(); index++) {
if (tourDistancesGradestrasse.get(index) > maxTourGradestrasse)
maxTourGradestrasse = tourDistancesGradestrasse.get(index);
if (tourDistancesGradestrasse.get(index) < minTourGradestrasse)
minTourGradestrasse = tourDistancesGradestrasse.get(index);
if (powerConsumptionTourGradestrasse.get(index) > maxPowerConsumptionGradestrasse)
maxPowerConsumptionGradestrasse = powerConsumptionTourGradestrasse.get(index);
if (powerConsumptionTourGradestrasse.get(index) < minPowerConsumptionGradestrasse)
minPowerConsumptionGradestrasse = powerConsumptionTourGradestrasse.get(index);
distanceToursGradestrasse = distanceToursGradestrasse + tourDistancesGradestrasse.get(index);
powerConsumptionGradestrasse = powerConsumptionGradestrasse
+ powerConsumptionTourGradestrasse.get(index);
}
averageTourDistanceGradestrasse = distanceToursGradestrasse / vehiclesGradestrasse;
averagePowerConsumptionGradestrasse = powerConsumptionGradestrasse / vehiclesGradestrasse;
}
FileWriter writer;
File file;
file = new File(scenario.getConfig().controller().getOutputDirectory() + "/01_Zusammenfassung.txt");
try {
writer = new FileWriter(file, true);
if (day != null) {
writer.write("Anzahl der Gebiete im gesamten Netzwerk:\t\t\t\t\t" + districtsWithGarbage.size() + "\n");
writer.write("Wochentag:\t\t\t\t\t\t\t\t\t\t\t\t\t" + day + "\n\n");
}
writer.write(
"Anzahl der untersuchten Gebiete mit Abholung:\t\t\t\t" + districtsWithShipments.size() + "\n");
writer.write("Untersuchte Gebiete mit Abholung:\t\t\t\t\t\t\t" + districtsWithShipments.toString() + "\n");
if (day != null) {
writer.write("\n" + "Anzahl der untersuchten Gebiete ohne Abholung:\t\t\t\t"
+ districtsWithNoShipments.size() + "\n");
writer.write("Untersuchte Gebiete ohne Abholung:\t\t\t\t\t\t\t" + districtsWithNoShipments.toString()
+ "\n");
}
writer.write("\n" + "Fahrzeug: \t\t\t\t\t\t\t\t\t\t\t\t\t" + vehicleTypeId + "\n");
writer.write(
"Kapazitรคt je Fahrzeug: \t\t\t\t\t\t\t\t\t\t" + (capacityTruck / 1000) + " Tonnen\n\n");
writer.write("Volumen der Mรผlltonne: \t\t\t\t\t\t\t\t\t\t" + volumeDustbin + " Liter\n");
writer.write(
"ServiceTime pro Mรผlltonne:\t\t\t\t\t\t\t\t\t" + secondsServiceTimePerDustbin + " Sekunden\n\n");
writer.write("Iterationen jsprit:\t\t\t\t\t\t\t\t\t\t\t" + jspritIterations + "\n");
writer.write("Iterationen MATSim:\t\t\t\t\t\t\t\t\t\t\t" + matsimIterations + "\n");
writer.write("\n" + "Die Summe des abzuholenden Mรผlls betrรคgt: \t\t\t\t\t" + ((double) allGarbage) / 1000
+ " t\n\n");
writer.write("Anzahl der Abholstellen: \t\t\t\t\t\t\t\t\t" + numberOfShipments + "\n");
writer.write("Anzahl der Abholstellen ohne Abholung: \t\t\t\t\t\t" + noPickup + "\n\n");
writer.write("Anzahl der Carrier mit Shipments:\t\t\t\t\t\t\t" + carrierWithShipments + "\n\n");
writer.write("Anzahl der entleerten Mรผlltonnen:\t\t\t\t\t\t\t" + amountOfCollectedDustbins + "\n\n");
writer.write("Anzahl der Muellfahrzeuge im Einsatz: \t\t\t\t\t\t" + (numberVehicles) + "\t\tMenge gesamt:\t"
+ ((double) allCollectedGarbage) / 1000 + " t\n\n");
if (day != null) {
writer.write("\t Anzahl aus dem Betriebshof Forckenbeckstrasse: \t\t\t" + vehiclesForckenbeck
+ "\t\t\tMenge:\t\t" + ((double) sizeForckenbeck) / 1000 + " t\n");
if (vehiclesForckenbeck > 0) {
writer.write("\t\t\tFahrstrecke Summe:\t\t\t\t" + distanceToursForckenbeck + " km\n");
writer.write("\t\t\tFahrstrecke Max:\t\t\t\t" + maxTourForckenbeck + " km\n");
writer.write("\t\t\tFahrstrecke Min:\t\t\t\t" + minTourForckenbeck + " km\n");
writer.write("\t\t\tFahrstrecke Durchschnitt:\t\t" + Math.round(averageTourDistanceForckenbeck)
+ " km\n");
if (electricCar) {
writer.write("\t\t\tEnergieverbrauch Summe:\t\t\t" + powerConsumptionForckenbeck + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Max:\t\t\t" + maxPowerConsumptionForckenbeck + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Min:\t\t\t" + minPowerConsumptionForckenbeck + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Durchschnitt:\t"
+ Math.round(averagePowerConsumptionForckenbeck) + " kwh\n");
}
}
writer.write("\n" + "\t Anzahl aus dem Betriebshof Malmoeer Strasse: \t\t\t\t" + vehiclesMalmoeer
+ "\t\t\tMenge:\t\t" + ((double) sizeMalmooer) / 1000 + " t\n");
if (vehiclesMalmoeer > 0) {
writer.write("\t\t\tFahrstrecke Summe:\t\t\t\t" + distanceToursMalmoeerStr + " km\n");
writer.write("\t\t\tFahrstrecke Max:\t\t\t\t" + maxTourMalmoeerStr + " km\n");
writer.write("\t\t\tFahrstrecke Min:\t\t\t\t" + minTourMalmoeerStr + " km\n");
writer.write("\t\t\tFahrstrecke Durchschnitt:\t\t" + Math.round(averageTourDistanceMalmoeerStr)
+ " km\n");
if (electricCar) {
writer.write("\t\t\tEnergieverbrauch Summe:\t\t\t" + powerConsumptionMalmoeerStr + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Max:\t\t\t" + maxPowerConsumptionMalmoeerStr + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Min:\t\t\t" + minPowerConsumptionMalmoeerStr + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Durchschnitt:\t"
+ Math.round(averagePowerConsumptionMalmoeerStr) + " kw/h\n");
}
}
writer.write("\n" + "\t Anzahl aus dem Betriebshof Nordring: \t\t\t\t\t\t" + vehiclesNordring
+ "\t\t\tMenge:\t\t" + ((double) sizeNordring) / 1000 + " t\n");
if (vehiclesNordring > 0) {
writer.write("\t\t\tFahrstrecke Summe:\t\t\t\t" + distanceToursNordring + " km\n");
writer.write("\t\t\tFahrstrecke Max:\t\t\t\t" + maxTourNordring + " km\n");
writer.write("\t\t\tFahrstrecke Min:\t\t\t\t" + minTourNordring + " km\n");
writer.write(
"\t\t\tFahrstrecke Durchschnitt:\t\t" + Math.round(averageTourDistanceNordring) + " km\n");
if (electricCar) {
writer.write("\t\t\tEnergieverbrauch Summe:\t\t\t" + powerConsumptionNordring + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Max:\t\t\t" + maxPowerConsumptionNordring + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Min:\t\t\t" + minPowerConsumptionNordring + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Durchschnitt:\t"
+ Math.round(averagePowerConsumptionNordring) + " kwh\n");
}
}
writer.write("\n" + "\t Anzahl aus dem Betriebshof Gradestraรe: \t\t\t\t\t" + vehiclesGradestrasse
+ "\t\t\tMenge:\t\t" + ((double) sizeGradestrasse) / 1000 + " t\n");
if (vehiclesGradestrasse > 0) {
writer.write("\t\t\tFahrstrecke Summe:\t\t\t\t" + distanceToursGradestrasse + " km\n");
writer.write("\t\t\tFahrstrecke Max:\t\t\t\t" + maxTourGradestrasse + " km\n");
writer.write("\t\t\tFahrstrecke Min:\t\t\t\t" + minTourGradestrasse + " km\n");
writer.write("\t\t\tFahrstrecke Durchschnitt:\t\t" + Math.round(averageTourDistanceGradestrasse)
+ " km\n");
if (electricCar) {
writer.write("\t\t\tEnergieverbrauch Summe:\t\t\t" + powerConsumptionGradestrasse + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Max:\t\t\t" + maxPowerConsumptionGradestrasse + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Min:\t\t\t" + minPowerConsumptionGradestrasse + " kwh\n");
writer.write("\t\t\tEnergieverbrauch Durchschnitt:\t"
+ Math.round(averagePowerConsumptionGradestrasse) + " kwh\n");
}
}
writer.write("\n" + "Anzuliefernde Menge (IST):\tMHKW Ruhleben:\t\t\t\t\t"
+ ((double) sizeRuhleben) / 1000 + " t\n");
writer.write("\t\t\t\t\t\t\tMPS Pankow:\t\t\t\t\t\t" + ((double) sizePankow) / 1000 + " t\n");
writer.write("\t\t\t\t\t\t\tMPS Reinickendorf:\t\t\t\t" + ((double) sizeReinickendorf) / 1000 + " t\n");
writer.write("\t\t\t\t\t\t\tUmladestation Gradestrasse:\t\t"
+ ((double) sizeUmladestationGradestrasse) / 1000 + " t\n");
writer.write(
"\t\t\t\t\t\t\tMA Gruenauer Str.:\t\t\t\t" + ((double) sizeGruenauerStr) / 1000 + " t\n\n");
}
if (vehiclesChessboard > 0) {
writer.write("Gefahrene Kilometer je Fahrzeug:\t\t\t\t\t\t\t" + tourDistancesChessboard + " \n");
if (electricCar)
writer.write(
"Energieverbrauch in kwh je Fahrzeug:\t\t\t\t\t\t" + powerConsumptionTourChessboard + "\n");
}
writer.write(
"Gefahrene Strecke gesamt:\t\t\t\t\t\t\t\t\t" + (distanceToursForckenbeck + distanceToursMalmoeerStr
+ distanceToursNordring + distanceToursGradestrasse + tourDistanceChessboard) + " km\n\n");
if (electricCar)
writer.write("Verbrauche Energie gesamt:\t\t\t\t\t\t\t\t\t"
+ (powerConsumptionForckenbeck + powerConsumptionMalmoeerStr + powerConsumptionNordring
+ powerConsumptionGradestrasse + powerConsumptionChessboard)
+ " kwh\n\n");
writer.write("Kosten (Jsprit): \t\t\t\t\t\t\t\t\t\t\t" + (Math.round(costsJsprit)) + " โฌ\n\n");
writer.write("Kosten (MatSim): \t\t\t\t\t\t\t\t\t\t\t" + ((-1) * Math.round(matsimCosts)) + " โฌ\n");
writer.flush();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
if (noPickup == 0) {
System.out.println("");
System.out.println("Abfaelle wurden komplett von " + numberVehicles + " Fahrzeugen eingesammelt!");
} else {
System.out.println("");
System.out.println("Abfall nicht komplett eingesammelt!");
}
}
/**
* Creates an output of a summary of important information of the created
* shipments
*
*/
static void outputSummaryShipments(Scenario scenario, String day, HashMap<String, Carrier> carrierMap) {
double capacityTruck = 0;
String vehicleTypeId = null;
Carriers allCarriers = (Carriers) scenario.getScenarioElement("carriers");
Carrier testCarrier = allCarriers.getCarriers().values().iterator().next();
for (VehicleType usedType : testCarrier.getCarrierCapabilities().getVehicleTypes()) {
capacityTruck = usedType.getCapacity().getOther();
vehicleTypeId = usedType.getId().toString();
}
FileWriter writer;
File file;
file = new File(scenario.getConfig().controller().getOutputDirectory() + "/01_ZusammenfassungShipments.txt");
try {
writer = new FileWriter(file, true);
writer.write("Anzahl der Abholgebiete:\t\t\t\t\t\t\t\t\t" + districtsWithShipments.size() + "\n");
writer.write("Abholgebiete:\t\t\t\t\t\t\t\t\t\t\t\t" + districtsWithShipments.toString() + "\n");
if (day != null)
writer.write("Wochentag:\t\t\t\t\t\t\t\t\t\t\t\t\t" + day + "\n");
writer.write("\n" + "Die Summe des abzuholenden Mรผlls betrรคgt: \t\t\t\t\t" + ((double) allGarbage) / 1000
+ " t\n\n");
writer.write("Fahrzeug: \t\t\t\t\t\t\t\t\t\t\t\t\t" + vehicleTypeId + "\n");
writer.write(
"Kapazitรคt je Fahrzeug: \t\t\t\t\t\t\t\t\t\t" + (capacityTruck / 1000) + " Tonnen\n\n");
writer.write("Anzahl der Abholstellen: \t\t\t\t\t\t\t\t\t" + numberOfShipments + "\n");
if (day != null) {
for (Carrier carrier : carrierMap.values()) {
writer.write("\t\t\t\t\t\t\t" + carrier.getId().toString() + ":\t\t\t\t\t\t"
+ carrier.getShipments().size() + "\n");
}
writer.write("\n" + "Anzuliefernde Menge (Soll):\tMHKW Ruhleben:\t\t\t\t\t"
+ ((double) garbageRuhleben) / 1000 + " t\n");
writer.write("\t\t\t\t\t\t\tMPS Pankow:\t\t\t\t\t\t" + ((double) garbagePankow) / 1000 + " t\n");
writer.write("\t\t\t\t\t\t\tMPS Reinickendorf:\t\t\t\t" + ((double) garbageReinickenD) / 1000 + " t\n");
writer.write(
"\t\t\t\t\t\t\tUmladestation Gradestrasse:\t\t" + ((double) garbageGradestr) / 1000 + " t\n");
writer.write("\t\t\t\t\t\t\tMA Gruenauer Str.:\t\t\t\t" + ((double) garbageGruenauerStr) / 1000 + " t");
}
writer.flush();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
*/
@SuppressWarnings("null")
static void createResultFile(Scenario scenario, Carriers carriers) throws Exception {
log.info("Starting");
// String inputDir;
Map<Id<Person>, Double> personId2tourDistance = new HashMap<>();
Map<Id<Person>, Double> personId2tourConsumptionkWh = new HashMap<>();
Map<String, Integer> usedNumberPerVehicleType = new HashMap<>();
ArrayList<String> toursWithOverconsumption = new ArrayList<>();
CarrierVehicleTypes vehicleTypes = new CarrierVehicleTypes();
Carriers allCarriers = (Carriers) scenario.getScenarioElement("carriers");
Carrier testCarrier = allCarriers.getCarriers().values().iterator().next();
for (VehicleType usedType : testCarrier.getCarrierCapabilities().getVehicleTypes()) {
vehicleTypes.getVehicleTypes().put(usedType.getId(), usedType);
usedNumberPerVehicleType.put(usedType.getId().toString(), 0);
}
Network network = scenario.getNetwork();
BufferedWriter writer;
File file;
file = new File(scenario.getConfig().controller().getOutputDirectory() + "/02_SummaryOutput.txt");
writer = new BufferedWriter(new FileWriter(file, true));
String now = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss").format(new Date());
writer.write("Tourenstatisitik erstellt am: " + now + "\n\n");
for (Carrier singleCarrier : carriers.getCarriers().values()) {
double totalDistance = 0;
int numberOfVehicles = 0;
double distanceTour;
int numCollections = 0;
int tourNumberCarrier = 1;
VehicleType vt = null;
for (ScheduledTour scheduledTour : singleCarrier.getSelectedPlan().getScheduledTours()) {
distanceTour = 0.0;
for (VehicleType vt2 : singleCarrier.getCarrierCapabilities().getVehicleTypes()) {
if (vt2.getId().toString()
.contains(scheduledTour.getVehicle().getType().getId().toString())) {
vt = vt2;
break;
}
}
int vehicleTypeCount = usedNumberPerVehicleType
.get(scheduledTour.getVehicle().getType().getId().toString());
usedNumberPerVehicleType.replace(scheduledTour.getVehicle().getType().getId().toString(),
vehicleTypeCount + 1);
List<TourElement> elements = scheduledTour.getTour().getTourElements();
for (TourElement element : elements) {
if (element instanceof Tour.Pickup) {
numCollections++;
}
if (element instanceof Leg legElement) {
if (legElement.getRoute().getDistance() != 0)
distanceTour = distanceTour
+ RouteUtils.calcDistance((NetworkRoute) legElement.getRoute(), 0, 0, network);
}
}
Id<Person> personId = Id.create(
scheduledTour.getVehicle().getType().getId() + "-Tour " + tourNumberCarrier,
Person.class);
personId2tourDistance.put(personId, distanceTour);
if (vt.getEngineInformation().getAttributes().getAttribute("fuelType").equals("electricity")) {
personId2tourConsumptionkWh.put(personId, (distanceTour / 1000) * (double) vt.getEngineInformation()
.getAttributes().getAttribute("engeryConsumptionPerKm"));
}
totalDistance = totalDistance + distanceTour;
tourNumberCarrier++;
}
numberOfVehicles = numberOfVehicles + (tourNumberCarrier - 1);
writer.write("\n\n" + "Version: " + singleCarrier.getId().toString() + "\n");
writer.write("\tAnzahl der Abholstellen (Soll): \t\t\t\t\t" + singleCarrier.getShipments().size() + "\n");
writer.write("\tAnzahl der Abholstellen ohne Abholung: \t\t\t\t"
+ (singleCarrier.getShipments().size() - numCollections) + "\n");
writer.write("\tAnzahl der Fahrzeuge:\t\t\t\t\t\t\t\t" + numberOfVehicles + "\n");
for (VehicleType singleVehicleType : vehicleTypes.getVehicleTypes().values()) {
if (singleCarrier.getId().toString().equals(singleVehicleType.getDescription())) {
writer.write("\t\t\tAnzahl Typ " + singleVehicleType.getId().toString() + ":\t\t\t\t"
+ usedNumberPerVehicleType.get(singleVehicleType.getId().toString()) + "\n");
}
}
writer.write(
"\n" + "\tGefahrene Kilometer insgesamt:\t\t\t\t\t\t" + Math.round(totalDistance / 1000) + " km\n");
writer.write("\tVerfรผgbare Fahrzeugtypen:\t\t\t\t\t\n\n");
for (VehicleType singleVehicleType : vehicleTypes.getVehicleTypes().values()) {
writer.write(
"\t\t\tID: " + singleVehicleType.getId() + "\t\tAntrieb: "
+ singleVehicleType.getEngineInformation().getAttributes().getAttribute("fuelType")
.toString()
+ "\t\tKapazitรคt: " + singleVehicleType.getCapacity().getOther() + "\t\tFixkosten:"
+ singleVehicleType.getCostInformation().getFixedCosts() + " โฌ");
if (singleVehicleType.getEngineInformation().getAttributes().getAttribute("fuelType")
.equals("electricity")) {
double electricityConsumptionPer100km;
double electricityCapacityinkWh;
electricityConsumptionPer100km = (double) singleVehicleType.getEngineInformation().getAttributes()
.getAttribute("engeryConsumptionPerKm");
electricityCapacityinkWh = (double) singleVehicleType.getEngineInformation().getAttributes()
.getAttribute("engeryCapacity");
writer.write("\t\tLadekapazitรคt: " + electricityCapacityinkWh + " kWh\t\tVerbrauch: "
+ electricityConsumptionPer100km + " kWh/100km\t\tReichweite: "
+ (int) Math.round(electricityCapacityinkWh / electricityConsumptionPer100km) + " km\n");
} else
writer.write("\n");
}
writer.write("\n\n" + "\tTourID\t\t\t\t\t\tdistance (max Distance) (km)\tconsumption (capacity) (kWh)\n\n");
for (Id<Person> id : personId2tourDistance.keySet()) {
int tourDistance = (int) Math.round(personId2tourDistance.get(id) / 1000);
int consumption = 0;
double distanceRange = 0;
double electricityCapacityinkWh = 0;
double electricityConsumptionPerkm;
for (VehicleType singleVehicleType : vehicleTypes.getVehicleTypes().values()) {
if (id.toString().contains(singleVehicleType.getId().toString()) && singleVehicleType
.getEngineInformation().getAttributes().getAttribute("fuelType").equals("electricity")) {
electricityConsumptionPerkm = (double) singleVehicleType.getEngineInformation().getAttributes()
.getAttribute("engeryConsumptionPerKm");
electricityCapacityinkWh = (double) singleVehicleType.getEngineInformation().getAttributes()
.getAttribute("engeryCapacity");
distanceRange = (int) Math.round(electricityCapacityinkWh / electricityConsumptionPerkm);
consumption = (int) Math.round(personId2tourConsumptionkWh.get(id));
if (consumption > electricityCapacityinkWh)
toursWithOverconsumption.add(id.toString());
}
}
writer.write("\t" + id + "\t\t" + tourDistance);
if (distanceRange > 0) {
writer.write(" (" + distanceRange + ")\t\t\t\t\t\t" + consumption + " (" + electricityCapacityinkWh
+ ")");
} else
writer.write("\t\t\t\t\t\t\t\t\t\t");
writer.newLine();
}
personId2tourConsumptionkWh.clear();
personId2tourDistance.clear();
}
writer.flush();
writer.close();
log.info("Output geschrieben");
log.info("### Done.");
if (!toursWithOverconsumption.isEmpty())
throw new Exception("The tour(s) " + toursWithOverconsumption
+ " have a higher consumption then their capacity");
}
}
| 62,777 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
Run_Abfall.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/run/wasteCollection/Run_Abfall.java | package org.matsim.legacy.run.wasteCollection;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.network.Link;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.controler.Controler;
import org.matsim.core.scenario.ScenarioUtils;
import org.matsim.core.utils.gis.ShapeFileReader;
import org.matsim.freight.carriers.*;
import org.opengis.feature.simple.SimpleFeature;
/**
* @author Ricardo Ewert MA: Modellierung und Simulation der staedtischen
* Abfallwirtschaft am Beispiel Berlins
*
*/
public class Run_Abfall {
static final Logger log = LogManager.getLogger(Run_Abfall.class);
private static final String original_Chessboard = "https://raw.githubusercontent.com/matsim-org/matsim/master/examples/scenarios/freight-chessboard-9x9/grid9x9.xml";
private static final String berlin = "https://svn.vsp.tu-berlin.de/repos/public-svn/matsim/scenarios/countries/de/berlin/berlin-v5.2-1pct/output-berlin-v5.2-1pct/berlin-v5.2-1pct.output_network.xml.gz";
private static final String berlinDistrictsWithGarbageInformations = "scenarios/berlin-v5.5-10pct/input/wasteCollection/garbageInput/districtsWithGarbageInformations.shp";
private static final String inputVehicleTypes = "scenarios/berlin-v5.5-10pct/input/wasteCollection/vehicleTypes.xml";
private static final String inputCarriersWithDieselVehicle = "scenarios/berlin-v5.5-10pct/input/wasteCollection/carriers_diesel_vehicle.xml";
private static final String inputCarriersWithMediumBatteryVehicle = "scenarios/berlin-v5.5-10pct/input/wasteCollection/carriers_medium_EV.xml";
private static final String inputCarriersWithSmallBatteryVehicle = "scenarios/berlin-v5.5-10pct/input/wasteCollection/carriers_small_EV.xml";
private enum netzwerkAuswahl {
originalChessboard, berlinNetwork
};
private enum scenarioAuswahl {
chessboardTotalGarbageToCollect, chessboardGarbagePerMeterToCollect, berlinSelectedDistricts,
berlinDistrictsWithInputTotalGarbagePerDistrict, berlinDistrictsWithInputGarbagePerMeter,
berlinCollectedGarbageForOneDay
};
private enum carrierChoice {
carriersWithDieselVehicle, carriersWithMediumBattereyVehicle, carriersWithSmallBatteryVehicle,
carriersFromInputFile
}
public static void main(String[] args) throws Exception {
/*
* You have to decide the network. If you choose one of the chessboard networks,
* you have to select a chessboard scenario and if you select the Berlin
* network, you have to select one of the Berlin cases. The beginning of the
* name of the scenario shows you the needed network.
*/
netzwerkAuswahl netzwerkWahl = netzwerkAuswahl.berlinNetwork;
scenarioAuswahl scenarioWahl = null;
carrierChoice chosenCarrier = null;
int jspritIterations;
double volumeDustbinInLiters;
double secondsServiceTimePerDustbin;
String outputLocation;
String day;
String networkChangeEventsFileLocation;
String carriersFileLocation = null;
String vehicleTypesFileLocation = null;
String shapeFileLocation;
boolean oneCarrierForOneDistrict;
for (String arg : args) {
log.info(arg);
}
if (args.length == 0) {
chosenCarrier = carrierChoice.carriersWithDieselVehicle;
scenarioWahl = scenarioAuswahl.berlinSelectedDistricts;
shapeFileLocation = berlinDistrictsWithGarbageInformations;
oneCarrierForOneDistrict = true;
jspritIterations = 100;
volumeDustbinInLiters = 1100; // in liter
secondsServiceTimePerDustbin = 41;
outputLocation = "output/wasteCollection/Scenario1";
day = "MO";
networkChangeEventsFileLocation = "";
} else {
scenarioWahl = scenarioAuswahl.berlinCollectedGarbageForOneDay;
jspritIterations = Integer.parseInt(args[0]);
volumeDustbinInLiters = Double.parseDouble(args[1]); // in liter
secondsServiceTimePerDustbin = Double.parseDouble(args[2]);
day = args[3];
outputLocation = args[4];
vehicleTypesFileLocation = args[5];
networkChangeEventsFileLocation = args[6];
carriersFileLocation = args[7];
shapeFileLocation = args[8];
oneCarrierForOneDistrict = Boolean.parseBoolean(args[9]);
chosenCarrier = carrierChoice.carriersFromInputFile;
}
// log.setLevel(Level.INFO); // method no longer exists
// MATSim config
Config config = ConfigUtils.createConfig();
switch (netzwerkWahl) {
case originalChessboard:
config.controller().setOutputDirectory("output/original_Chessboard/04_Distances");
config.network().setInputFile(original_Chessboard);
break;
case berlinNetwork:
// Berlin scenario network
config.controller().setOutputDirectory(outputLocation);
config.network().setInputFile(berlin);
if (networkChangeEventsFileLocation != "") {
log.info("Setting networkChangeEventsInput file: " + networkChangeEventsFileLocation);
config.network().setTimeVariantNetwork(true);
config.network().setChangeEventsInputFile(networkChangeEventsFileLocation);
}
break;
default:
new RuntimeException("no network selected.");
}
switch (chosenCarrier) {
case carriersWithDieselVehicle:
vehicleTypesFileLocation = inputVehicleTypes;
carriersFileLocation = inputCarriersWithDieselVehicle;
break;
case carriersWithSmallBatteryVehicle:
vehicleTypesFileLocation = inputVehicleTypes;
carriersFileLocation = inputCarriersWithSmallBatteryVehicle;
break;
case carriersWithMediumBattereyVehicle:
vehicleTypesFileLocation = inputVehicleTypes;
carriersFileLocation = inputCarriersWithMediumBatteryVehicle;
break;
case carriersFromInputFile:
break;
default:
new RuntimeException("no carriers selected.");
}
config = AbfallUtils.prepareConfig(config, 0, vehicleTypesFileLocation, carriersFileLocation);
Scenario scenario = ScenarioUtils.loadScenario(config);
CarriersUtils.loadCarriersAccordingToFreightConfig(scenario);
// creates carrier
Carriers carriers = CarriersUtils.addOrGetCarriers(scenario);
HashMap<String, Carrier> carrierMap = AbfallUtils.createCarrier(carriers);
Map<Id<Link>, ? extends Link> allLinks = scenario.getNetwork().getLinks();
HashMap<String, Id<Link>> garbageDumps = AbfallUtils.createDumpMap();
Collection<SimpleFeature> districtsWithGarbage = ShapeFileReader
.getAllFeatures(shapeFileLocation);
AbfallUtils.createMapWithLinksInDistricts(districtsWithGarbage, allLinks);
switch (scenarioWahl) {
case chessboardTotalGarbageToCollect:
int kgGarbageToCollect = 12 * 1000;
CarrierVehicleTypes carrierVehicleTypes = CarriersUtils.getCarrierVehicleTypes(scenario);
AbfallChessboardUtils.createShipmentsForChessboardI(carrierMap, kgGarbageToCollect, allLinks,
volumeDustbinInLiters, secondsServiceTimePerDustbin, scenario, carriers);
CarrierCapabilities.FleetSize fleetSize = CarrierCapabilities.FleetSize.INFINITE;
AbfallChessboardUtils.createCarriersForChessboard(carriers, fleetSize, carrierVehicleTypes);
break;
case chessboardGarbagePerMeterToCollect:
double kgGarbagePerMeterToCollect = 0.2;
CarrierVehicleTypes carrierVehicleTypes2 = CarriersUtils.getCarrierVehicleTypes(scenario);
AbfallChessboardUtils.createShipmentsForChessboardII(carrierMap, kgGarbagePerMeterToCollect, allLinks,
volumeDustbinInLiters, secondsServiceTimePerDustbin, scenario, carriers);
CarrierCapabilities.FleetSize fleetSize2 = CarrierCapabilities.FleetSize.INFINITE;
AbfallChessboardUtils.createCarriersForChessboard(carriers, fleetSize2, carrierVehicleTypes2);
break;
case berlinSelectedDistricts:
// day input: MO or DI or MI or DO or FR
List<String> districtsForShipments = Arrays.asList("Malchow");
day = "MI";
AbfallUtils.createShipmentsForSelectedArea(districtsWithGarbage, districtsForShipments, day, garbageDumps,
scenario, carriers, carrierMap, allLinks, volumeDustbinInLiters, secondsServiceTimePerDustbin);
break;
case berlinDistrictsWithInputGarbagePerMeter:
// day input: MO or DI or MI or DO or FR
// input for Map .put("district", double kgGarbagePerMeterToCollect)
HashMap<String, Double> areasForShipmentPerMeterMap = new HashMap<String, Double>();
areasForShipmentPerMeterMap.put("Malchow", 1.0);
day = "MI";
AbfallUtils.createShipmentsWithGarbagePerMeter(districtsWithGarbage, areasForShipmentPerMeterMap, day,
garbageDumps, scenario, carriers, carrierMap, allLinks, volumeDustbinInLiters,
secondsServiceTimePerDustbin);
break;
case berlinDistrictsWithInputTotalGarbagePerDistrict:
// day input: MO or DI or MI or DO or FR
// input for Map .put("district", int kgGarbageToCollect)
HashMap<String, Integer> areasForShipmentPerVolumeMap = new HashMap<String, Integer>();
areasForShipmentPerVolumeMap.put("Malchow", 5 * 1000);
// areasForShipmentPerVolumeMap.put("Hansaviertel", 20 * 1000);
day = "MI";
AbfallUtils.createShipmentsGarbagePerVolume(districtsWithGarbage, areasForShipmentPerVolumeMap, day,
garbageDumps, scenario, carriers, carrierMap, allLinks, volumeDustbinInLiters,
secondsServiceTimePerDustbin);
break;
case berlinCollectedGarbageForOneDay:
// MO or DI or MI or DO or FR
AbfallUtils.createShipmentsForSelectedDay(districtsWithGarbage, day, garbageDumps, scenario, carriers,
carrierMap, allLinks, volumeDustbinInLiters, secondsServiceTimePerDustbin, oneCarrierForOneDistrict);
break;
default:
new RuntimeException("no scenario selected.");
}
/*
* This xml output gives a summary with information about the created shipments,
* so that you can already have this information, while jsprit and matsim are
* still running.
*/
AbfallUtils.outputSummaryShipments(scenario, day, carrierMap);
// jsprit
AbfallUtils.solveWithJsprit(scenario, carriers, carrierMap, jspritIterations);
// final Controler controler = new Controler(scenario);
Controler controler = AbfallUtils.prepareControler(scenario);
// AbfallUtils.scoringAndManagerFactory(scenario, controler);
controler.run();
new CarrierPlanXmlWriterV2(carriers)
.write(scenario.getConfig().controller().getOutputDirectory() + "/output_CarrierPlans.xml");
AbfallUtils.outputSummary(districtsWithGarbage, scenario, carrierMap, day, volumeDustbinInLiters,
secondsServiceTimePerDustbin);
AbfallUtils.createResultFile(scenario, carriers);
}
}
| 10,519 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunBerlinAccidents.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/RunBerlinAccidents.java | package org.matsim.legacy.analysis;
import java.io.IOException;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Scenario;
import org.matsim.contrib.accidents.AccidentsConfigGroup;
import org.matsim.contrib.accidents.AccidentsModule;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.controler.Controler;
import org.matsim.core.controler.OutputDirectoryHierarchy.OverwriteFileSetting;
import org.matsim.legacy.run.RunBerlinScenario;
/**
* @author Hugo
*/
public class RunBerlinAccidents {
private static final Logger log = LogManager.getLogger(RunBerlinAccidents.class);
public static void main(String[] args) throws IOException {
for (String arg : args) {
log.info( arg );
}
if ( args.length==0 ) {
args = new String[] {"scenarios/berlin-v5.5-10pct/input/berlin-v5.5-10pct.config.xml"} ;
}
String outputFile = "scenarios/berlin-v5.5-10pct/output-berlin-v5.5-10pct-accidents/";
String BVWPNetwork = "https://svn.vsp.tu-berlin.de/repos/public-svn/matsim/scenarios/countries/de/berlin/berlin-v5.5-10pct/input/berlin-v5.5-network-with-bvwp-accidents-attributes.xml.gz";
String plans = "https://svn.vsp.tu-berlin.de/repos/public-svn/matsim/scenarios/countries/de/berlin/berlin-v5.5-10pct/input/berlin-v5.5-10pct.plans.xml.gz";
Config config = RunBerlinScenario.prepareConfig(args);
config.controller().setOutputDirectory(outputFile);
config.controller().setOverwriteFileSetting(OverwriteFileSetting.deleteDirectoryIfExists);
config.controller().setLastIteration(500);
config.plans().setInputFile(plans);
AccidentsConfigGroup accidentsSettings = ConfigUtils.addOrGetModule(config, AccidentsConfigGroup.class);
accidentsSettings.setEnableAccidentsModule(true);
accidentsSettings.setScaleFactor(10);
config.network().setInputFile(BVWPNetwork);
config.scoring().getModes().get("car").setMonetaryDistanceRate(-0.0004);
Scenario scenario = RunBerlinScenario.prepareScenario(config);
Controler controler = RunBerlinScenario.prepareControler(scenario);
controler.addOverridingModule(new AccidentsModule());
controler.run();
}
}
| 2,192 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunDirectWalkAnalysis.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/RunDirectWalkAnalysis.java | package org.matsim.legacy.analysis;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.TransportMode;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.router.TripStructureUtils;
import org.matsim.core.scenario.ScenarioUtils;
import org.matsim.legacy.run.drt.OpenBerlinIntermodalPtDrtRouterAnalysisModeIdentifier;
public class RunDirectWalkAnalysis {
private static final Logger log = LogManager.getLogger(RunDirectWalkAnalysis.class);
public static void main(String[] args) {
String runDirectory = "/home/gregor/tmp/open-berlin-intermodal/Z127e";
String runId = "Z127e"; // 15979 direct walk trips of total 55204 trips.
// String runDirectory = "/home/gregor/tmp/open-berlin-intermodal/Z148e";
// String runId = "Z148e"; // 20642 direct walk trips of total 59952 trips.
run(runDirectory, runId);
}
private static void run(String runDirectory, String runId) {
Scenario scenario = loadScenario(runDirectory, runId);
OpenBerlinIntermodalPtDrtRouterAnalysisModeIdentifier mainModeIdentifier = new OpenBerlinIntermodalPtDrtRouterAnalysisModeIdentifier();
long counterTrips = scenario.getPopulation().getPersons().values().stream().
map(person -> person.getSelectedPlan()).
map(plan -> TripStructureUtils.getTrips(plan)).
flatMap(trips -> trips.stream()).
filter(trip -> TripStructureUtils.getRoutingMode(trip.getLegsOnly().get(0)).equals(TransportMode.pt)).
count();
long counterDirectWalkTrips = scenario.getPopulation().getPersons().values().stream().
map(person -> person.getSelectedPlan()).
map(plan -> TripStructureUtils.getTrips(plan)).
flatMap(trips -> trips.stream()).
filter(trip ->
trip.getLegsOnly().size() == 1 &&
trip.getLegsOnly().get(0).getMode().equals(TransportMode.walk) &&
( /*!*/ TripStructureUtils.getRoutingMode(trip.getLegsOnly().get(0)).equals(TransportMode.pt))).
count();
log.info(counterDirectWalkTrips + " direct walk trips of total " + counterTrips + " trips.");
}
private static Scenario loadScenario(String runDirectory, String runId) {
log.info("Loading scenario...");
if (runDirectory == null || runDirectory.equals("") || runDirectory.equals("null")) {
return null;
}
if (!runDirectory.endsWith("/")) runDirectory = runDirectory + "/";
String networkFile;
String populationFile;
String configFile;
configFile = runDirectory + runId + ".output_config.xml";
networkFile = runId + ".output_network.xml.gz";
populationFile = runId + ".output_plans.xml.gz";
Config config = ConfigUtils.loadConfig(configFile);
if (!runId.equals(config.controller().getRunId()))
throw new RuntimeException("Given run ID " + runId + " doesn't match the run ID given in the config file. Aborting...");
config.controller().setOutputDirectory(runDirectory);
config.plans().setInputFile(populationFile);
config.network().setInputFile(networkFile);
config.vehicles().setVehiclesFile(null);
config.transit().setTransitScheduleFile(null);
config.transit().setVehiclesFile(null);
return ScenarioUtils.loadScenario(config);
}
}
| 3,632 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
IncomeDependentPersonAnalysis.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/IncomeDependentPersonAnalysis.java | /* *********************************************************************** *
* project: org.matsim.*
* Controler.java
* *
* *********************************************************************** *
* *
* copyright : (C) 2007 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.analysis;
import one.util.streamex.StreamEx;
import org.matsim.api.core.v01.population.Person;
import org.matsim.api.core.v01.population.Population;
import org.matsim.core.population.PersonUtils;
import org.matsim.core.population.PopulationUtils;
import org.matsim.core.router.TripStructureUtils;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import static java.util.stream.Collectors.toList;
public class IncomeDependentPersonAnalysis {
private static final String INPUT_POPULATION = "";
public static void main(String[] args) {
Population population = PopulationUtils.readPopulation(INPUT_POPULATION);
printNrOfPersonsClassifiedByDRTLegsAndIncome(population);
}
private static void printNrOfPersonsClassifiedByDRTLegsAndIncome(Population population) {
Map<Double, List<Integer>> nrOfDrtLegsByIncome = StreamEx.of(population.getPersons().values())
.filter(p -> PopulationUtils.getSubpopulation(p).equals("person"))
.mapToEntry(p -> PersonUtils.getIncome(p) == null ? -999.999 : (double) PersonUtils.getIncome(p),
p -> getNumberOfDrtLegs(p))
.filterValues(v -> v > 0)
.grouping(toList());
int lowerBound = 2;
int upperBound = 5;
System.out.println("\t<2\t2\t3\t4\t5\t>5");
nrOfDrtLegsByIncome.forEach((income, drtLegsList) -> System.out.println(income + printArray(getListClassified(drtLegsList, lowerBound, upperBound))) );
}
private static String printArray(int[] array){
String s = "";
for (int i : array) {
s+= "\t" + i;
}
return s;
}
/**
* returns an array with that contains the classified list...
* i.e. how many elements in the list are
* @param l
* @param lowerBound
* @param upperBound
* @return
*/
private static int[] getListClassified(List<Integer> l, int lowerBound, int upperBound){
int[] array = new int[upperBound - lowerBound + 3];
Arrays.fill(array,0);
l.forEach(nr -> {
if (nr < lowerBound) array[0]++;
else if (nr > upperBound) array[array.length-1]++;
else array[array.length - 2 - upperBound + nr]++;
});
return array;
}
private static int getNumberOfDrtLegs(Person person){
return (int) TripStructureUtils.getLegs(person.getSelectedPlan()).stream()
.filter(l -> l.getMode().equals("drt"))
.count();
}
}
| 3,650 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunOfflineNoiseAnalysis.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/RunOfflineNoiseAnalysis.java | /* *********************************************************************** *
* project: org.matsim.*
* *
* *********************************************************************** *
* *
* copyright : (C) 2014 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.analysis;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Scenario;
import org.matsim.contrib.noise.MergeNoiseCSVFile;
import org.matsim.contrib.noise.NoiseConfigGroup;
import org.matsim.contrib.noise.NoiseOfflineCalculation;
import org.matsim.contrib.noise.ProcessNoiseImmissions;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.scenario.ScenarioUtils;
/**
*
* @author ikaddoura
*
*/
public class RunOfflineNoiseAnalysis {
private static final Logger log = LogManager.getLogger(RunOfflineNoiseAnalysis.class);
private final String runDirectory;
private final String runId;
private final String analysisOutputDirectory;
// private final String tunnelLinkIdFile = "https://svn.vsp.tu-berlin.de/repos/public-svn/matsim/scenarios/countries/de/berlin/berlin-v5.4-10pct/input/berlin-v5.1.tunnel-linkIDs.csv";
private final String tunnelLinkIdFile = null;
// private final String noiseBarriersFile = "https://svn.vsp.tu-berlin.de/repos/public-svn/matsim/scenarios/countries/de/berlin/berlin-v5.5-10pct/input/berlin-buildings/osm-buildings-dissolved.geojson";
private final String noiseBarriersFile = null;
public RunOfflineNoiseAnalysis(String runDirectory, String runId, String analysisOutputDirectory) {
this.runDirectory = runDirectory;
this.runId = runId;
if (!analysisOutputDirectory.endsWith("/")) analysisOutputDirectory = analysisOutputDirectory + "/";
this.analysisOutputDirectory = analysisOutputDirectory;
}
public static void main(String[] args) {
final String runDirectory = "https://svn.vsp.tu-berlin.de/repos/public-svn/matsim/scenarios/countries/de/berlin/berlin-v5.4-1pct/output-berlin-v5.4-1pct/";
final String runId = "berlin-v5.4-1pct";
RunOfflineNoiseAnalysis analysis = new RunOfflineNoiseAnalysis(runDirectory, runId, "./scenario/");
analysis.run();
}
void run() {
double receiverPointGap = 100.;
double timeBinSize = 3600.;
Config config = ConfigUtils.createConfig(new NoiseConfigGroup());
config.global().setCoordinateSystem("GK4");
config.network().setInputFile(runDirectory + runId + ".output_network.xml.gz");
config.plans().setInputFile(runDirectory + runId + ".output_plans.xml.gz");
config.controller().setOutputDirectory(runDirectory);
config.controller().setRunId(runId);
// adjust the default noise parameters
NoiseConfigGroup noiseParameters = (NoiseConfigGroup) config.getModules().get(NoiseConfigGroup.GROUP_NAME);
noiseParameters.setReceiverPointGap(receiverPointGap);
double xMin = 4573258.;
double yMin = 5801225.;
double xMax = 4620323.;
double yMax = 5839639.;
noiseParameters.setReceiverPointsGridMinX(xMin);
noiseParameters.setReceiverPointsGridMinY(yMin);
noiseParameters.setReceiverPointsGridMaxX(xMax);
noiseParameters.setReceiverPointsGridMaxY(yMax);
String[] consideredActivitiesForDamages = {"home*", "work*", "leisure*", "shopping*", "other*"};
noiseParameters.setConsideredActivitiesForDamageCalculationArray(consideredActivitiesForDamages);
// ################################
noiseParameters.setUseActualSpeedLevel(false);
noiseParameters.setAllowForSpeedsOutsideTheValidRange(false);
noiseParameters.setScaleFactor(100.);
noiseParameters.setComputePopulationUnits(true);
noiseParameters.setComputeNoiseDamages(true);
noiseParameters.setInternalizeNoiseDamages(false);
noiseParameters.setComputeCausingAgents(false);
noiseParameters.setThrowNoiseEventsAffected(true);
noiseParameters.setThrowNoiseEventsCaused(false);
String[] hgvIdPrefixes = { "freight" };
noiseParameters.setHgvIdPrefixesArray(hgvIdPrefixes);
noiseParameters.setTunnelLinkIdFile(tunnelLinkIdFile);
noiseParameters.setTimeBinSizeNoiseComputation(timeBinSize);
noiseParameters.setConsiderNoiseBarriers(false);
noiseParameters.setNoiseBarriersFilePath(noiseBarriersFile);
noiseParameters.setNoiseBarriersSourceCRS("EPSG:31468");
Scenario scenario = ScenarioUtils.loadScenario(config);
NoiseOfflineCalculation noiseCalculation = new NoiseOfflineCalculation(scenario, analysisOutputDirectory);
noiseCalculation.run();
// some processing of the output data
String outputFilePath = analysisOutputDirectory + "noise-analysis/";
ProcessNoiseImmissions process = new ProcessNoiseImmissions(outputFilePath + "immissions/", outputFilePath + "receiverPoints/receiverPoints.csv", noiseParameters.getReceiverPointGap());
process.run();
final String[] labels = { "damages_receiverPoint" };
final String[] workingDirectories = { outputFilePath + "/damages_receiverPoint/" };
MergeNoiseCSVFile merger = new MergeNoiseCSVFile() ;
merger.setReceiverPointsFile(outputFilePath + "receiverPoints/receiverPoints.csv");
merger.setOutputDirectory(outputFilePath);
merger.setTimeBinSize(noiseParameters.getTimeBinSizeNoiseComputation());
merger.setWorkingDirectory(workingDirectories);
merger.setLabel(labels);
merger.run();
log.info("Done.");
}
}
| 6,394 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
GenerateAirPollutionSpatialPlots.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/emissions/GenerateAirPollutionSpatialPlots.java | /* *********************************************************************** *
* project: org.matsim.*
* *
* *********************************************************************** *
* *
* copyright : (C) 2014 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.analysis.emissions;
import java.io.FileWriter;
import java.io.IOException;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVPrinter;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.matsim.contrib.emissions.Pollutant;
import org.matsim.contrib.emissions.analysis.FastEmissionGridAnalyzer;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.network.NetworkUtils;
import org.matsim.core.utils.geometry.geotools.MGC;
/**
* @author amit, ihab, janek
*/
public abstract class GenerateAirPollutionSpatialPlots {
private static final Logger log = LogManager.getLogger(GenerateAirPollutionSpatialPlots.class);
private static final double xMin = 4565039. - 125.;
private static final double xMax = 4632739. + 125.;
private static final double yMin = 5801108. - 125.;
private static final double yMax = 5845708. + 125.;
public static void main(String[] args) {
String rootDirectory;
if (args.length == 1) {
rootDirectory = args[0];
} else {
throw new RuntimeException("Please set the root directory. Aborting...");
}
final double gridSize = 100.;
final double scaleFactor = 100.;
final String runDir = rootDirectory + "public-svn/matsim/scenarios/countries/de/berlin/berlin-v5.4-1pct/output-berlin-v5.4-1pct/";
final String runId = "berlin-v5.4-1pct";
final String events = runDir + runId + ".emission.events.offline.xml.gz";
final String configFile = runDir + runId + "output_config.xml";
final String networkFile = runDir + runId + "output_network.xml.gz";
final String outputFile = runDir + runId + ".emissions." + Pollutant.NOx + ".csv";
// filter the network onto the bounding box. This way only the links within the bounding box will collect emissions
var boundingBox = createBoundingBox();
Config config = ConfigUtils.loadConfig(configFile);
var filteredNetwork = NetworkUtils.readNetwork(networkFile, config).getLinks().values().parallelStream()
.filter(link -> boundingBox.covers(MGC.coord2Point(link.getFromNode().getCoord())) || boundingBox.covers(MGC.coord2Point(link.getToNode().getCoord())))
.collect(NetworkUtils.getCollector(config));
// do the actual rastering. Reducing the radius will lead to less smoothed emissions
// reduce to 0, to only draw emissions onto cells which are covered by a link.
var rasterMap = FastEmissionGridAnalyzer.processEventsFile(events, filteredNetwork, gridSize, 20);
// write the raster for nox
var noxRaster = rasterMap.get(Pollutant.NOx);
try (CSVPrinter printer = new CSVPrinter(new FileWriter(outputFile), CSVFormat.TDF)) {
// write header
printer.printRecord("x", "y", Pollutant.NOx);
// write values
noxRaster.forEachCoordinate((x, y, value) -> {
// skip values smaller than 0.1g/ha to reduce file size
if (value < 0.1) return;
// unfortunately one has to wrap this in try/catch because it is inside a lambda function
try {
printer.printRecord(x, y, value * scaleFactor);
} catch (IOException e) {
e.printStackTrace();
}
});
} catch (IOException e) {
e.printStackTrace();
}
}
private static Geometry createBoundingBox() {
return new GeometryFactory().createPolygon(new Coordinate[]{
new Coordinate(xMin, yMin), new Coordinate(xMax, yMin),
new Coordinate(xMax, yMax), new Coordinate(xMin, yMax),
new Coordinate(xMin, yMin)
});
}
}
| 5,318 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
EmissionsOnLinkHandler.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/emissions/EmissionsOnLinkHandler.java | package org.matsim.legacy.analysis.emissions;
import java.util.HashMap;
import java.util.Map;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.network.Link;
import org.matsim.contrib.emissions.Pollutant;
import org.matsim.contrib.emissions.events.ColdEmissionEvent;
import org.matsim.contrib.emissions.events.ColdEmissionEventHandler;
import org.matsim.contrib.emissions.events.WarmEmissionEvent;
import org.matsim.contrib.emissions.events.WarmEmissionEventHandler;
public class EmissionsOnLinkHandler implements WarmEmissionEventHandler, ColdEmissionEventHandler {
private final Map<Id<Link>, Map<Pollutant, Double>> link2pollutants = new HashMap<>();
@Override
public void reset(int iteration) {
link2pollutants.clear();
}
@Override
public void handleEvent(WarmEmissionEvent event) {
Map<Pollutant,Double> map = new HashMap<>() ;
for( Map.Entry<Pollutant, Double> entry : event.getWarmEmissions().entrySet() ){
map.put( entry.getKey(), entry.getValue() ) ;
}
handleEmissionEvent(event.getTime(), event.getLinkId(), map );
}
@Override
public void handleEvent(ColdEmissionEvent event) {
handleEmissionEvent(event.getTime(), event.getLinkId(), event.getColdEmissions());
}
private void handleEmissionEvent(double time, Id<Link> linkId, Map<Pollutant, Double> emissions) {
if (link2pollutants.get(linkId) == null) {
link2pollutants.put(linkId, emissions);
} else {
for (Pollutant pollutant : emissions.keySet()) {
link2pollutants.get(linkId).merge(pollutant, emissions.get(pollutant), Double::sum);
}
}
}
public Map<Id<Link>, Map<Pollutant, Double>> getLink2pollutants() {
return link2pollutants;
}
}
| 1,772 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunOfflineAirPollutionAnalysisByVehicleCategory.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/emissions/RunOfflineAirPollutionAnalysisByVehicleCategory.java | /* *********************************************************************** *
* project: org.matsim.*
* *
* *********************************************************************** *
* *
* copyright : (C) 2017 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.analysis.emissions;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.Scenario;
import org.matsim.contrib.emissions.EmissionModule;
import org.matsim.contrib.emissions.HbefaVehicleCategory;
import org.matsim.contrib.emissions.VspHbefaRoadTypeMapping;
import org.matsim.contrib.emissions.utils.EmissionsConfigGroup;
import org.matsim.contrib.emissions.utils.EmissionsConfigGroup.DetailedVsAverageLookupBehavior;
import org.matsim.contrib.emissions.utils.EmissionsConfigGroup.NonScenarioVehicles;
import org.matsim.core.api.experimental.events.EventsManager;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.controler.AbstractModule;
import org.matsim.core.controler.Injector;
import org.matsim.core.events.EventsUtils;
import org.matsim.core.events.MatsimEventsReader;
import org.matsim.core.events.algorithms.EventWriterXML;
import org.matsim.core.scenario.ScenarioUtils;
import org.matsim.vehicles.EngineInformation;
import org.matsim.vehicles.VehicleType;
import org.matsim.vehicles.VehicleUtils;
/**
* @author ikaddoura
*/
public class RunOfflineAirPollutionAnalysisByVehicleCategory {
private final String runDirectory;
private final String runId;
private final String hbefaWarmFile;
private final String hbefaColdFile;
private final String analysisOutputDirectory;
public RunOfflineAirPollutionAnalysisByVehicleCategory(String runDirectory, String runId, String hbefaFileWarm, String hbefaFileCold, String analysisOutputDirectory) {
this.runDirectory = runDirectory;
this.runId = runId;
this.hbefaWarmFile = hbefaFileWarm;
this.hbefaColdFile = hbefaFileCold;
if (!analysisOutputDirectory.endsWith("/")) analysisOutputDirectory = analysisOutputDirectory + "/";
this.analysisOutputDirectory = analysisOutputDirectory;
}
public static void main(String[] args) {
if (args.length == 1) {
String rootDirectory = args[0];
if (!rootDirectory.endsWith("/")) rootDirectory = rootDirectory + "/";
final String runDirectory = "public-svn/matsim/scenarios/countries/de/berlin/berlin-v5.4-10pct/output-berlin-v5.4-10pct/";
final String runId = "berlin-v5.4-10pct";
final String hbefaFileCold = "shared-svn/projects/matsim-germany/hbefa/hbefa-files/v3.2/EFA_ColdStart_vehcat_2005average.txt";
final String hbefaFileWarm = "shared-svn/projects/matsim-germany/hbefa/hbefa-files/v3.2/EFA_HOT_vehcat_2005average.txt";
RunOfflineAirPollutionAnalysisByVehicleCategory analysis = new RunOfflineAirPollutionAnalysisByVehicleCategory(
rootDirectory + runDirectory,
runId,
rootDirectory + hbefaFileWarm,
rootDirectory + hbefaFileCold,
rootDirectory + runDirectory);
analysis.run();
} else {
throw new RuntimeException("Please set the root directory. Aborting...");
}
}
void run() {
Config config = ConfigUtils.createConfig();
config.vehicles().setVehiclesFile(runDirectory + runId + ".output_vehicles.xml.gz");
config.network().setInputFile(runDirectory + runId + ".output_network.xml.gz");
config.transit().setTransitScheduleFile(runDirectory + runId + ".output_transitSchedule.xml.gz");
config.transit().setVehiclesFile(runDirectory + runId + ".output_transitVehicles.xml.gz");
config.global().setCoordinateSystem("GK4");
config.plans().setInputFile(null);
config.eventsManager().setNumberOfThreads(null);
config.eventsManager().setEstimatedNumberOfEvents(null);
config.global().setNumberOfThreads(1);
EmissionsConfigGroup eConfig = ConfigUtils.addOrGetModule(config, EmissionsConfigGroup.class);
eConfig.setDetailedVsAverageLookupBehavior(DetailedVsAverageLookupBehavior.directlyTryAverageTable);
eConfig.setAverageColdEmissionFactorsFile(this.hbefaColdFile);
eConfig.setAverageWarmEmissionFactorsFile(this.hbefaWarmFile);
eConfig.setNonScenarioVehicles(NonScenarioVehicles.ignore);
final String emissionEventOutputFile = analysisOutputDirectory + runId + ".emission.events.offline.xml.gz";
final String eventsFile = runDirectory + runId + ".output_events.xml.gz";
Scenario scenario = ScenarioUtils.loadScenario(config);
// network
new VspHbefaRoadTypeMapping().addHbefaMappings(scenario.getNetwork());
// vehicles
Id<VehicleType> carVehicleTypeId = Id.create("car", VehicleType.class);
Id<VehicleType> freightVehicleTypeId = Id.create("freight", VehicleType.class);
VehicleType carVehicleType = scenario.getVehicles().getVehicleTypes().get(carVehicleTypeId);
VehicleType freightVehicleType = scenario.getVehicles().getVehicleTypes().get(freightVehicleTypeId);
EngineInformation carEngineInformation = carVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( carEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( carEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( carEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( carEngineInformation, "average" );
EngineInformation freightEngineInformation = freightVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( freightEngineInformation, HbefaVehicleCategory.HEAVY_GOODS_VEHICLE.toString());
VehicleUtils.setHbefaTechnology( freightEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( freightEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( freightEngineInformation, "average" );
// public transit vehicles should be considered as non-hbefa vehicles
for (VehicleType type : scenario.getTransitVehicles().getVehicleTypes().values()) {
EngineInformation engineInformation = type.getEngineInformation();
// TODO: Check! Is this a zero emission vehicle?!
VehicleUtils.setHbefaVehicleCategory( engineInformation, HbefaVehicleCategory.NON_HBEFA_VEHICLE.toString());
VehicleUtils.setHbefaTechnology( engineInformation, "average" );
VehicleUtils.setHbefaSizeClass( engineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( engineInformation, "average" );
}
// the following is copy paste from the example...
EventsManager eventsManager = EventsUtils.createEventsManager();
AbstractModule module = new AbstractModule(){
@Override
public void install(){
bind( Scenario.class ).toInstance( scenario );
bind( EventsManager.class ).toInstance( eventsManager );
bind( EmissionModule.class ) ;
}
};
com.google.inject.Injector injector = Injector.createInjector(config, module);
EmissionModule emissionModule = injector.getInstance(EmissionModule.class);
EventWriterXML emissionEventWriter = new EventWriterXML(emissionEventOutputFile);
emissionModule.getEmissionEventsManager().addHandler(emissionEventWriter);
eventsManager.initProcessing();
MatsimEventsReader matsimEventsReader = new MatsimEventsReader(eventsManager);
matsimEventsReader.readFile(eventsFile);
eventsManager.finishProcessing();
emissionEventWriter.closeFile();
}
}
| 8,363 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunOfflineAirPollutionAnalysisByEngineInformationWithDrt.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/emissions/RunOfflineAirPollutionAnalysisByEngineInformationWithDrt.java | /* *********************************************************************** *
* project: org.matsim.*
* *
* *********************************************************************** *
* *
* copyright : (C) 2017 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.analysis.emissions;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.network.Link;
import org.matsim.contrib.emissions.EmissionModule;
import org.matsim.contrib.emissions.HbefaVehicleCategory;
import org.matsim.contrib.emissions.Pollutant;
import org.matsim.contrib.emissions.VspHbefaRoadTypeMapping;
import org.matsim.contrib.emissions.utils.EmissionsConfigGroup;
import org.matsim.contrib.emissions.utils.EmissionsConfigGroup.DetailedVsAverageLookupBehavior;
import org.matsim.contrib.emissions.utils.EmissionsConfigGroup.NonScenarioVehicles;
import org.matsim.core.api.experimental.events.EventsManager;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.controler.AbstractModule;
import org.matsim.core.controler.Injector;
import org.matsim.core.events.EventsUtils;
import org.matsim.core.events.MatsimEventsReader;
import org.matsim.core.events.algorithms.EventWriterXML;
import org.matsim.core.gbl.MatsimRandom;
import org.matsim.core.scenario.ScenarioUtils;
import org.matsim.vehicles.EngineInformation;
import org.matsim.vehicles.Vehicle;
import org.matsim.vehicles.VehicleType;
import org.matsim.vehicles.VehicleUtils;
/**
*
* Computes the emissions using the 'allVehicles' output file which should be written out as a default in more recent MATSim runs
*
* @author ikaddoura
*/
public class RunOfflineAirPollutionAnalysisByEngineInformationWithDrt {
private static final Logger log = LogManager.getLogger(RunOfflineAirPollutionAnalysisByEngineInformationWithDrt.class);
private final String runDirectory;
private final String runId;
private final String hbefaWarmFile;
private final String hbefaColdFile;
private final String analysisOutputDirectory;
// provided by HBEFA for 2020
private final double petrolShare = 0.512744724750519;
private final double dieselShare = 0.462841421365738;
private final double lpgShare = 0.011381645;
private final double cngShare = 0.0038579236716032;
private final double hybridPetrolShare = 0.005743607878685;
private final double hybridDieselShare = 0.00014232617104426;
private final static double shareOfPrivateVehiclesChangedToElectric = 0.0; // in addition to electric vehicle share in the reference case!
public RunOfflineAirPollutionAnalysisByEngineInformationWithDrt(String runDirectory, String runId, String hbefaFileWarm, String hbefaFileCold, String analysisOutputDirectory) {
if (!runDirectory.endsWith("/")) runDirectory = runDirectory + "/";
this.runDirectory = runDirectory;
this.runId = runId;
this.hbefaWarmFile = hbefaFileWarm;
this.hbefaColdFile = hbefaFileCold;
if (!analysisOutputDirectory.endsWith("/")) analysisOutputDirectory = analysisOutputDirectory + "/";
this.analysisOutputDirectory = analysisOutputDirectory;
}
public static void main(String[] args) throws IOException {
if (args.length == 1) {
String rootDirectory = args[0];
if (!rootDirectory.endsWith("/")) rootDirectory = rootDirectory + "/";
final String hbefaFileCold = "shared-svn/projects/matsim-germany/hbefa/hbefa-files/v4.1/EFA_ColdStart_Concept_2020_detailed_perTechAverage_Bln_carOnly.csv";
final String hbefaFileWarm = "shared-svn/projects/matsim-germany/hbefa/hbefa-files/v4.1/EFA_HOT_Concept_2020_detailed_perTechAverage_Bln_carOnly.csv";
final String runDirectory = "./test/output/org/matsim/run/drt/RunDrtOpenBerlinScenarioTest/eTest0_1pctUntilIteration3/";
final String runId = "berlin-drt-v5.5-1pct";
RunOfflineAirPollutionAnalysisByEngineInformationWithDrt analysis = new RunOfflineAirPollutionAnalysisByEngineInformationWithDrt(
runDirectory,
runId,
rootDirectory + hbefaFileWarm,
rootDirectory + hbefaFileCold,
runDirectory + "emission-analysis-hbefa-v4.1");
analysis.run();
} else {
throw new RuntimeException("Please set the root directory. Aborting...");
}
}
void run() throws IOException {
Config config = ConfigUtils.createConfig();
config.vehicles().setVehiclesFile(runDirectory + runId + ".output_allVehicles.xml.gz");
config.network().setInputFile(runDirectory + runId + ".output_network.xml.gz");
config.transit().setTransitScheduleFile(runDirectory + runId + ".output_transitSchedule.xml.gz");
config.transit().setVehiclesFile(runDirectory + runId + ".output_transitVehicles.xml.gz");
config.global().setCoordinateSystem("EPSG:31468");
config.plans().setInputFile(null);
config.eventsManager().setNumberOfThreads(null);
config.eventsManager().setEstimatedNumberOfEvents(null);
config.global().setNumberOfThreads(1);
EmissionsConfigGroup eConfig = ConfigUtils.addOrGetModule(config, EmissionsConfigGroup.class);
eConfig.setDetailedVsAverageLookupBehavior(DetailedVsAverageLookupBehavior.tryDetailedThenTechnologyAverageElseAbort);
eConfig.setDetailedColdEmissionFactorsFile(hbefaColdFile);
eConfig.setDetailedWarmEmissionFactorsFile(hbefaWarmFile);
eConfig.setNonScenarioVehicles(NonScenarioVehicles.ignore);
eConfig.setWritingEmissionsEvents(true);
File folder = new File(analysisOutputDirectory);
folder.mkdirs();
final String eventsFile = runDirectory + runId + ".output_events.xml.gz";
final String emissionEventOutputFile = analysisOutputDirectory + runId + ".emission.events.offline.xml.gz";
final String linkEmissionAnalysisFile = analysisOutputDirectory + runId + ".emissionsPerLink.csv";
final String linkEmissionPerMAnalysisFile = analysisOutputDirectory + runId + ".emissionsPerLinkPerM.csv";
final String vehicleTypeFile = analysisOutputDirectory + runId + ".emissionVehicleInformation.csv";
Scenario scenario = ScenarioUtils.loadScenario(config);
// network
new VspHbefaRoadTypeMapping().addHbefaMappings(scenario.getNetwork());
// car vehicles
VehicleType petrolCarVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("petrolCar", VehicleType.class));
scenario.getVehicles().addVehicleType(petrolCarVehicleType);
EngineInformation petrolCarEngineInformation = petrolCarVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( petrolCarEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( petrolCarEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( petrolCarEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( petrolCarEngineInformation, "petrol (4S)" );
VehicleType dieselCarVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("dieselCar", VehicleType.class));
scenario.getVehicles().addVehicleType(dieselCarVehicleType);
EngineInformation dieselCarEngineInformation = dieselCarVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( dieselCarEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( dieselCarEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( dieselCarEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( dieselCarEngineInformation, "diesel" );
VehicleType cngVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("cngCar", VehicleType.class));
scenario.getVehicles().addVehicleType(cngVehicleType);
EngineInformation cngCarEngineInformation = cngVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( cngCarEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( cngCarEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( cngCarEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( cngCarEngineInformation, "bifuel CNG/petrol" );
VehicleType lpgVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("lpgCar", VehicleType.class));
scenario.getVehicles().addVehicleType(lpgVehicleType);
EngineInformation lpgCarEngineInformation = lpgVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( lpgCarEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( lpgCarEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( lpgCarEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( lpgCarEngineInformation, "bifuel LPG/petrol" );
// electric vehicles
VehicleType electricVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("electricCar", VehicleType.class));
scenario.getVehicles().addVehicleType(electricVehicleType);
EngineInformation electricEngineInformation = electricVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( electricEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( electricEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( electricEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( electricEngineInformation, "electricity" );
// plug-in hybrid petrol vehicles
VehicleType pluginHybridPetrolVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("pluginHybridPetrol", VehicleType.class));
scenario.getVehicles().addVehicleType(pluginHybridPetrolVehicleType);
EngineInformation pluginHybridPetrolEngineInformation = pluginHybridPetrolVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( pluginHybridPetrolEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( pluginHybridPetrolEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( pluginHybridPetrolEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( pluginHybridPetrolEngineInformation, "Plug-in Hybrid petrol/electric" );
// plug-in hybrid petrol vehicles
VehicleType pluginHybridDieselVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("pluginHybridDiesel", VehicleType.class));
scenario.getVehicles().addVehicleType(pluginHybridDieselVehicleType);
EngineInformation pluginHybridDieselEngineInformation = pluginHybridDieselVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( pluginHybridDieselEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( pluginHybridDieselEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( pluginHybridDieselEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( pluginHybridDieselEngineInformation, "Plug-in Hybrid diesel/electric" );
VehicleType defaultCarVehicleType = scenario.getVehicles().getVehicleTypes().get(Id.create("car", VehicleType.class));
VehicleType freightVehicleType = scenario.getVehicles().getVehicleTypes().get(Id.create("freight", VehicleType.class));
VehicleUtils.setHbefaVehicleCategory( freightVehicleType.getEngineInformation(), HbefaVehicleCategory.NON_HBEFA_VEHICLE.toString());
for (VehicleType type : scenario.getVehicles().getVehicleTypes().values()) {
if (scenario.getTransitVehicles().getVehicleTypes().containsKey(type.getId())) {
// consider transit vehicles as non-hbefa vehicles
VehicleUtils.setHbefaVehicleCategory( type.getEngineInformation(), HbefaVehicleCategory.NON_HBEFA_VEHICLE.toString());
}
}
List<Id<Vehicle>> vehiclesToChangeToElectric = new ArrayList<>();
List<Id<Vehicle>> carVehiclesToChangeToSpecificType = new ArrayList<>();
final Random rnd = MatsimRandom.getLocalInstance();
// change some vehicle types, e.g. to investigate decarbonization scenarios, or to account for electric drt vehicles
int totalVehiclesCounter = 0;
for (Vehicle vehicle : scenario.getVehicles().getVehicles().values()) {
totalVehiclesCounter++;
if (scenario.getTransitVehicles().getVehicles().get(vehicle.getId()) != null) {
// skip transit vehicles
} else if (vehicle.getType().getId().toString().equals(freightVehicleType.getId().toString())) {
// skip freight vehicles
} else if (vehicle.getId().toString().contains("freight")) {
// some freight vehicles have the type "car", skip them...
log.info("Freight vehicle " + vehicle.getId().toString());
} else if (vehicle.getType().getId().toString().equals(defaultCarVehicleType.getId().toString())) {
carVehiclesToChangeToSpecificType.add(vehicle.getId());
if (rnd.nextDouble() < shareOfPrivateVehiclesChangedToElectric) {
vehiclesToChangeToElectric.add(vehicle.getId());
}
} else if (vehicle.getId().toString().contains("drt")) {
vehiclesToChangeToElectric.add(vehicle.getId());
} else {
throw new RuntimeException("Unknown vehicle type: " + vehicle.getType().getId().toString() + ". Aborting...");
}
}
for (Id<Vehicle> id : carVehiclesToChangeToSpecificType) {
scenario.getVehicles().removeVehicle(id);
VehicleType vehicleType;
double rndNumber = rnd.nextDouble();
if (rndNumber < petrolShare) {
// petrol
vehicleType = petrolCarVehicleType;
} else if (rndNumber >= petrolShare && rndNumber < petrolShare + dieselShare) {
// diesel
vehicleType = dieselCarVehicleType;
} else if (rndNumber >= petrolShare + dieselShare && rndNumber < petrolShare + dieselShare + lpgShare) {
// lpg
vehicleType = lpgVehicleType;
} else if (rndNumber >= petrolShare + dieselShare + lpgShare && rndNumber < petrolShare + dieselShare + lpgShare + cngShare) {
// cng
vehicleType = cngVehicleType;
} else if (rndNumber >= petrolShare + dieselShare + lpgShare + cngShare && rndNumber < petrolShare + dieselShare + lpgShare + cngShare + hybridPetrolShare) {
// hybrid petrol
vehicleType = pluginHybridPetrolVehicleType;
} else if (rndNumber >= petrolShare + dieselShare + lpgShare + cngShare + hybridPetrolShare && rndNumber < petrolShare + dieselShare + lpgShare + cngShare + hybridPetrolShare + hybridDieselShare) {
// hybrid diesel
vehicleType = pluginHybridDieselVehicleType;
} else {
// electric
vehicleType = electricVehicleType;
}
Vehicle vehicleNew = scenario.getVehicles().getFactory().createVehicle(id, vehicleType);
scenario.getVehicles().addVehicle(vehicleNew);
log.info("Type for vehicle " + id + " changed to: " + vehicleType.getId().toString());
}
for (Id<Vehicle> id : vehiclesToChangeToElectric) {
scenario.getVehicles().removeVehicle(id);
Vehicle vehicleNew = scenario.getVehicles().getFactory().createVehicle(id, electricVehicleType);
scenario.getVehicles().addVehicle(vehicleNew);
log.info("Type for vehicle " + id + " changed to electric.");
}
// the following is copy paste from the example...
EventsManager eventsManager = EventsUtils.createEventsManager();
AbstractModule module = new AbstractModule(){
@Override
public void install(){
bind( Scenario.class ).toInstance( scenario );
bind( EventsManager.class ).toInstance( eventsManager );
bind( EmissionModule.class ) ;
}
};
com.google.inject.Injector injector = Injector.createInjector(config, module);
EmissionModule emissionModule = injector.getInstance(EmissionModule.class);
EventWriterXML emissionEventWriter = new EventWriterXML(emissionEventOutputFile);
emissionModule.getEmissionEventsManager().addHandler(emissionEventWriter);
EmissionsOnLinkHandler emissionsEventHandler = new EmissionsOnLinkHandler();
eventsManager.addHandler(emissionsEventHandler);
eventsManager.initProcessing();
MatsimEventsReader matsimEventsReader = new MatsimEventsReader(eventsManager);
matsimEventsReader.readFile(eventsFile);
log.info("Done reading the events file.");
log.info("Finish processing...");
eventsManager.finishProcessing();
log.info("Closing events file...");
emissionEventWriter.closeFile();
log.info("Total number of vehicles: " + totalVehiclesCounter);
log.info("Number of passenger car vehicles: " + carVehiclesToChangeToSpecificType.size());
log.info("Number of passenger car vehicles that are changed to electric vehicles: " + vehiclesToChangeToElectric.size());
log.info("Emission analysis completed.");
log.info("Writing output...");
{
File file1 = new File(linkEmissionAnalysisFile);
BufferedWriter bw1 = new BufferedWriter(new FileWriter(file1));
bw1.write("linkId");
for (Pollutant pollutant : Pollutant.values()) {
bw1.write(";" + pollutant + " [g]");
}
bw1.newLine();
Map<Id<Link>, Map<Pollutant, Double>> link2pollutants = emissionsEventHandler.getLink2pollutants();
for (Id<Link> linkId : link2pollutants.keySet()) {
bw1.write(linkId.toString());
for (Pollutant pollutant : Pollutant.values()) {
double value = 0.;
if (link2pollutants.get(linkId).get(pollutant) != null) {
value = link2pollutants.get(linkId).get(pollutant);
}
bw1.write(";" + value);
}
bw1.newLine();
}
bw1.close();
log.info("Output written to " + linkEmissionAnalysisFile);
}
{
File file1 = new File(linkEmissionPerMAnalysisFile);
BufferedWriter bw1 = new BufferedWriter(new FileWriter(file1));
bw1.write("linkId");
for (Pollutant pollutant : Pollutant.values()) {
bw1.write(";" + pollutant + " [g/m]");
}
bw1.newLine();
Map<Id<Link>, Map<Pollutant, Double>> link2pollutants = emissionsEventHandler.getLink2pollutants();
for (Id<Link> linkId : link2pollutants.keySet()) {
bw1.write(linkId.toString());
for (Pollutant pollutant : Pollutant.values()) {
double emission = 0.;
if (link2pollutants.get(linkId).get(pollutant) != null) {
emission = link2pollutants.get(linkId).get(pollutant);
}
double emissionPerM = Double.NaN;
Link link = scenario.getNetwork().getLinks().get(linkId);
if (link != null) {
emissionPerM = emission / link.getLength();
}
bw1.write(";" + emissionPerM);
}
bw1.newLine();
}
bw1.close();
log.info("Output written to " + linkEmissionPerMAnalysisFile);
}
{
File file2 = new File(vehicleTypeFile);
BufferedWriter bw2 = new BufferedWriter(new FileWriter(file2));
bw2.write("vehicleId;vehicleType;emissionsConcept");
bw2.newLine();
for (Vehicle vehicle : scenario.getVehicles().getVehicles().values()) {
String emissionsConcept = "null";
if (vehicle.getType().getEngineInformation() != null && VehicleUtils.getHbefaEmissionsConcept(vehicle.getType().getEngineInformation()) != null) {
emissionsConcept = VehicleUtils.getHbefaEmissionsConcept(vehicle.getType().getEngineInformation()).toString();
}
bw2.write(vehicle.getId() + ";" + vehicle.getType().getId().toString() + ";" + emissionsConcept);
bw2.newLine();
}
bw2.close();
log.info("Output written to " + vehicleTypeFile);
}
}
}
| 20,626 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunOfflineAirPollutionAnalysisByEngineInformation.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/emissions/RunOfflineAirPollutionAnalysisByEngineInformation.java | /* *********************************************************************** *
* project: org.matsim.*
* *
* *********************************************************************** *
* *
* copyright : (C) 2017 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.analysis.emissions;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.stream.Collectors;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.Identifiable;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.network.Link;
import org.matsim.contrib.emissions.EmissionModule;
import org.matsim.contrib.emissions.HbefaVehicleCategory;
import org.matsim.contrib.emissions.Pollutant;
import org.matsim.contrib.emissions.VspHbefaRoadTypeMapping;
import org.matsim.contrib.emissions.utils.EmissionsConfigGroup;
import org.matsim.contrib.emissions.utils.EmissionsConfigGroup.DetailedVsAverageLookupBehavior;
import org.matsim.contrib.emissions.utils.EmissionsConfigGroup.NonScenarioVehicles;
import org.matsim.core.api.experimental.events.EventsManager;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.controler.AbstractModule;
import org.matsim.core.controler.Injector;
import org.matsim.core.events.EventsUtils;
import org.matsim.core.events.MatsimEventsReader;
import org.matsim.core.events.algorithms.EventWriterXML;
import org.matsim.core.gbl.MatsimRandom;
import org.matsim.core.scenario.ScenarioUtils;
import org.matsim.vehicles.EngineInformation;
import org.matsim.vehicles.Vehicle;
import org.matsim.vehicles.VehicleType;
import org.matsim.vehicles.VehicleUtils;
/**
* @author ikaddoura
*/
public class RunOfflineAirPollutionAnalysisByEngineInformation {
private static final Logger log = LogManager.getLogger(RunOfflineAirPollutionAnalysisByEngineInformation.class);
private final String runDirectory;
private final String runId;
private final String hbefaWarmFile;
private final String hbefaColdFile;
private final String analysisOutputDirectory;
private final static double shareOfPrivateVehiclesChangedToElectric = 0.0; // in addition to electric vehicle share in the reference case!
public RunOfflineAirPollutionAnalysisByEngineInformation(String runDirectory, String runId, String hbefaFileWarm, String hbefaFileCold, String analysisOutputDirectory) {
this.runDirectory = runDirectory;
this.runId = runId;
this.hbefaWarmFile = hbefaFileWarm;
this.hbefaColdFile = hbefaFileCold;
if (!analysisOutputDirectory.endsWith("/")) analysisOutputDirectory = analysisOutputDirectory + "/";
this.analysisOutputDirectory = analysisOutputDirectory;
}
public static void main(String[] args) throws IOException {
if (args.length == 1) {
String rootDirectory = args[0];
if (!rootDirectory.endsWith("/")) rootDirectory = rootDirectory + "/";
final String runDirectory = "public-svn/matsim/scenarios/countries/de/berlin/berlin-v5.4-0.1pct/output-berlin-v5.4-0.1pct/";
final String runId = "berlin-v5.4-0.1pct";
final String hbefaFileCold = "shared-svn/projects/matsim-germany/hbefa/hbefa-files/v4.1/EFA_ColdStart_Concept_2020_detailed_perTechAverage_Bln_carOnly.csv";
final String hbefaFileWarm = "shared-svn/projects/matsim-germany/hbefa/hbefa-files/v4.1/EFA_HOT_Concept_2020_detailed_perTechAverage_Bln_carOnly.csv";
RunOfflineAirPollutionAnalysisByEngineInformation analysis = new RunOfflineAirPollutionAnalysisByEngineInformation(
rootDirectory + runDirectory,
runId,
rootDirectory + hbefaFileWarm,
rootDirectory + hbefaFileCold,
rootDirectory + runDirectory + "emission-analysis-hbefa-v4.1");
analysis.run();
} else {
throw new RuntimeException("Please set the root directory. Aborting...");
}
}
void run() throws IOException {
Config config = ConfigUtils.createConfig();
config.vehicles().setVehiclesFile(runDirectory + runId + ".output_vehicles.xml.gz");
config.network().setInputFile(runDirectory + runId + ".output_network.xml.gz");
config.transit().setTransitScheduleFile(runDirectory + runId + ".output_transitSchedule.xml.gz");
config.transit().setVehiclesFile(runDirectory + runId + ".output_transitVehicles.xml.gz");
config.global().setCoordinateSystem("GK4");
config.plans().setInputFile(null);
config.eventsManager().setNumberOfThreads(null);
config.eventsManager().setEstimatedNumberOfEvents(null);
config.global().setNumberOfThreads(1);
EmissionsConfigGroup eConfig = ConfigUtils.addOrGetModule(config, EmissionsConfigGroup.class);
eConfig.setDetailedVsAverageLookupBehavior(DetailedVsAverageLookupBehavior.tryDetailedThenTechnologyAverageElseAbort);
eConfig.setDetailedColdEmissionFactorsFile(hbefaColdFile);
eConfig.setDetailedWarmEmissionFactorsFile(hbefaWarmFile);
eConfig.setNonScenarioVehicles(NonScenarioVehicles.ignore);
eConfig.setWritingEmissionsEvents(true);
File folder = new File(analysisOutputDirectory);
folder.mkdirs();
final String eventsFile = runDirectory + runId + ".output_events.xml.gz";
final String emissionEventOutputFile = analysisOutputDirectory + runId + ".emission.events.offline.xml.gz";
final String linkEmissionAnalysisFile = analysisOutputDirectory + runId + ".emissionsPerLink.csv";
final String linkEmissionPerMAnalysisFile = analysisOutputDirectory + runId + ".emissionsPerLinkPerM.csv";
final String vehicleTypeFile = analysisOutputDirectory + runId + ".emissionVehicleInformation.csv";
Scenario scenario = ScenarioUtils.loadScenario(config);
// network
new VspHbefaRoadTypeMapping().addHbefaMappings(scenario.getNetwork());
// car vehicles
VehicleType petrolCarVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("petrolCar", VehicleType.class));
scenario.getVehicles().addVehicleType(petrolCarVehicleType);
EngineInformation petrolCarEngineInformation = petrolCarVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( petrolCarEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( petrolCarEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( petrolCarEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( petrolCarEngineInformation, "petrol (4S)" );
VehicleType dieselCarVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("dieselCar", VehicleType.class));
scenario.getVehicles().addVehicleType(dieselCarVehicleType);
EngineInformation dieselCarEngineInformation = dieselCarVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( dieselCarEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( dieselCarEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( dieselCarEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( dieselCarEngineInformation, "diesel" );
VehicleType cngVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("cngCar", VehicleType.class));
scenario.getVehicles().addVehicleType(cngVehicleType);
EngineInformation cngCarEngineInformation = cngVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( cngCarEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( cngCarEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( cngCarEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( cngCarEngineInformation, "bifuel CNG/petrol" );
VehicleType lpgVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("lpgCar", VehicleType.class));
scenario.getVehicles().addVehicleType(lpgVehicleType);
EngineInformation lpgCarEngineInformation = lpgVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( lpgCarEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( lpgCarEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( lpgCarEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( lpgCarEngineInformation, "bifuel LPG/petrol" );
// electric vehicles
VehicleType electricVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("electricCar", VehicleType.class));
scenario.getVehicles().addVehicleType(electricVehicleType);
EngineInformation electricEngineInformation = electricVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( electricEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( electricEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( electricEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( electricEngineInformation, "electricity" );
// plug-in hybrid petrol vehicles
VehicleType pluginHybridPetrolVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("pluginHybridPetrol", VehicleType.class));
scenario.getVehicles().addVehicleType(pluginHybridPetrolVehicleType);
EngineInformation pluginHybridPetrolEngineInformation = pluginHybridPetrolVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( pluginHybridPetrolEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( pluginHybridPetrolEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( pluginHybridPetrolEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( pluginHybridPetrolEngineInformation, "Plug-in Hybrid petrol/electric" );
// plug-in hybrid petrol vehicles
VehicleType pluginHybridDieselVehicleType = scenario.getVehicles().getFactory().createVehicleType(Id.create("pluginHybridDiesel", VehicleType.class));
scenario.getVehicles().addVehicleType(pluginHybridDieselVehicleType);
EngineInformation pluginHybridDieselEngineInformation = pluginHybridDieselVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( pluginHybridDieselEngineInformation, HbefaVehicleCategory.PASSENGER_CAR.toString());
VehicleUtils.setHbefaTechnology( pluginHybridDieselEngineInformation, "average" );
VehicleUtils.setHbefaSizeClass( pluginHybridDieselEngineInformation, "average" );
VehicleUtils.setHbefaEmissionsConcept( pluginHybridDieselEngineInformation, "Plug-in Hybrid diesel/electric" );
// ignore default car vehicles
VehicleType defaultCarVehicleType = scenario.getVehicles().getVehicleTypes().get(Id.create("car", VehicleType.class));
EngineInformation carEngineInformation = defaultCarVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( carEngineInformation, HbefaVehicleCategory.NON_HBEFA_VEHICLE.toString());
// ignore freight vehicles
VehicleType freightVehicleType = scenario.getVehicles().getVehicleTypes().get(Id.create("freight", VehicleType.class));
EngineInformation freightEngineInformation = freightVehicleType.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( freightEngineInformation, HbefaVehicleCategory.NON_HBEFA_VEHICLE.toString());
// ignore public transit vehicles
for (VehicleType type : scenario.getTransitVehicles().getVehicleTypes().values()) {
EngineInformation engineInformation = type.getEngineInformation();
VehicleUtils.setHbefaVehicleCategory( engineInformation, HbefaVehicleCategory.NON_HBEFA_VEHICLE.toString());
}
List<Id<Vehicle>> carVehiclesToChangeToSpecificType = new ArrayList<>();
final Random rnd = MatsimRandom.getLocalInstance();
int totalVehiclesCounter = 0;
// randomly change some vehicle types
List<Id<Vehicle>> vehiclesToChangeToElectric = scenario.getVehicles().getVehicles().values().stream()
.filter(vehicle -> vehicle.getType().getId().equals(defaultCarVehicleType.getId()))
.filter(vehicle -> !vehicle.getId().toString().contains("freight"))// some freight vehicles have the type "car", skip them...
.filter(vehicle -> rnd.nextDouble() < shareOfPrivateVehiclesChangedToElectric)
.map(Identifiable::getId)
.collect(Collectors.toList());
final double petrolShare = 0.512744724750519;
final double dieselShare = 0.462841421365738;
final double lpgShare = 0.011381645;
final double cngShare = 0.0038579236716032;
final double hybridPetrolShare = 0.005743607878685;
final double hybridDieselShare = 0.00014232617104426;
for (Id<Vehicle> id : carVehiclesToChangeToSpecificType) {
scenario.getVehicles().removeVehicle(id);
VehicleType vehicleType;
double rndNumber = rnd.nextDouble();
if (rndNumber < petrolShare) {
// petrol
vehicleType = petrolCarVehicleType;
} else if (rndNumber >= petrolShare && rndNumber < petrolShare + dieselShare) {
// diesel
vehicleType = dieselCarVehicleType;
} else if (rndNumber >= petrolShare + dieselShare && rndNumber < petrolShare + dieselShare + lpgShare) {
// lpg
vehicleType = lpgVehicleType;
} else if (rndNumber >= petrolShare + dieselShare + lpgShare && rndNumber < petrolShare + dieselShare + lpgShare + cngShare) {
// cng
vehicleType = cngVehicleType;
} else if (rndNumber >= petrolShare + dieselShare + lpgShare + cngShare && rndNumber < petrolShare + dieselShare + lpgShare + cngShare + hybridPetrolShare) {
// hybrid petrol
vehicleType = pluginHybridPetrolVehicleType;
} else if (rndNumber >= petrolShare + dieselShare + lpgShare + cngShare + hybridPetrolShare && rndNumber < petrolShare + dieselShare + lpgShare + cngShare + hybridPetrolShare + hybridDieselShare) {
// hybrid diesel
vehicleType = pluginHybridDieselVehicleType;
} else {
// electric
vehicleType = electricVehicleType;
}
Vehicle vehicleNew = scenario.getVehicles().getFactory().createVehicle(id, vehicleType);
scenario.getVehicles().addVehicle(vehicleNew);
log.info("Type for vehicle " + id + " changed to: " + vehicleType.getId().toString());
}
for (Id<Vehicle> id : vehiclesToChangeToElectric) {
scenario.getVehicles().removeVehicle(id);
Vehicle vehicleNew = scenario.getVehicles().getFactory().createVehicle(id, electricVehicleType);
scenario.getVehicles().addVehicle(vehicleNew);
log.info("Type for vehicle " + id + " changed to electric.");
}
// the following is copy paste from the example...
EventsManager eventsManager = EventsUtils.createEventsManager();
AbstractModule module = new AbstractModule(){
@Override
public void install(){
bind( Scenario.class ).toInstance( scenario );
bind( EventsManager.class ).toInstance( eventsManager );
bind( EmissionModule.class ) ;
}
};
com.google.inject.Injector injector = Injector.createInjector(config, module);
EmissionModule emissionModule = injector.getInstance(EmissionModule.class);
EventWriterXML emissionEventWriter = new EventWriterXML(emissionEventOutputFile);
emissionModule.getEmissionEventsManager().addHandler(emissionEventWriter);
EmissionsOnLinkHandler emissionsEventHandler = new EmissionsOnLinkHandler();
eventsManager.addHandler(emissionsEventHandler);
eventsManager.initProcessing();
MatsimEventsReader matsimEventsReader = new MatsimEventsReader(eventsManager);
matsimEventsReader.readFile(eventsFile);
log.info("Done reading the events file.");
log.info("Finish processing...");
eventsManager.finishProcessing();
log.info("Closing events file...");
emissionEventWriter.closeFile();
log.info("Total number of vehicles: " + totalVehiclesCounter);
log.info("Number of passenger car vehicles: " + carVehiclesToChangeToSpecificType.size());
log.info("Number of passenger car vehicles that are changed to electric vehicles: " + vehiclesToChangeToElectric.size());
log.info("Emission analysis completed.");
log.info("Writing output...");
{
File file1 = new File(linkEmissionAnalysisFile);
BufferedWriter bw1 = new BufferedWriter(new FileWriter(file1));
bw1.write("linkId");
for (Pollutant pollutant : Pollutant.values()) {
bw1.write(";" + pollutant + " [g]");
}
bw1.newLine();
Map<Id<Link>, Map<Pollutant, Double>> link2pollutants = emissionsEventHandler.getLink2pollutants();
for (Id<Link> linkId : link2pollutants.keySet()) {
bw1.write(linkId.toString());
for (Pollutant pollutant : Pollutant.values()) {
double value = 0.;
if (link2pollutants.get(linkId).get(pollutant) != null) {
value = link2pollutants.get(linkId).get(pollutant);
}
bw1.write(";" + value);
}
bw1.newLine();
}
bw1.close();
log.info("Output written to " + linkEmissionAnalysisFile);
}
{
File file1 = new File(linkEmissionPerMAnalysisFile);
BufferedWriter bw1 = new BufferedWriter(new FileWriter(file1));
bw1.write("linkId");
for (Pollutant pollutant : Pollutant.values()) {
bw1.write(";" + pollutant + " [g/m]");
}
bw1.newLine();
Map<Id<Link>, Map<Pollutant, Double>> link2pollutants = emissionsEventHandler.getLink2pollutants();
for (Id<Link> linkId : link2pollutants.keySet()) {
bw1.write(linkId.toString());
for (Pollutant pollutant : Pollutant.values()) {
double emission = 0.;
if (link2pollutants.get(linkId).get(pollutant) != null) {
emission = link2pollutants.get(linkId).get(pollutant);
}
double emissionPerM = Double.NaN;
Link link = scenario.getNetwork().getLinks().get(linkId);
if (link != null) {
emissionPerM = emission / link.getLength();
}
bw1.write(";" + emissionPerM);
}
bw1.newLine();
}
bw1.close();
log.info("Output written to " + linkEmissionPerMAnalysisFile);
}
{
File file2 = new File(vehicleTypeFile);
BufferedWriter bw2 = new BufferedWriter(new FileWriter(file2));
bw2.write("vehicleId;vehicleType;emissionsConcept");
bw2.newLine();
for (Vehicle vehicle : scenario.getVehicles().getVehicles().values()) {
String emissionsConcept = "null";
if (vehicle.getType().getEngineInformation() != null && VehicleUtils.getHbefaEmissionsConcept(vehicle.getType().getEngineInformation()) != null) {
emissionsConcept = VehicleUtils.getHbefaEmissionsConcept(vehicle.getType().getEngineInformation()).toString();
}
bw2.write(vehicle.getId() + ";" + vehicle.getType().getId().toString() + ";" + emissionsConcept);
bw2.newLine();
}
bw2.close();
log.info("Output written to " + vehicleTypeFile);
}
}
}
| 19,953 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunAnalyse.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/legacy/analysis/wasteCollection/RunAnalyse.java | /* *********************************************************************** *
* project: org.matsim.*
* *********************************************************************** *
* *
* copyright : (C) 2019 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.legacy.analysis.wasteCollection;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.network.Network;
import org.matsim.api.core.v01.population.Person;
import org.matsim.core.network.NetworkUtils;
import org.matsim.core.population.routes.NetworkRoute;
import org.matsim.core.population.routes.RouteUtils;
import org.matsim.freight.carriers.*;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Map.Entry;
public class RunAnalyse {
static final Logger log = LogManager.getLogger(RunAnalyse.class);
private static final String dir_moLargeBinsDiesel100it = "../tubCloud/Shared/vsp_zerocuts/scenarios/Muellentsorgung/Montag/a1_Mo_Big_Diesel_100it/";
private static final String dir_moSmallBinsDiesel100it = "../../tubCloud/Shared/vsp_zerocuts/scenarios/Muellentsorgung/Montag/a2_Mo_Small_Diesel_100it/";
private static final String dir_moLargeBinsElektro100it = "../../tubCloud/Shared/vsp_zerocuts/scenarios/Muellentsorgung/Montag/e1_Mo_Big_Electro_100it/";
private static final String dir_moSmallBinsElektro100it = "../../tubCloud/Shared/vsp_zerocuts/scenarios/Muellentsorgung/Montag/e2_Mo_Small_Elektro_100it/";
private static final String dir_weLargeBinsDiesel100it = "../../tubCloud/Shared/vsp_zerocuts/scenarios/Muellentsorgung/Mittwoch/a1_Mo_Big_Diesel_100it/";
private static final String dir_weSmallBinsDiesel100it = "../../tubCloud/Shared/vsp_zerocuts/scenarios/Muellentsorgung/Mittwoch/a2_Mo_Small_Diesel_100it/";
private static final String dir_weLargeBinsElektro100it = "../../tubCloud/Shared/vsp_zerocuts/scenarios/Muellentsorgung/Mittwoch/e1_Mo_Big_Electro_100it/";
private static final String dir_weSmallBinsElektro100it = "../../tubCloud/Shared/vsp_zerocuts/scenarios/Muellentsorgung/Mittwoch/e2_Mo_Small_Elektro_100it/";
private enum scenarioAuswahl {
moLargeBinsDiesel100it, moLargeBinsElektro100it, moSmallBinsDiesel100it, moSmallBinsElektro100it,
weLargeBinsDiesel100it, weLargeBinsElektro100it, weSmallBinsDiesel100it, weSmallBinsElektro100it,
}
public static void main(String[] args) throws IOException {
log.info("Starting");
scenarioAuswahl scenarioWahl = scenarioAuswahl.moLargeBinsDiesel100it;
String inputDir;
Map<Id<Person>, Double> personId2tourDistanceKm = new HashMap<>();
Map<Id<Person>, Integer> personId2tourNumCollections = new HashMap<>();
Map<Id<Person>, Double> personId2tourWasteCollectedTons = new HashMap<>();
Map<Id<Person>, Integer> personId2tourDurations = new HashMap<>();
switch (scenarioWahl) {
case moLargeBinsDiesel100it:
inputDir = dir_moLargeBinsDiesel100it;
break;
case moSmallBinsDiesel100it:
inputDir = dir_moSmallBinsDiesel100it;
break;
case moLargeBinsElektro100it:
inputDir = dir_moLargeBinsElektro100it;
break;
case moSmallBinsElektro100it:
inputDir = dir_moSmallBinsElektro100it;
break;
case weLargeBinsDiesel100it:
inputDir = dir_weLargeBinsDiesel100it;
break;
case weSmallBinsDiesel100it:
inputDir = dir_weSmallBinsDiesel100it;
break;
case weLargeBinsElektro100it:
inputDir = dir_weLargeBinsElektro100it;
break;
case weSmallBinsElektro100it:
inputDir = dir_weSmallBinsElektro100it;
break;
default:
throw new IllegalStateException("Unexpected value: " + scenarioWahl);
}
log.info("Running analysis for " + scenarioWahl + " : " + inputDir);
Carriers carriers = new Carriers();
CarrierVehicleTypes carrierVehicleTypes = new CarrierVehicleTypes();
new CarrierPlanXmlReader(carriers, carrierVehicleTypes)
.readFile(new File(inputDir + "output_CarrierPlans.xml").getCanonicalPath());
Network network = NetworkUtils.readNetwork(inputDir + "output_network.xml.gz");
for (Carrier carrier : carriers.getCarriers().values()) {
double distanceTourKM;
int numCollections;
double wasteCollectedTons;
int tourNumber = 0;
Collection<ScheduledTour> tours = carrier.getSelectedPlan().getScheduledTours();
Map<Id<CarrierShipment>, CarrierShipment> shipments = carrier.getShipments();
HashMap<String, Integer> shipmentSizes = new HashMap<String, Integer>();
for (Entry<Id<CarrierShipment>, CarrierShipment> entry : shipments.entrySet()) {
String shipmentId = entry.getKey().toString();
int shipmentSize = entry.getValue().getSize();
shipmentSizes.put(shipmentId, shipmentSize);
}
for (ScheduledTour scheduledTour : tours) {
distanceTourKM = 0.0;
numCollections = 0;
wasteCollectedTons = 0.0;
int startTime = 10000000;
int endTime = 0;
List<Tour.TourElement> elements = scheduledTour.getTour().getTourElements();
for (Tour.TourElement element : elements) {
if (element instanceof Tour.Pickup) {
numCollections++;
Tour.Pickup pickupElement = (Tour.Pickup) element;
String pickupShipmentId = pickupElement.getShipment().getId().toString();
wasteCollectedTons = wasteCollectedTons + (shipmentSizes.get(pickupShipmentId) / 1000);
}
if (element instanceof Tour.Leg) {
Tour.Leg legElement = (Tour.Leg) element;
if (legElement.getRoute().getDistance() != 0)
distanceTourKM = distanceTourKM
+ RouteUtils.calcDistance((NetworkRoute) legElement.getRoute(), 0, 0, network)
/ 1000;
if (startTime > legElement.getExpectedDepartureTime())
startTime = (int) legElement.getExpectedDepartureTime();
if (endTime < (legElement.getExpectedDepartureTime() + legElement.getExpectedTransportTime()))
endTime = (int) (legElement.getExpectedDepartureTime()
+ legElement.getExpectedTransportTime());
}
}
Id<Person> personId = Id.create(
carrier.getId().toString() + scheduledTour.getVehicle().getId().toString() + tourNumber,
Person.class);
personId2tourDistanceKm.put(personId, distanceTourKM);
personId2tourNumCollections.put(personId, numCollections);
personId2tourWasteCollectedTons.put(personId, wasteCollectedTons);
personId2tourDurations.put(personId, endTime - startTime);
tourNumber++;
}
}
writeOutput(inputDir, personId2tourDistanceKm, personId2tourNumCollections, personId2tourWasteCollectedTons,
personId2tourDurations);
log.info("### Done.");
}
static void writeOutput(String directory, Map<Id<Person>, Double> personId2tourDistanceKm,
Map<Id<Person>, Integer> personId2tourNumCollections,
Map<Id<Person>, Double> personId2tourWasteCollectedTons, Map<Id<Person>, Integer> personId2tourDurations) {
BufferedWriter writer;
File file;
file = new File(directory + "/03_TourStatistics.txt");
try {
writer = new BufferedWriter(new FileWriter(file, true));
String now = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss").format(new Date());
writer.write("Tourenstatisitik erstellt am: " + now + "\n\n");
// Headline
writer.write(
"TourID\t\t\t\t\t\t\t\t\t\tduration hh:mm:ss\t\tdistance (km)\t\t#ofDeliveries\t\tdelivered Volume (m3)\n\n");
for (Id<Person> id : personId2tourDistanceKm.keySet()) {
Double tourDistance = (double) Math.round(personId2tourDistanceKm.get(id) / 1000);
Integer tourNumCollections = personId2tourNumCollections.get(id);
Double tourWasteCollected = personId2tourWasteCollectedTons.get(id);
int duration = personId2tourDurations.get(id);
writer.write(id + "\t\t" + timeTransmission(duration) + "\t\t\t\t\t" + tourDistance + "\t\t\t\t"
+ tourNumCollections + "\t\t\t\t\t" + tourWasteCollected);
writer.newLine();
}
writer.flush();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
log.info("Output geschrieben");
}
public static String timeTransmission(int duration) {
int stunden = (int) duration / 3600;
int minuten = (int) (duration - stunden * 3600) / 60;
int sekunden = duration - stunden * 3600 - minuten * 60;
return stunden + ":" + minuten + ":" + sekunden;
}
}
| 9,309 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
RunOpenBerlinScenario.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/RunOpenBerlinScenario.java | package org.matsim.run;
import org.matsim.application.MATSimApplication;
/**
* Run the {@link OpenBerlinScenario} with default configuration.
*/
public final class RunOpenBerlinScenario {
private RunOpenBerlinScenario() {
}
public static void main(String[] args) {
MATSimApplication.runWithDefaults(OpenBerlinScenario.class, args);
}
}
| 350 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
Activities.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/Activities.java | package org.matsim.run;
import org.matsim.core.config.Config;
import org.matsim.core.config.groups.ScoringConfigGroup;
/**
* Defines available activity types.
*/
public enum Activities {
home,
other,
outside_recreation,
transport,
visit,
edu_kiga(7, 17),
edu_primary(7, 17),
edu_secondary(7, 17),
edu_higher(7, 19),
edu_other(7, 22),
work(6, 21),
work_business(8, 21),
personal_business(8, 20),
leisure(9, 27),
dining(8, 27),
shop_daily(8, 20),
shop_other(8, 20),
// Commercial traffic types
service;
/**
* Start time of an activity in hours, can be -1 if not defined.
*/
private final double start;
/**
* End time of an activity in hours, can be -1 if not defined.
*/
private final double end;
Activities(double start, double end) {
this.start = start;
this.end = end;
}
Activities() {
this.start = -1;
this.end = -1;
}
/**
* Apply start and end time to params.
*/
public ScoringConfigGroup.ActivityParams apply(ScoringConfigGroup.ActivityParams params) {
if (start >= 0)
params = params.setOpeningTime(start * 3600.);
if (end >= 0)
params = params.setClosingTime(end * 3600.);
return params;
}
/**
* Add required activity params for the scenario.
*/
public static void addScoringParams(Config config, boolean splitTypes) {
for (Activities value : Activities.values()) {
// Default length if none is given
config.scoring().addActivityParams(value.apply(new ScoringConfigGroup.ActivityParams(value.name())).setTypicalDuration(6 * 3600));
if (splitTypes)
for (long ii = 600; ii <= 97200; ii += 600) {
config.scoring().addActivityParams(value.apply(new ScoringConfigGroup.ActivityParams(value.name() + "_" + ii).setTypicalDuration(ii)));
}
}
config.scoring().addActivityParams(new ScoringConfigGroup.ActivityParams("commercial_start").setTypicalDuration(3600));
config.scoring().addActivityParams(new ScoringConfigGroup.ActivityParams("commercial_end").setTypicalDuration(3600));
config.scoring().addActivityParams(new ScoringConfigGroup.ActivityParams("freight_start").setTypicalDuration(3600));
config.scoring().addActivityParams(new ScoringConfigGroup.ActivityParams("freight_end").setTypicalDuration(3600));
}
}
| 2,237 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
OpenBerlinScenario.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/OpenBerlinScenario.java | package org.matsim.run;
import com.google.inject.Key;
import com.google.inject.name.Names;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.TransportMode;
import org.matsim.application.MATSimApplication;
import org.matsim.application.options.SampleOptions;
import org.matsim.core.config.Config;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.config.groups.ReplanningConfigGroup;
import org.matsim.core.controler.AbstractModule;
import org.matsim.core.controler.Controler;
import org.matsim.core.replanning.strategies.DefaultPlanStrategiesModule;
import org.matsim.core.router.costcalculators.TravelDisutilityFactory;
import org.matsim.core.router.util.TravelTime;
import org.matsim.prepare.RunOpenBerlinCalibration;
import org.matsim.prepare.population.AssignIncome;
import org.matsim.run.scoring.AdvancedScoringConfigGroup;
import org.matsim.run.scoring.AdvancedScoringModule;
import org.matsim.simwrapper.SimWrapperConfigGroup;
import org.matsim.simwrapper.SimWrapperModule;
import picocli.CommandLine;
import java.util.List;
@CommandLine.Command(header = ":: Open Berlin Scenario ::", version = OpenBerlinScenario.VERSION, mixinStandardHelpOptions = true)
public class OpenBerlinScenario extends MATSimApplication {
private static final Logger log = LogManager.getLogger(RunOpenBerlinCalibration.class);
public static final String VERSION = "6.1";
public static final String CRS = "EPSG:25832";
@CommandLine.Mixin
private final SampleOptions sample = new SampleOptions(10, 25, 3, 1);
public OpenBerlinScenario() {
super(String.format("input/v%s/berlin-v%s.config.xml", VERSION, VERSION));
}
public static void main(String[] args) {
MATSimApplication.run(OpenBerlinScenario.class, args);
}
@Override
protected Config prepareConfig(Config config) {
SimWrapperConfigGroup sw = ConfigUtils.addOrGetModule(config, SimWrapperConfigGroup.class);
if (sample.isSet()) {
double sampleSize = sample.getSample();
config.qsim().setFlowCapFactor(sampleSize);
config.qsim().setStorageCapFactor(sampleSize);
// Counts can be scaled with sample size
config.counts().setCountsScaleFactor(sampleSize);
sw.sampleSize = sampleSize;
config.controller().setRunId(sample.adjustName(config.controller().getRunId()));
config.controller().setOutputDirectory(sample.adjustName(config.controller().getOutputDirectory()));
config.plans().setInputFile(sample.adjustName(config.plans().getInputFile()));
}
Activities.addScoringParams(config, true);
// Required for all calibration strategies
for (String subpopulation : List.of("person", "freight", "goodsTraffic", "commercialPersonTraffic", "commercialPersonTraffic_service")) {
config.replanning().addStrategySettings(
new ReplanningConfigGroup.StrategySettings()
.setStrategyName(DefaultPlanStrategiesModule.DefaultSelector.ChangeExpBeta)
.setWeight(1.0)
.setSubpopulation(subpopulation)
);
config.replanning().addStrategySettings(
new ReplanningConfigGroup.StrategySettings()
.setStrategyName(DefaultPlanStrategiesModule.DefaultStrategy.ReRoute)
.setWeight(0.15)
.setSubpopulation(subpopulation)
);
}
config.replanning().addStrategySettings(
new ReplanningConfigGroup.StrategySettings()
.setStrategyName(DefaultPlanStrategiesModule.DefaultStrategy.TimeAllocationMutator)
.setWeight(0.15)
.setSubpopulation("person")
);
config.replanning().addStrategySettings(
new ReplanningConfigGroup.StrategySettings()
.setStrategyName(DefaultPlanStrategiesModule.DefaultStrategy.SubtourModeChoice)
.setWeight(0.15)
.setSubpopulation("person")
);
return config;
}
@Override
protected void prepareScenario(Scenario scenario) {
AssignIncome income = new AssignIncome();
// Calculate the income for each person, in next versions this might also be done during creation of the population
scenario.getPopulation().getPersons().values().forEach(income::run);
}
@Override
protected void prepareControler(Controler controler) {
controler.addOverridingModule(new SimWrapperModule());
controler.addOverridingModule(new TravelTimeBinding());
if (ConfigUtils.hasModule(controler.getConfig(), AdvancedScoringConfigGroup.class)) {
controler.addOverridingModule(new AdvancedScoringModule());
}
}
/**
* Add travel time bindings for ride and freight modes, which are not actually network modes.
*/
public static final class TravelTimeBinding extends AbstractModule {
@Override
public void install() {
addTravelTimeBinding(TransportMode.ride).to(networkTravelTime());
addTravelDisutilityFactoryBinding(TransportMode.ride).to(carTravelDisutilityFactoryKey());
addTravelTimeBinding("freight").to(Key.get(TravelTime.class, Names.named(TransportMode.truck)));
addTravelDisutilityFactoryBinding("freight").to(Key.get(TravelDisutilityFactory.class, Names.named(TransportMode.truck)));
}
}
}
| 5,029 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
AdvancedScoringOutputWriter.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/scoring/AdvancedScoringOutputWriter.java | package org.matsim.run.scoring;
import com.google.inject.Inject;
import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVPrinter;
import org.matsim.api.core.v01.population.Person;
import org.matsim.core.controler.OutputDirectoryHierarchy;
import org.matsim.core.controler.events.IterationEndsEvent;
import org.matsim.core.controler.listener.IterationEndsListener;
import org.matsim.core.scoring.functions.ScoringParametersForPerson;
import org.matsim.core.utils.io.IOUtils;
import java.io.IOException;
import java.io.UncheckedIOException;
/**
* This class writes person specific information from {@link IndividualPersonScoringParameters} to the output.
*/
public class AdvancedScoringOutputWriter implements IterationEndsListener {
@Inject
private ScoringParametersForPerson scoring;
private boolean outputWritten = false;
@Override
public void notifyIterationEnds(IterationEndsEvent event) {
if (outputWritten)
return;
if (!(scoring instanceof IndividualPersonScoringParameters params))
return;
OutputDirectoryHierarchy io = event.getServices().getControlerIO();
String output = io.getOutputFilename("person_util_variations.csv");
// Write scoring information for each person
try (CSVPrinter csv = new CSVPrinter(IOUtils.getBufferedWriter(output), CSVFormat.DEFAULT)) {
csv.print("person");
csv.printRecord(params.header);
for (Person person : event.getServices().getScenario().getPopulation().getPersons().values()) {
Object2DoubleMap<String> values = params.info.get(person.getId());
if (values == null) {
continue;
}
csv.print(person.getId());
for (String s : params.header) {
csv.print(values.getDouble(s));
}
csv.println();
}
} catch (IOException e) {
throw new UncheckedIOException(e);
}
params.header.clear();
params.info.clear();
outputWritten = true;
}
}
| 1,946 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
DistanceGroupModeUtilityParameters.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/scoring/DistanceGroupModeUtilityParameters.java | package org.matsim.run.scoring;
import it.unimi.dsi.fastutil.doubles.DoubleArrayList;
import it.unimi.dsi.fastutil.doubles.DoubleList;
import org.matsim.core.scoring.functions.ModeUtilityParameters;
/**
* Mode utility with separate marginalUtilityOfDistance_m per distance group.
*/
public class DistanceGroupModeUtilityParameters extends ModeUtilityParameters {
private final DistanceGroup[] groups;
/**
* Constructor which copies the base params from given modeParams.
*/
DistanceGroupModeUtilityParameters(ModeUtilityParameters modeParams, DeltaBuilder delta, DistanceGroup[] groups) {
super(modeParams.marginalUtilityOfTraveling_s,
modeParams.marginalUtilityOfDistance_m,
modeParams.monetaryDistanceCostRate,
modeParams.constant + delta.constant,
modeParams.dailyMoneyConstant,
modeParams.dailyUtilityConstant + delta.dailyUtilityConstant);
this.groups = groups;
}
/**
* Calculate the utility for given distance.
*/
public double calcUtilityDistDelta(double dist) {
if (groups == null)
return 0;
DistanceGroup group = groups[0];
for (int i = 1; i < groups.length; i++) {
if (groups[i].dist() > dist)
break;
group = groups[i];
}
return group.constant() + group.utilPerM() * (dist - group.dist());
}
static final class DeltaBuilder {
private final DoubleList perDistGroup = new DoubleArrayList();
double constant;
double dailyUtilityConstant;
public DoubleList getPerDistGroup() {
return perDistGroup;
}
/**
* Sum delta of distance utilities.
*/
public void addUtilsDistance(AdvancedScoringConfigGroup.ModeParams params) {
if (params.deltaPerDistGroup != null && !params.deltaPerDistGroup.isEmpty()) {
if (perDistGroup.isEmpty()) {
perDistGroup.addAll(params.deltaPerDistGroup);
return;
}
if (perDistGroup.size() != params.deltaPerDistGroup.size()) {
throw new IllegalArgumentException("Distance utility parameters do not match");
}
for (int i = 0; i < perDistGroup.size(); i++) {
perDistGroup.set(i, perDistGroup.getDouble(i) + params.deltaPerDistGroup.get(i));
}
}
}
}
}
| 2,127 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
DistanceGroup.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/scoring/DistanceGroup.java | package org.matsim.run.scoring;
/**
* Store distance group.
*
* @param dist lower bound for distance group
* @param constant added constant
* @param utilPerM utility per meter, i.e. slope of linear function
*/
record DistanceGroup(double dist, double constant, double utilPerM) implements Comparable<DistanceGroup> {
@Override
public int compareTo(DistanceGroup o) {
return Double.compare(dist, o.dist);
}
}
| 426 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
AdvancedScoringFunctionFactory.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/scoring/AdvancedScoringFunctionFactory.java | package org.matsim.run.scoring;
import com.google.inject.Inject;
import org.matsim.api.core.v01.network.Network;
import org.matsim.api.core.v01.population.Person;
import org.matsim.core.config.Config;
import org.matsim.core.scoring.ScoringFunction;
import org.matsim.core.scoring.ScoringFunctionFactory;
import org.matsim.core.scoring.SumScoringFunction;
import org.matsim.core.scoring.functions.*;
/**
* Same as {@link org.matsim.core.scoring.functions.CharyparNagelScoringFunctionFactory} but with {@link PiecewiseLinearlLegScoring}.
*/
public class AdvancedScoringFunctionFactory implements ScoringFunctionFactory {
@Inject
private Config config;
@Inject
private ScoringParametersForPerson params;
@Inject
private Network network;
@Override
public ScoringFunction createNewScoringFunction(Person person) {
final ScoringParameters parameters = params.getScoringParameters(person);
SumScoringFunction sumScoringFunction = new SumScoringFunction();
sumScoringFunction.addScoringFunction(new CharyparNagelActivityScoring(parameters));
// replaced original leg scoring
sumScoringFunction.addScoringFunction(new PiecewiseLinearlLegScoring(parameters, this.network, config.transit().getTransitModes()));
sumScoringFunction.addScoringFunction(new CharyparNagelMoneyScoring(parameters));
sumScoringFunction.addScoringFunction(new CharyparNagelAgentStuckScoring(parameters));
sumScoringFunction.addScoringFunction(new ScoreEventScoring());
return sumScoringFunction;
}
}
| 1,501 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
AdvancedScoringConfigGroup.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/scoring/AdvancedScoringConfigGroup.java | package org.matsim.run.scoring;
import org.matsim.core.config.ConfigGroup;
import org.matsim.core.config.ReflectiveConfigGroup;
import org.matsim.utils.objectattributes.attributable.Attributes;
import java.util.*;
/**
* Stores scoring parameters for {@link AdvancedScoringModule}.
*/
@SuppressWarnings("checkstyle:VisibilityModifier")
public final class AdvancedScoringConfigGroup extends ReflectiveConfigGroup {
private static final String GROUP_NAME = "advancedScoring";
private final List<ScoringParameters> scoringParameters = new ArrayList<>();
@Parameter
@Comment("The distance groups if marginal utility of distance is adjusted. In meters.")
public List<Integer> distGroups;
@Parameter
@Comment("Enable income dependent marginal utility of money.")
public boolean incomeDependent = true;
// TODO: maybe option to re-assign variations or use them from attributes
// TODO: could load the random variations from a file, helper function to only generate the variations
// TODO: reference population?, for which the loglikelihood could be calculated
public AdvancedScoringConfigGroup() {
super(GROUP_NAME);
}
/**
* Return the defined scoring parameters.
*/
public List<ScoringParameters> getScoringParameters() {
return Collections.unmodifiableList(scoringParameters);
}
@Override
public ConfigGroup createParameterSet(String type) {
if (type.equals(ScoringParameters.GROUP_NAME)) {
return new ScoringParameters();
} else {
throw new IllegalArgumentException("Unsupported parameter set type: " + type);
}
}
@Override
public void addParameterSet(ConfigGroup set) {
if (set instanceof ScoringParameters p) {
super.addParameterSet(set);
scoringParameters.add(p);
} else {
throw new IllegalArgumentException("Unsupported parameter set class: " + set);
}
}
/**
* Scoring parameters for a specific group of agents.
* This group allows arbitrary attributes to be defined, which are matched against person attributes.
*/
public static final class ScoringParameters extends ReflectiveConfigGroup {
private static final String GROUP_NAME = "scoringParameters";
/**
* Params per mode.
*/
private final Map<String, ModeParams> modeParams = new HashMap<>();
public ScoringParameters() {
super(GROUP_NAME, true);
}
/**
* Checks if the given attributes match the config. If true these parameters are applicable to tbe object.
*/
public boolean matchObject(Attributes attr, Map<String, Category> categories) {
for (Map.Entry<String, String> e : this.getParams().entrySet()) {
// might be null if not defined
Object objValue = attr.getAttribute(e.getKey());
String category = categories.get(e.getKey()).categorize(objValue);
// compare as string
if (!Objects.toString(category).equals(e.getValue()))
return false;
}
return true;
}
public Map<String, ModeParams> getModeParams() {
return modeParams;
}
@Override
public ConfigGroup createParameterSet(final String type) {
return switch (type) {
case ModeParams.GROUP_NAME -> new ModeParams();
default -> throw new IllegalArgumentException(type);
};
}
@Override
public void addParameterSet(ConfigGroup set) {
if (set instanceof ModeParams p) {
super.addParameterSet(set);
modeParams.put(p.mode, p);
} else {
throw new IllegalArgumentException("Unsupported parameter set class: " + set);
}
}
/**
* Retrieve mode parameters.
*/
public ModeParams getOrCreateModeParams(String mode) {
if (!modeParams.containsKey(mode)) {
ModeParams p = new ModeParams();
p.mode = mode;
addParameterSet(p);
return p;
}
return modeParams.get(mode);
}
}
/**
* Stores mode specific parameters and also attributes to whom to apply this specification.
*/
public static final class ModeParams extends ReflectiveConfigGroup {
private static final String GROUP_NAME = "modeParams";
@Parameter
@Comment("The mode for which the parameters are defined.")
public String mode;
@Parameter
@Comment("[utils/leg] alternative-specific constant.")
public double deltaConstant;
@Parameter
@Comment("Variation of the constant across individuals.")
public VariationType varConstant = VariationType.fixed;
@Parameter
@Comment("[utils/day] if the mode is used at least once.")
public double deltaDailyConstant;
@Parameter
@Comment("Variation of the daily constant across individuals.")
public VariationType varDailyConstant = VariationType.fixed;
@Parameter
@Comment("total delta utility per dist group.")
public List<Double> deltaPerDistGroup;
public ModeParams() {
super(GROUP_NAME);
}
}
/**
* Variate values with random draw from specific distribution.
*/
public enum VariationType {
fixed, normal, truncatedNormal
}
}
| 4,834 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
Category.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/scoring/Category.java | package org.matsim.run.scoring;
import java.util.*;
/**
* Categorize values into groups.
*/
public final class Category {
private static final Set<String> TRUE = Set.of("true", "yes", "1", "on", "y", "j", "ja");
private static final Set<String> FALSE = Set.of("false", "no", "0", "off", "n", "nein");
/**
* Unique values of the category.
*/
private final Set<String> values;
/**
* Groups of values that have been subsumed under a single category.
* These are values separated by ,
*/
private final Map<String, String> grouped;
/**
* Range categories.
*/
private final List<Range> ranges;
public Category(Set<String> values) {
this.values = values;
this.grouped = new HashMap<>();
for (String v : values) {
if (v.contains(",")) {
String[] grouped = v.split(",");
for (String g : grouped) {
this.grouped.put(g, v);
}
}
}
boolean range = this.values.stream().allMatch(v -> v.contains("-") || v.contains("+"));
if (range) {
ranges = new ArrayList<>();
for (String value : this.values) {
if (value.contains("-")) {
String[] parts = value.split("-");
ranges.add(new Range(Double.parseDouble(parts[0]), Double.parseDouble(parts[1]), value));
} else if (value.contains("+")) {
ranges.add(new Range(Double.parseDouble(value.replace("+", "")), Double.POSITIVE_INFINITY, value));
}
}
ranges.sort(Comparator.comparingDouble(r -> r.left));
} else
ranges = null;
// Check if all values are boolean
if (values.stream().allMatch(v -> TRUE.contains(v.toLowerCase()) || FALSE.contains(v.toLowerCase()))) {
for (String value : values) {
Set<String> group = TRUE.contains(value.toLowerCase()) ? TRUE : FALSE;
for (String g : group) {
this.grouped.put(g, value);
}
}
}
}
/**
* Categorize a single value.
*/
public String categorize(Object value) {
if (value == null)
return null;
if (value instanceof Boolean) {
// Booleans and synonyms are in the group map
return categorize(((Boolean) value).toString().toLowerCase());
} else if (value instanceof Number) {
return categorizeNumber((Number) value);
} else {
String v = value.toString();
if (values.contains(v))
return v;
else if (grouped.containsKey(v))
return grouped.get(v);
try {
double d = Double.parseDouble(v);
return categorizeNumber(d);
} catch (NumberFormatException e) {
return null;
}
}
}
private String categorizeNumber(Number value) {
if (ranges != null) {
for (Range r : ranges) {
if (value.doubleValue() >= r.left && value.doubleValue() < r.right)
return r.label;
}
}
// Match string representation
String v = value.toString();
if (values.contains(v))
return v;
else if (grouped.containsKey(v))
return grouped.get(v);
// Convert the number to a whole number, which will have a different string representation
if (value instanceof Float || value instanceof Double) {
return categorizeNumber(value.longValue());
}
return null;
}
/**
* Number range.
* @param left Left bound of the range.
* @param right Right bound of the range. (exclusive)
* @param label Label of this group.
*/
private record Range(double left, double right, String label) {
}
}
| 3,275 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
PiecewiseLinearlLegScoring.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/scoring/PiecewiseLinearlLegScoring.java | /* *********************************************************************** *
* project: org.matsim.*
* CharyparNagelOpenTimesScoringFunctionFactory.java
* *
* *********************************************************************** *
* *
* copyright : (C) 2007 by the members listed in the COPYING, *
* LICENSE and WARRANTY file. *
* email : info at matsim dot org *
* *
* *********************************************************************** *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* See also COPYING, LICENSE and WARRANTY file *
* *
* *********************************************************************** */
package org.matsim.run.scoring;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.TransportMode;
import org.matsim.api.core.v01.events.ActivityEndEvent;
import org.matsim.api.core.v01.events.Event;
import org.matsim.api.core.v01.events.PersonDepartureEvent;
import org.matsim.api.core.v01.events.PersonEntersVehicleEvent;
import org.matsim.api.core.v01.network.Network;
import org.matsim.api.core.v01.population.Leg;
import org.matsim.api.core.v01.population.Route;
import org.matsim.core.gbl.Gbl;
import org.matsim.core.scoring.functions.ModeUtilityParameters;
import org.matsim.core.scoring.functions.ScoringParameters;
import org.matsim.pt.PtConstants;
import java.util.HashSet;
import java.util.Set;
/**
* This is a copy of {@link org.matsim.core.scoring.functions.CharyparNagelLegScoring}.
* Distance utilities are scored with different linear functions per distance group.
*/
@SuppressWarnings("checkstyle")
public final class PiecewiseLinearlLegScoring implements org.matsim.core.scoring.SumScoringFunction.LegScoring, org.matsim.core.scoring.SumScoringFunction.ArbitraryEventScoring {
// yyyy URL in above javadoc is broken. kai, feb'17
private static final Logger log = LogManager.getLogger(PiecewiseLinearlLegScoring.class);
private static int ccc = 0;
/**
* The parameters used for scoring.
*/
private final ScoringParameters params;
private final Set<String> ptModes;
private final double marginalUtilityOfMoney;
private final Set<String> modesAlreadyConsideredForDailyConstants;
private double score;
private Network network;
private boolean nextEnterVehicleIsFirstOfTrip = true;
private boolean nextStartPtLegIsFirstOfTrip = true;
private boolean currentLegIsPtLeg = false;
private double lastActivityEndTime = Double.NaN;
public PiecewiseLinearlLegScoring(final ScoringParameters params, Network network, Set<String> ptModes) {
this.params = params;
this.network = network;
this.ptModes = ptModes;
this.modesAlreadyConsideredForDailyConstants = new HashSet<>();
this.marginalUtilityOfMoney = this.params.marginalUtilityOfMoney;
}
@Override
public void finish() {
}
@Override
public double getScore() {
return this.score;
}
/**
* Calculate the score for a leg.
*/
private double calcLegScore(final double departureTime, final double arrivalTime, final Leg leg) {
double tmpScore = 0.0;
// travel time in seconds
double travelTime = arrivalTime - departureTime;
ModeUtilityParameters modeParams = this.params.modeParams.get(leg.getMode());
if (modeParams == null) {
if (leg.getMode().equals(TransportMode.transit_walk) || leg.getMode().equals(TransportMode.non_network_walk)) {
modeParams = this.params.modeParams.get(TransportMode.walk);
} else {
// modeParams = this.params.modeParams.get(TransportMode.other);
throw new RuntimeException("just encountered mode for which no scoring parameters are defined: " + leg.getMode());
}
}
tmpScore += travelTime * modeParams.marginalUtilityOfTraveling_s;
if (modeParams instanceof DistanceGroupModeUtilityParameters distParams) {
if (modeParams.monetaryDistanceCostRate != 0.0) {
Route route = leg.getRoute();
// distance in meters
double dist = route.getDistance();
if (Double.isNaN(dist)) {
if (ccc < 10) {
ccc++;
LogManager.getLogger(this.getClass()).warn("distance is NaN. Will make score of this plan NaN. Possible reason: Simulation does not report " +
"a distance for this trip. Possible reason for that: mode is teleported and router does not " +
"write distance into plan. Needs to be fixed or these plans will die out.");
if (ccc == 10) {
LogManager.getLogger(this.getClass()).warn(Gbl.FUTURE_SUPPRESSED);
}
}
}
tmpScore += modeParams.monetaryDistanceCostRate * this.marginalUtilityOfMoney * dist;
}
Route route = leg.getRoute();
double dist = route.getDistance();
// Apply the default distance scoring parameter.
if (modeParams.marginalUtilityOfDistance_m != 0) {
tmpScore += modeParams.marginalUtilityOfDistance_m * dist;
}
tmpScore += distParams.calcUtilityDistDelta(dist);
} else {
// standard leg scoring
if (modeParams.marginalUtilityOfDistance_m != 0.0
|| modeParams.monetaryDistanceCostRate != 0.0) {
Route route = leg.getRoute();
// distance in meters
double dist = route.getDistance();
if (Double.isNaN(dist)) {
if (ccc < 10) {
ccc++;
LogManager.getLogger(this.getClass()).warn("distance is NaN. Will make score of this plan NaN. Possible reason: Simulation does not report " +
"a distance for this trip. Possible reason for that: mode is teleported and router does not " +
"write distance into plan. Needs to be fixed or these plans will die out.");
if (ccc == 10) {
LogManager.getLogger(this.getClass()).warn(Gbl.FUTURE_SUPPRESSED);
}
}
}
tmpScore += modeParams.marginalUtilityOfDistance_m * dist;
tmpScore += modeParams.monetaryDistanceCostRate * this.marginalUtilityOfMoney * dist;
}
}
tmpScore += modeParams.constant;
// (yyyy once we have multiple legs without "real" activities in between, this will produce wrong results. kai, dec'12)
// (yy NOTE: the constant is added for _every_ pt leg. This is not how such models are estimated. kai, nov'12)
// account for the daily constants
if (!modesAlreadyConsideredForDailyConstants.contains(leg.getMode())) {
tmpScore += modeParams.dailyUtilityConstant + modeParams.dailyMoneyConstant * this.marginalUtilityOfMoney;
modesAlreadyConsideredForDailyConstants.add(leg.getMode());
}
// yyyy the above will cause problems if we ever decide to differentiate pt mode into bus, tram, train, ...
// Might have to move the MainModeIdentifier then. kai, sep'18
return tmpScore;
}
@Override
public void handleEvent(Event event) {
if (event instanceof ActivityEndEvent) {
// When there is a "real" activity, flags are reset:
if (!PtConstants.TRANSIT_ACTIVITY_TYPE.equals(((ActivityEndEvent) event).getActType())) {
this.nextEnterVehicleIsFirstOfTrip = true;
this.nextStartPtLegIsFirstOfTrip = true;
}
this.lastActivityEndTime = event.getTime();
}
if (event instanceof PersonEntersVehicleEvent && currentLegIsPtLeg) {
if (!this.nextEnterVehicleIsFirstOfTrip) {
// all vehicle entering after the first triggers the disutility of line switch:
this.score += params.utilityOfLineSwitch;
}
this.nextEnterVehicleIsFirstOfTrip = false;
// add score of waiting, _minus_ score of travelling (since it is added in the legscoring above):
this.score += (event.getTime() - this.lastActivityEndTime) * (this.params.marginalUtilityOfWaitingPt_s - this.params.modeParams.get(TransportMode.pt).marginalUtilityOfTraveling_s);
}
if (event instanceof PersonDepartureEvent) {
String mode = ((PersonDepartureEvent) event).getLegMode();
this.currentLegIsPtLeg = this.ptModes.contains(mode);
if (currentLegIsPtLeg) {
if (!this.nextStartPtLegIsFirstOfTrip) {
this.score -= params.modeParams.get(mode).constant;
// (yyyy deducting this again, since is it wrongly added above. should be consolidated; this is so the code
// modification is minimally invasive. kai, dec'12)
}
this.nextStartPtLegIsFirstOfTrip = false;
}
}
}
@Override
public void handleLeg(Leg leg) {
Gbl.assertIf(leg.getDepartureTime().isDefined());
Gbl.assertIf(leg.getTravelTime().isDefined());
double legScore = calcLegScore(
leg.getDepartureTime().seconds(), leg.getDepartureTime().seconds() + leg.getTravelTime()
.seconds(), leg);
if (Double.isNaN(legScore)) {
log.error("dpTime=" + leg.getDepartureTime().seconds()
+ "; ttime=" + leg.getTravelTime().seconds() + "; leg=" + leg);
throw new RuntimeException("score is NaN");
}
this.score += legScore;
}
}
| 9,345 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
AdvancedScoringModule.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/scoring/AdvancedScoringModule.java | package org.matsim.run.scoring;
import jakarta.inject.Singleton;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.controler.AbstractModule;
import org.matsim.core.scoring.functions.ScoringParametersForPerson;
/**
* Module to bind components needed for advanced scoring functionality configured by {@link AdvancedScoringConfigGroup}.
*/
public class AdvancedScoringModule extends AbstractModule {
@Override
public void install() {
ConfigUtils.addOrGetModule(getConfig(), AdvancedScoringConfigGroup.class);
bind(ScoringParametersForPerson.class).to(IndividualPersonScoringParameters.class).in(Singleton.class);
addControlerListenerBinding().to(AdvancedScoringOutputWriter.class).in(Singleton.class);
bindScoringFunctionFactory().to(AdvancedScoringFunctionFactory.class).in(Singleton.class);
}
}
| 830 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
IndividualPersonScoringParameters.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/run/scoring/IndividualPersonScoringParameters.java | package org.matsim.run.scoring;
import com.google.inject.Inject;
import it.unimi.dsi.fastutil.doubles.DoubleList;
import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
import it.unimi.dsi.fastutil.objects.Object2DoubleOpenHashMap;
import org.apache.commons.rng.simple.RandomSource;
import org.apache.commons.statistics.distribution.ContinuousDistribution;
import org.apache.commons.statistics.distribution.NormalDistribution;
import org.apache.commons.statistics.distribution.TruncatedNormalDistribution;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.IdMap;
import org.matsim.api.core.v01.Scenario;
import org.matsim.api.core.v01.population.Person;
import org.matsim.api.core.v01.population.Population;
import org.matsim.core.config.ConfigUtils;
import org.matsim.core.config.groups.ScoringConfigGroup;
import org.matsim.core.population.PersonUtils;
import org.matsim.core.population.PopulationUtils;
import org.matsim.core.scoring.functions.ActivityUtilityParameters;
import org.matsim.core.scoring.functions.ModeUtilityParameters;
import org.matsim.core.scoring.functions.ScoringParameters;
import org.matsim.core.scoring.functions.ScoringParametersForPerson;
import org.matsim.pt.PtConstants;
import org.matsim.pt.config.TransitConfigGroup;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
/**
* Scoring parameters for {@link AdvancedScoringConfigGroup}. This makes use of the standard scoring and adds persons specific differences.
*/
public class IndividualPersonScoringParameters implements ScoringParametersForPerson {
private static final Logger log = LogManager.getLogger(IndividualPersonScoringParameters.class);
/**
* Header for info file.
*/
final Set<String> header = new LinkedHashSet<>();
/**
* This map contains debug information to be written out after first iteration.
*/
final Map<Id<Person>, Object2DoubleMap<String>> info = new ConcurrentHashMap<>();
/**
* Cache instances of {@link ActivityUtilityParameters} for each subpopulation.
*/
private final Map<String, Map<String, ActivityUtilityParameters>> actUtils = new ConcurrentHashMap<>();
/**
* Cache instances of {@link ScoringParameters} for each person.
*/
private final IdMap<Person, ScoringParameters> cache;
/**
* Cache and reuse distance group arrays.
*/
private final Map<DoubleList, DistanceGroup[]> distGroups = new ConcurrentHashMap<>();
/**
* Categories from config group.
*/
private final Map<String, Category> categories;
/**
* Thread-local random number generator.
*/
private final ThreadLocal<Context> rnd = ThreadLocal.withInitial(Context::new);
private final Scenario scenario;
private final ScoringConfigGroup basicScoring;
private final TransitConfigGroup transitConfig;
private final AdvancedScoringConfigGroup scoring;
/**
* Average income of all agents with this attribute. Can be NaN if not used.
*/
private final double globalAvgIncome;
@Inject
public IndividualPersonScoringParameters(Scenario scenario) {
this.scenario = scenario;
this.basicScoring = scenario.getConfig().scoring();
this.scoring = ConfigUtils.addOrGetModule(scenario.getConfig(), AdvancedScoringConfigGroup.class);
this.transitConfig = scenario.getConfig().transit();
this.globalAvgIncome = computeAvgIncome(scenario.getPopulation());
this.categories = buildCategories(this.scoring);
this.cache = new IdMap<>(Person.class, scenario.getPopulation().getPersons().size());
}
static Map<String, Category> buildCategories(AdvancedScoringConfigGroup scoring) {
Map<String, Set<String>> categories = new HashMap<>();
// Collect all values
for (AdvancedScoringConfigGroup.ScoringParameters parameter : scoring.getScoringParameters()) {
for (Map.Entry<String, String> kv : parameter.getParams().entrySet()) {
categories.computeIfAbsent(kv.getKey(), k -> new HashSet<>()).add(kv.getValue());
}
}
return categories.entrySet().stream()
.collect(HashMap::new, (m, e) -> m.put(e.getKey(), new Category(e.getValue())), HashMap::putAll);
}
static DistanceGroup[] calcDistanceGroups(List<Integer> dists, DoubleList distUtils) {
// Nothing to do if no distance groups are defined.
if (dists == null || dists.isEmpty() || distUtils.isEmpty()) {
return null;
}
List<Integer> copy = new ArrayList<>(dists);
if (copy.get(0) != 0)
copy.add(0, 0);
// Effectively no distance groups present
if (copy.size() <= 1) {
return null;
}
// No delta for distance groups
if (distUtils.doubleStream().allMatch(d -> d == 0))
return null;
DistanceGroup[] groups = new DistanceGroup[copy.size()];
if (groups.length - 1 != distUtils.size()) {
log.error("Distance groups: {}, utils: {}", dists, distUtils);
throw new IllegalArgumentException("Distance groups and distance utilities must have the same size.");
}
for (int i = 0; i < copy.size() - 1; i++) {
double dist = copy.get(i);
double nextDist = copy.get(i + 1);
double constant = i == 0 ? 0 : distUtils.getDouble(i - 1);
double next = distUtils.getDouble(i);
groups[i] = new DistanceGroup(dist, constant, (next - constant) / (nextDist - dist));
}
// Last open ended dist group
int lastDist = copy.get(copy.size() - 1);
double lastUtil = distUtils.getDouble(distUtils.size() - 1);
groups[copy.size() - 1] = new DistanceGroup(lastDist, lastUtil, lastUtil / lastDist);
return groups;
}
private double computeAvgIncome(Population population) {
if (!scoring.incomeDependent)
return Double.NaN;
log.info("reading income attribute using " + PersonUtils.class + " of all agents and compute global average.\n" +
"Make sure to set this attribute only to appropriate agents (i.e. true 'persons' and not freight agents) \n" +
"Income values <= 0 are ignored. Agents that have negative or 0 income will use the marginalUtilityOfMoney in their subpopulation's scoring params..");
OptionalDouble averageIncome = population.getPersons().values().stream()
//consider only agents that have a specific income provided
.filter(person -> PersonUtils.getIncome(person) != null)
.mapToDouble(PersonUtils::getIncome)
.filter(dd -> dd > 0)
.average();
if (averageIncome.isEmpty()) {
throw new RuntimeException("you have enabled income dependent scoring but there is not a single income attribute in the population! " +
"If you are not aiming for person-specific marginalUtilityOfMoney, better use other PersonScoringParams, e.g. SubpopulationPersonScoringParams, which have higher performance." +
"Otherwise, please provide income attributes in the population...");
} else {
log.info("global average income is " + averageIncome);
return averageIncome.getAsDouble();
}
}
@Override
public ScoringParameters getScoringParameters(Person person) {
return this.cache.computeIfAbsent(person.getId(), id -> {
String subpopulation = PopulationUtils.getSubpopulation(person);
ScoringConfigGroup.ScoringParameterSet scoringParameters = basicScoring.getScoringParameters(subpopulation);
// Activity params can be reused per subpopulation
Map<String, ActivityUtilityParameters> activityParams = actUtils.computeIfAbsent(subpopulation, k -> {
Map<String, ActivityUtilityParameters> ap = new TreeMap<>();
for (ScoringConfigGroup.ActivityParams params : scoringParameters.getActivityParams()) {
ActivityUtilityParameters.Builder factory = new ActivityUtilityParameters.Builder(params);
ap.put(params.getActivityType(), factory.build());
}
// The code to add this activity type is always copied between different scoring implementations
// it might not be actually needed anymore (because default staging activities are also added elsewhere)
// but it's not clear if it's safe to remove it.
if (transitConfig.isUseTransit()) {
ScoringConfigGroup.ActivityParams transitActivityParams = new ScoringConfigGroup.ActivityParams(PtConstants.TRANSIT_ACTIVITY_TYPE);
transitActivityParams.setTypicalDuration(120.0);
transitActivityParams.setOpeningTime(0.);
transitActivityParams.setClosingTime(0.);
ActivityUtilityParameters.Builder modeParamsBuilder = new ActivityUtilityParameters.Builder(transitActivityParams);
modeParamsBuilder.setScoreAtAll(false);
ap.put(PtConstants.TRANSIT_ACTIVITY_TYPE, modeParamsBuilder.build());
}
return ap;
});
ScoringParameters.Builder builder = new ScoringParameters.Builder(basicScoring,
scoringParameters, activityParams, scenario.getConfig().scenario());
Double personalIncome = PersonUtils.getIncome(person);
// Income dependent scoring might be disabled
if (!Double.isNaN(globalAvgIncome) && personalIncome != null) {
if (personalIncome != 0) {
builder.setMarginalUtilityOfMoney(scoringParameters.getMarginalUtilityOfMoney() * globalAvgIncome / personalIncome);
} else {
log.warn("you have set income to " + personalIncome + " for person " + person + ". This is invalid and gets ignored." +
"Instead, the marginalUtilityOfMoney is derived from the subpopulation's scoring parameters.");
}
}
Map<String, DistanceGroupModeUtilityParameters.DeltaBuilder> deltaParams = new HashMap<>();
for (AdvancedScoringConfigGroup.ScoringParameters parameter : scoring.getScoringParameters()) {
if (parameter.matchObject(person.getAttributes(), categories)) {
for (Map.Entry<String, AdvancedScoringConfigGroup.ModeParams> mode : parameter.getModeParams().entrySet()) {
DistanceGroupModeUtilityParameters.DeltaBuilder b =
deltaParams.computeIfAbsent(mode.getKey(), k -> new DistanceGroupModeUtilityParameters.DeltaBuilder());
b.addUtilsDistance(mode.getValue());
addDeltaParams(b, mode.getValue(), person);
}
}
}
for (Map.Entry<String, DistanceGroupModeUtilityParameters.DeltaBuilder> mode : deltaParams.entrySet()) {
ModeUtilityParameters params = builder.getModeParameters(mode.getKey());
DistanceGroupModeUtilityParameters.DeltaBuilder delta = mode.getValue();
// These arrays are re-used if possible
DistanceGroup[] groups = distGroups.computeIfAbsent(delta.getPerDistGroup(), k -> calcDistanceGroups(scoring.distGroups, k));
DistanceGroupModeUtilityParameters p = new DistanceGroupModeUtilityParameters(params, delta, groups);
builder.setModeParameters(mode.getKey(), p);
// Collect final adjustments information
Object2DoubleMap<String> values = info.computeIfAbsent(person.getId(), k -> new Object2DoubleOpenHashMap<>());
// Write the overall constants, but only if they are different to the base values
if (delta.constant != 0)
values.put(mode.getKey() + "_constant", p.constant);
if (delta.dailyUtilityConstant != 0)
values.put(mode.getKey() + "_dailyConstant", p.dailyUtilityConstant);
if (groups != null) {
for (DistanceGroup group : groups) {
values.put("%s_dist_%.0f".formatted(mode.getKey(), group.dist()), group.utilPerM());
}
}
header.addAll(values.keySet());
}
return builder.build();
});
}
/**
* Compute or retrieve delta params for person.
*/
private void addDeltaParams(DistanceGroupModeUtilityParameters.DeltaBuilder delta, AdvancedScoringConfigGroup.ModeParams params, Person person) {
ContinuousDistribution.Sampler normal = this.rnd.get().normal;
ContinuousDistribution.Sampler tn = this.rnd.get().tn;
switch (params.varConstant) {
case fixed -> delta.constant += params.deltaConstant;
case normal -> delta.constant += normal.sample() * params.deltaConstant;
case truncatedNormal -> delta.constant += tn.sample() * params.deltaConstant;
default -> throw new IllegalArgumentException("Unsupported varConstant: " + params.varConstant);
}
switch (params.varDailyConstant) {
case fixed -> delta.dailyUtilityConstant += params.deltaDailyConstant;
case normal -> delta.dailyUtilityConstant += normal.sample() * params.deltaDailyConstant;
case truncatedNormal -> delta.dailyUtilityConstant += tn.sample() * params.deltaDailyConstant;
default -> throw new IllegalArgumentException("Unsupported varDailyConstant: " + params.varDailyConstant);
}
}
private record Context(ContinuousDistribution.Sampler normal, ContinuousDistribution.Sampler tn) {
Context() {
this(NormalDistribution.of(0, 1).createSampler(RandomSource.KISS.create(123L)),
TruncatedNormalDistribution.of(0, 1, 0, Double.POSITIVE_INFINITY)
.createSampler(RandomSource.KISS.create(123L))
);
}
}
}
| 12,595 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
DTVComparisonDashboard.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/dashboard/DTVComparisonDashboard.java | package org.matsim.dashboard;
import org.matsim.analysis.DTVAnalysis;
import org.matsim.application.prepare.network.CreateGeoJsonNetwork;
import org.matsim.simwrapper.Dashboard;
import org.matsim.simwrapper.Header;
import org.matsim.simwrapper.Layout;
import org.matsim.simwrapper.viz.ColorScheme;
import org.matsim.simwrapper.viz.MapPlot;
import org.matsim.simwrapper.viz.Plotly;
import tech.tablesaw.plotly.components.Axis;
import tech.tablesaw.plotly.traces.BarTrace;
import java.util.List;
/**
* Dashboard to compare dtv quality.
*/
public class DTVComparisonDashboard implements Dashboard {
private final String dtvPath;
public DTVComparisonDashboard(String dtvPath) {
this.dtvPath = dtvPath;
}
@Override
public double priority() {
return -1;
}
@Override
public void configure(Header header, Layout layout) {
header.title = "DTV";
header.description = "Analysis of dtv data provided by 'FIS-Broker' (Open geo-data portal by Berlin). Error metrics: under: < 0.75; over: > 1.25";
layout.row("overview")
.el(Plotly.class, (viz, data) -> {
viz.title = "DTV comparison";
viz.description = "over all roads";
Plotly.DataSet ds = viz.addDataset(data.compute(DTVAnalysis.class, "dtv_quality_per_road_type.csv", "--input-dtv", dtvPath))
.aggregate(List.of("quality"), "n", Plotly.AggrFunc.SUM);
viz.layout = tech.tablesaw.plotly.components.Layout.builder()
.barMode(tech.tablesaw.plotly.components.Layout.BarMode.STACK)
.xAxis(Axis.builder().title("Number").build())
.build();
viz.addTrace(BarTrace.builder(Plotly.OBJ_INPUT, Plotly.INPUT).orientation(BarTrace.Orientation.HORIZONTAL).build(), ds.mapping()
.x("n")
.name("quality", ColorScheme.RdYlBu)
);
}).el(Plotly.class, (viz, data) -> {
viz.title = "DTV comparison";
viz.description = "by road type";
Plotly.DataSet ds = viz.addDataset(data.compute(DTVAnalysis.class, "dtv_quality_per_road_type.csv", "--input-dtv", dtvPath));
viz.layout = tech.tablesaw.plotly.components.Layout.builder()
.yAxis(Axis.builder().title("Share").build())
.barMode(tech.tablesaw.plotly.components.Layout.BarMode.STACK)
.build();
viz.addTrace(BarTrace.builder(Plotly.OBJ_INPUT, Plotly.INPUT).build(), ds.mapping()
.x("road_type")
.y("share")
.name("quality", ColorScheme.RdYlBu)
);
});
layout.row("map")
.el(MapPlot.class, (viz, data) -> {
viz.title = "Relative traffic volumes";
viz.height = 8.0;
viz.setShape(data.compute(CreateGeoJsonNetwork.class, "network.geojson", "--with-properties"), "id");
viz.addDataset("dtv", data.compute(DTVAnalysis.class, "dtv_comparison.csv", "--input-dtv", dtvPath));
viz.center = data.context().getCenter();
viz.zoom = data.context().mapZoomLevel;
viz.display.lineColor.dataset = "dtv";
viz.display.lineColor.columnName = "quality";
viz.display.lineColor.join = "link_id";
viz.display.lineColor.setColorRamp(ColorScheme.RdYlBu, 3, false);
// 8px
viz.display.lineWidth.dataset = "@8";
});
}
}
| 3,071 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
BerlinDashboardProvider.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/dashboard/BerlinDashboardProvider.java | package org.matsim.dashboard;
import org.matsim.api.core.v01.TransportMode;
import org.matsim.application.ApplicationUtils;
import org.matsim.core.config.Config;
import org.matsim.run.OpenBerlinScenario;
import org.matsim.simwrapper.Dashboard;
import org.matsim.simwrapper.DashboardProvider;
import org.matsim.simwrapper.SimWrapper;
import org.matsim.simwrapper.dashboard.TrafficCountsDashboard;
import org.matsim.simwrapper.dashboard.TravelTimeComparisonDashboard;
import org.matsim.simwrapper.dashboard.TripDashboard;
import java.util.List;
import java.util.Set;
/**
* Provider for default dashboards in the scenario.
*/
public class BerlinDashboardProvider implements DashboardProvider {
@Override
public List<Dashboard> getDashboards(Config config, SimWrapper simWrapper) {
TripDashboard trips = new TripDashboard("mode_share_ref.csv", "mode_share_per_dist_ref.csv", "mode_users_ref.csv");
trips.setAnalysisArgs("--match-id", "^berlin.+", "--shp-filter", "none");
return List.of(
trips,
new TravelTimeComparisonDashboard(ApplicationUtils.resolve(config.getContext(), "berlin-v" + OpenBerlinScenario.VERSION + "-routes-ref.csv.gz")),
new TrafficCountsDashboard()
.withModes(TransportMode.car, Set.of(TransportMode.car))
.withModes(TransportMode.truck, Set.of(TransportMode.truck, "freight"))
);
}
}
| 1,338 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
DTVAnalysis.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/analysis/DTVAnalysis.java | package org.matsim.analysis;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.TransportMode;
import org.matsim.api.core.v01.network.Link;
import org.matsim.api.core.v01.network.Network;
import org.matsim.application.CommandSpec;
import org.matsim.application.MATSimAppCommand;
import org.matsim.application.options.InputOptions;
import org.matsim.application.options.OutputOptions;
import org.matsim.application.options.SampleOptions;
import org.matsim.core.api.experimental.events.EventsManager;
import org.matsim.core.events.EventsUtils;
import org.matsim.core.network.NetworkUtils;
import org.matsim.core.utils.io.IOUtils;
import picocli.CommandLine;
import tech.tablesaw.api.*;
import tech.tablesaw.io.csv.CsvReadOptions;
import tech.tablesaw.selection.Selection;
import java.io.BufferedReader;
import java.util.*;
import static tech.tablesaw.aggregate.AggregateFunctions.count;
@CommandLine.Command(name = "dtv", description = "analysis of simulated traffic volumes")
@CommandSpec(
requireEvents = true,
requireNetwork = true,
produces = {"dtv_comparison.csv", "dtv_quality_per_road_type.csv"}
)
public class DTVAnalysis implements MATSimAppCommand {
private static final Logger log = LogManager.getLogger(DTVAnalysis.class);
@CommandLine.Mixin
private final InputOptions input = InputOptions.ofCommand(DTVAnalysis.class);
@CommandLine.Mixin
private final OutputOptions output = OutputOptions.ofCommand(DTVAnalysis.class);
@CommandLine.Mixin
private final SampleOptions sample = new SampleOptions();
@CommandLine.Option(names = "--input-dtv", description = "Path to the dtv matched file", required = true)
private String dtvPath;
public static void main(String[] args) {
new DTVAnalysis().execute(args);
}
@Override
public Integer call() throws Exception {
Table dtv;
try (BufferedReader reader = IOUtils.getBufferedReader(dtvPath)) {
dtv = Table.read().csv(CsvReadOptions.builder(reader)
.columnTypesPartial(Map.of("from_link", ColumnType.TEXT, "to_link", ColumnType.TEXT))
.build());
}
Network network = input.getNetwork();
//reading events file & create volumes
EventsManager eventsManager = EventsUtils.createEventsManager();
VolumesAnalyzer volume = new VolumesAnalyzer(3600, 86400, network, true);
eventsManager.addHandler(volume);
eventsManager.initProcessing();
EventsUtils.readEvents(eventsManager, input.getEventsPath());
eventsManager.finishProcessing();
Table sim = createSimDtvTable(dtv, network, volume);
// Sort by quality
List<String> labels = List.of("under", "ok", "over");
Comparator<Row> cmp = Comparator.comparingInt(row -> labels.indexOf(row.getString("quality")));
sim = sim.sortOn(cmp);
sim.write().csv(output.getPath("dtv_comparison.csv").toFile());
Table aggr = sim.summarize("quality", count).by("quality", "road_type");
aggr.doubleColumn("Count [quality]").setName("n");
aggr.addColumns(DoubleColumn.create("share"));
Set<String> roadTypes = aggr.stringColumn("road_type").asSet();
// Norm within each road type
for (String roadType : roadTypes) {
DoubleColumn share = aggr.doubleColumn("n");
Selection sel = aggr.stringColumn("road_type").isEqualTo(roadType);
double total = share.where(sel).sum();
if (total > 0)
aggr.doubleColumn("share").set(sel, share.divide(total));
}
aggr = aggr.sortOn(cmp.thenComparing(row -> row.getString("road_type")));
aggr.write().csv(output.getPath("dtv_quality_per_road_type.csv").toFile());
return 0;
}
private Table createSimDtvTable(Table dtv, Network network, VolumesAnalyzer volume) {
dtv.addColumns(
TextColumn.create("link_id"),
StringColumn.create("road_type"),
DoubleColumn.create("simulated_traffic_volume"),
DoubleColumn.create("abs_error"),
DoubleColumn.create("rel_error"),
StringColumn.create("quality")
);
for (Row row : dtv) {
Id<Link> linkId = null;
String fromLink = row.getString("from_link");
String toLink = row.getString("to_link");
double volCar = 0;
if (fromLink != null && !fromLink.isBlank()) {
linkId = Id.createLinkId(fromLink);
volCar = sum(volume.getVolumesForLink(linkId, TransportMode.car)) / sample.getSample();
}
if (toLink != null && !toLink.isBlank()) {
linkId = Id.createLinkId(toLink);
volCar += sum(volume.getVolumesForLink(linkId, TransportMode.car)) / sample.getSample();
}
row.setText("link_id", linkId.toString());
row.setText("road_type", NetworkUtils.getHighwayType(network.getLinks().get(linkId)));
row.setDouble("simulated_traffic_volume", volCar);
row.setDouble("abs_error", Math.abs(volCar - row.getInt("vol_car")));
double relError = row.getDouble("abs_error") / row.getInt("vol_car");
row.setDouble("rel_error", relError);
double rel = volCar / row.getInt("vol_car");
if (rel > 1.25)
row.setString("quality", "over");
else if (relError < 0.85)
row.setString("quality", "under");
else
row.setString("quality", "ok");
}
return dtv;
}
private static double sum(int[] volumes) {
return volumes == null ? 0 : Arrays.stream(volumes).sum();
}
}
| 5,207 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
TravelTimeComparison.java | /FileExtraction/Java_unseen/matsim-scenarios_matsim-berlin/src/main/java/org/matsim/analysis/TravelTimeComparison.java | package org.matsim.analysis;
import org.matsim.api.core.v01.Id;
import org.matsim.api.core.v01.network.Link;
import org.matsim.api.core.v01.network.Network;
import org.matsim.api.core.v01.network.Node;
import org.matsim.application.CommandSpec;
import org.matsim.application.MATSimAppCommand;
import org.matsim.application.options.InputOptions;
import org.matsim.application.options.OutputOptions;
import org.matsim.core.api.experimental.events.EventsManager;
import org.matsim.core.events.EventsUtils;
import org.matsim.core.router.DijkstraFactory;
import org.matsim.core.router.costcalculators.OnlyTimeDependentTravelDisutility;
import org.matsim.core.router.util.LeastCostPathCalculator;
import org.matsim.core.router.util.TravelTime;
import org.matsim.core.trafficmonitoring.FreeSpeedTravelTime;
import org.matsim.core.trafficmonitoring.TravelTimeCalculator;
import org.matsim.core.utils.io.IOUtils;
import picocli.CommandLine;
import tech.tablesaw.api.ColumnType;
import tech.tablesaw.api.DoubleColumn;
import tech.tablesaw.api.Row;
import tech.tablesaw.api.Table;
import tech.tablesaw.columns.Column;
import tech.tablesaw.io.csv.CsvReadOptions;
import java.io.BufferedReader;
import java.util.List;
import java.util.Map;
import static tech.tablesaw.aggregate.AggregateFunctions.mean;
@CommandLine.Command(
name = "travel-time-comparison",
description = "Compare travel time with routes from API"
)
@CommandSpec(
requireEvents = true,
requireNetwork = true,
produces = {"travel_time_comparison_by_hour.csv", "travel_time_comparison_by_route.csv"},
group = "travelTime"
)
public class TravelTimeComparison implements MATSimAppCommand {
@CommandLine.Mixin
private InputOptions input = InputOptions.ofCommand(TravelTimeComparison.class);
@CommandLine.Mixin
private OutputOptions output = OutputOptions.ofCommand(TravelTimeComparison.class);
@CommandLine.Option(names = "--input-ref", description = "File with reference data", required = true)
private String apiFile;
public static void main(String[] args) {
new TravelTimeComparison().execute(args);
}
@Override
public Integer call() throws Exception {
Table data;
try (BufferedReader reader = IOUtils.getBufferedReader(apiFile)) {
data = Table.read().csv(CsvReadOptions.builder(reader).columnTypesPartial(Map.of(
"from_node", ColumnType.STRING,
"to_node", ColumnType.STRING
)).build());
}
Network network = input.getNetwork();
TravelTime tt = collectTravelTimes(network).getLinkTravelTimes();
TravelTime fs = new FreeSpeedTravelTime();
OnlyTimeDependentTravelDisutility util = new OnlyTimeDependentTravelDisutility(tt);
LeastCostPathCalculator congestedRouter = new DijkstraFactory(false).createPathCalculator(network, util, tt);
LeastCostPathCalculator freeflowRouter = new DijkstraFactory(false).createPathCalculator(network, new OnlyTimeDependentTravelDisutility(fs), fs);
data.addColumns(
DoubleColumn.create("simulated", data.rowCount()),
DoubleColumn.create("free_flow", data.rowCount())
);
for (Row row : data) {
LeastCostPathCalculator.Path congested = computePath(network, congestedRouter, row);
double dist = congested.links.stream().mapToDouble(Link::getLength).sum();
double speed = 3.6 * dist / congested.travelTime;
row.setDouble("simulated", speed);
LeastCostPathCalculator.Path freeflow = computePath(network, freeflowRouter, row);
dist = freeflow.links.stream().mapToDouble(Link::getLength).sum();
speed = 3.6 * dist / freeflow.travelTime;
row.setDouble("free_flow", speed);
}
data.addColumns(
data.doubleColumn("simulated").subtract(data.doubleColumn("mean")).setName("bias")
);
data.addColumns(data.doubleColumn("bias").abs().setName("abs_error"));
data.write().csv(output.getPath("travel_time_comparison_by_route.csv").toFile());
List<String> columns = List.of("min", "max", "mean", "std", "simulated", "free_flow", "bias", "abs_error");
Table aggr = data.summarize(columns, mean).by("hour");
for (Column<?> column : aggr.columns()) {
String name = column.name();
if (name.startsWith("Mean"))
column.setName(name.substring(6, name.length() - 1));
}
aggr.write().csv(output.getPath("travel_time_comparison_by_hour.csv").toFile());
return 0;
}
private LeastCostPathCalculator.Path computePath(Network network, LeastCostPathCalculator router, Row row) {
Node fromNode = network.getNodes().get(Id.createNodeId(row.getString("from_node")));
Node toNode = network.getNodes().get(Id.createNodeId(row.getString("to_node")));
return router.calcLeastCostPath(fromNode, toNode, row.getInt("hour") * 3600, null, null);
}
private TravelTimeCalculator collectTravelTimes(Network network) {
TravelTimeCalculator.Builder builder = new TravelTimeCalculator.Builder(network);
builder.setCalculateLinkTravelTimes(true);
builder.setMaxTime(86400);
builder.setTimeslice(900);
TravelTimeCalculator travelTimes = builder.build();
EventsManager manager = EventsUtils.createEventsManager();
manager.addHandler(travelTimes);
manager.initProcessing();
EventsUtils.readEvents(manager, input.getEventsPath());
manager.finishProcessing();
return travelTimes;
}
}
| 5,195 | Java | .java | matsim-scenarios/matsim-berlin | 28 | 111 | 2 | 2018-05-23T12:30:42Z | 2024-05-07T19:56:36Z |
OssControllerTest.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/test/java/oss/fosslight/controller/OssControllerTest.java | /*
Copyright (c) 2021 Jongun Chae
Copyright (c) 2021 JaeHyeuk Lee
SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.controller;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.transaction.annotation.Transactional;
import java.util.Map;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@AutoConfigureMockMvc(addFilters = false)
@SpringBootTest
@Transactional
public class OssControllerTest {
@Autowired
private MockMvc mockMvc;
@Test
@DisplayName("oss list add should be success When parameter is valid")
void ossListAddShouldBeSuccess() throws Exception{
mockMvc.perform(post("/oss/saveAjax")
.param("ossId","")
.param("ossName","testOssAdd")
.param("ossVersion","v1")
.param("copyright","")
.param("licenseDiv","")
.param("downloadLocation","")
.param("homepage","")
.param("summaryDescription","")
.param("ossType", "")
.param("licenseId ","")
.param("ossLicensesJson","[]")
.param("ossNicknames ","")
.param("licenseType ","PMS")
.param("obligationType","10")
.param("comment","")
.param("validationType ","HOMEPAGE")
.param("attribution ","")
.param("addNicknameYn ","N")
.param("deactivateFlag ","N")
.param("loginUserName ","user")
.param("loginUserRole ","ROLE_ADMIN")
.param("sortField ","")
.param("sortOrder ","")
.param("hotYn ","N")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> assertOssAdded(result.getResponse()));
}
@Test
@DisplayName("oss list add should be fail When parameter(ossName) is invalid")
void ossListAddShouldBeFail() throws Exception{
mockMvc.perform(post("/oss/saveAjax")
.param("ossId","")
.param("ossVersion","v1")
.param("copyright","")
.param("licenseDiv","")
.param("downloadLocation","")
.param("homepage","")
.param("summaryDescription","")
.param("ossType", "")
.param("licenseId ","")
.param("ossLicensesJson","[]")
.param("ossNicknames ","")
.param("licenseType ","PMS")
.param("obligationType","10")
.param("comment","")
.param("validationType ","HOMEPAGE")
.param("attribution ","")
.param("addNicknameYn ","N")
.param("deactivateFlag ","N")
.param("loginUserName ","user")
.param("loginUserRole ","ROLE_ADMIN")
.param("sortField ","")
.param("sortOrder ","")
.param("hotYn ","N")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> {
Map<String,String> responseMap = new ObjectMapper().readValue(result.getResponse().getContentAsString(),Map.class);
assertThat(responseMap.get("resCd")).isEqualTo("00");
});
}
private void assertOssAdded(MockHttpServletResponse response) throws Exception {
Map<String, String> responseMap = new ObjectMapper().readValue(response.getContentAsString(), Map.class);
String ossId = responseMap.get("ossId");
mockMvc.perform(MockMvcRequestBuilders.get("/oss/edit/" + ossId)
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36"))
.andExpect(status().isOk())
.andExpect(result -> {
String oss = (String) result.getModelAndView().getModel().get("ossId");
assertThat(oss).isEqualTo(ossId);
});
}
}
| 5,269 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ProjectControllerIntegrationTest.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/test/java/oss/fosslight/controller/ProjectControllerIntegrationTest.java | /*
Copyright (c) 2021 Jongun Chae
Copyright (c) 2021 Mingu Kang
SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.controller;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.transaction.annotation.Transactional;
import oss.fosslight.domain.Project;
import java.io.UnsupportedEncodingException;
import java.util.Map;
import java.util.UUID;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@AutoConfigureMockMvc(addFilters = false)
@SpringBootTest
@Transactional
class ProjectControllerIntegrationTest {
@Autowired
private MockMvc mockMvc;
@Test
@DisplayName("Registration should be success When parameter is valid")
void registrationShouldBeSuccess() throws Exception {
// given
// when
mockMvc.perform(post("/project/saveAjax")
.param("copy", "false")
.param("prjName", UUID.randomUUID().toString())
.param("prjVersion", "v1")
.param("noticeType", "10")
.param("distributionType", "10")
.param("comment", "<p>test</p>")
.param("osType", "100")
.param("priority", "30")
.param("statusRequestYn", "")
.param("listId", "")
.param("publicYn", "Y")
.param("networkServerType", "N")
.param("prjDivision", "999")
.param("prjUserId", "test2")
.param("prjId", "")
.param("prjDivision", "")
.param("distributeTarget", "NA")
.param("prjModelJson", "[]")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> assertProjectAdded(result.getResponse()));
// then
}
private void assertProjectAdded(MockHttpServletResponse response) throws Exception {
Map<String, Map<String, String>> responseMap = new ObjectMapper().readValue(response.getContentAsString(), Map.class);
String prjId = responseMap.get("resultData").get("prjId");
mockMvc.perform(MockMvcRequestBuilders.get("/project/edit/" + prjId)
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
)
.andExpect(status().isOk())
.andExpect(result -> {
Project project = (Project) result.getModelAndView().getModel().get("project");
assertThat(project.getPrjId()).isEqualTo(prjId);
});
}
@Test
@DisplayName("Adding project should be failed when prjName is empty")
void addProjectFailTest() throws Exception {
// given
// when
mockMvc.perform(post("/project/saveAjax")
.param("copy", "false")
.param("prjVersion", "v1")
.param("noticeType", "10")
.param("distributionType", "10")
.param("comment", "<p>test</p>")
.param("osType", "100")
.param("priority", "30")
.param("statusRequestYn", "")
.param("listId", "")
.param("publicYn", "Y")
.param("networkServerType", "N")
.param("prjDivision", "999")
.param("prjUserId", "test2")
.param("prjId", "")
.param("prjDivision", "")
.param("distributeTarget", "NA")
.param("prjModelJson", "[]")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> {
Map<String, String> responseMap = new ObjectMapper().readValue(result.getResponse().getContentAsString(), Map.class);
assertThat(responseMap.get("isValid")).isEqualTo("false");
});
// then
}
@Test
@DisplayName("starting review the package should be success When parameter is valid")
void startingReviewThePackageShouldBeSuccess() throws Exception {
// given
String prjId = createProject();
Project project = requestReviewThePackage(prjId);
project.setIdentificationStatus("REV");
project.setLoginUserName("admin");
project.setLoginUserRole("ROLE_ADMIN");
// when
mockMvc.perform(post("/project/updateProjectStatus")
.content(new ObjectMapper().writeValueAsString(project))
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> assertReviewStarted(result.getResponse()));
// then
}
@Test
@DisplayName("starting review the package should be failed When prjId is empty")
void failTestWhenStartingReview() throws Exception {
// given
String prjId = createProject();
Project project = requestReviewThePackage(prjId);
project.setPrjId("");
project.setIdentificationStatus("REV");
project.setLoginUserName("admin");
project.setLoginUserRole("ROLE_ADMIN");
// when
mockMvc.perform(post("/project/updateProjectStatus")
.content(new ObjectMapper().writeValueAsString(project))
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> {
Map<String, String> responseMap = new ObjectMapper().readValue(result.getResponse().getContentAsString(), Map.class);
assertThat(responseMap.get("isValid")).isEqualTo("false");
});
// then
}
private String createProject() throws Exception {
MockHttpServletResponse response = mockMvc.perform(post("/project/saveAjax")
.param("copy", "false")
.param("prjName", UUID.randomUUID().toString())
.param("prjVersion", "v1")
.param("noticeType", "10")
.param("distributionType", "10")
.param("comment", "<p>test</p>")
.param("osType", "100")
.param("priority", "30")
.param("statusRequestYn", "")
.param("listId", "")
.param("publicYn", "Y")
.param("networkServerType", "N")
.param("prjDivision", "999")
.param("prjUserId", "tester")
.param("prjId", "")
.param("prjDivision", "")
.param("distributeTarget", "NA")
.param("prjModelJson", "[]")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andReturn().getResponse();
Map<String, Map<String, String>> responses = new ObjectMapper().readValue(response.getContentAsString(), Map.class);
return responses.get("resultData").get("prjId");
}
private Project requestReviewThePackage(String prjId) throws Exception {
Project project = new Project();
project.setPrjId(prjId);
project.setIdentificationStatus("REQ");
project.setCopyFlag("N");
project.setDistributeDeployModelYn("N");
project.setExcelDownloadFlag("N");
project.setNetworkServerFlag("N");
project.setLoadFromAndroidProjectFlag("N");
project.setVersionMatchedFlag("N");
project.setResetDistributionStatus("N");
project.setSkipPackageFlag("N");
project.setUserComment("review start");
project.setReProcessDistributionFlag("N");
project.setChangedNoticeYn("N");
project.setModelListAppendFlag("N");
project.setLoginUserName("tester");
project.setLoginUserRole("ROLE_USER");
project.setHotYn("N");
mockMvc.perform(post("/project/updateProjectStatus")
.content(new ObjectMapper().writeValueAsString(project))
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk());
return project;
}
private void assertReviewStarted(MockHttpServletResponse response) throws UnsupportedEncodingException, JsonProcessingException {
Map<String, String> responseMap = new ObjectMapper().readValue(response.getContentAsString(), Map.class);
assertThat(responseMap.get("isValid")).isEqualTo("true");
}
} | 10,574 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ProjectIdentificationReviewConfirmIntegrationTest.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/test/java/oss/fosslight/controller/ProjectIdentificationReviewConfirmIntegrationTest.java | /*
Copyright (c) 2021 Jongun Chae
Copyright (c) 2021 Sewon Park
SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.controller;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.transaction.annotation.Transactional;
import oss.fosslight.domain.Project;
import java.util.Map;
import java.util.UUID;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@AutoConfigureMockMvc(addFilters = false)
@SpringBootTest
@Transactional
public class ProjectIdentificationReviewConfirmIntegrationTest {
private static final String USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36";
@Autowired
private MockMvc mockMvc;
private String prjId;
@BeforeEach
void createProject() throws Exception {
MockHttpServletResponse response = mockMvc.perform(post("/project/saveAjax")
.param("copy", "false")
.param("prjName", UUID.randomUUID().toString())
.param("prjVersion", "v1")
.param("noticeType", "10")
.param("distributionType", "10")
.param("comment", "<p>test</p>")
.param("osType", "100")
.param("priority", "30")
.param("statusRequestYn", "")
.param("listId", "")
.param("publicYn", "Y")
.param("networkServerType", "N")
.param("prjDivision", "999")
.param("prjUserId", "test2")
.param("prjId", "")
.param("prjDivision", "")
.param("distributeTarget", "NA")
.param("prjModelJson", "[]")
.header("user-agent", USER_AGENT)
.contentType(MediaType.APPLICATION_JSON))
.andReturn().getResponse();
Map<String, Map<String, String>> responseMapForProject = new ObjectMapper().readValue(response.getContentAsString(), Map.class);
prjId = responseMapForProject.get("resultData").get("prjId");
String content = "{\"prjId\":\"" + prjId + "\",\"identificationStatus\":\"REV\"}";
mockMvc.perform(post("/project/updateProjectStatus")
.content(content)
.header("user-agent", USER_AGENT)
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk());
}
@Test
@DisplayName("Identification Review Confirm should be success When parameter is valid")
void identificationReviewConfirmShouldBeSuccess() throws Exception {
//given
String content = "{\"prjId\":\"" + prjId + "\",\"identificationStatus\":\"CONF\"}";
//when
mockMvc.perform(post("/project/updateProjectStatus")
.content(content)
.header("user-agent", USER_AGENT)
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> assertReviewConfirm("CONF"));
//then
}
private void assertReviewConfirm(String identificationStatus) throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/project/edit/" + prjId)
.header("user-agent", USER_AGENT))
.andExpect(status().isOk())
.andExpect(result -> {
Project project = (Project) result.getModelAndView().getModel().get("project");
assertThat(project.getIdentificationStatus()).isEqualTo(identificationStatus);
});
}
@Test
@DisplayName("Identification Review Confirm should be failed When identificationStatus value is not given")
void identificationReviewConfirmFailTest() throws Exception {
//given
String content = "{\"prjId\":\"" + prjId + "\"}";
//when
mockMvc.perform(post("/project/updateProjectStatus")
.content(content)
.header("user-agent", USER_AGENT)
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> assertReviewConfirm("REV"));
//then
}
}
| 4,952 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ProjectIdentificationRequestReviewIntegrationTest.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/test/java/oss/fosslight/controller/ProjectIdentificationRequestReviewIntegrationTest.java | /*
Copyright (c) 2021 Jongun Chae
Copyright (c) 2021 Sewon Park
SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.controller;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.transaction.annotation.Transactional;
import oss.fosslight.domain.Project;
import java.util.Map;
import java.util.UUID;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@AutoConfigureMockMvc(addFilters = false)
@SpringBootTest
@Transactional
public class ProjectIdentificationRequestReviewIntegrationTest {
private static final String USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36";
@Autowired
private MockMvc mockMvc;
private String prjId;
@BeforeEach
void createProject() throws Exception {
MockHttpServletResponse response = mockMvc.perform(post("/project/saveAjax")
.param("copy", "false")
.param("prjName", UUID.randomUUID().toString())
.param("prjVersion", "v1")
.param("noticeType", "10")
.param("distributionType", "10")
.param("comment", "<p>test</p>")
.param("osType", "100")
.param("priority", "30")
.param("statusRequestYn", "")
.param("listId", "")
.param("publicYn", "Y")
.param("networkServerType", "N")
.param("prjDivision", "999")
.param("prjUserId", "test2")
.param("prjId", "")
.param("prjDivision", "")
.param("distributeTarget", "NA")
.param("prjModelJson", "[]")
.header("user-agent", USER_AGENT)
.contentType(MediaType.APPLICATION_JSON))
.andReturn().getResponse();
Map<String, Map<String, String>> responseMapForProject = new ObjectMapper().readValue(response.getContentAsString(), Map.class);
prjId = responseMapForProject.get("resultData").get("prjId");
String content = "{\"merge\":\"Y\",\"gridData\":\"[]\",\"referenceId\":\"" + prjId + "\",\"checkGridData\":\"[]\"}";
mockMvc.perform(post("/project/saveBom")
.content(content)
.header("user-agent", USER_AGENT)
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> {
Map<String, String> responseMap = new ObjectMapper().readValue(result.getResponse().getContentAsString(), Map.class);
assertThat(responseMap.get("identificationStatus")).isEqualTo("PROG");
});
}
@Test
@DisplayName("Identification Request review should be success When parameter is valid")
void requestReviewShouldBeSuccess() throws Exception {
// given
String content = "{\"prjId\":\"" + prjId + "\",\"identificationStatus\":\"REQ\"}";
// when
mockMvc.perform(post("/project/updateProjectStatus")
.content(content)
.header("user-agent", USER_AGENT)
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> assertRequestReview("REQ"));
// then
}
private void assertRequestReview(String identificationStatus) throws Exception {
mockMvc.perform(MockMvcRequestBuilders.get("/project/edit/" + prjId)
.header("user-agent", USER_AGENT))
.andExpect(status().isOk())
.andExpect(result -> {
Project project = (Project) result.getModelAndView().getModel().get("project");
assertThat(project.getIdentificationStatus()).isEqualTo(identificationStatus);
});
}
@Test
@DisplayName("Request review should be failed When identificationStatus value is not given")
void requestReviewFailTest() throws Exception {
//given
String content = "{\"prjId\":\"" + prjId + "\"}";
//when
mockMvc.perform(post("/project/updateProjectStatus")
.content(content)
.header("user-agent", USER_AGENT)
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> assertRequestReview("PROG"));
//then
}
}
| 5,213 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
PackingRequestTest.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/test/java/oss/fosslight/controller/PackingRequestTest.java | /*
Copyright (c) 2021 Jongun Chae
Copyright (c) 2021 JaeHyeuk Lee
SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.controller;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import oss.fosslight.domain.OssNotice;
import oss.fosslight.domain.Project;
import javax.transaction.Transactional;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Map;
import java.util.UUID;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@AutoConfigureMockMvc(addFilters = false)
@SpringBootTest
@Transactional
public class PackingRequestTest {
@Autowired
private MockMvc mockMvc;
private Project prj;
@BeforeEach
void createProjectAndOssNotice() throws Exception{
MockHttpServletResponse prResponse = mockMvc.perform(post("/project/saveAjax")
.param("prjId", "")
.param("prjName", UUID.randomUUID().toString())
.param("useCustomNoticeYn","N")
.param("allowDownloadBitFlag","1")
.param("allowDownloadNoticeHTMLYn","Y")
.param("allowDownloadNoticeTextYn","N")
.param("allowDownloadSimpleHTMLYn","N")
.param("allowDownloadSimpleTextYn","N")
.param("allowDownloadSPDXSheetYn","N")
.param("allowDownloadSPDXRdfYn","N")
.param("allowDownloadSPDXTagYn","N")
.param("prjVersion", "v1")
.param("noticeType", "10")
.param("distributionType", "10")
.param("comment", "<p>test</p>")
.param("osType", "100")
.param("priority", "30")
.param("statusRequestYn", "")
.param("listId", "")
.param("publicYn", "Y")
.param("networkServerType", "N")
.param("prjModelJson", "[]")
.param("verificationStatus","REQ")
.param("distributeDeployModelYn","N")
.param("excelDownloadFlag","N")
.param("referenceDiv","12")
.param("networkServerFlag","N")
.param("loadFromAndroidProjectFlag","N")
.param("versionMatchedFlag","N")
.param("resetDistributionStatus","N")
.param("skipPackageFlag","N")
.param("userComment","")
.param("reProcessDistributionFlag","N")
.param("changedNoticeYn","N")
.param("modelListAppendFlag","N")
.param("copyFlag","N")
.param("loginUserName","user")
.param("loginUserRole","ROLE_ADMIN")
.param("sortField","")
.param("sortOrder","")
.param("hotYn","N")
.param("copy","false")
.param("confirmStatusCopy","false")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andReturn().getResponse();
Map<String, Map<String, String>> responseMapForProject = new ObjectMapper().readValue(prResponse.getContentAsString(), Map.class);
String prjId = responseMapForProject.get("resultData").get("prjId");
prj = (Project) mockMvc.perform(MockMvcRequestBuilders.get("/project/edit/" + prjId)
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36"))
.andExpect(status().isOk())
.andReturn().getModelAndView().getModel().get("project");
prj.setVerificationStatus("REQ");
}
Project editProject(String prjId) throws Exception {
Project pr;
pr = (Project) mockMvc.perform(MockMvcRequestBuilders.get("/project/edit/" + prj.getPrjId())
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36"))
.andExpect(status().isOk())
.andReturn().getModelAndView().getModel().get("project");
return pr;
}
@Test
@DisplayName("packing request review should be success When parameter is valid")
void PackingRequestReviewSuccess() throws Exception{
// given
//when
String content = new ObjectMapper().writeValueAsString(prj);
mockMvc.perform(post("/project/verification/saveAjax")
.content(EntityUtils.toString(new UrlEncodedFormEntity(Arrays.asList(
new BasicNameValuePair("prjId", prj.getPrjId()),
new BasicNameValuePair("noticeType", "10"),
new BasicNameValuePair("appended", ""),
new BasicNameValuePair("appendedTEXT", ""),
new BasicNameValuePair("networkServerFlag", "N"),
new BasicNameValuePair("setPackageJson", ""),
new BasicNameValuePair("setPackageFileId", ""),
new BasicNameValuePair("setEditCompanyYn", "Y")
))))
.param("useCustomNoticeYn", "N")
.param("allowDownloadNoticeHTMLYn", "Y")
.param("allowDownloadNoticeTextYn", "N")
.param("allowDownloadSimpleHTMLYn", "N")
.param("allowDownloadSimpleTextYn", "N")
.param("allowDownloadSPDXSheetYn", "N")
.param("allowDownloadSPDXRdfYn", "N")
.param("allowDownloadSPDXTagYn", "N")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_FORM_URLENCODED))
.andExpect(status().isOk());
mockMvc.perform(post("/project/updateProjectStatus")
.content(content)
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result ->
Assertions.assertThat(editProject(prj.getPrjId()).getVerificationStatus()).isEqualTo("REQ")
);
//then
}
@Test
@DisplayName("packing request review should be fail When parameter is invalid")
void PackingRequestReviewFail() throws Exception{
// given
// when
prj.setVerificationStatus("REV");
String content = new ObjectMapper().writeValueAsString(prj);
mockMvc.perform(post("/project/verification/saveAjax")
.content(EntityUtils.toString(new UrlEncodedFormEntity(Arrays.asList(
new BasicNameValuePair("prjId", prj.getPrjId()),
new BasicNameValuePair("noticeType", "10"),
new BasicNameValuePair("appended", ""),
new BasicNameValuePair("appendedTEXT", ""),
new BasicNameValuePair("networkServerFlag", "N"),
new BasicNameValuePair("setPackageJson", ""),
new BasicNameValuePair("setPackageFileId", ""),
new BasicNameValuePair("setEditCompanyYn", "Y")
))))
.param("useCustomNoticeYn", "N")
.param("allowDownloadNoticeHTMLYn", "Y")
.param("allowDownloadNoticeTextYn", "N")
.param("allowDownloadSimpleHTMLYn", "N")
.param("allowDownloadSimpleTextYn", "N")
.param("allowDownloadSPDXSheetYn", "N")
.param("allowDownloadSPDXRdfYn", "N")
.param("allowDownloadSPDXTagYn", "N")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_FORM_URLENCODED))
.andExpect(status().isOk());
mockMvc.perform(post("/project/updateProjectStatus")
.content(content)
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> {
Assertions.assertThat(editProject(prj.getPrjId()).getVerificationStatus()).isNotEqualTo("REQ");
});
// then
}
}
| 9,943 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
SelfCheckControllerIntegrationTest.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/test/java/oss/fosslight/controller/SelfCheckControllerIntegrationTest.java | /*
Copyright (c) 2021 JaeHyuk Lee
SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.controller;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.transaction.annotation.Transactional;
import oss.fosslight.domain.Project;
import java.util.Map;
import java.util.UUID;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@AutoConfigureMockMvc(addFilters = false)
@SpringBootTest
@Transactional
public class SelfCheckControllerIntegrationTest {
@Autowired
private MockMvc mockMvc;
@Test
@DisplayName("Adding Self-Check list should be success When parameter is valid")
void registrationShouldBeSuccess() throws Exception {
mockMvc.perform(post("/selfCheck/saveAjax")
.param("prjId", "")
.param("prjName", "test")
.param("prjVersion", "")
.param("comment", "")
.param("copyFlag", "N")
.param("distributeDeployModelYn","N")
.param("excelDownloadFlag","N")
.param("prjModelJson","")
.param("networkServerFlag","N")
.param("loadFromAndroidProjectFlag","N")
.param("creatorNm","")
.param("versionMatchedFlag","N")
.param("resetDistributionStatus","N")
.param("deleteMemo","")
.param("skipPackageFlag","N")
.param("reProcessDistributionFlag","N")
.param("changedNoticeYn","N")
.param("modelListAppendFlag","N")
.param("loginUserName","user")
.param("loginUserRole","ROLE_ADMIN")
.param("sortField","")
.param("sortOrder","")
.param("hotYn","N")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andDo(result -> {
Map<String, String> responseMap = new ObjectMapper().readValue(result.getResponse().getContentAsString(), Map.class);
assertThat(responseMap.get("isValid")).isEqualTo("true");
});
}
@Test
@DisplayName("Adding Self-Check list should be failed when parameter is invalid")
void registrationShouldBeFail() throws Exception {
mockMvc.perform(post("/selfCheck/saveAjax")
.param("prjId", "")
.param("prjVersion", "")
.param("comment", "")
.param("copyFlag", "N")
.param("distributeDeployModelYn","N")
.param("excelDownloadFlag","N")
.param("prjModelJson","")
.param("networkServerFlag","N")
.param("loadFromAndroidProjectFlag","N")
.param("creatorNm","")
.param("versionMatchedFlag","N")
.param("resetDistributionStatus","N")
.param("deleteMemo","")
.param("skipPackageFlag","N")
.param("reProcessDistributionFlag","N")
.param("changedNoticeYn","N")
.param("modelListAppendFlag","N")
.param("loginUserName","user")
.param("loginUserRole","ROLE_ADMIN")
.param("sortField","")
.param("sortOrder","")
.param("hotYn","N")
.header("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.107 Safari/537.36")
.contentType(MediaType.APPLICATION_JSON))
.andExpect(status().is5xxServerError())
.andDo(result -> {
Map<String, String> responseMap = new ObjectMapper().readValue(result.getResponse().getContentAsString(), Map.class);
assertThat(String.valueOf(responseMap.get("success"))).isEqualTo("false");
});
}
}
| 4,815 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
FOSSLightApplication.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/FOSSLightApplication.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight;
import java.text.NumberFormat;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.core.env.Environment;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import lombok.extern.slf4j.Slf4j;
import oss.fosslight.common.CoConstDef;
import oss.fosslight.common.CommonFunction;
@SpringBootApplication
@MapperScan(basePackages = CoConstDef.MAPPER_PACKAGE)
@Slf4j
public class FOSSLightApplication implements CommandLineRunner {
@Resource private Environment env; /** The env. */
public static void main(String[] args) {
SpringApplication.run(FOSSLightApplication.class, args);
}
@Override
public void run(String... args) throws Exception {
boolean checkFlag = false;
if (env.containsProperty("secret.key")) {
List<String> argsList = Arrays.asList(args)
.stream()
.filter(c -> c.indexOf("secretKey") > -1)
.collect(Collectors.toList());
if (argsList != null && argsList.size() > 0) {
String checkSecretKey = String.join("", argsList).split("=")[1];
String secretKey = env.getProperty("secret.key");
checkFlag = new BCryptPasswordEncoder().matches(checkSecretKey, secretKey);
}
}
System.setProperty("checkFlag", checkFlag ? CoConstDef.FLAG_YES : CoConstDef.FLAG_NO);
}
@EventListener(ApplicationReadyEvent.class)
public void doSomethingAfterStartup() {
Runtime runtime = Runtime.getRuntime();
final NumberFormat format = NumberFormat.getInstance();
final long maxMemory = runtime.maxMemory();
final long allocatedMemory = runtime.totalMemory();
final long freeMemory = runtime.freeMemory();
final long mb = 1024 * 1024;
final String mega = " MB";
log.info("========================== Memory Info ==========================");
log.info("Free memory: " + format.format(freeMemory / mb) + mega);
log.info("Allocated memory: " + format.format(allocatedMemory / mb) + mega);
log.info("Max memory: " + format.format(maxMemory / mb) + mega);
log.info("Total free memory: " + format.format((freeMemory + (maxMemory - allocatedMemory)) / mb) + mega);
log.info("=================================================================\n");
}
}
| 2,727 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ServletInitializer.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/ServletInitializer.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
public class ServletInitializer extends SpringBootServletInitializer {
public ServletInitializer() {
super();
setRegisterErrorPageFilter(false);
}
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(FOSSLightApplication.class);
}
}
| 583 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CoTopComponent.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/CoTopComponent.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight;
import java.io.IOException;
import java.lang.reflect.Type;
import java.net.HttpURLConnection;
import java.net.URLEncoder;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.PropertySources;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.core.env.Environment;
import org.springframework.core.io.FileSystemResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Component;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import com.google.gson.Gson;
import oss.fosslight.common.CommonFunction;
import oss.fosslight.config.AppConstBean;
import oss.fosslight.domain.ComBean;
import oss.fosslight.domain.T2Authorities;
import oss.fosslight.domain.T2Users;
import oss.fosslight.util.StringUtil;
import oss.fosslight.validation.T2CoValidationResult;
import oss.fosslight.validation.custom.T2CoAdminValidator;
@Component
@PropertySources(value = {@PropertySource(value=AppConstBean.APP_CONFIG_PROPERTIES_PATH)})
public class CoTopComponent {
protected static WebApplicationContext applicationContext;
/* Separation by log type_20210802 */
protected static final Logger scheduler_log = LoggerFactory.getLogger("SCHEDULER_LOG");
protected static final Logger oss_history_log = LoggerFactory.getLogger("OSS_HISTORY_LOG");
protected static final Logger oss_auto_analysis_log = LoggerFactory.getLogger("OSS_AUTO_ANALYSIS_LOG");
@SuppressWarnings("static-access")
@Autowired
public void setWebApplicationContext(WebApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
/** The message source. */
protected static MessageSource messageSource;
@SuppressWarnings("static-access")
@Autowired
public void setMessageSource(MessageSource messageSource) {
this.messageSource = messageSource;
}
protected static Environment appEnv;
@SuppressWarnings("static-access")
@Resource
public void setEnvironment(Environment env) throws IOException {
this.appEnv = env;
}
public static Boolean isEmpty(String s) {
return StringUtil.isEmptyTrimmed(s);
}
public static Boolean isEmptyWithLineSeparator(String s) {
if (s != null) {
s = s.replaceAll(System.lineSeparator(), "");
}
return StringUtil.isEmptyTrimmed(s);
}
public static Boolean isNullObject(Object o) {
if (o instanceof String) {
return StringUtil.isEmptyTrimmed((String) o);
} else {
return o == null;
}
}
public static String nvl(String s){
return StringUtil.defaultString(s);
}
public static String nvl(String checkedString, String defaultString) {
return StringUtil.isEmptyTrimmed(checkedString) ? defaultString : checkedString;
}
protected static String loginUserName() {
try {
return SecurityContextHolder.getContext().getAuthentication().getName();
} catch(Exception e) {
return "";
}
}
@SuppressWarnings("unchecked")
protected static String loginUserRole() {
String result = "anonymousUser";
try {
Collection<GrantedAuthority> authorities = (Collection<GrantedAuthority>) SecurityContextHolder.getContext().getAuthentication().getAuthorities();
if (!authorities.isEmpty()) {
for (GrantedAuthority authority : authorities) {
result = (authority.getAuthority()).replaceFirst(AppConstBean.SECURITY_ROLE_PREFIX, "");
break;
}
}
} catch(Exception e){}
return result;
}
protected static String userRole(T2Users userInfo) {
String result = "anonymousUser";
if (!isEmpty(userInfo.getAuthority())) {
return userInfo.getAuthority();
}
List<T2Authorities> authList = userInfo.getAuthoritiesList();
if (authList != null && !authList.isEmpty()) {
result = authList.get(0).getAuthority();
}
return result;
}
protected static boolean isLogin() {
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
if (auth != null && !"anonymousUser".equalsIgnoreCase(auth.getName()) && auth.isAuthenticated()) {
return true;
}
return false;
}
protected static String encodePassword(String rawPassword) {
if (rawPassword == null || rawPassword.length() < 1) {
return null;
}
return new BCryptPasswordEncoder().encode(rawPassword);
}
protected static String toJson(Object obj) {
Gson gson = CommonFunction.getGsonBuiler();
return gson.toJson(obj);
}
protected static Object fromJson(String jsonString, Type collectionType) {
Gson gson = CommonFunction.getGsonBuiler();
return gson.fromJson(jsonString, collectionType);
}
protected static ResponseEntity<Object> makeJsonResponseHeader(Object obj) {
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.set("Content-Type", MediaType.APPLICATION_JSON_VALUE + "; charset=utf-8");
return new ResponseEntity<Object>(obj, responseHeaders, HttpStatus.OK);
}
protected static ResponseEntity<Object> makeJsonResponseHeader() {
return makeJsonResponseHeader(true, null);
}
protected static ResponseEntity<Object> makeJsonResponseHeader(String alertMsg) {
return makeJsonResponseHeader(true, alertMsg);
}
protected static ResponseEntity<Object> makeJsonResponseHeader(boolean isValid, String alertMsg) {
return makeJsonResponseHeader(isValid, alertMsg, null);
}
protected static ResponseEntity<Object> makeJsonResponseHeader(boolean isValid, String alertMsg, Object obj) {
return makeJsonResponseHeader(isValid, alertMsg, obj, null);
}
protected static ResponseEntity<Object> makeJsonResponseHeader(boolean isValid, String alertMsg, Object obj, Object extObj) {
return makeJsonResponseHeader(isValid, alertMsg, obj, extObj, null);
}
protected static ResponseEntity<Object> makeJsonResponseHeader(boolean isValid, String alertMsg, Object obj, Object extObj, Object extObj2) {
return makeJsonResponseHeader(isValid, alertMsg, obj, extObj, extObj2, null);
}
protected static ResponseEntity<Object> makeJsonResponseHeader(boolean isValid, String alertMsg, Object obj, Object extObj, Object extObj2, Object extObj3) {
HttpHeaders responseHeaders = new HttpHeaders();
Map<String, Object> resultMap = new HashMap<>();
resultMap.put("isValid", isValid ? "true" : "false");
if (!isEmpty(alertMsg)) {
resultMap.put("validMsg", alertMsg);
}
if (obj != null) {
resultMap.put("resultData", obj);
}
if (extObj != null) {
resultMap.put("externalData", extObj);
}
if (extObj2 != null){
resultMap.put("externalData2", extObj2);
}
if (extObj3 != null) {
resultMap.put("externalData3", extObj3);
}
responseHeaders.set("Content-Type", MediaType.APPLICATION_JSON_VALUE + "; charset=utf-8");
return new ResponseEntity<Object>(resultMap, responseHeaders, HttpStatus.OK);
}
protected static Map<String, Object> getGridPagerMap(ComBean vo) {
HashMap<String, Object> map = new HashMap<>();
map.put("page", vo.getPage());
map.put("total", vo.getTotBlockSize());
map.put("records", vo.getTotListSize());
return map;
}
protected T2CoValidationResult validate(HttpServletRequest req) {
return validate(req, null, null, null, null);
}
protected T2CoValidationResult validateWithAppendix(HttpServletRequest req, String appendixKey, Object appendixObj) {
return validate(req, null, null, appendixKey, appendixObj);
}
protected T2CoValidationResult validate(HttpServletRequest req, String ignore) {
return validate(req, ignore, null, null, null);
}
protected T2CoValidationResult validate(HttpServletRequest req, String ignore, String hint, String appendixKey, Object appendixObj) {
T2CoAdminValidator validator = new T2CoAdminValidator();
if (!isEmpty(ignore)) {
validator.setIgnore(ignore);
}
if (!isEmpty(hint)) {
validator.setHint(hint);
}
if (!isEmpty(appendixKey) && appendixObj != null) {
validator.setAppendix(appendixKey, appendixObj);
}
return validator.validateRequest(req);
}
protected T2CoValidationResult validate(Object sourceVO) {
T2CoAdminValidator validator = new T2CoAdminValidator();
return validator.validateObject(sourceVO);
}
protected static Locale getLocale() {
return LocaleContextHolder.getLocale();
}
protected static String getMessage(String code) {
return messageSource.getMessage(code, null, getLocale());
}
protected static String getMessage(String code, Object[] args) {
return messageSource.getMessage(code, args, getLocale());
}
protected static String getEnvMessage(String code) {
return appEnv.getProperty(code);
}
protected static WebApplicationContext getWebappContext() {
return applicationContext;
}
public static ResponseEntity<FileSystemResource> excelToResponseEntity(String excelPath ,String downFileName) throws IOException{
String fullLogiPath = excelPath;
String encodedFilename = URLEncoder.encode(downFileName,"UTF-8").replace("+", "%20");
String contentType = CommonFunction.getMsApplicationContentType(downFileName);
ResponseEntity<FileSystemResource> responseEntity = null;
java.io.File file = new java.io.File(fullLogiPath);
file.setLastModified(new Date().getTime());
FileSystemResource fileSystemResource = new FileSystemResource(file);
HttpHeaders responseHeaders = new HttpHeaders();
if (!isEmpty(contentType)) {
responseHeaders.add(HttpHeaders.CONTENT_TYPE, contentType);
}
responseHeaders.set(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=" + encodedFilename + ";filename*= UTF-8''" + encodedFilename);
responseHeaders.add(HttpHeaders.CONTENT_LENGTH, Long.toString(fileSystemResource.contentLength()));
responseEntity = new ResponseEntity<FileSystemResource>(fileSystemResource, responseHeaders, HttpStatus.OK);
return responseEntity;
}
public static ResponseEntity<FileSystemResource> noticeToResponseEntity(String filePath ,String downFileName) throws IOException{
String fullLogiPath = filePath;
String encodedFilename = URLEncoder.encode(downFileName,"UTF-8").replace("+", "%20");
ResponseEntity<FileSystemResource> responseEntity = null;
java.io.File file = new java.io.File(fullLogiPath);
FileSystemResource fileSystemResource = new FileSystemResource(file);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.add(HttpHeaders.CONTENT_TYPE, "application/octet-stream");
responseHeaders.set(HttpHeaders.CONTENT_DISPOSITION, "attachment;filename=" + encodedFilename + ";filename*= UTF-8''" + encodedFilename);
responseHeaders.add(HttpHeaders.CONTENT_LENGTH, Long.toString(fileSystemResource.contentLength()));
responseEntity = new ResponseEntity<FileSystemResource>(fileSystemResource, responseHeaders, HttpStatus.OK);
return responseEntity;
}
public static ResponseEntity<FileSystemResource> reviewReportToResponseEntity(String filePath, String downFileName) throws IOException {
return noticeToResponseEntity(filePath, downFileName);
}
public static String avoidNull(String s) {
return avoidNull(s, "");
}
public static String avoidNull(String s, String rep) {
return isEmpty(s) ? rep : s;
}
public static boolean putSessionObject(String key, Object obj) {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
if (request != null) {
HttpSession session = request.getSession();
if (session != null) {
session.setAttribute(key, obj);
return true;
}
}
return false;
}
public static String getSessionString(String key) {
return (String) getSessionObject(key, false);
}
public static Object getSessionObject(String key) {
return getSessionObject(key, false);
}
public static Object getSessionObject(String key, boolean oneTimeFlag) {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
if (request != null) {
HttpSession session = request.getSession();
if (session != null) {
Object sessionObj = session.getAttribute(key);
if (oneTimeFlag) {
try {
session.removeAttribute(key);
} catch (Exception e) {
}
}
return sessionObj;
}
}
return null;
}
public static void deleteSession(String key) {
try {
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
if (request != null) {
HttpSession session = request.getSession();
if (session != null) {
session.removeAttribute(key);
}
}
} catch (Exception e) {
}
}
public static String httpCodePrint(int code){
String res = Integer.toString(code);
switch(code){
case HttpURLConnection.HTTP_ACCEPTED: res = "HTTP_ACCEPTED"; break;
case HttpURLConnection.HTTP_BAD_GATEWAY: res = "HTTP_BAD_GATEWAY"; break;
case HttpURLConnection.HTTP_BAD_METHOD: res = "HTTP_BAD_METHOD"; break;
case HttpURLConnection.HTTP_BAD_REQUEST: res = "HTTP_BAD_REQUEST"; break;
case HttpURLConnection.HTTP_CLIENT_TIMEOUT: res = "HTTP_CLIENT_TIMEOUT"; break;
case HttpURLConnection.HTTP_CONFLICT: res = "HTTP_CONFLICT"; break;
case HttpURLConnection.HTTP_CREATED: res = "HTTP_CREATED"; break;
case HttpURLConnection.HTTP_ENTITY_TOO_LARGE: res = "HTTP_ENTITY_TOO_LARGE"; break;
case HttpURLConnection.HTTP_FORBIDDEN: res = "HTTP_FORBIDDEN"; break;
case HttpURLConnection.HTTP_GATEWAY_TIMEOUT: res = "HTTP_GATEWAY_TIMEOUT"; break;
case HttpURLConnection.HTTP_GONE: res = "HTTP_GONE"; break;
case HttpURLConnection.HTTP_INTERNAL_ERROR: res = "HTTP_INTERNAL_ERROR"; break;
case HttpURLConnection.HTTP_LENGTH_REQUIRED: res = "HTTP_LENGTH_REQUIRED"; break;
case HttpURLConnection.HTTP_MOVED_PERM: res = "HTTP_MOVED_PERM"; break;
case HttpURLConnection.HTTP_MOVED_TEMP: res = "HTTP_MOVED_TEMP"; break;
case HttpURLConnection.HTTP_MULT_CHOICE: res = "HTTP_MULT_CHOICE"; break;
case HttpURLConnection.HTTP_NO_CONTENT: res = "HTTP_NO_CONTENT"; break;
case HttpURLConnection.HTTP_NOT_ACCEPTABLE: res = "HTTP_NOT_ACCEPTABLE"; break;
case HttpURLConnection.HTTP_NOT_AUTHORITATIVE:res = "HTTP_NOT_AUTHORITATIVE"; break;
case HttpURLConnection.HTTP_NOT_FOUND: res = "HTTP_NOT_FOUND"; break;
case HttpURLConnection.HTTP_NOT_IMPLEMENTED: res = "HTTP_NOT_IMPLEMENTED"; break;
case HttpURLConnection.HTTP_NOT_MODIFIED: res = "HTTP_NOT_MODIFIED"; break;
case HttpURLConnection.HTTP_OK: res = "HTTP_OK"; break;
case HttpURLConnection.HTTP_PARTIAL: res = "HTTP_PARTIAL"; break;
case HttpURLConnection.HTTP_PAYMENT_REQUIRED: res = "HTTP_PAYMENT_REQUIRED"; break;
case HttpURLConnection.HTTP_PRECON_FAILED: res = "HTTP_PRECON_FAILED"; break;
case HttpURLConnection.HTTP_PROXY_AUTH: res = "HTTP_PROXY_AUTH"; break;
case HttpURLConnection.HTTP_REQ_TOO_LONG: res = "HTTP_REQ_TOO_LONG"; break;
case HttpURLConnection.HTTP_RESET: res = "HTTP_RESET"; break;
case HttpURLConnection.HTTP_SEE_OTHER: res = "HTTP_SEE_OTHER"; break;
case HttpURLConnection.HTTP_UNAUTHORIZED: res = "HTTP_UNAUTHORIZED"; break;
case HttpURLConnection.HTTP_UNAVAILABLE: res = "HTTP_UNAVAILABLE"; break;
case HttpURLConnection.HTTP_UNSUPPORTED_TYPE: res = "HTTP_UNSUPPORTED_TYPE"; break;
case HttpURLConnection.HTTP_USE_PROXY: res = "HTTP_USE_PROXY"; break;
case HttpURLConnection.HTTP_VERSION: res = "HTTP_VERSION"; break;
default: break;
}
return res;
}
}
| 17,506 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ComBeanSerializer.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/ComBeanSerializer.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.lang.reflect.Type;
import com.google.gson.JsonElement;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import oss.fosslight.domain.ComBean;
public class ComBeanSerializer implements JsonSerializer<ComBean> {
@Override
public JsonElement serialize(ComBean vo, Type typeOfVo, JsonSerializationContext context) {
return context.serialize((Object) vo);
}
}
| 560 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ExternalLicenseServiceType.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/ExternalLicenseServiceType.java | /*
* Copyright (c) 2021 Dongmin Kang
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.util.Arrays;
import java.util.List;
import org.springframework.web.util.UriComponentsBuilder;
/* External API support dependency type (GitHub, Clearly Defined) */
public enum ExternalLicenseServiceType {
GITHUB(
"https",
"api.github.com",
"/repos/{onwer}/{repo}/license",
"github license api",
Arrays.asList(
DependencyType.GITHUB
)
),
CLEARLY_DEFINED(
"https",
"api.clearlydefined.io",
"/definitions/{type}/{provider}/{namespace}/{name}/{revision}",
"Clearly Defined definitions api",
Arrays.asList(
DependencyType.NPM,
DependencyType.MAVEN_CENTRAL,
DependencyType.MAVEN_GOOGLE,
DependencyType.PYPI,
DependencyType.COCOAPODS
)
);
private String schema;
private String host;
private String path;
private String description;
private List<DependencyType> types;
ExternalLicenseServiceType(String schema, String host, String path, String description, List<DependencyType> types) {
this.schema = schema;
this.host = host;
this.path = path;
this.description = description;
this.types = types;
}
public List<DependencyType> getTypes() {
return types;
}
public String getDescription() {
return description;
}
public String getPath() {
return path;
}
public String getSchema() {
return schema;
}
public String getHost() {
return host;
}
public boolean hasDependencyType(DependencyType type) {
return types.stream()
.anyMatch(dependencyType -> dependencyType.equals(type));
}
public static String githubLicenseRequestUri(String owner, String repo) {
return UriComponentsBuilder.newInstance()
.scheme(GITHUB.getSchema())
.host(GITHUB.getHost())
.path(GITHUB.getPath())
.build()
.expand(owner, repo)
.encode().toUriString();
}
public static String clearlyDefinedLicenseRequestUri(String type, String provider, String namespace, String name, String revision) {
return UriComponentsBuilder.newInstance()
.scheme(CLEARLY_DEFINED.getSchema())
.host(CLEARLY_DEFINED.getHost())
.path(CLEARLY_DEFINED.getPath())
.build()
.expand(type, provider, namespace, name, revision)
.encode().toUriString();
}
} | 2,293 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
DependencyType.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/DependencyType.java | /*
* Copyright (c) 2021 Dongmin Kang
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.util.Arrays;
import java.util.regex.Pattern;
/* dependency type enum */
public enum DependencyType {
GITHUB("git", "github", CoConstDef.GITHUB_PATTERN),
NPM("npm", "npmjs", CoConstDef.NPM_PATTERN),
PYPI("pypi", "pypi", CoConstDef.PYPI_PATTERN),
MAVEN_CENTRAL("maven", "mavencentral", CoConstDef.MAVEN_CENTRAL_PATTERN),
MAVEN_GOOGLE("maven", "mavengoogle", CoConstDef.MAVEN_GOOGLE_PATTERN),
COCOAPODS("pod", "cocoapods", CoConstDef.COCOAPODS_PATTERN),
UNSUPPORTED("unsupported", "unsupported", CoConstDef.UNSUPPORTED_PATTERN);
String type;
String provider;
private Pattern pattern;
DependencyType(String type, String provider, Pattern pattern) {
this.type = type;
this.provider = provider;
this.pattern = pattern;
}
public String getType() {
return type;
}
public String getProvider() {
return provider;
}
public Pattern getPattern() {
return pattern;
}
public static DependencyType downloadLocationToType(String downloadLocation) {
return Arrays.stream(DependencyType.values())
.filter(dependency -> {
Pattern pattern = dependency.getPattern();
return pattern.matcher(downloadLocation).matches();
})
.findAny()
.orElse(DependencyType.UNSUPPORTED);
}
} | 1,340 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CoCodeManager.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/CoCodeManager.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import oss.fosslight.CoTopComponent;
import oss.fosslight.domain.CoCode;
import oss.fosslight.domain.CoCodeDtl;
import oss.fosslight.domain.CodeDtlBean;
import oss.fosslight.domain.LicenseMaster;
import oss.fosslight.domain.OssLicense;
import oss.fosslight.domain.OssMaster;
import oss.fosslight.repository.CodeManagerMapper;
import oss.fosslight.repository.LicenseMapper;
import oss.fosslight.repository.OssMapper;
@Component
@Slf4j
public class CoCodeManager extends CoTopComponent {
private static CoCodeManager instance;
private static HashMap<String, CoCode> codes;
private static Vector<String[]> emptyVector;
public static Map<String, LicenseMaster> LICENSE_INFO = new HashMap<>();
public static Map<String, LicenseMaster> LICENSE_INFO_UPPER = new HashMap<>();
public static Map<String, LicenseMaster> LICENSE_INFO_BY_ID = new HashMap<>();
public static Map<String, OssMaster> OSS_INFO_UPPER = new HashMap<>();
public static Map<String, OssMaster> OSS_INFO_BY_ID = new HashMap<>();
public static Map<String, String> OSS_INFO_UPPER_NAMES = new HashMap<>();
public static List<String> LICENSE_USER_GUIDE_LIST = new ArrayList<>();
/** ROLE OUT LICENSE */
public static String CD_ROLE_OUT_LICENSE = "";
public static List<String> CD_ROLE_OUT_LICENSE_ID_LIST = new ArrayList<>();
private static CodeManagerMapper codeManagerMapper;
public static void setCodeManagerMapper(CodeManagerMapper mapper) {
codeManagerMapper = mapper;
}
private static LicenseMapper licenseMapper;
public static void setLicenseMapper(LicenseMapper mapper) {
licenseMapper = mapper;
}
private static OssMapper ossMapper;
public static void setOssMapper(OssMapper mapper) {
ossMapper = mapper;
}
public void init() {
codes = new HashMap<String, CoCode>();
emptyVector = new Vector<String[]>();
instance = new CoCodeManager();
List<CodeDtlBean> list = null;
CoCode code = null;
CoCodeDtl codedtl = null;
try {
list = codeManagerMapper.getCodeListAll();
if (list == null) {
throw new RuntimeException("SYSTEM ERR GET CODE INFO FAIL");
}
for (CodeDtlBean vo : list) {
String s = vo.getCdNo();
code = (CoCode) codes.get(s);
if (code == null) {
code = new CoCode(s, vo.getCdNm());
codes.put(s, code);
}
codedtl = new CoCodeDtl(
vo.getCdDtlNo(),
vo.getCdSubNo(),
vo.getCdDtlNm(),
vo.getCdDtlNm2(),
vo.getCdDtlExp(),
Integer.parseInt(CommonFunction.avoidNull(vo.getCdOrder(), "1")),
CommonFunction.avoidNull(vo.getUseYn(), CoConstDef.FLAG_YES));
code.addCodeDtl(codedtl);
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
loadLicenseInfo();
loadOssInfo();
}
public void refreshOssInfo () {
loadOssInfo();
}
private void loadOssInfo() {
try {
List<OssMaster> list = ossMapper.getOssInfoAll();
List<OssMaster> listNick = ossMapper.getOssInfoAllWithNick();
List<OssMaster> nickNameList = ossMapper.getOssAllNickNameList();
Map<String, String[]> nickNameMap = new HashMap<>();
Map<String, OssMaster> _ossMap = new HashMap<>();
Map<String, String> _ossNamesMap = new HashMap<>();
if (nickNameList != null) {
for (OssMaster bean : nickNameList) {
if (bean.getOssNickname() != null) {
nickNameMap.put(bean.getOssName(), bean.getOssNickname().split(","));
}
}
}
if (list != null) {
for (OssMaster bean : list) {
OssMaster targetBean = null;
String key = bean.getOssName() +"_"+ avoidNull(bean.getOssVersion()); // oss name์ nick name์ผ๋ก ๊ฐ์ ธ์จ๋ค.
key = key.toUpperCase();
if (_ossMap.containsKey(key)) {
targetBean = _ossMap.get(key);
} else {
targetBean = bean;
if (nickNameMap.containsKey(targetBean.getOssNameTemp())) {
targetBean.setOssNicknames(nickNameMap.get(targetBean.getOssNameTemp()));
}
}
OssLicense subBean = new OssLicense();
subBean.setOssId(bean.getOssId());
subBean.setLicenseId(bean.getLicenseId());
subBean.setLicenseName(bean.getLicenseName());
subBean.setLicenseType(bean.getOssLicenseType());
subBean.setOssLicenseIdx(bean.getOssLicenseIdx());
subBean.setOssLicenseComb(bean.getOssLicenseComb());
subBean.setOssLicenseText(bean.getOssLicenseText());
subBean.setOssCopyright(bean.getOssCopyright());
// oss์ license type์ license์ license type ์ ์ฉ ์ดํ์ set
targetBean.setLicenseType(bean.getOssLicenseType());
targetBean.addOssLicense(subBean);
if (_ossMap.containsKey(key)) {
_ossMap.replace(key, targetBean);
} else {
_ossMap.put(key, targetBean);
}
if (!_ossNamesMap.containsKey(bean.getOssName().toUpperCase())) {
_ossNamesMap.put(bean.getOssName().toUpperCase(), bean.getOssName());
}
}
}
Map<String, OssMaster> _idMasterMap = new HashMap<>();
for (OssMaster bean : _ossMap.values()) {
if (!_idMasterMap.containsKey(bean.getOssId())) {
_idMasterMap.put(bean.getOssId(), bean);
}
}
OSS_INFO_BY_ID = _idMasterMap;
if (listNick != null) {
for (OssMaster bean : listNick) {
//OssMaster targetBean = null;
String key = bean.getOssName() +"_"+ avoidNull(bean.getOssVersion()); // oss name์ nick name์ผ๋ก ๊ฐ์ ธ์จ๋ค.
String ossNickNameKey = bean.getOssName().toUpperCase();
if (!_ossNamesMap.containsKey(ossNickNameKey)) {
_ossNamesMap.put(ossNickNameKey, bean.getOssNameTemp());
}
String sourceKey = (bean.getOssNameTemp() + "_" + avoidNull(bean.getOssVersion())).toUpperCase();
OssMaster sourceBean = _ossMap.get(sourceKey);
bean.setLicenseDiv(sourceBean.getLicenseDiv());
bean.setDownloadLocation(sourceBean.getDownloadLocation());
bean.setDownloadLocationGroup(sourceBean.getDownloadLocationGroup());
bean.setHomepage(sourceBean.getHomepage());
bean.setSummaryDescription(sourceBean.getSummaryDescription());
bean.setAttribution(sourceBean.getAttribution());
bean.setCopyright(sourceBean.getCopyright());
bean.setCvssScore(sourceBean.getCvssScore());
bean.setCveId(sourceBean.getCveId());
bean.setVulnYn(sourceBean.getVulnYn());
bean.setVulnRecheck(sourceBean.getVulnRecheck());
bean.setVulnDate(sourceBean.getVulnDate());
bean.setLicenseType(sourceBean.getLicenseType());
bean.setOssLicenses(sourceBean.getOssLicenses());
bean.setOssType(sourceBean.getOssType());
bean.setMultiLicenseFlag(sourceBean.getMultiLicenseFlag());
bean.setDualLicenseFlag(sourceBean.getDualLicenseFlag());
bean.setVersionDiffFlag(sourceBean.getVersionDiffFlag());
if (sourceBean.getDetectedLicenses() != null) {
bean.setDetectedLicenses(sourceBean.getDetectedLicenses());
}
_ossMap.put(key.toUpperCase(), bean);
}
}
if (!_ossMap.isEmpty()) {
OSS_INFO_UPPER = _ossMap;
}
if (!_ossNamesMap.isEmpty()) {
OSS_INFO_UPPER_NAMES = _ossNamesMap;
}
} catch(Exception e) {
log.error(e.getMessage(), e);
}
}
/**
* ๋ชจ๋ ๋ผ์ด์ ์ค ์ ๋ณด๋ฅผ load
*/
private void loadLicenseInfo() {
try {
List<LicenseMaster> list = licenseMapper.getLicenseInfoInit();
List<LicenseMaster> nickList = licenseMapper.getLicenseInfoInitNick();
if (list == null) {
throw new RuntimeException("SYSTEM ERR GET CODE LICENSE MASTER INFO");
}
Map<String, LicenseMaster> license_info_map = new HashMap<>();
Map<String, LicenseMaster> license_info_upper_map = new HashMap<>();
Map<String, LicenseMaster> license_info_by_id_map = new HashMap<>();
for (LicenseMaster vo : list) {
if (!isEmpty(vo.getLicenseNicknameStr())) {
for (String nick : vo.getLicenseNicknameStr().split("\\|")) {
vo.addLicenseNicknameList(nick);
}
}
if (!isEmpty(vo.getRestriction())) {
vo.setRestrictionStr(CommonFunction.setLicenseRestrictionList(vo.getRestriction()));
}
license_info_map.put(vo.getLicenseName(),vo);
license_info_upper_map.put(vo.getLicenseName().toUpperCase(),vo);
//SHORT_IDENTIFIER
if (!isEmpty(vo.getShortIdentifier())) {
if (!license_info_map.containsKey(vo.getShortIdentifier())) {
license_info_map.put(vo.getShortIdentifier(),vo);
}
if (!license_info_upper_map.containsKey(vo.getShortIdentifier().toUpperCase())) {
license_info_upper_map.put(vo.getShortIdentifier().toUpperCase(), vo);
}
}
license_info_by_id_map.put(vo.getLicenseId(), vo);
}
for (LicenseMaster vo : nickList) {
LicenseMaster sourceBean = license_info_by_id_map.get(vo.getLicenseId());
vo.setLicenseNicknameList(sourceBean.getLicenseNicknameList());
vo.setRestrictionStr(sourceBean.getRestrictionStr());
license_info_map.put(vo.getLicenseName(),vo);
license_info_upper_map.put(vo.getLicenseName().toUpperCase(),vo);
}
if (!license_info_map.isEmpty()) {
LICENSE_INFO = license_info_map;
}
if (!license_info_upper_map.isEmpty()) {
LICENSE_INFO_UPPER = license_info_upper_map;
}
if (!license_info_by_id_map.isEmpty()) {
LICENSE_INFO_BY_ID = license_info_by_id_map;
}
// 2017.04.27 add by yuns
// no opensource license ๋์์ ํ๋์ฝ๋ฉ์์ license master์ license type์ผ๋ก ๋ณ๊ฒฝ
List<LicenseMaster> roleOutLicenseList = licenseMapper.getRoleOutLicense();
List<String> roleOutLicenseNames = new ArrayList<>();
List<String> roleOutLicenseIds = new ArrayList<>();
if (roleOutLicenseList != null) {
for (LicenseMaster bean : roleOutLicenseList) {
if (!roleOutLicenseNames.contains(bean.getLicenseName())) {
roleOutLicenseNames.add(bean.getLicenseName());
}
if (!roleOutLicenseIds.contains(bean.getLicenseId())) {
roleOutLicenseIds.add(bean.getLicenseId());
}
}
}
String noOpensourceStr = "";
for (String s : roleOutLicenseNames) {
if (!isEmpty(noOpensourceStr)) {
noOpensourceStr += "|";
}
noOpensourceStr += s;
}
CD_ROLE_OUT_LICENSE = noOpensourceStr;
CD_ROLE_OUT_LICENSE_ID_LIST = roleOutLicenseIds;
} catch (Exception e) {
log.error(e.getMessage(), e);
}
if (LICENSE_INFO_UPPER != null) {
List<String> _licenseUserGuideList = new ArrayList<>();
for (String s : LICENSE_INFO_UPPER.keySet()) {
LicenseMaster _license = LICENSE_INFO_UPPER.get(s);
if (_license != null && !isEmptyWithLineSeparator(_license.getDescription())) {
_licenseUserGuideList.add(s);
}
}
if (!_licenseUserGuideList.isEmpty()) {
LICENSE_USER_GUIDE_LIST = _licenseUserGuideList;
}
}
}
public void refreshLicenseInfo () {
loadLicenseInfo();
}
private CoCodeManager() {}
public static CoCodeManager getInstance() {
if (instance == null) {
instance = new CoCodeManager();
}
return instance;
}
private static CoCode getCodeInstance(String s) {
CoCode code = (CoCode) codes.get(s);
if (code == null) {
log.debug((new StringBuilder()).append("Code No.").append(s)
.append(" is not found. request code no : " + avoidNull(s)).toString());
}
return code;
}
public String getGroupName(String s) {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdNm() : null;
}
public static Vector<String[]> getValues(String s) {
return getValues(s, null);
}
public static Vector<String[]> getValues(String s, String lang) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlNoCdDtlNmPairVector(false) : emptyVector;
}
}
//์๋ก ์ถ๊ฐ : hj-kim - 2016-05-31
public static String getValuesJson(String s) {
return getValuesJson(s, null);
}
//์๋ก ์ถ๊ฐ : hj-kim - 2016-05-31
public static String getValuesJson(String s, String lang) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
Gson gson = new Gson();
String jsonStr = gson.toJson(code.getCdDtlNoCdDtlNmPairVectorBean(false));
return code != null ? jsonStr: "[]";
}
}
public static Vector<String[]> getValuesIgnoreUse(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlNoCdDtlNmPairVector(true) : emptyVector;
}
}
//์๋ก ์ถ๊ฐ : hj-kim - 2016-05-31
public static String getValuesIgnoreUseJson(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
Vector<CoCodeDtl> t = code.getCdDtlNoCdDtlNmPairVectorBean(true);
Gson gson = new Gson();
String jsonStr = gson.toJson(t);
return code != null ? jsonStr: "[]";
}
}
public static Vector<String[]> getAllValues(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdAllPairVector(false) : emptyVector;
}
}
//์๋ก ์ถ๊ฐ : hj-kim - 2016-05-31
public static String getAllValuesJson(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
Vector<CoCodeDtl> t = code.getCdAllPairVectorBean(false);
Gson gson = new Gson();
String jsonStr = gson.toJson(t);
return code != null ? jsonStr : "[]";
}
}
public static Vector<String[]> getAllValuesIgnoreUse(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdAllPairVector(true) : emptyVector;
}
}
public static Vector<String> getCodes(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlNoVector(false) : new Vector<String>();
}
}
public static Vector<String> getCodesIgnoreUse(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlNoVector(true) : null;
}
}
public static Vector<String> getCodeNames(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlNmVector(false) : new Vector<String>();
}
}
public static Vector<String> getCodeNames(String s, String lang) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlNmVector(false) : new Vector<String>();
}
}
public static String getCodeNamesJson(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
Vector<String> t = code.getCdDtlNmVector(false);
Gson gson = new Gson();
String jsonStr = gson.toJson(t);
return code != null ? jsonStr : "[]";
}
}
public static String getCodeNamesJson(String s, String lang) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
Vector<String> t = code.getCdDtlNmVector(false);
Gson gson = new Gson();
String jsonStr = gson.toJson(t);
return code != null ? jsonStr : "[]";
}
}
public static Vector<String> getCodeNamesIgnoreUse(String s) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlNmVector(true) : null;
}
}
public static String getCodeString(String s, String s1) {
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlNm(s1) : "";
}
}
public static String getCodeExpString(String s, String s1) {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlExp(s1) : "";
}
public static String getCodeExpStringAppend(String RootCd, String RootDtlCd, String SubDtlCd) {
return getCodeExpStringAppend(RootCd, RootDtlCd, RootCd, SubDtlCd);
}
public static String getCodeExpStringAppend(String RootCd, String RootDtlCd, String SubCd, String SubDtlCd) {
return getCodeExpString(RootCd, RootDtlCd) + getCodeExpString(SubCd, SubDtlCd);
}
public static String getCodeExpStringByName(String s, String s1) {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlExpByName(s1) : "";
}
public static String getSubCodeNo(String s, String s1) {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdSubCdNo(s1) : "";
}
public static int getCodePriority(String s, String s1) {
CoCode code = getCodeInstance(s);
return code != null ? code.getCdDtlPrior(s1) : -1;
}
public String genComboBox(String s, String s1) {
return genComboBox(s, s1, null, -1);
}
public String genComboBox(String s, String s1, String s2, int i) {
CoCode code = getCodeInstance(s);
if (code != null) {
return code.createComboBoxString(s1, s2, i);
} else {
return "<select name='" + s1 + "'>\n</select>\n";
}
}
public static String genOption(String s) {
return genOption(s, null, -1);
}
public static String genOption(String s, String s1) {
return genOption(s, s1, 0);
}
public static String genOption(String s, String s1, int i) {
CoCode code = getCodeInstance(s);
if (code != null) {
return code.createOptionString(s1, i);
} else {
return null;
}
}
public static String genOptionCheckbox(String s, String s1) {
return genOptionCheckbox(s, s1, -1);
}
private static String genOptionCheckbox(String s, String s1, int i) {
CoCode code = getCodeInstance(s);
if (code != null) {
return code.createOptionCheckboxString(s, s1, i);
} else {
return null;
}
}
public static String genRadio(String s, String distributionType, String networkServerType) {
CoCode code = getCodeInstance(s);
if (code != null) {
return code.createRadioString(s, distributionType, networkServerType);
} else {
return null;
}
}
public static String genCheckbox(String s, String status, String callType) {
CoCode code = getCodeInstance(s);
if (code != null) {
return code.createCheckboxString(status, s, callType);
} else {
return null;
}
}
public static String genCommonCheckbox(String s, String name, String val, Boolean NAExceptionFlag) {
CoCode code = getCodeInstance(s);
if (!StringUtils.isEmpty(code)) {
return code.createCommonCheckboxString(val, name, NAExceptionFlag);
} else {
return null;
}
}
public String getCode(String s) {
Vector<String> vector = getCodes(s);
if (vector != null) {
return (String) vector.get(0);
} else {
return null;
}
}
public void refreshCodes() {
HashMap<String, CoCode> hashmap = new HashMap<String, CoCode>();
List<CodeDtlBean> list = null;
CoCode code = null;
CoCodeDtl codedtl = null;
try {
list = codeManagerMapper.getCodeListAll();
if (list == null) {
throw new RuntimeException("SYSTEM ERR GET CODE INFO FAIL");
}
for (CodeDtlBean vo : list) {
String s = vo.getCdNo();
code = (CoCode) hashmap.get(s);
if (code == null) {
code = new CoCode(s, vo.getCdNm());
hashmap.put(s, code);
}
codedtl = new CoCodeDtl(
vo.getCdDtlNo()
, vo.getCdSubNo()
, vo.getCdDtlNm()
, vo.getCdDtlNm2()
, vo.getCdDtlExp()
, Integer.parseInt(CommonFunction.avoidNull(vo.getCdOrder(), "1"))
, vo.getUseYn());
code.addCodeDtl(codedtl);
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
if (!hashmap.isEmpty()) {
codes = hashmap;
// Const ํ์ผ์ ์ง์ ์ฐธ์กฐํ๋ ์ฝ๋ value ๊ฐ ์์ ๊ฒฝ์ฐ ๋ณ๊ฒฝํด์ค์ผํจ
CoConstDef.DISP_PAGENATION_DEFAULT = getCodes(CoConstDef.CD_PAGENATION).firstElement();
CoConstDef.DISP_PAGENATION_LIST_STR = CommonFunction.arrayToString(CoCodeManager.getCodes(CoConstDef.CD_PAGENATION));
}
}
public static Vector<String> getStandardCodeExp(String s){
Vector<String> ret = null;
Vector<String> codes = null;
Vector<String> exps = new Vector<String>();
int size = 0;
int i = 0;
int j = 0;
if (instance == null) {
throw new IllegalStateException();
} else {
CoCode code = getCodeInstance(s);
codes = code != null ? code.getCdDtlNoVector(false) : new Vector<String>();
while (i < codes.size()){
if (!("").equals(codes.get(i))){
String temp = code != null ? code.getCdDtlExp(codes.get(i)) : "";
if (!temp.equals("")){
exps.add(temp);
CoCode code_ = getCodeInstance(temp);
Vector<String> temps = code_ != null ? code_.getCdDtlNoVector(false) : null;
if (temps != null && temps.size() > size){
size = temps.size();
j++;
}
}
}
i++;
}
if (size > 0){
code = getCodeInstance(exps.get(j-1));
ret = code != null ? code.getCdDtlNoVector(false) : null;
}
}
return ret;
}
public static String getLicenseUserGuideJsonString() {
String jsonStr = null;
if (LICENSE_USER_GUIDE_LIST != null) {
Gson gson = new Gson();
jsonStr = gson.toJson(LICENSE_USER_GUIDE_LIST);
}
return !isEmpty(jsonStr) ? jsonStr : "[]";
}
public static String getCommentColor(String code) {
String returnStr = "";
switch (code) {
case "10": // Identification
returnStr = "#ffb526";
break;
case "12": // Pacaging
returnStr = "#4cf58c";
break;
case "14": // Distribution
returnStr = "#f54cf3";
break;
case "19": // project Info
returnStr = "#059bf1";
break;
case "60": // Security
returnStr = "#02304b";
break;
default:
break;
}
return returnStr;
}
}
| 27,330 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ShellCommander.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/ShellCommander.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import lombok.extern.slf4j.Slf4j;
import oss.fosslight.CoTopComponent;
@Slf4j
public class ShellCommander extends CoTopComponent {
public static List<String> shellCommandToList(String command) throws Exception {
Process process = null;
InputStream is = null;
InputStreamReader isr = null;
BufferedReader br = null;
List<String> list = new ArrayList<>();
try {
process = Runtime.getRuntime().exec(command);
is = process.getInputStream();
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
String line;
while ((line = br.readLine()) != null) {
list.add(line);
}
} finally {
if (br != null) {
try {br.close();} catch (Exception e) {}
}
if (isr != null) {
try {isr.close();} catch (Exception e) {}
}
if (is != null) {
try {is.close();} catch (Exception e) {}
}
if (process != null) {
try {process.destroy();} catch (Exception e) {}
}
}
return list;
}
public static List<String> shellCommandToList(String[] command) throws Exception {
Process process = null;
InputStream is = null;
InputStreamReader isr = null;
BufferedReader br = null;
List<String> list = new ArrayList<>();
try {
process = Runtime.getRuntime().exec(command);
is = process.getInputStream();
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
String line;
while ((line = br.readLine()) != null) {
list.add(line);
}
} finally {
if (br != null) {
try {br.close();} catch (Exception e) {}
}
if (isr != null) {
try {isr.close();} catch (Exception e) {}
}
if (is != null) {
try {is.close();} catch (Exception e) {}
}
if (process != null) {
try {process.destroy();} catch (Exception e) {}
}
}
return list;
}
public static void shellCommandWaitFor(String command) throws Exception {
Process process = null;
InputStream is = null;
InputStreamReader isr = null;
BufferedReader br = null;
try {
process = Runtime.getRuntime().exec(command);
is = process.getInputStream();
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
String line;
while ((line = br.readLine()) != null) {
log.debug("ShellCommander : "+line);
}
} finally {
if (br != null) {
try {br.close();} catch (Exception e) {}
}
if (isr != null) {
try {isr.close();} catch (Exception e) {}
}
if (is != null) {
try {is.close();} catch (Exception e) {}
}
if (process != null) {
try {process.destroy();} catch (Exception e) {}
}
}
}
public static void shellCommandWaitFor(String[] command) throws Exception {
Process process = null;
try {
process = Runtime.getRuntime().exec(command);
process.waitFor();
} catch (Exception e) {
log.error(e.getMessage(), e);
throw new Exception(e);
} finally {
if (process != null) {
try {
process.destroy();
} catch (Exception e2) {}
}
}
}
public static boolean shellCommandWaitForIgnoreException(String[] command) throws Exception {
Process process = null;
try {
process = Runtime.getRuntime().exec(command);
process.waitFor();
return true;
} catch (Exception e) {
log.error(e.getMessage(), e);
//throw new Exception(e);
return false;
} finally {
if (process != null) {
try {
process.destroy();
} catch (Exception e2) {}
}
}
}
}
| 3,875 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CustomXssFilter.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/CustomXssFilter.java | /*
* Copyright (c) 2021 Taeseong Yu
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.util.List;
import com.nhncorp.lucy.security.xss.XssPreventer;
import com.nhncorp.lucy.security.xss.XssFilter;
import com.nhncorp.lucy.security.xss.XssSaxFilter;
import lombok.extern.slf4j.Slf4j;
import oss.fosslight.domain.LicenseMaster;
import oss.fosslight.domain.OssMaster;
import oss.fosslight.domain.Project;
import oss.fosslight.domain.PartnerMaster;
@Slf4j
public class CustomXssFilter {
public static void licenseMasterFilter(List<LicenseMaster> list) {
for (LicenseMaster licenseMaster : list) {
licenseMasterFilter(licenseMaster);
}
}
public static void licenseMasterFilter(LicenseMaster licenseMaster) {
String escapedLicenseName = XssPreventer.escape(licenseMaster.getLicenseName());
String escapedLicenseType = XssPreventer.escape(licenseMaster.getLicenseType());
String escapedShortIdentifier = XssPreventer.escape(licenseMaster.getShortIdentifier());
String escapedDescription = XssPreventer.escape(licenseMaster.getDescription());
String escapedWebpage = XssPreventer.escape(licenseMaster.getWebpage());
//licenseMaster.setLicenseName(escapedLicenseName);
licenseMaster.setLicenseType(escapedLicenseType);
licenseMaster.setShortIdentifier(escapedShortIdentifier);
licenseMaster.setDescription(escapedDescription);
licenseMaster.setWebpage(escapedWebpage);
}
public static void ossMasterFilter(List<OssMaster> list) {
for (OssMaster ossMaster : list) {
ossMasterFilter(ossMaster);
}
}
public static void ossMasterFilter(OssMaster ossMaster) {
String escapedLicenseName = XssPreventer.escape(ossMaster.getLicenseName());
String escapedLicenseType = XssPreventer.escape(ossMaster.getLicenseType());
String escapedSummaryDescription = XssPreventer.escape(ossMaster.getSummaryDescription());
String escapedDownloadLocation = XssPreventer.escape(ossMaster.getDownloadLocation());
String escapedHomepage = XssPreventer.escape(ossMaster.getHomepage());
ossMaster.setLicenseName(escapedLicenseName);
ossMaster.setLicenseType(escapedLicenseType);
ossMaster.setSummaryDescription(escapedSummaryDescription);
ossMaster.setDownloadLocation(escapedDownloadLocation);
ossMaster.setHomepage(escapedHomepage);
}
public static void projectFilter(List<Project> list) {
for (Project project : list) {
projectFilter(project);
}
}
public static void projectFilter(Project project) {
String escapedName = XssPreventer.escape(project.getPrjName());
project.setPrjName(escapedName);
}
public static void partnerFilter(List<PartnerMaster> list) {
for (PartnerMaster partner : list) {
partnerFilter(partner);
}
}
public static void partnerFilter(PartnerMaster partner) {
String escapedPartnerName = XssPreventer.escape(partner.getPartnerName());
String escapedSoftwareVersion = XssPreventer.escape(partner.getSoftwareVersion());
String escapedSoftwareName = XssPreventer.escape(partner.getSoftwareName());
String escapedDescription = XssPreventer.escape(partner.getDescription());
String escapedDivision = XssPreventer.escape(partner.getDivision());
partner.setPartnerName(escapedPartnerName);
partner.setSoftwareVersion(escapedSoftwareVersion);
partner.setSoftwareName(escapedSoftwareName);
partner.setDescription(escapedDescription);
partner.setDivision(escapedDivision);
}
}
| 3,747 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CoPostConstruct.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/CoPostConstruct.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import javax.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
import oss.fosslight.repository.CodeManagerMapper;
import oss.fosslight.repository.LicenseMapper;
import oss.fosslight.repository.OssMapper;
import oss.fosslight.repository.ProjectMapper;
import oss.fosslight.service.OssService;
import oss.fosslight.service.T2UserService;
@Component
@Slf4j
public class CoPostConstruct {
@Autowired T2UserService t2UserService;
@Autowired OssService ossService;
@Autowired CodeManagerMapper codeManagerMapper;
@Autowired LicenseMapper licenseMapper;
@Autowired OssMapper ossMapper;
@Autowired ProjectMapper projectMapper;
@PostConstruct
public void initPostConstruct() {
try {
CommonFunction.setT2UserService(t2UserService);
CommonFunction.setOssService(ossService);
CoCodeManager.setCodeManagerMapper(codeManagerMapper);
CoCodeManager.setLicenseMapper(licenseMapper);
CoCodeManager.setOssMapper(ossMapper);
CoCodeManager.getInstance().init();
} catch (Exception e) {
log.error(e.getMessage());
}
}
}
| 1,337 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CommonFunction.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/CommonFunction.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.net.HttpURLConnection;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Properties;
import java.util.Scanner;
import java.util.TimeZone;
import java.util.TreeMap;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.beanutils.BeanMap;
import org.apache.commons.beanutils.PropertyUtilsBean;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.VelocityEngine;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.jsoup.parser.Parser;
import org.jsoup.select.Elements;
import org.mozilla.universalchardet.UniversalDetector;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.util.HtmlUtils;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.internal.LinkedTreeMap;
import com.google.gson.reflect.TypeToken;
import lombok.extern.slf4j.Slf4j;
import oss.fosslight.CoTopComponent;
import oss.fosslight.config.AppConstBean;
import oss.fosslight.domain.ComBean;
import oss.fosslight.domain.LicenseHtmlGeneratorFromXml;
import oss.fosslight.domain.LicenseMaster;
import oss.fosslight.domain.OssAnalysis;
import oss.fosslight.domain.OssComponents;
import oss.fosslight.domain.OssComponentsLicense;
import oss.fosslight.domain.OssLicense;
import oss.fosslight.domain.OssMaster;
import oss.fosslight.domain.PartnerMaster;
import oss.fosslight.domain.Project;
import oss.fosslight.domain.ProjectIdentification;
import oss.fosslight.domain.T2File;
import oss.fosslight.domain.T2Users;
import oss.fosslight.domain.UploadFile;
import oss.fosslight.service.OssService;
import oss.fosslight.service.PartnerService;
import oss.fosslight.service.ProjectService;
import oss.fosslight.service.T2UserService;
import oss.fosslight.util.DateUtil;
import oss.fosslight.util.FileUtil;
import oss.fosslight.util.StringUtil;
import oss.fosslight.validation.T2CoValidationResult;
import oss.fosslight.validation.custom.T2CoOssValidator;
@Component
@Slf4j
public class CommonFunction extends CoTopComponent {
private static T2UserService t2UserService;
public static void setT2UserService(T2UserService service) {
t2UserService = service;
}
private static OssService ossService;
public static void setOssService(OssService service) {
ossService = service;
}
private static ProjectService projectService;
public static void setProjectService(ProjectService service) {
projectService = service;
}
private static PartnerService partnerService;
public static void setPartnerService(PartnerService service) {
partnerService = service;
}
public static String getCoConstDefVal(String nm) {
try {
return (String) CoConstDef.class.getField(nm).get(null);
} catch (Exception e) {
throw new RuntimeException(nm + ":" + e);
}
}
public static String formatDate(String dt, String separator) {
StringBuffer ret = new StringBuffer();
dt = dt.replaceAll("[^\\d]*", "");
if (dt.length() >= 8) {
if (CoConstDef.DISP_FORMAT_DATE_TAG_SIMPLE.equals(separator)) {
// yyyyMMdd
dt = dt.substring(0, 8);
} else if (dt.length() >= 14) {
dt = dt.substring(0, 14);
}
}
if (dt.length() < 4) {
ret.append(dt);
} else {
int i = 0;
ret.append(dt.substring(0, 4));
if (separator.length() > i) {
ret.append(separator.charAt(i++));
}
dt = dt.substring(4);
while (dt.length() >= 2) {
ret.append(dt.substring(0, 2));
if (separator.length() > i) {
ret.append(separator.charAt(i++));
}
dt = dt.substring(2);
}
}
return ret.toString();
}
public static String formatDate(String dt) {
return formatDate(dt, CoConstDef.DISP_FORMAT_DATE_TAG_DEFAULT);
}
public static String formatDateSimple(String dt) {
return formatDate(dt, CoConstDef.DISP_FORMAT_DATE_TAG_SIMPLE);
}
public static boolean contains(Object[] array, Object item) {
if (array != null) {
return Arrays.asList(array).contains(item);
}
return false;
}
public static String arrayToString(String[] arr, String sep) {
String tmpStr = CoConstDef.EMPTY_STRING;
if (isEmpty(sep)) {
sep = ","; // default value
}
if (arr != null) {
for (String s : arr) {
tmpStr += (isEmpty(tmpStr) ? "" : sep) + s.trim();
}
}
return tmpStr;
}
public static String arrayToStringForSql(String[] arr) {
String tmpStr = CoConstDef.EMPTY_STRING;
if (arr != null) {
for (String s : arr) {
tmpStr += (isEmpty(tmpStr) ? "" : ",") + "\'" + avoidNull(s) + "\'";
}
}
return tmpStr;
}
public static String arrayToString(List<String> list) {
if (list == null || list.isEmpty()) {
return "";
}
String[] arr = new String[list.size()];
return arrayToString(list.toArray(arr), null);
}
public static String getCurrentDateTime() {
DateFormat df = new SimpleDateFormat("yyMMdd");
return df.format(new Date());
}
public static String getCurrentDateTime(String format) {
DateFormat df = new SimpleDateFormat(format);
return df.format(new Date());
}
public static String getCurrentDateTime(String format, String timeZone) {
DateFormat df = new SimpleDateFormat(format);
TimeZone tx=TimeZone.getTimeZone( timeZone );
df.setTimeZone(tx);
return df.format(new Date());
}
public static Boolean isEmpty(String s) {
return StringUtil.isEmptyTrimmed(s);
}
public static Boolean isNotEmpty(String s) {
return !isEmpty(s);
}
public static String avoidNull(String s)
{
return StringUtil.defaultString(s);
}
public static String avoidNull(String s0, String s1)
{
return StringUtil.isEmptyTrimmed(s0) ? s1 : s0;
}
public static HashMap<String, Object> uploadInfoCreate(MultipartFile uploadFile) {
// ํ์ผ๊ด๋ จ ๋ณ์
String uploadCode = "01";
String orgFileName = "";
String destFileFullPath = "";
File destFile = null;
// ๋ฐํํ map ์ ์ธ
HashMap<String, Object> resultMap = new HashMap<String, Object>();
// ํ์ผ null ์ฒดํฌ
if (uploadFile != null && uploadFile.getSize() > 0){
// STEP 1 : ๋๋ ํ ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ์ ํ๊ณ ๋๋ ํ ๋ฆฌ๋ฅผ ๋ง๋ ๋ค.
String thisDate = DateUtil.getCurrentDateTime("yyyy-MM-dd-hh-mm-ss");
String[] thisDateSplit = thisDate.split("\\-");
String year = thisDateSplit[0];
String month = thisDateSplit[1];
String day = thisDateSplit[2];
String hour = thisDateSplit[3];
String minute = thisDateSplit[4];
String second = thisDateSplit[5];
// STEP 1.2 : ํ์ผ์ ๊ฒฝ๋ก๋ฅผ get
String rUploadPath = "";
// ์์ฑํ ๋๋ ํ ๋ฆฌ ๊ฒฝ๋ก ์์ฑ(๋
- ์)
rUploadPath += "attach/" +year + "/" + month;
// ํ์ฅ์ ์ถ์ถ
String fileExt = uploadFile.getOriginalFilename().substring(uploadFile.getOriginalFilename().lastIndexOf("."));
// TODO : ํ์ฅ์ ์ฒดํฌ ๋ก์ง ์ถ๊ฐ
// ์๋ณธ ํ์ผ๋ช
์ ์ ํ๋ค.
orgFileName = uploadFile.getOriginalFilename();
// ํ์ผ๋ช
์ ์ ํ๋ค.
String frontFileName = day + hour + minute + second;
String destFileName = frontFileName + "_" + UUID.randomUUID().toString();
destFileFullPath = rUploadPath + "/" + destFileName + fileExt;
// STEP 2 : ์
๋ก๋ํ full path๋ฅผ ์ ํ๋ค.
try {
//
destFile = new File(rUploadPath, destFileName+fileExt);
} catch(Exception e) {
log.error(e.getMessage(), e);
uploadCode = "00";
}
}
resultMap.put("uploadCode",uploadCode);
resultMap.put("orgFileName",orgFileName);
resultMap.put("destFileFullPath",destFileFullPath);
resultMap.put("destFile",destFile);
return resultMap;
}
public static String getMacAddressForm(String s) {
String ret = "";
String Hyphen = "-";
if (s.length() == 12) {
ret += s.substring(0, 2) + Hyphen + s.substring(2, 4) + Hyphen + s.substring(4, 6) + Hyphen + s.substring(6, 8);
ret += Hyphen + s.substring(8, 10) + Hyphen + s.substring(10, 12);
}else{
ret = "ํ์์ ๋ง์ง ์์ต๋๋ค.";
}
return ret;
}
public static Gson getGsonBuiler() {
GsonBuilder gbuilder = new GsonBuilder();
gbuilder.registerTypeAdapter(ComBean.class, new ComBeanSerializer());
return gbuilder.create();
}
public static String genOptionUsers(String authority) {
List<T2Users> users = t2UserService.getAuthorityUsers(authority);
StringBuffer stringbuffer = new StringBuffer();
for (int k = users.size(), j = 0; j < k; j++) {
T2Users user = users.get(j);
stringbuffer.append(" <option value='").append(user.getUserId()).append('\'');
stringbuffer.append(">").append(user.getUserName()).append("</option>\n");
}
return stringbuffer.toString();
}
@SuppressWarnings("unchecked")
public static boolean isAdmin() {
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
String result = "";
try{
Collection<GrantedAuthority> authorities = (Collection<GrantedAuthority>) SecurityContextHolder.getContext().getAuthentication().getAuthorities();
if (!authorities.isEmpty()){
for (GrantedAuthority authority : authorities) {
result = (authority.getAuthority()).replaceFirst(AppConstBean.SECURITY_ROLE_PREFIX, "");
break;
}
}
} catch(Exception e){}
if (auth != null && "ROLE_ADMIN".equalsIgnoreCase(result) && auth.isAuthenticated()) {
return true;
}
if (auth == null) {
return true;
}
return false;
}
@SuppressWarnings("unchecked")
public static boolean isViewer() {
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
String result = "";
try{
Collection<GrantedAuthority> authorities = (Collection<GrantedAuthority>) SecurityContextHolder.getContext().getAuthentication().getAuthorities();
if (!authorities.isEmpty()){
for (GrantedAuthority authority : authorities) {
result = (authority.getAuthority()).replaceFirst(AppConstBean.SECURITY_ROLE_PREFIX, "");
break;
}
}
} catch(Exception e){}
if (auth != null && "ROLE_VIEWER".equalsIgnoreCase(result) && auth.isAuthenticated()) {
return true;
}
return false;
}
public static String makeLicenseExpressionIdentify(List<ProjectIdentification> list) {
return makeLicenseExpressionIdentify(list, "");
}
public static String makeLicenseExpressionIdentify(List<ProjectIdentification> list, String delimiter) {
if (list == null || list.isEmpty()) {
return "";
}
List<OssLicense> licenseList = new ArrayList<>();
// ํ์ํ ์ ๋ณด๋ง ์ฌ์ค์ ํ๋ค.
for (ProjectIdentification bean : list) {
OssLicense license = new OssLicense();
license.setOssLicenseComb(bean.getOssLicenseComb());
license.setLicenseName(bean.getLicenseName());
if (!CoConstDef.FLAG_YES.equals(bean.getExcludeYn())){
license.setLicenseName(license.getLicenseName());
licenseList.add(license);
}
}
if (isEmpty(delimiter)) {
return makeLicenseExpression(licenseList);
}else {
return makeLicenseString(licenseList, delimiter);
}
}
public static String makeRecommendedLicenseString(OssMaster ossmaster, ProjectIdentification bean) {
List<ProjectIdentification> list = new ArrayList<>();
boolean dual = false;
for (OssLicense license : ossmaster.getOssLicenses()) {
ProjectIdentification prj = new ProjectIdentification();
prj.setOssLicenseComb(license.getOssLicenseComb());
prj.setLicenseType(license.getLicenseType());
prj.setLicenseName(license.getLicenseName());
list.add(prj);
if(!isEmpty(license.getOssLicenseComb()) && license.getOssLicenseComb().equals("OR")) {
dual = true;
}
}
Map<String, LicenseMaster> licenseInfo = CoCodeManager.LICENSE_INFO_UPPER;
if(dual) {
if(list.size() != 0) {
list = CommonFunction.makeLicenseExcludeYn(list);
String licenseText = CommonFunction.makeLicenseExpressionIdentify(list, ",");
if(!isEmpty(licenseText)) {
String[] recommended = licenseText.split(",");
String[] userinput = bean.getLicenseName().split(",");
List<String> recType = new ArrayList<>();
List<String> userType = new ArrayList<>();
for(String s : recommended) {
if(licenseInfo.get(s.toUpperCase()) != null){
recType.add(licenseInfo.get(s.toUpperCase()).getLicenseType());
}
}
for(String s : userinput) {
if(licenseInfo.get(s.toUpperCase()) != null) {
userType.add(licenseInfo.get(s.toUpperCase()).getLicenseType());
}
}
List<String> recTypeList = recType.stream().distinct().collect(Collectors.toList());
List<String> userTypeList = userType.stream().distinct().collect(Collectors.toList());
if(recTypeList.size() == 1 && userTypeList.size() == 1) {
if(recTypeList.get(0).equals(userTypeList.get(0))) {
return null;
}
}
int cnt = 0;
for(String s : recommended) {
for(String s2 : userinput) {
if(s.equals(s2)) {
cnt++;
}
}
}
if(cnt == 0) {
return licenseText;
}
}
}
}
return null;
}
public static String makeLicenseString(List<OssLicense> list, String delimiter) {
String result = "";
for (OssLicense bean : list) {
if (!isEmpty(result)) {
result += delimiter;
}
String licenseName = bean.getLicenseName();
if (CoCodeManager.LICENSE_INFO.containsKey(licenseName)) {
licenseName = avoidNull(CoCodeManager.LICENSE_INFO.get(licenseName).getShortIdentifier(), licenseName);
}
result += licenseName;
}
return result;
}
public static String makeLicenseExpression(List<OssLicense> list) {
return makeLicenseExpression(list, false);
}
public static String makeLicenseExpression(List<OssLicense> list, boolean htmlLinkType) {
return makeLicenseExpression(list, htmlLinkType, false);
}
public static String makeLicenseExpression(List<OssLicense> list, boolean htmlLinkType, boolean spdxConvert) {
return makeLicenseExpression(list, htmlLinkType, spdxConvert, false);
}
public static String makeLicenseExpressionMsgType(List<OssLicense> list, boolean msgType) {
return makeLicenseExpression(list, false, false, msgType);
}
public static String makeLicenseExpression(List<OssLicense> list, boolean htmlLinkType, boolean spdxConvert, boolean msgType) {
String rtnVal = "";
List<List<String>> licenseNameList = new ArrayList<>();
List<String> andLicenseList = new ArrayList<>();
boolean isFirstLicense = true;
for (OssLicense bean : list) {
if (!isFirstLicense && "OR".equals(bean.getOssLicenseComb())) {
if (!andLicenseList.isEmpty()) {
licenseNameList.add(andLicenseList);
andLicenseList = new ArrayList<>();
andLicenseList.add(bean.getLicenseName());
}
} else {
andLicenseList.add(bean.getLicenseName());
}
isFirstLicense = false;
}
if (!andLicenseList.isEmpty()) {
licenseNameList.add(andLicenseList);
}
// ์ฐ์ญ์ ์ ์ฉ ๋ฐ Short Identifier ๋ก ๋ณ๊ฒฝ
if (!licenseNameList.isEmpty()) {
for (List<String> combList : licenseNameList) {
if (!isEmpty(rtnVal)) {
rtnVal += " OR ";
}
String andStr = "";
for (String s : combList) {
if (!isEmpty(andStr)) {
if (msgType) {
andStr += ", ";
} else {
andStr += " AND ";
}
}
LicenseMaster licenseMaster = null;
if (CoCodeManager.LICENSE_INFO.containsKey(s)) {
s = avoidNull(CoCodeManager.LICENSE_INFO.get(s).getShortIdentifier(), s);
licenseMaster = CoCodeManager.LICENSE_INFO.get(s);
}
if (htmlLinkType && licenseMaster != null) {
andStr += "<a href='javascript:void(0);' class='urlLink' onclick='showLicenseText(" + licenseMaster.getLicenseId() + ");' >" + s + "</a>" ;
} else {
if (spdxConvert) {
// identifier๊ฐ ์๋ ๊ฒฝ์ฐ ๋ผ์ด์ ์ค ์ด๋ฆ์ spdx ์ฐ๋ ์ฉ์ผ๋ก ๋ณ๊ฒฝํ๋ค.
s = licenseStrToSPDXLicenseFormat(s);
}
andStr += s;
}
}
rtnVal += licenseNameList.size() > 1 ? ( combList.size() != 1 && !msgType ? ("(" + andStr + ")") : andStr ) : andStr;
}
}
return rtnVal;
}
public static String licenseStrToSPDXLicenseFormat(String licenseStr) {
if (CoCodeManager.LICENSE_INFO.containsKey(licenseStr) && isEmpty(CoCodeManager.LICENSE_INFO.get(licenseStr).getShortIdentifier())) {
licenseStr = "LicenseRef-" + licenseStr;
licenseStr = CommonFunction.removeSpecialCharacters(licenseStr, true).replaceAll("\\(", "-").replaceAll("\\)", "");
}
return licenseStr;
}
public static String makeLicenseFromFiles(OssMaster _ossBean, boolean booleanflag) {
List<String> resultList = new ArrayList<>(); // declared License
if (_ossBean != null) {
for (OssLicense license : _ossBean.getOssLicenses()) {
String licenseName = license.getLicenseName();
if (booleanflag) {
licenseName = avoidNull(CoCodeManager.LICENSE_INFO.get(licenseName).getShortIdentifier(), "LicenseRef-" + licenseName);
if (licenseName.startsWith("LicenseRef-")) {
licenseName = CommonFunction.removeSpecialCharacters(licenseName, true).replaceAll("\\(", "-").replaceAll("\\)", "");
}
}
if (!resultList.contains(licenseName)) {
resultList.add(licenseName);
}
}
List<String> detectedLicenseList = _ossBean.getDetectedLicenses(); // detected License
if (detectedLicenseList != null && detectedLicenseList.isEmpty()) {
for (String licenseName : detectedLicenseList) {
if (booleanflag) {
licenseName = avoidNull(CoCodeManager.LICENSE_INFO.get(licenseName).getShortIdentifier(), "LicenseRef-" + licenseName);
if (licenseName.startsWith("LicenseRef-")) {
licenseName = CommonFunction.removeSpecialCharacters(licenseName, true).replaceAll("\\(", "-").replaceAll("\\)", "");
}
}
if (!resultList.contains(licenseName)) {
resultList.add(licenseName);
}
}
}
}
return String.join(",", resultList);
}
public static String removeSpecialCharacters(String licenseStr, boolean convertDashFlag) {
String[] patternCheckList = new String[] {"!", "@", "#", "$", "%", "^", "&", "*", ",", "?", "\\", "\"", ":", "{", "}", "|", "<", ">", "/", "_"};
for (String pattern : patternCheckList) {
if (licenseStr.contains(pattern)) {
licenseStr = licenseStr.replaceAll(pattern, "");
}
}
if (convertDashFlag) {
String[] dashConversionPatternCheckList = new String[] {"--", " "};
for (String pattern : dashConversionPatternCheckList) {
if (licenseStr.contains(pattern)) {
licenseStr = licenseStr.replaceAll(pattern, "-");
}
}
}
return licenseStr;
}
public static List<ProjectIdentification> makeLicenseExcludeYn(List<ProjectIdentification> list){
// OR ์กฐ๊ฑด์ผ๋ก ๊ฐ list๋ก ๊ตฌ๋ถํ๋ค.
List<List<ProjectIdentification>> andCombLicenseList = new ArrayList<>();
for (ProjectIdentification bean : list) {
if (andCombLicenseList.isEmpty() || "OR".equals(bean.getOssLicenseComb())) {
andCombLicenseList.add(new ArrayList<>());
}
andCombLicenseList.get(andCombLicenseList.size()-1).add(bean);
}
// ์ต์ข
ํผ๋ฏธ์
int selectedIdx = 0;
int idx = 0;
List<Integer> permissiveListNA = new ArrayList<>();
List<Integer> permissiveListPF = new ArrayList<>();
List<Integer> permissiveListPSM = new ArrayList<>(); // ๋ฏธ์ฌ์ฉ
List<Integer> permissiveListWCP = new ArrayList<>(); // ๋ฏธ์ฌ์ฉ
List<Integer> permissiveListCP = new ArrayList<>(); // ๋ฏธ์ฌ์ฉ
String finalPermissive = null; // or ๊ธฐ์ค ๊ฐ์ฅ permissive ํ ๋ผ์ด์ ์ค๊ฐ ๋ฌด์์ธ์ง
for (List<ProjectIdentification> andList : andCombLicenseList) {
// ๊ทธ๋ฃน๋ณ ํผ๋ฏธ์
์ทจ๋
switch (getLicensePermissive(andList)) {
case CoConstDef.CD_LICENSE_TYPE_PMS:
finalPermissive = CoConstDef.CD_LICENSE_TYPE_PMS;
selectedIdx = idx;
permissiveListPSM.add(selectedIdx);
break;
case CoConstDef.CD_LICENSE_TYPE_WCP:
if (!CoConstDef.CD_LICENSE_TYPE_PMS.equals(finalPermissive)) {
finalPermissive = CoConstDef.CD_LICENSE_TYPE_WCP;
selectedIdx = idx;
permissiveListWCP.add(selectedIdx);
}
break;
case CoConstDef.CD_LICENSE_TYPE_CP:
if (!CoConstDef.CD_LICENSE_TYPE_PMS.equals(finalPermissive)
&& !CoConstDef.CD_LICENSE_TYPE_WCP.equals(finalPermissive)) {
finalPermissive = CoConstDef.CD_LICENSE_TYPE_CP;
selectedIdx = idx;
permissiveListCP.add(selectedIdx);
}
break;
case CoConstDef.CD_LICENSE_TYPE_PF:
if (!CoConstDef.CD_LICENSE_TYPE_PMS.equals(finalPermissive)
&& !CoConstDef.CD_LICENSE_TYPE_WCP.equals(finalPermissive)
&& !CoConstDef.CD_LICENSE_TYPE_CP.equals(finalPermissive)) {
finalPermissive = CoConstDef.CD_LICENSE_TYPE_PF;
selectedIdx = idx;
permissiveListPF.add(selectedIdx);
}
break;
case CoConstDef.CD_LICENSE_TYPE_NA:
if (isEmpty(finalPermissive)) {
finalPermissive = CoConstDef.CD_LICENSE_TYPE_NA;
selectedIdx = idx;
permissiveListNA.add(selectedIdx);
}
break;
}
idx++;
}
// OR ๊ธฐ์ค์ผ๋ก ๋ค์ ์กฐํฉ
idx = 0;
List<ProjectIdentification> resultList = new ArrayList<>();
boolean hasSelected = false;
for (List<ProjectIdentification> andList : andCombLicenseList) {
boolean _break = false;
for (ProjectIdentification bean : andList) {
if (hasSelected) {
bean.setExcludeYn(CoConstDef.FLAG_YES);
} else {
List<Integer> containsList = CoConstDef.CD_LICENSE_TYPE_PMS.equals(finalPermissive) ?
permissiveListPSM : CoConstDef.CD_LICENSE_TYPE_WCP.equals(finalPermissive) ?
permissiveListWCP : CoConstDef.CD_LICENSE_TYPE_CP.equals(finalPermissive) ?
permissiveListCP : CoConstDef.CD_LICENSE_TYPE_PF.equals(finalPermissive) ?
permissiveListPF : CoConstDef.CD_LICENSE_TYPE_NA.equals(finalPermissive) ?
permissiveListNA : new ArrayList<>();
if (containsList.contains(idx)) {
bean.setExcludeYn(CoConstDef.FLAG_NO);
_break = true;
} else {
bean.setExcludeYn(CoConstDef.FLAG_YES);
}
//bean.setExcludeYn(containsList.contains(idx) ? CoConstDef.FLAG_NO : CoConstDef.FLAG_YES);
}
resultList.add(bean);
}
if (_break) {
hasSelected = true;
}
idx++;
}
return resultList;
}
private static String getLicensePermissive(List<ProjectIdentification> andList) {
String rtnVal = "";
for (ProjectIdentification bean : andList) {
// ๊ฐ์ฅ Strongํ ๋ผ์ด์ ์ค๋ถํฐ case
switch (bean.getLicenseType()) {
case CoConstDef.CD_LICENSE_TYPE_NA:
rtnVal = CoConstDef.CD_LICENSE_TYPE_NA;
break;
case CoConstDef.CD_LICENSE_TYPE_PF:
if (!CoConstDef.CD_LICENSE_TYPE_NA.equals(rtnVal)) {
rtnVal = CoConstDef.CD_LICENSE_TYPE_PF;
}
break;
case CoConstDef.CD_LICENSE_TYPE_CP:
if (!CoConstDef.CD_LICENSE_TYPE_NA.equals(rtnVal)
&& !CoConstDef.CD_LICENSE_TYPE_PF.equals(rtnVal)) {
rtnVal = CoConstDef.CD_LICENSE_TYPE_CP;
}
break;
case CoConstDef.CD_LICENSE_TYPE_WCP:
if (!CoConstDef.CD_LICENSE_TYPE_NA.equals(rtnVal)
&& !CoConstDef.CD_LICENSE_TYPE_PF.equals(rtnVal)
&& !CoConstDef.CD_LICENSE_TYPE_CP.equals(rtnVal)) {
rtnVal = CoConstDef.CD_LICENSE_TYPE_WCP;
}
break;
case CoConstDef.CD_LICENSE_TYPE_PMS:
if (isEmpty(rtnVal)) {
rtnVal = CoConstDef.CD_LICENSE_TYPE_PMS;
}
break;
default:
break;
}
}
return rtnVal;
}
public static String getLicensePermissiveType(List<OssLicense> andList) {
String rtnVal = "";
for (OssLicense bean : andList) {
// ๊ฐ์ฅ Strongํ ๋ผ์ด์ ์ค๋ถํฐ case
switch (bean.getLicenseType()) {
case CoConstDef.CD_LICENSE_TYPE_CP:
rtnVal = CoConstDef.CD_LICENSE_TYPE_CP;
break;
case CoConstDef.CD_LICENSE_TYPE_WCP:
if (!CoConstDef.CD_LICENSE_TYPE_CP.equals(rtnVal)) {
rtnVal = CoConstDef.CD_LICENSE_TYPE_WCP;
}
break;
case CoConstDef.CD_LICENSE_TYPE_PMS:
if (isEmpty(rtnVal)) {
rtnVal = CoConstDef.CD_LICENSE_TYPE_PMS;
}
break;
default:
break;
}
}
return rtnVal;
}
/**
* AND ์กฐ๊ฑด์์๋ ๊ฐ์ฅ Strongํ license๋ฅผ ๊ธฐ์ค์ผ๋ก ํ๋ค. multilicense OSS ๋ฑ๋ก์ ์ฌ์ฉ
* @param andList
* @return
*/
public static OssLicense getLicensePermissiveTypeLicense(List<OssLicense> andList) {
OssLicense rtnVal = null;
String currentType = "";
boolean breakFlag = false;
if (andList != null) {
for (OssLicense bean : andList) {
// ๊ฐ์ฅ Strongํ ๋ผ์ด์ ์ค๋ถํฐ case
switch (bean.getLicenseType()) {
case CoConstDef.CD_LICENSE_TYPE_NA:
currentType = CoConstDef.CD_LICENSE_TYPE_NA;
rtnVal = bean;
breakFlag = true;
break;
case CoConstDef.CD_LICENSE_TYPE_PF:
if (!CoConstDef.CD_LICENSE_TYPE_NA.equals(currentType)) {
currentType = CoConstDef.CD_LICENSE_TYPE_PF;
rtnVal = bean;
}
break;
case CoConstDef.CD_LICENSE_TYPE_CP:
if (!CoConstDef.CD_LICENSE_TYPE_PF.equals(currentType)) {
currentType = CoConstDef.CD_LICENSE_TYPE_CP;
rtnVal = bean;
}
break;
case CoConstDef.CD_LICENSE_TYPE_WCP:
if (!CoConstDef.CD_LICENSE_TYPE_CP.equals(currentType)) {
currentType = CoConstDef.CD_LICENSE_TYPE_WCP;
rtnVal = bean;
}
break;
case CoConstDef.CD_LICENSE_TYPE_PMS:
if (isEmpty(currentType)) {
currentType = CoConstDef.CD_LICENSE_TYPE_PMS;
rtnVal = bean;
}
break;
default:
break;
}
if (breakFlag) {
break;
}
}
}
return rtnVal;
}
public static String getStringFromFile(String path) {
StringBuffer sb = new StringBuffer();
File file = new File(path);
if (file.exists() && file.isFile()) {
BufferedReader br = null;
InputStreamReader isr = null;
FileInputStream fis = null;
String temp = "";
try {
// ํ์ผ์ ์ฝ์ด๋ค์ฌ File Input ์คํธ๋ฆผ ๊ฐ์ฒด ์์ฑ
fis = new FileInputStream(file);
// File Input ์คํธ๋ฆผ ๊ฐ์ฒด๋ฅผ ์ด์ฉํด Input ์คํธ๋ฆผ ๊ฐ์ฒด๋ฅผ ์์ํ๋๋ฐ ์ธ์ฝ๋ฉ์ UTF-8๋ก ์ง์
isr = new InputStreamReader(fis, "UTF-8");
// Input ์คํธ๋ฆผ ๊ฐ์ฒด๋ฅผ ์ด์ฉํ์ฌ ๋ฒํผ๋ฅผ ์์ฑ
br = new BufferedReader(isr);
// ๋ฒํผ๋ฅผ ํ์คํ์ค ์ฝ์ด๋ค์ฌ ๋ด์ฉ ์ถ์ถ
while ( (temp = br.readLine()) != null) {
sb.append(temp).append(System.lineSeparator());
}
} catch (FileNotFoundException e) {
log.error(e.getMessage(), e);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
if (fis != null) {
try {fis.close();} catch (IOException e) {}
}
if (isr != null) {
try {isr.close();} catch (IOException e) {}
}
if (br != null) {
try {br.close();} catch (IOException e) {}
}
}
} else {
log.error("ํ์ผ์ด ์กด์ฌํ์ง ์์ต๋๋ค. path : " + path);
}
file = null;
return sb.toString();
}
public static String getStringFromFile(String path, String ignorePathStr, List<String> checkList, List<String> ignoreList) {
StringBuffer sb = new StringBuffer();
File file = new File(path);
if (file.exists() && file.isFile()) {
BufferedReader br = null;
InputStreamReader isr = null;
FileInputStream fis = null;
String temp = "";
List<String> duplicationCheckList = new ArrayList<>();
try {
// ํ์ผ์ ์ฝ์ด๋ค์ฌ File Input ์คํธ๋ฆผ ๊ฐ์ฒด ์์ฑ
fis = new FileInputStream(file);
// File Input ์คํธ๋ฆผ ๊ฐ์ฒด๋ฅผ ์ด์ฉํด Input ์คํธ๋ฆผ ๊ฐ์ฒด๋ฅผ ์์ํ๋๋ฐ ์ธ์ฝ๋ฉ์ UTF-8๋ก ์ง์
isr = new InputStreamReader(fis, "UTF-8");
// Input ์คํธ๋ฆผ ๊ฐ์ฒด๋ฅผ ์ด์ฉํ์ฌ ๋ฒํผ๋ฅผ ์์ฑ
br = new BufferedReader(isr);
// ๋ฒํผ๋ฅผ ํ์คํ์ค ์ฝ์ด๋ค์ฌ ๋ด์ฉ ์ถ์ถ
while ( (temp = br.readLine()) != null) {
if (duplicationCheckList.contains(temp.trim())) {
continue;
}
if (checkExceptionWords(temp, ignorePathStr, checkList, ignoreList)) {
sb.append(temp).append(System.lineSeparator());
}
duplicationCheckList.add(temp.trim());
}
} catch (FileNotFoundException e) {
log.error(e.getMessage(), e);
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
if (fis != null) {
try {fis.close();} catch (IOException e) {}
}
if (isr != null) {
try {isr.close();} catch (IOException e) {}
}
if (br != null) {
try {br.close();} catch (IOException e) {}
}
}
} else {
log.error("ํ์ผ์ด ์กด์ฌํ์ง ์์ต๋๋ค. path : " + path);
}
file = null;
return sb.toString();
}
private static boolean checkExceptionWords(String line, String ignorePathStr, List<String> checkList, List<String> ignoreList) {
line = line.replaceAll(ignorePathStr, "");
line = line.toUpperCase();
for (String s : ignoreList) {
if (line.replaceAll(" ", "").replaceAll("\t", "").contains(s.toUpperCase().replaceAll(" ", "").replaceAll("\t", ""))) {
return false;
}
}
for (String s : checkList) {
if (line.contains(s.toUpperCase())) {
return true;
}
}
return false;
}
public static String getFileEncode(String filePath) {
String encoding = null;
java.io.FileInputStream fis = null;
try {
byte[] buf = new byte[4096];
String fileName = filePath;
fis = new java.io.FileInputStream(fileName);
UniversalDetector detector = new UniversalDetector(null);
int nread;
while ((nread = fis.read(buf)) > 0 && !detector.isDone()) {
detector.handleData(buf, 0, nread);
}
detector.dataEnd();
encoding = detector.getDetectedCharset();
detector.reset();
} catch (Exception e) {
} finally {
if (fis != null) {
try {
fis.close();
} catch (Exception e2) {
}
}
}
return encoding;
}
public static String sortLicenseName(List<OssLicense> ossLicenses) {
List<String> l = new ArrayList<>();
if (ossLicenses != null && !ossLicenses.isEmpty()){
for (OssLicense bean : ossLicenses) {
l.add(avoidNull(bean.getLicenseId()));
}
}
Collections.sort(l);
String rtn = "";
for (String s : l) {
rtn += (!isEmpty(s) ? "|" : "") + s;
}
return rtn;
}
public static String getShortIdentify(String licenseName) {
if (CoCodeManager.LICENSE_INFO.containsKey(licenseName)) {
LicenseMaster bean = CoCodeManager.LICENSE_INFO.get(licenseName);
return !isEmpty(bean.getShortIdentifier()) ? bean.getShortIdentifier() : licenseName;
}
return licenseName;
}
public static String getLicenseIdByName(String licenseName) {
if (!isEmpty(licenseName)) {
licenseName = licenseName.trim().toUpperCase();
if (CoCodeManager.LICENSE_INFO_UPPER.containsKey(licenseName)) {
return CoCodeManager.LICENSE_INFO_UPPER.get(licenseName).getLicenseId();
}
}
return null;
}
public static String getLicenseNameById(String licenseId, String licenseName) {
if (!isEmpty(licenseId)) {
if (CoCodeManager.LICENSE_INFO_BY_ID.containsKey(licenseId)) {
LicenseMaster licenseInfo = CoCodeManager.LICENSE_INFO_BY_ID.get(licenseId);
if (licenseInfo != null) {
// short identify๋ฅผ ์ต์ฐ์
if (!isEmpty(licenseInfo.getShortIdentifier())) {
return licenseInfo.getShortIdentifier();
}
if (!isEmpty(licenseInfo.getLicenseNameTemp())) {
// ์ ์ ๋ช
์นญ์ผ๋ก ๋ณํ
return licenseInfo.getLicenseNameTemp();
}
}
}
}
return licenseName;
}
public static List<OssLicense> changeLicenseNameToShort(List<OssLicense> list) {
if (list != null) {
for (OssLicense bean : list) {
if (CoCodeManager.LICENSE_INFO.containsKey(bean.getLicenseName()) && !isEmpty(CoCodeManager.LICENSE_INFO.get(bean.getLicenseName()).getShortIdentifier())) {
bean.setLicenseName(CoCodeManager.LICENSE_INFO.get(bean.getLicenseName()).getShortIdentifier());
}
}
}
return list;
}
public static Map<String, Object> mergeGridAndReport(List<ProjectIdentification> ossComponents,
List<List<ProjectIdentification>> ossComponentsLicense, List<ProjectIdentification> addComponents, String readType) {
return makeGridDataFromReport(ossComponents, ossComponentsLicense, addComponents, null, null, readType);
}
public static Map<String, Object> convertToProjectIdentificationList(List<OssComponents> reportData, String fileSeq) {
Map<String, Object> resultMap = new HashMap<>();
List<ProjectIdentification> resultList = new ArrayList<>();
List<String> versionChangeList = new ArrayList<>(); // version ์ ๋ณด ๋ณ๊ฒฝ ์ด๋ ฅ ์ ๋ณด
List<String> versionChangeCheckList = new ArrayList<>(); // ์ค๋ณต ์ฒดํฌ์ฉ
ProjectIdentification gridBean;
ProjectIdentification gridLicenseBean;
int keyCnt = 1;
for (OssComponents bean : reportData) {
gridBean = new ProjectIdentification();
gridBean.setGridId(CoConstDef.GRID_NEWROW_DEFAULT_PREFIX+fileSeq +"f"+keyCnt++);
gridBean.setComponentId(bean.getComponentId());
gridBean.setReferenceId(bean.getReferenceId());
gridBean.setReferenceDiv(bean.getReferenceDiv());
gridBean.setOssId(bean.getOssId());
gridBean.setOssName(bean.getOssName());
// oss version์ด ์ ์ํ์ธ ๊ฒฝ์ฐ ๋ถ์๊ฒฐ๊ณผ์ ์์์ ๋ฐ๋ผ, ".0" ์ด ์ฌ๋ผ์ง๋ ๊ฒฝ์ฐ๋ฅผ ์ํด
// ๊ธฐ ๋ฑ๋ก๋ oss์ ์กด์ฌํ๋ ๊ฒฝ์ฐ ์๋์ผ๋ก .0์ ์ฑ์์ค
if (!isEmpty(bean.getOssName()) && !isEmpty(bean.getOssVersion()) && StringUtil.isNumeric(bean.getOssVersion())) {
String _test = bean.getOssName().trim() + "_" + bean.getOssVersion().trim();
String _test2 = bean.getOssName().trim() + "_" + bean.getOssVersion().trim() + ".0";
if (!CoCodeManager.OSS_INFO_UPPER.containsKey(_test.toUpperCase())
&& CoCodeManager.OSS_INFO_UPPER.containsKey(_test2.toUpperCase())) {
if (!versionChangeCheckList.contains(bean.getOssName() + "_" + bean.getOssVersion())) {
versionChangeCheckList.add(bean.getOssName() + "_" + bean.getOssVersion());
versionChangeList.add(bean.getOssName() + " : " + bean.getOssVersion() + " => " + bean.getOssVersion().trim() + ".0");
}
bean.setOssVersion(bean.getOssVersion().trim() + ".0");
}
}
gridBean.setOssVersion(bean.getOssVersion());
gridBean.setDownloadLocation(bean.getDownloadLocation().replaceAll("<[^>]*>", ""));
gridBean.setHomepage(bean.getHomepage().replaceAll("<[^>]*>", ""));
gridBean.setFilePath(bean.getFilePath());
gridBean.setExcludeYn(bean.getExcludeYn());
gridBean.setBinaryName(bean.getBinaryName());
gridBean.setBinaryNotice(bean.getBinaryNotice());
gridBean.setCustomBinaryYn(bean.getCustomBinaryYn());
gridBean.setRefPartnerId(bean.getRefPartnerId());
gridBean.setRefPrjId(bean.getRefPrjId());
gridBean.setRefComponentId(bean.getRefComponentId());
gridBean.setMergePreDiv(bean.getMergePreDiv());
gridBean.setObligationType(bean.getObligationType());
gridBean.setBatStringMatchPercentage(bean.getBatStringMatchPercentage());
gridBean.setBatPercentage(bean.getBatPercentage());
gridBean.setBatScore(bean.getBatScore());
gridBean.setLicenseDiv((bean.getOssComponentsLicense() != null && bean.getOssComponentsLicense().size() > 1) ? CoConstDef.LICENSE_DIV_MULTI : CoConstDef.LICENSE_DIV_SINGLE);
gridBean.setCopyrightText(bean.getCopyrightText());
gridBean.setComments(bean.getComments());
if (!isEmpty(bean.getOssNickName())) {
gridBean.setOssNickName(bean.getOssNickName());
}
if (!isEmpty(bean.getDependencies())) {
gridBean.setDependencies(bean.getDependencies());
}
// license
int licenseIdx = 1;
if (bean.getOssComponentsLicense() != null) {
String licenseText = "";
for (OssComponentsLicense license : bean.getOssComponentsLicense()) {
gridLicenseBean = new ProjectIdentification();
gridLicenseBean.setGridId(gridBean.getGridId() + "-" + licenseIdx++);
gridLicenseBean.setComponentLicenseId(license.getComponentLicenseId());
gridLicenseBean.setComponentId(license.getComponentId());
gridLicenseBean.setLicenseId(license.getLicenseId());
gridLicenseBean.setLicenseName(CommonFunction.getShortIdentify(license.getLicenseName()));
gridLicenseBean.setLicenseText(license.getLicenseText());
gridLicenseBean.setCopyrightText(license.getCopyrightText());
gridLicenseBean.setExcludeYn(license.getExcludeYn());
gridLicenseBean.setOssLicenseComb(license.getOssLicenseComb());
gridLicenseBean.setEditable(license.getEditable());
gridBean.addComponentLicenseList(gridLicenseBean);
if (!isEmpty(license.getLicenseText())) {
licenseText += (!isEmpty(licenseText) ? "\r\n" : "") + license.getLicenseText();
}
}
gridBean.setLicenseText(licenseText);
if (CoConstDef.LICENSE_DIV_MULTI.equals(gridBean.getLicenseDiv())) {
gridBean.setLicenseName(CommonFunction.makeLicenseExpressionIdentify(gridBean.getComponentLicenseList(), ","));
} else {
gridBean.setLicenseName(CommonFunction.makeLicenseExpressionIdentify(gridBean.getComponentLicenseList()));
}
}
resultList.add(gridBean);
}
if (!versionChangeList.isEmpty()) {
resultMap.put("versionChangeList", versionChangeList);
}
resultMap.put("resultList", resultList);
return resultMap;
}
public static Map<String, Object> makeGridDataFromReport(List<OssComponents> reportData, String fileSeq) {
return makeGridDataFromReport(null, null, reportData, fileSeq);
}
public static Map<String, Object> makeGridDataFromReport(List<ProjectIdentification> ossComponents,
List<List<ProjectIdentification>> ossComponentsLicense, List<OssComponents> reportData, String fileSeq) {
return makeGridDataFromReport(ossComponents, ossComponentsLicense, null, reportData, fileSeq, "");
}
@SuppressWarnings("unchecked")
public static Map<String, Object> makeGridDataFromReport(List<ProjectIdentification> ossComponents,
List<List<ProjectIdentification>> ossComponentsLicense, List<ProjectIdentification> addOssComponents,
List<OssComponents> reportData, String fileSeq, String readType) {
Map<String, Object> resultMap = new HashMap<>();
Map<String, Object> subMap = new HashMap<>();
ProjectIdentification gridLicenseBean;
List<ProjectIdentification> mainGridList = ossComponents != null ? ossComponents : new ArrayList<>();
// single license ์ ๊ฒฝ์ฐ ๋ฉ์ธgrid๋ก ์ฒ๋ฆฌํ๊ธฐ ๋๋ฌธ์ ๋ค์ license์ ๋ณด๋ฅผ ์์ฑํด์ค์ผํจ
for (ProjectIdentification bean : mainGridList) {
if (CoConstDef.LICENSE_DIV_SINGLE.equals(bean.getLicenseDiv())) {
gridLicenseBean = new ProjectIdentification();
gridLicenseBean.setComponentLicenseId(bean.getComponentLicenseId());
gridLicenseBean.setComponentId(bean.getComponentId());
gridLicenseBean.setLicenseId(bean.getLicenseId());
gridLicenseBean.setLicenseName(bean.getLicenseName());
gridLicenseBean.setLicenseText(bean.getLicenseText());
gridLicenseBean.setCopyrightText(bean.getCopyrightText());
gridLicenseBean.setExcludeYn(bean.getExcludeYn());
gridLicenseBean.setGridId(bean.getGridId()+"-1");
List<ProjectIdentification> licenseList = new ArrayList<>();
licenseList.add(gridLicenseBean);
subMap.put(bean.getGridId(), licenseList);
}
}
if (ossComponentsLicense != null) {
for (List<ProjectIdentification> licenseList : ossComponentsLicense) {
String gridId = licenseList.get(0).getGridId();
String key = licenseList.get(0).getGridId().split(gridId.indexOf("-") > -1 ? "-" : "_")[0];
subMap.put(key, licenseList);
}
}
if (addOssComponents != null) {
String key = "";
for (ProjectIdentification bean : addOssComponents) {
String key2 = bean.getBinaryName()+ "-" + bean.getOssName() + "-" + bean.getOssVersion();
if (key.equals(key2)) {
ProjectIdentification result = mainGridList.get(mainGridList.size()-1);
result.setLicenseName(result.getLicenseName() + "," + bean.getLicenseName());
mainGridList.set(mainGridList.size()-1, result);
} else {
bean.setLicenseName(CommonFunction.makeLicenseExpressionIdentify(bean.getComponentLicenseList(), ","));
mainGridList.add(bean);
key = key2;
}
if (bean.getComponentLicenseList() != null) {
subMap.put(bean.getGridId(), bean.getComponentLicenseList());
}
}
}
if (reportData != null) {
Map<String, Object> convertObj = convertToProjectIdentificationList(reportData, fileSeq);
List<ProjectIdentification> _list = (List<ProjectIdentification>) convertObj.get("resultList");
if (_list != null) {
Map<String, ProjectIdentification> sortMap = new TreeMap<String, ProjectIdentification>();
for (ProjectIdentification gridBean : _list) { // ์ค๋ณต์ ๊ฑฐ ๋ฐ ์ ๋ ฌ
String key = "";
if ("BIN".equals(readType.toUpperCase()) || "BINANDROID".equals(readType.toUpperCase()) || "PARTNER".equals(readType.toUpperCase())) {
if (!isEmpty(gridBean.getFilePath()) && isEmpty(gridBean.getBinaryName())) {
gridBean.setBinaryName(gridBean.getFilePath());
}
key = gridBean.getBinaryName() + "-" + gridBean.getOssName() + "-" + gridBean.getOssVersion() + "-" + gridBean.getLicenseName() + "-"
+ gridBean.getDownloadLocation() + "-" + gridBean.getHomepage() + "-" + gridBean.getCopyrightText() + "-" + gridBean.getExcludeYn();
}else {
if (isEmpty(gridBean.getFilePath()) && !isEmpty(gridBean.getBinaryName())) {
gridBean.setFilePath(gridBean.getBinaryName());
}
key = gridBean.getFilePath() + "-" + gridBean.getOssName() + "-" + gridBean.getOssVersion() + "-" + gridBean.getLicenseName() + "-"
+ gridBean.getDownloadLocation() + "-" + gridBean.getHomepage() + "-" + gridBean.getCopyrightText() + "-" + gridBean.getExcludeYn();
}
if (!sortMap.keySet().contains(key)) {
List<ProjectIdentification> resultLicenseList = new ArrayList<ProjectIdentification>();
List<String> duplicateLicense = new ArrayList<String>();
if (gridBean.getComponentLicenseList() != null) {
for (ProjectIdentification licenseList : gridBean.getComponentLicenseList()) {
if (licenseList.getLicenseName().contains(",")){
ProjectIdentification copyLicenseList = null;
String[] licenses = licenseList.getLicenseName().split(",");
for (String li : licenses) {
if (!duplicateLicense.contains(StringUtil.trim(li).toUpperCase())) {
try {
copyLicenseList = licenseList.copy();
copyLicenseList.setLicenseName(StringUtil.trim(li));
resultLicenseList.add(copyLicenseList);
duplicateLicense.add(licenseList.getLicenseName());
} catch (CloneNotSupportedException e) {
log.error(e.getMessage());
}
}
}
}else {
if (!duplicateLicense.contains(licenseList.getLicenseName()) && CoConstDef.FLAG_NO.equals(avoidNull(licenseList.getExcludeYn(), CoConstDef.FLAG_NO))) {
resultLicenseList.add(licenseList);
duplicateLicense.add(StringUtil.trim(licenseList.getLicenseName()).toUpperCase());
}
}
}
}
gridBean.setComponentLicenseList(resultLicenseList);
sortMap.put(key, gridBean);
}
}
String key = "";
String key3 = "";
for (ProjectIdentification gridBean : sortMap.values()) {
LicenseMaster licenseMaster = CoCodeManager.LICENSE_INFO.get(gridBean.getLicenseName());
String ossName = isEmpty(gridBean.getOssName()) ? "-" : gridBean.getOssName();
String key2 = "";
String key4 = ossName + "-" + (licenseMaster != null ? licenseMaster.getLicenseType() : "");
String gridId = "";
if ("BIN".equals(readType.toUpperCase()) || "BINANDROID".equals(readType.toUpperCase()) || "PARTNER".equals(readType.toUpperCase())) {
key2 = gridBean.getBinaryName() + "-" + ossName + "-" + gridBean.getOssVersion() + "-" + gridBean.getExcludeYn();
}else {
key2 = gridBean.getFilePath() + "-" + ossName + "-" + gridBean.getOssVersion() + "-" + gridBean.getExcludeYn();
}
if (!"-".equals(ossName)
&& key.equals(key2)
&& !"--NA".equals(key3)
&& !"--NA".equals(key4)) { // ๋จ, OSS Name: - ์ด๋ฉด์, License Type: Proprietary์ด ์๋ ๊ฒฝ์ฐ Row๋ฅผ ํฉ์น์ง ์์.
ProjectIdentification result = mainGridList.get(mainGridList.size()-1);
if (!result.getLicenseName().contains(StringUtil.trim(gridBean.getLicenseName()))) {
String resultLicenseName = StringUtil.trim(result.getLicenseName());
String licenseNameList = StringUtil.trim(gridBean.getLicenseName());
if (licenseNameList.contains(",")) {
for (String licensename : licenseNameList.split(",")) {
if (!resultLicenseName.contains(licensename) && !isEmpty(licensename)) {
resultLicenseName += "," + licensename;
}
}
}else {
resultLicenseName += isEmpty(licenseNameList) ? "" : ("," + licenseNameList);
}
result.setLicenseName(resultLicenseName);
mainGridList.set(mainGridList.size()-1, result);
gridId = result.getGridId();
}
}else {
mainGridList.add(gridBean);
key = key2;
key3 = key4;
}
if (gridBean.getComponentLicenseList() != null) {
if (isEmpty(gridId)) {
subMap.put(gridBean.getGridId(), gridBean.getComponentLicenseList());
}else {
List<ProjectIdentification> result = (List<ProjectIdentification>) subMap.get(gridId);
for (ProjectIdentification subData : gridBean.getComponentLicenseList()) {
for (ProjectIdentification resultData : result) {
if (!resultData.getLicenseName().equals(resultData.getLicenseName())) {
result.add(subData);
break;
}
}
}
if (result.size() > 0) {
subMap.replace(gridId, result);
}else {
subMap.replace(gridId, gridBean.getComponentLicenseList());
}
}
}
}
}
// OSC-486
// version ์ ๋ณด๊ฐ ์๋์ผ๋ก ๋ณ๊ฒฝ๋ Data ์ฒดํฌ
if (convertObj.containsKey("versionChangeList")) {
resultMap.put("versionChangedList",convertObj.get("versionChangeList"));
}
}
resultMap.put("subData", subMap);
resultMap.put("mainData", mainGridList);
return resultMap;
}
public static String makeLicenseObligationStr(String obligationChecks) {
String rtnStr = "";
if (avoidNull(obligationChecks).length() == 3) {
// ์ฐ์ ์์๊ฐ ๋์ ์์ผ๋ก
if (CoConstDef.FLAG_YES.equals(obligationChecks.substring(2))) {
rtnStr = CoCodeManager.getCodeString(CoConstDef.CD_OBLIGATION_TYPE, CoConstDef.CD_DTL_OBLIGATION_NEEDSCHECK);
} else if (CoConstDef.FLAG_YES.equals(obligationChecks.substring(1, 2))) {
rtnStr = CoCodeManager.getCodeString(CoConstDef.CD_OBLIGATION_TYPE, CoConstDef.CD_DTL_OBLIGATION_DISCLOSURE);
} else if (CoConstDef.FLAG_YES.equals(obligationChecks.substring(0, 1))) {
rtnStr = CoCodeManager.getCodeString(CoConstDef.CD_OBLIGATION_TYPE, CoConstDef.CD_DTL_OBLIGATION_NOTICE);
}
}
return rtnStr;
}
public static String makeLicenseObligationStr(String notice, String disclose, String needsCheck) {
return makeLicenseObligationStr(avoidNull(notice, CoConstDef.FLAG_NO) + avoidNull(disclose, CoConstDef.FLAG_NO) + avoidNull(needsCheck, CoConstDef.FLAG_NO));
}
public static String makeCategoryFormat(String distributeTarget, String mainCategoryCd, String subCategoryCode) {
String categoryCode = CoConstDef.CD_DTL_DISTRIBUTE_SKS.equals(avoidNull(distributeTarget, CoConstDef.CD_DTL_DISTRIBUTE_LGE)) ? CoConstDef.CD_MODEL_TYPE2 : CoConstDef.CD_MODEL_TYPE;
return CoCodeManager.getCodeString(categoryCode, mainCategoryCd) + " > " + CoCodeManager.getCodeString(CoCodeManager.getSubCodeNo(categoryCode, mainCategoryCd), subCategoryCode);
}
public static String makeCategoryFormat(String distributeTarget, String categoryCd) {
if (!isEmpty(categoryCd) && categoryCd.length() == 6) {
return makeCategoryFormat(distributeTarget, categoryCd.substring(0,3), categoryCd.substring(3));
}
return "";
}
public static boolean isSameLicense(List<OssComponentsLicense> list1,
List<OssComponentsLicense> list2) {
if (list1 == null && list2 == null) {
return false;
}
if ((list1 == null && list2 != null) || (list1 != null && list2 == null)) {
return false;
}
if (list1.size() != list2.size()) {
return false;
}
List<String> licenseNames = new ArrayList<>();
for (OssComponentsLicense bean : list1) {
LicenseMaster liMaster = CoCodeManager.LICENSE_INFO.get(bean.getLicenseName());
if (liMaster == null) {
licenseNames.add(avoidNull( bean.getLicenseName()));
} else {
licenseNames.add(liMaster.getLicenseName());
if (!isEmpty(liMaster.getShortIdentifier())) {
licenseNames.add(liMaster.getShortIdentifier());
}
if (liMaster.getLicenseNicknameList() != null && !liMaster.getLicenseNicknameList().isEmpty()) {
licenseNames.addAll(liMaster.getLicenseNicknameList());
}
}
}
for (OssComponentsLicense bean : list2) {
if (!licenseNames.contains(bean.getLicenseName())) {
return false;
}
}
return true;
}
public static Object identificationSortByValidInfo(List<ProjectIdentification> list, Map<String, String> validMap, Map<String, String> validDiffMap) {
return identificationSortByValidInfo(list, validMap, validDiffMap, null, false, false);
}
public static Object identificationSortByValidInfo(List<ProjectIdentification> list, Map<String, String> validMap, Map<String, String> validDiffMap, boolean hideObligation) {
return identificationSortByValidInfo(list, validMap, validDiffMap, null, hideObligation, false);
}
public static Object identificationSortByValidInfo(List<ProjectIdentification> list, Map<String, String> validMap, Map<String, String> validDiffMap, Map<String, String> validInfoMap, boolean hideObligation) {
return identificationSortByValidInfo(list, validMap, validDiffMap, validInfoMap, hideObligation, false);
}
public static Object identificationSortByValidInfo(List<ProjectIdentification> list, Map<String, String> validMap, Map<String, String> validDiffMap, Map<String, String> validInfoMap, boolean hideObligation, boolean RestrictionFlag) {
List<ProjectIdentification> sortList = new ArrayList<>();
List<ProjectIdentification> sortList2 = new ArrayList<>();
List<ProjectIdentification> sortListOk = new ArrayList<>();
Map<String, ProjectIdentification> sortMap = new HashMap<>();
List<String> hideObligationColumns = Arrays.asList(new String[]{"OSSNAME", "OSSVERSION", "LICENSENAME"});
// validation ๊ฒฐ๊ณผ์์ componentId๋ณ error๊ฐ ๋ฐ์ํ ์นผ๋ผ ์ ๋ณด๋ฅผ ๊ฒฉ๋ฉํ๋ค.
Map<String, List<String>> errorMap = new HashMap<>(); // error level
Map<String, List<String>> restrictionMap = new HashMap<>(); // restriction level
Map<String, List<String>> warningMap = new HashMap<>(); // warning level
Map<String, List<String>> warningVerMap = new HashMap<>(); // warning level (oss version)
Map<String, List<String>> infoBiMap = new HashMap<>(); // info level (new bianry)
Map<String, List<String>> infoModifyMap = new HashMap<>(); // info level (modified = new + tlsh > 120)
Map<String, List<String>> infoOnlyMap = new HashMap<>(); // info level
Map<String, List<String>> infoCopyrightMap = new HashMap<>(); // info level (copyright)
Map<String, String> hideObligationIdList = new HashMap<>();
if (RestrictionFlag) {
for (ProjectIdentification p : list) {
if (!StringUtil.isEmpty(p.getRestriction()) && CoConstDef.FLAG_NO.equals(p.getExcludeYn())) {
restrictionMap.put(avoidNull(p.getGridId(), p.getComponentId()), new ArrayList<String>());
}
}
}
if (validMap != null && !validMap.isEmpty()) {
for (String errKey : validMap.keySet()) {
if (errKey.indexOf(".") > -1) {
String _key = errKey.substring(errKey.indexOf(".") + 1, errKey.length());
if (errorMap.containsKey(_key)) {
List<String> _list = errorMap.get(_key);
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
errorMap.replace(_key, _list);
} else {
List<String> _list = new ArrayList<>();
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
errorMap.put(_key, _list);
}
/*
if (hideObligation) {
if (hideObligationColumns.contains(errKey.substring(0, errKey.indexOf(".")).toUpperCase())) {
// hideObligationIdList.put(_key, validMap.get(errKey));
hideObligationIdList.put(_key, getMessage("msg.project.obligation.unclear"));
}
}
*/
}
}
}
// warning message ๊ฐ ํฌํจ๋์ด ์๋ ๊ฒฝ์ฐ ์ ๋ ฌ (์ฐ์ ์์ 3) or oss version warning message "This field is required" (Priority : 4)
if (validDiffMap != null && !validDiffMap.isEmpty()) {
for (String errKey : validDiffMap.keySet()) {
if (errKey.indexOf(".") > -1) {
String msg = validDiffMap.get(errKey);
String _key = errKey.substring(errKey.indexOf(".") + 1, errKey.length());
// oss version warning message "This field is required" (Priority : 4)
if (errKey.startsWith("ossVersion") && msg.equals("This field is required.")) {
if (warningVerMap.containsKey(_key)) {
List<String> _list = warningVerMap.get(_key);
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
warningVerMap.replace(_key, _list);
} else {
List<String> _list = new ArrayList<>();
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
warningVerMap.put(_key, _list);
}
} else {// warning message ๊ฐ ํฌํจ๋์ด ์๋ ๊ฒฝ์ฐ ์ ๋ ฌ (์ฐ์ ์์ 3)
if (warningMap.containsKey(_key)) {
List<String> _list = warningMap.get(_key);
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
warningMap.replace(_key, _list);
} else {
List<String> _list = new ArrayList<>();
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
warningMap.put(_key, _list);
}
}
/*
if (hideObligation) {
if (hideObligationColumns.contains(errKey.substring(0, errKey.indexOf(".")).toUpperCase())) {
// hideObligationIdList.put(_key, validDiffMap.get(errKey));
hideObligationIdList.put(_key, getMessage("msg.project.obligation.unclear"));
}
}
*/
}
}
}
// info message๊ฐ ํฌํจ๋์ด ์๋ ๊ฒฝ์ฐ ์ ๋ ฌ (์ฐ์ ์์ 6)
if (validInfoMap != null && !validInfoMap.isEmpty()) {
for (String errKey : validInfoMap.keySet()) {
if (errKey.indexOf(".") > -1) {
String _key = errKey.substring(errKey.indexOf(".") + 1, errKey.length());
if (hideObligation) {
if (hideObligationColumns.contains(errKey.substring(0, errKey.indexOf(".")).toUpperCase())) {
// hideObligationIdList.put(_key, validInfoMap.get(errKey));
hideObligationIdList.put(_key, getMessage("msg.project.obligation.unclear"));
}
}
// info level message ์ค์์ new binary message๋ info level ์๋จ์ผ๋ก ์ ๋ ฌํ๊ธฐ ์ํด ์ฐ์ ์์ 5๋ก ๊ตฌ๋ถํ์ฌ ๊ฒฉ๋ฉํจ
if (errKey.startsWith("binaryName.") && "NEW".equalsIgnoreCase(validInfoMap.get(errKey))) {
if (infoBiMap.containsKey(_key)) {
List<String> _list = infoBiMap.get(_key);
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
infoBiMap.replace(_key, _list);
} else {
List<String> _list = new ArrayList<>();
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
infoBiMap.put(_key, _list);
}
} else if (errKey.startsWith("binaryName.") && validInfoMap.get(errKey).toUpperCase().startsWith("MODIFIED")) {
if (infoModifyMap.containsKey(_key)) {
List<String> _list = infoModifyMap.get(_key);
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
infoModifyMap.replace(_key, _list);
} else {
List<String> _list = new ArrayList<>();
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
infoModifyMap.put(_key, _list);
}
} else if (errKey.startsWith("copyrightText.") && validInfoMap.get(errKey).toUpperCase().startsWith("NOT")) {
if (infoCopyrightMap.containsKey(_key)) {
List<String> _list = infoCopyrightMap.get(_key);
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
infoCopyrightMap.replace(_key, _list);
} else {
List<String> _list = new ArrayList<>();
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
infoCopyrightMap.put(_key, _list);
}
} else {
if (infoOnlyMap.containsKey(_key)) {
List<String> _list = infoOnlyMap.get(_key);
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
infoOnlyMap.replace(_key, _list);
} else {
List<String> _list = new ArrayList<>();
_list.add(errKey.substring(0, errKey.indexOf(".")).toUpperCase());
infoOnlyMap.put(_key, _list);
}
}
}
}
}
// bom์ ๊ฒฝ์ฐ ์ฐ์ ์์๊ฐ ๋์ 1๊ฐ row๋ง sort๋์์ผ๋ก ์ทจ๊ธ
String currentGroup = "";
for (ProjectIdentification bean : list) {
// self check case only
if (hideObligation) {
if (hideObligationIdList.containsKey(bean.getGridId())) {
bean.setObligationGrayFlag(CoConstDef.FLAG_YES);
bean.setObligationMsg(hideObligationIdList.get(bean.getGridId()));
}
// Need Check license์ธ ๊ฒฝ์ฐ
else if (hasNeedCheckLicense(bean, true)) {
bean.setObligationGrayFlag(CoConstDef.FLAG_YES);
bean.setObligationMsg(getMessage("msg.info.selfcheck.include.needcheck.licnese"));
}
// ์ ํ๋ license๋ก ๋ค์ ๊ณ์ฐํด์ผํจ obligation type
else if (CoConstDef.LICENSE_DIV_MULTI.equals(bean.getLicenseDiv())) {
bean.setObligationType(CommonFunction.getObligationTypeWithSelectedLicense(bean));
}
}
if (!(!isEmpty(bean.getGroupingColumn()) && currentGroup.equals(bean.getGroupingColumn()))) {
// 0(1) : error level
if (errorMap.containsKey(avoidNull(bean.getGridId(), bean.getComponentId()))) {
//sortList.add(bean);
sortMap.put(makeValidSortKey(errorMap.get(avoidNull(bean.getGridId(), bean.getComponentId())), avoidNull(bean.getGridId(), bean.getComponentId()) , "0"), bean);
} else if (checkMultiLicenseError(errorMap, bean.getComponentLicenseList()) != null) {
String _id = checkMultiLicenseError(errorMap, bean.getComponentLicenseList());
sortMap.put(makeValidSortKey(errorMap.get(_id), _id, "0"), bean);
} else if (CoConstDef.CD_DTL_OBLIGATION_NEEDSCHECK.equals(bean.getObligationLicense())) {
sortMap.put(makeValidSortKey(new ArrayList<String>(), avoidNull(bean.getGridId(), bean.getComponentId()) , "0", bean.getObligationLicense()), bean);
}
// 2 : Restriction
else if (restrictionMap.containsKey(avoidNull(bean.getGridId(), bean.getComponentId()))) {
//sortList.add(bean);
sortMap.put(makeValidSortKey(restrictionMap.get(avoidNull(bean.getGridId(), bean.getComponentId())), avoidNull(bean.getGridId(), bean.getComponentId()) , "2"), bean);
}
// 3 : warning level
else if (warningMap.containsKey(avoidNull(bean.getGridId(), bean.getComponentId()))) {
//sortList.add(bean);
sortMap.put(makeValidSortKey(warningMap.get(avoidNull(bean.getGridId(), bean.getComponentId())), avoidNull(bean.getGridId(), bean.getComponentId()) , "3"), bean);
} else if (checkMultiLicenseError(warningMap, bean.getComponentLicenseList()) != null) {
String _id = checkMultiLicenseError(warningMap, bean.getComponentLicenseList());
sortMap.put(makeValidSortKey(warningMap.get(_id), _id, "3"), bean);
}
// 4 : warning level (oss version)
else if (warningVerMap.containsKey(avoidNull(bean.getGridId(), bean.getComponentId()))) {
//sortList.add(bean);
sortMap.put(makeValidSortKey(warningVerMap.get(avoidNull(bean.getGridId(), bean.getComponentId())), avoidNull(bean.getGridId(), bean.getComponentId()) , "4"), bean);
} else if (checkMultiLicenseError(warningVerMap, bean.getComponentLicenseList()) != null) {
String _id = checkMultiLicenseError(warningVerMap, bean.getComponentLicenseList());
sortMap.put(makeValidSortKey(warningVerMap.get(_id), _id, "4"), bean);
}
// 5 : info level (new binary)
else if (infoBiMap.containsKey(avoidNull(bean.getGridId(), bean.getComponentId()))) {
//sortList.add(bean);
sortMap.put(makeValidSortKey(infoBiMap.get(avoidNull(bean.getGridId(), bean.getComponentId())), avoidNull(bean.getGridId(), bean.getComponentId()) , "5"), bean);
} else if (checkMultiLicenseError(infoBiMap, bean.getComponentLicenseList()) != null) {
String _id = checkMultiLicenseError(infoBiMap, bean.getComponentLicenseList());
sortMap.put(makeValidSortKey(infoBiMap.get(_id), _id, "5"), bean);
}
// 6 : info level (Modified = new + tlsh > 120)
else if (infoModifyMap.containsKey(avoidNull(bean.getGridId(), bean.getComponentId()))) {
sortMap.put(makeValidSortKey(infoModifyMap.get(avoidNull(bean.getGridId(), bean.getComponentId())), avoidNull(bean.getGridId(), bean.getComponentId()) , "6"), bean);
} else if (checkMultiLicenseError(infoModifyMap, bean.getComponentLicenseList()) != null) {
String _id = checkMultiLicenseError(infoBiMap, bean.getComponentLicenseList());
sortMap.put(makeValidSortKey(infoModifyMap.get(_id), _id, "6"), bean);
}
// 7 : info level
else if (infoOnlyMap.containsKey(avoidNull(bean.getGridId(), bean.getComponentId()))) {
//sortList.add(bean);
sortMap.put(makeValidSortKey(infoOnlyMap.get(avoidNull(bean.getGridId(), bean.getComponentId())), avoidNull(bean.getGridId(), bean.getComponentId()) , "7"), bean);
} else if (checkMultiLicenseError(infoOnlyMap, bean.getComponentLicenseList()) != null) {
String _id = checkMultiLicenseError(infoOnlyMap, bean.getComponentLicenseList());
sortMap.put(makeValidSortKey(infoOnlyMap.get(_id), _id, "7"), bean);
}
// 10 : info level (copyright)
else if (infoCopyrightMap.containsKey(avoidNull(bean.getGridId(), bean.getComponentId()))) {
sortMap.put(makeValidSortKey(infoCopyrightMap.get(avoidNull(bean.getGridId(), bean.getComponentId())), avoidNull(bean.getGridId(), bean.getComponentId()) , "10"), bean);
}
else {
sortListOk.add(bean);
}
} else {
sortListOk.add(bean);
}
}
// validation ์์น๋ณ ์ฌ์ ๋ ฌ
if (!sortMap.isEmpty()) {
List<String> sortKeyList = sortMap.keySet().stream().collect(Collectors.toList());
if (sortKeyList.size() > 1) {
Collections.sort(sortKeyList, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
if (new BigDecimal(o1.split("[_]")[0]).compareTo(new BigDecimal(o2.split("[_]")[0])) > 0) {
return 1;
} else if (new BigDecimal(o1.split("[_]")[0]).compareTo(new BigDecimal(o2.split("[_]")[0])) == 0) {
return 0;
} else {
return -1;
}
}
});
}
for (String sortKey : sortKeyList) {
sortList.add(sortMap.get(sortKey));
}
}
// subGrid์์ ์ค๋ฅ๊ฐ ์๋ row
if (!sortList2.isEmpty()) {
sortList.addAll(sortList2);
}
// ์ค๋ฅ๊ฐ ์๋ row
if (!sortListOk.isEmpty()) {
sortList.addAll(sortListOk);
}
return sortList;
}
private static String getObligationTypeWithSelectedLicense(ProjectIdentification identificationBean) {
if (identificationBean != null && identificationBean.getComponentLicenseList() != null && !identificationBean.getComponentLicenseList().isEmpty()) {
// oss master์ obligation๊ณผ๋ ๋ฌ๋ฆฌ, exclude ์ด์ธ์ license๋ ๋ชจ๋ ์ ํ์ค์ธ license๋ก ํ๋จํ๋ค. (AND)
List<OssLicense> checkForObligationLicenseList = new ArrayList<>();
for (ProjectIdentification bean : identificationBean.getComponentLicenseList()) {
if (CoConstDef.FLAG_YES.equals(bean.getExcludeYn())) {
continue;
}
LicenseMaster master = CoCodeManager.LICENSE_INFO_UPPER.get(avoidNull(bean.getLicenseName()).toUpperCase());
if (master != null) {
OssLicense license = new OssLicense();
license.setLicenseName(master.getLicenseNameTemp());
license.setLicenseId(master.getLicenseId());
license.setLicenseType(master.getLicenseType());
checkForObligationLicenseList.add(license);
}
}
if (!checkForObligationLicenseList.isEmpty()) {
OssLicense obligationLicense = CommonFunction.getLicensePermissiveTypeLicense(checkForObligationLicenseList);
if (obligationLicense != null) {
// ์ ํํ license ์ค์์ ๊ฐ์ฅ Strongํ ๋ผ์ด์ ์ค์ obligation ์ค์ ์ ๋ฐ๋ผ ํ์
LicenseMaster master = CoCodeManager.LICENSE_INFO_UPPER.get(avoidNull(obligationLicense.getLicenseName()).toUpperCase());
if (master != null) {
if (CoConstDef.FLAG_YES.equals(avoidNull(master.getObligationNeedsCheckYn()))) {
return CoConstDef.CD_DTL_OBLIGATION_NEEDSCHECK;
} else if (CoConstDef.FLAG_YES.equals(avoidNull(master.getObligationDisclosingSrcYn()))) {
return CoConstDef.CD_DTL_OBLIGATION_DISCLOSURE;
} else if (CoConstDef.FLAG_YES.equals(avoidNull(master.getObligationNotificationYn()))) {
return CoConstDef.CD_DTL_OBLIGATION_NOTICE;
}
}
}
}
}
return null;
}
private static boolean hasNeedCheckLicense(ProjectIdentification bean, boolean withSelectedLicense) {
if (bean != null && bean.getComponentLicenseList() != null && !bean.getComponentLicenseList().isEmpty()) {
for (ProjectIdentification license : bean.getComponentLicenseList()) {
if (withSelectedLicense && CoConstDef.FLAG_YES.equals(license.getExcludeYn())) {
continue;
}
if (CoConstDef.CD_DTL_OBLIGATION_NEEDSCHECK.equals(license.getObligationType())) {
return true;
}
}
}
return false;
}
private static String makeValidSortKey(List<String> list, String _id, String prevSortKey, String obligationType) {
String rtn = "";
// compareArray ์์๋๋ก ์ ๋ ฌ๋๋ค.
// ์ ์๋์ง ์์ ๊ฒฝ์ฐ๋ ์ ๋ ฌ๋์์์ ์ ์ธ
String[] compareArray = new String[]{"NOTICE", "BINARYNOTICE", "BINARYNAME", "OSSNAME", "OSSVERSION", "LICENSENAME", "LICENSETEXT", "FILEPATH", "DOWNLOADLOCATION", "HOMEPAGE"};
Map<String, String> compareSortMap = new LinkedHashMap<>(); // [Identification] Auto ID message์๋ Row ์ ๋ ฌ ํ์.
int sortIdx = 0;
for (String key : compareArray) {
compareSortMap.put(key, StringUtil.leftPad(Integer.toString(sortIdx++), 2, "0") );
}
//String preSortKey = useNextSort ? "2" : "0";
String preSortKey = avoidNull(prevSortKey, "0");
boolean hasErrorCode = false;
for (String key : compareSortMap.keySet()) {
rtn += preSortKey + (list.contains(key) ? compareSortMap.get(key) : "99");
if (list.contains(key)) {
hasErrorCode = true;
}
}
// error code๊ฐ ์๊ณ , obligation type์ด need check ์ธ ๊ฒฝ์ฐ, error ์ warning ์ฌ์ด์ ํ์ํ๋ค.
if (!isEmpty(obligationType) && CoConstDef.CD_DTL_OBLIGATION_NEEDSCHECK.equals(obligationType) && !hasErrorCode) {
preSortKey = "1";
rtn = "";
for (String key : compareSortMap.keySet()) {
rtn += preSortKey + (list.contains(key) ? compareSortMap.get(key) : "99");
}
}
rtn += "_" + _id;
return rtn;
}
private static String makeValidSortKey(List<String> list, String _id, String prevSortKey) {
return makeValidSortKey(list, _id, prevSortKey, null);
}
private static String checkMultiLicenseError(Map<String, List<String>> addedIdList, List<ProjectIdentification> list) {
if (list != null) {
for (ProjectIdentification bean : list) {
if (addedIdList.containsKey(avoidNull(bean.getGridId(), bean.getComponentId()))) {
return avoidNull(bean.getGridId(), bean.getComponentId());
}
}
}
return null;
}
public static List<String> getAndroidNoticeBinaryList(String noticeContents) {
List<String> noticeBinaryList = new ArrayList<>();
// html ํ์ผ๋ด์์ binary name ์์ญ๋ง ์ฐพ๋๋ค.
Document doc = Jsoup.parse(noticeContents);
Elements binaryEmList = doc.select("div.toc ul li");
binaryEmList.addAll(doc.select("ul[class=file-list] li"));
binaryEmList.addAll(doc.select("strong"));
for (Element em : binaryEmList) {
String binaryName = em.text();
binaryName = binaryName.replaceAll("//", "/").replaceAll("\\u0000", "");
noticeBinaryList.add(binaryName);
if (binaryName.startsWith("/")) {
noticeBinaryList.add(binaryName.substring(1));
} else {
noticeBinaryList.add("/" + binaryName);
}
//if ( binaryName.equals('/')) {
//log.info("abcde---" + binaryName);
//}
// path ์ ๋ณด๋ฅผ ๋ฌด์ํ๊ณ binary ํ์ผ๋ช
๋ง ์ถ๊ฐ (binary file์ ์ฌ์ ์ ์ค๋ณต ์ ๊ฑฐ๋์ด ์ ๋ํฌํ๋ค)
noticeBinaryList.add(FilenameUtils.getName(binaryName));
if (binaryName.indexOf("/") > -1) {
noticeBinaryList.add(binaryName.substring(binaryName.lastIndexOf("/")));
noticeBinaryList.add(binaryName.substring(binaryName.lastIndexOf("/") + 1));
} else {
if (!noticeBinaryList.contains( ("/" + binaryName) )) {
noticeBinaryList.add("/" + binaryName);
}
}
}
binaryEmList = doc.select("div.file-list");
for (Element em : binaryEmList) {
String _fileStr = (em.html()).replaceAll("<br>", "\n").replaceAll("<br />", "\n").replaceAll("<br/>", "\n").replaceAll("\r\n", "\n");
for (String s : _fileStr.split("\n", -1)) {
if (isEmpty(s)) {
continue;
}
s = s.trim();
// root dir ์์ด ๊ฒฉ๋ฉ
if (s.startsWith("/")) {
noticeBinaryList.add(s.substring(1));
} else {
noticeBinaryList.add(s);
}
// root dir ํฌํจํ์ฌ ๊ฒฉ๋ฉ
noticeBinaryList.add("/" + s);
// path ์ ๋ณด๋ฅผ ๋ฌด์ํ๊ณ binary ํ์ผ๋ช
๋ง ์ถ๊ฐ (binary file์ ์ฌ์ ์ ์ค๋ณต ์ ๊ฑฐ๋์ด ์ ๋ํฌํ๋ค)
if (!s.endsWith("/") && s.indexOf("/") > -1) {
noticeBinaryList.add(s.substring(s.lastIndexOf("/")));
noticeBinaryList.add(s.substring(s.lastIndexOf("/") + 1));
}
}
}
return noticeBinaryList;
}
public static List<String> getAndroidNoticeBinaryXmlList(String url) throws Exception {
List<String> noticeBinaryList = new ArrayList<>();
Document doc = Jsoup.parse(new File(url), "UTF-8").parser(Parser.xmlParser());
Elements fileList = doc.getElementsByTag("file-name");
for (Element el : fileList) {
if (el.childNodeSize() == 0) {
continue;
}
Node node = el.childNode(0);
String nodeValue = node.toString();
nodeValue = StringUtil.avoidNull(nodeValue, "").replace("\n", "");
if (StringUtil.isEmpty(nodeValue)) {
continue;
}
noticeBinaryList.add(nodeValue);
if (nodeValue.startsWith("/")) {
noticeBinaryList.add(nodeValue.substring(1));
} else {
noticeBinaryList.add("/" + nodeValue);
}
// path ์ ๋ณด๋ฅผ ๋ฌด์ํ๊ณ binary ํ์ผ๋ช
๋ง ์ถ๊ฐ (binary file์ ์ฌ์ ์ ์ค๋ณต ์ ๊ฑฐ๋์ด ์ ๋ํฌํ๋ค)
if (nodeValue.indexOf("/") > -1) {
noticeBinaryList.add(nodeValue.substring(nodeValue.lastIndexOf("/")));
noticeBinaryList.add(nodeValue.substring(nodeValue.lastIndexOf("/") + 1));
} else {
if (!noticeBinaryList.contains( ("/" + nodeValue) )) {
noticeBinaryList.add("/" + nodeValue);
}
}
}
// DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
// //DOM ํ์๋ก๋ถํฐ ์
๋ ฅ๋ฐ์ ํ์ผ์ ํ์ฑํ๋๋ก ์์ฒญ
// DocumentBuilder db = f.newDocumentBuilder();
// org.w3c.dom.Document xmlDoc = db.parse(url);
//
// //๋ฃจํธ ์๋ฆฌ๋จผํธ ์ ๊ทผ
// org.w3c.dom.Element root = xmlDoc.getDocumentElement();
// org.w3c.dom.NodeList fileList = root.getElementsByTagName("file-name");
//
// for (int i = 0; i < fileList.getLength(); i++) {
// org.w3c.dom.Node node = fileList.item(i);
// String nodeValue = node.getNodeValue();
// noticeBinaryList.add(nodeValue);
//
// if (nodeValue.startsWith("/")) {
// noticeBinaryList.add(nodeValue.substring(1));
// } else {
// noticeBinaryList.add("/" + nodeValue);
// }
//
// // path ์ ๋ณด๋ฅผ ๋ฌด์ํ๊ณ binary ํ์ผ๋ช
๋ง ์ถ๊ฐ (binary file์ ์ฌ์ ์ ์ค๋ณต ์ ๊ฑฐ๋์ด ์ ๋ํฌํ๋ค)
// if (nodeValue.indexOf("/") > -1) {
// noticeBinaryList.add(nodeValue.substring(nodeValue.lastIndexOf("/")));
// noticeBinaryList.add(nodeValue.substring(nodeValue.lastIndexOf("/") + 1));
// } else {
// if (!noticeBinaryList.contains( ("/" + nodeValue) )) {
// noticeBinaryList.add("/" + nodeValue);
// }
// }
// }
return noticeBinaryList;
}
// TODO - ์ฌ์ฉํ๋ ๊ณณ ์์
public static String getNoticeFileContents(String noticeContents) {
// html ํ์ผ๋ด์์ binary name ์์ญ๋ง ์ฐพ๋๋ค.
Document doc = Jsoup.parse(noticeContents);
doc.select("html");
doc.select("header");
doc.select("body");
return doc.toString();
}
public static String html2text(String html) {
return Jsoup.parse(avoidNull(html)).text();
}
public static String checkObligationSelectedLicense(List<OssComponentsLicense> licenseList) {
String rtnVal = "";
if (licenseList != null) {
for (OssComponentsLicense bean : licenseList) {
if (!CoConstDef.FLAG_YES.equals(bean.getExcludeYn())) {
// ํ์ธ ๊ฐ๋ฅํ ๋ผ์ด์ ์ค ์ค์์๋ง obligation ๋์์ผ๋ก ํ๋ค.
if (CoCodeManager.LICENSE_INFO_UPPER.containsKey(avoidNull(bean.getLicenseName()).toUpperCase())) {
LicenseMaster license = CoCodeManager.LICENSE_INFO_UPPER.get(bean.getLicenseName().toUpperCase());
if (CoConstDef.FLAG_YES.equals(avoidNull(license.getObligationNeedsCheckYn()))) {
return CoConstDef.CD_DTL_OBLIGATION_NEEDSCHECK;
} else if (CoConstDef.FLAG_YES.equals(avoidNull(license.getObligationDisclosingSrcYn()))) {
rtnVal = CoConstDef.CD_DTL_OBLIGATION_DISCLOSURE;
} else if (isEmpty(rtnVal) && CoConstDef.FLAG_YES.equals(avoidNull(license.getObligationNotificationYn()))) {
rtnVal = CoConstDef.CD_DTL_OBLIGATION_NOTICE;
}
}
}
}
}
return rtnVal;
}
public static String checkObligationSelectedLicense2(List<ProjectIdentification> licenseList) {
String rtnVal = "";
if (licenseList != null) {
for (ProjectIdentification bean : licenseList) {
if (!CoConstDef.FLAG_YES.equals(bean.getExcludeYn())) {
// ํ์ธ ๊ฐ๋ฅํ ๋ผ์ด์ ์ค ์ค์์๋ง obligation ๋์์ผ๋ก ํ๋ค.
if (CoCodeManager.LICENSE_INFO_UPPER.containsKey(avoidNull(bean.getLicenseName()).toUpperCase())) {
LicenseMaster license = CoCodeManager.LICENSE_INFO_UPPER.get(bean.getLicenseName().toUpperCase());
if (CoConstDef.FLAG_YES.equals(avoidNull(license.getObligationNeedsCheckYn()))) {
return CoConstDef.CD_DTL_OBLIGATION_NEEDSCHECK;
} else if (CoConstDef.FLAG_YES.equals(avoidNull(license.getObligationDisclosingSrcYn()))) {
rtnVal = CoConstDef.CD_DTL_OBLIGATION_DISCLOSURE;
} else if (isEmpty(rtnVal) && CoConstDef.FLAG_YES.equals(avoidNull(license.getObligationNotificationYn()))) {
rtnVal = CoConstDef.CD_DTL_OBLIGATION_NOTICE;
}
}
}
}
}
return rtnVal;
}
public static String convertUrlLinkFormat(String url) {
// if (!isEmpty(url) && url.startsWith("www")) {
// return "http://" + url;
// }
return url;
}
public static String makeOssTypeStr(String ossType) {
String rtn = "";
if (!isEmpty(ossType)) {
ossType = ossType.toUpperCase();
if (ossType.indexOf("M") > -1) {
if (!isEmpty(rtn)) {
rtn += ", ";
}
rtn += "Multi";
}
if (ossType.indexOf("D") > -1) {
if (!isEmpty(rtn)) {
rtn += ", ";
}
rtn += "Dual";
}
if (ossType.indexOf("V") > -1) {
if (!isEmpty(rtn)) {
rtn += ", ";
}
rtn += "v-Diff";
}
}
return rtn;
}
public static String getMsApplicationContentType(String fileName) {
String type = "";
if (!isEmpty(fileName)) {
type = "application/octet-stream";
}
return type;
}
public static String lineReplaceToBR(String s) {
return avoidNull(s).replaceAll("\r\n", "<br>").replaceAll("\r", "<br>").replaceAll("\n", "<br>");
}
public static String brReplaceToLine(String s) {
return avoidNull(s).replaceAll("\r\n", "\n").replaceAll("<br>", "\n").replaceAll("<br />", "\n").replaceAll("<br/>", "\n").replaceAll("<br \\>", "\n").replaceAll("<br\\>", "\n");
}
public static boolean isIgnoreLicense(String licenseName) {
boolean result = false;
if (!isEmpty(CoCodeManager.CD_ROLE_OUT_LICENSE)) {
for (String license : avoidNull(licenseName).split(",")) {
for (String s : CoCodeManager.CD_ROLE_OUT_LICENSE.split("\\|")) {
if (s.trim().equalsIgnoreCase(license)) {
result = true;
break;
}
}
}
}
// license type์ด NA๊ฐ ์๋ ๋ผ์ด์ ์ค๊ฐ ํฌํจ๋์ด ์๊ฑฐ๋, Unconfirmed license์ธ ๊ฒฝ์ฐ false
if (result) {
for (String license : avoidNull(licenseName).split(",")) {
if (CoCodeManager.LICENSE_INFO_UPPER.containsKey(license.toUpperCase())) {
LicenseMaster licenseMaster = CoCodeManager.LICENSE_INFO_UPPER.get(license.toUpperCase());
if (!"NA".equalsIgnoreCase(licenseMaster.getLicenseType())) {
return false;
}
} else {
return false;
}
}
}
return result;
}
public static String htmlEscape(String s) {
if (!isEmpty(s)) {
try {
return CommonFunction.lineReplaceToBR(HtmlUtils.htmlEscape(brReplaceToLine(s)));
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
return s;
}
public static boolean isIgnoreLicense(List<OssComponentsLicense> list) {
if (list != null && !list.isEmpty()) {
return isIgnoreLicense(list.get(0));
}
return false;
}
public static boolean isIgnoreLicense(OssComponentsLicense bean) {
return isIgnoreLicense(bean.getLicenseName());
}
public static String makeSessionKey(String userName, String type, String typeId) {
return "FOSSLIGHT_SESSION_KEY_" + avoidNull(userName) + "_" + avoidNull(type) + "_" + avoidNull(typeId);
}
public static String makeSessionKey(String userName, String type, String typeId, String typeId2) {
return "FOSSLIGHT_SESSION_KEY_" + avoidNull(userName) + "_" + avoidNull(type) + "_" + avoidNull(typeId) + "_" + avoidNull(typeId2);
}
public static List<List<ProjectIdentification>> mergeGridAndSession(String sessionKey,
List<ProjectIdentification> ossComponents, List<List<ProjectIdentification>> ossComponentsLicense) {
return mergeGridAndSession(sessionKey, ossComponents, ossComponentsLicense, null);
}
@SuppressWarnings("unchecked")
public static List<List<ProjectIdentification>> mergeGridAndSession(String sessionKey,
List<ProjectIdentification> ossComponents, List<List<ProjectIdentification>> ossComponentsLicense, String reportkey) {
List<String> duplicateCheckList = new ArrayList<>();
// ๋จผ์ ์ธ์
์ ํด๋น ์ ๋ณด๊ฐ ์กด์ฌํ๋์ง ํ์ธํ๋ค.
Object sessionObj = getSessionObject(sessionKey);
Object sessionObjReport = null;
if (!isEmpty(reportkey)) {
sessionObjReport = getSessionObject(reportkey);
}
if ( (sessionObj != null || sessionObjReport != null) && ossComponents != null) {
// session์ mergeํ ์ ๋ณด๊ฐ ์กด์ฌํ๋ฉด, ์ฌ์ฉ์ ํธ์ง ์ ๋ณด์, session ์ ๋ณด๋ฅผ ๋ชจ๋ Map ํํ๋ก ๋ณํํ์ฌ ์์ grid์ ๋ณด๋ฅผ ๊ธฐ์ค์ผ๋ก merge ํ๋ค.
Map<String, List<ProjectIdentification>> subGridInfo = new HashMap<>();
Map<String, Object> sessionMap = null;
Map<String, Object> sessionMapReport = null;
if (sessionObj != null) {
sessionMap = (Map<String, Object>) sessionObj;
}
if (sessionObjReport != null) {
sessionMapReport = (Map<String, Object>) sessionObjReport;
}
if ( (sessionMap != null && sessionMap.containsKey("subData")) || (sessionMapReport != null && sessionMapReport.containsKey("subData"))) {
Map<String, List<ProjectIdentification>> subGridSessionInfo = null;
Map<String, List<ProjectIdentification>> subGridSessionInfoReport = null;
if (sessionMap != null) {
subGridSessionInfo = (Map<String, List<ProjectIdentification>>) sessionMap.get("subData");
}
if (sessionMapReport != null) {
subGridSessionInfoReport = (Map<String, List<ProjectIdentification>>) sessionMapReport.get("subData");
}
if (ossComponentsLicense != null) {
for (List<ProjectIdentification> subTables : ossComponentsLicense) {
String _key = subTables.get(0).getComponentId();
// ์ต์ด์ ์ฅ์ด๋ฉด component id๋ ์ค์ ๋์ด ์์ง ์์
// ์ด๋ฐ๊ฒฝ์ฐ๋ grid id์์ "-" ์์๋ฆฌ๋ฅผ ํค๋ก ๊ฐ์ ธ์ผํจ
if (isEmpty(_key)) {
_key = subTables.get(0).getGridId().split("-")[0];
}
subGridInfo.put(_key, subTables);
}
}
if (subGridSessionInfo != null && !subGridSessionInfo.isEmpty()) {
for (ProjectIdentification bean : ossComponents) {
// subGrid key์ ์ฃผ์ ํด์ผํจ grid id๋ก ๋งคํ
if (!duplicateCheckList.contains(bean.getGridId()) && !subGridInfo.containsKey(bean.getGridId()) && subGridSessionInfo.containsKey(bean.getGridId())) {
duplicateCheckList.add(bean.getGridId());
// multi => single๋ก ๋ณ๊ฒฝํ ๊ฒฝ์ฐ ๋์
// subGridInfo ์ ํด๋น grid id ๋ก ๊ฐ์ด ์๋ค๋ ๊ฒ์ธ single์ ์๋ฏธํ๋ค.
if (CoConstDef.LICENSE_DIV_SINGLE.equals(bean.getLicenseDiv()) && subGridSessionInfo.get(bean.getGridId()) != null && subGridSessionInfo.get(bean.getGridId()).size() > 1) {
} else {
ossComponentsLicense.add(subGridSessionInfo.get(bean.getGridId()));
}
}
}
}
if (subGridSessionInfoReport != null && !subGridSessionInfoReport.isEmpty()) {
for (ProjectIdentification bean : ossComponents) {
// subGrid key์ ์ฃผ์ ํด์ผํจ grid id๋ก ๋งคํ
if (!duplicateCheckList.contains(bean.getGridId()) && !subGridInfo.containsKey(bean.getGridId()) && subGridSessionInfoReport.containsKey(bean.getGridId())) {
duplicateCheckList.add(bean.getGridId());
ossComponentsLicense.add(subGridSessionInfoReport.get(bean.getGridId()));
}
}
}
}
}
return ossComponentsLicense;
}
public static String makeSessionReportKey(String loginUserName, String code, String prjId) {
String reportKey = null;
if (!isEmpty(code)) {
switch (code) {
case CoConstDef.CD_DTL_COMPONENT_ID_SRC:
reportKey = CoConstDef.SESSION_KEY_UPLOAD_REPORT_PROJECT_SRC;
break;
case CoConstDef.CD_DTL_COMPONENT_ID_BIN:
reportKey = CoConstDef.SESSION_KEY_UPLOAD_REPORT_PROJECT_BIN;
break;
case CoConstDef.CD_DTL_COMPONENT_ID_ANDROID:
reportKey = CoConstDef.SESSION_KEY_UPLOAD_REPORT_PROJECT_ANDROID;
break;
case CoConstDef.CD_DTL_COMPONENT_ID_BAT:
reportKey = CoConstDef.SESSION_KEY_UPLOAD_REPORT_PROJECT_BAT;
break;
case CoConstDef.CD_DTL_COMPONENT_BAT:
reportKey = CoConstDef.SESSION_KEY_UPLOAD_REPORT_BAT;
break;
case CoConstDef.CD_DTL_COMPONENT_PARTNER:
reportKey = CoConstDef.SESSION_KEY_UPLOAD_REPORT_PARTNER;
break;
default:
break;
}
}
if (!isEmpty(reportKey)) {
return makeSessionKey(loginUserName(), reportKey, prjId);
}
return null;
}
public static OssComponentsLicense reMakeLicenseBean(ProjectIdentification comLicense, String licenseDiv) {
OssComponentsLicense license = new OssComponentsLicense();
// ์ปดํฌ๋ํธ ID ์ค์
license.setComponentId(comLicense.getComponentId());
// ๋ผ์ด์ผ์ค ID ์ค์
// 2017-11-13 yuns ๋ผ์ด์ ์ค ID ๋ฐ ์ด๋ฆ์ DB๋ฅผ ๊ธฐ์ค์ผ๋ก ์ฌ์ค์ ํจ
String licenseName = comLicense.getLicenseName();
if (!isEmpty(licenseName)) {
licenseName = licenseName.replaceAll("\\<.*\\>", ""); // ์์ ์ด ๋ง์ง์์์ licenseName์ valid Message๊ฐ ํฌํจ๋์ด ์ ์ฅํ ๊ฒฝ์ฐ ์ ๊ฑฐ ํจ.
}
license.setLicenseId(CommonFunction.getLicenseIdByName(licenseName));
license.setLicenseName(CommonFunction.getLicenseNameById(license.getLicenseId(), licenseName));
// ๊ธฐํ ์ค์
//license.setLicenseName(comLicense.getLicenseName());
license.setLicenseText(comLicense.getLicenseText());
license.setCopyrightText(comLicense.getCopyrightText());
//TODO - License ExcludeYn๊ฐ์ ๋ํด์ ์ฌ์ ๊ฒํด์ผ ํจ.
if (CoConstDef.LICENSE_DIV_SINGLE.equals(licenseDiv)) {
license.setExcludeYn(CoConstDef.FLAG_NO);
}else {
license.setExcludeYn(avoidNull(comLicense.getExcludeYn(), CoConstDef.FLAG_NO));
}
return license;
}
public static List<ProjectIdentification> reMakeLicenseComponentList(List<OssLicense> list, ProjectIdentification selectedLicenseBean) {
List<ProjectIdentification> licenseList = new ArrayList<>();
String selectedLicenseName = avoidNull(selectedLicenseBean.getLicenseName());
boolean hasLicense = false;
List<String> licenseNameList = new ArrayList<String>();
for (OssLicense bean : list) {
ProjectIdentification liBean = new ProjectIdentification();
liBean.setLicenseId(bean.getLicenseId());
liBean.setOssLicenseComb(bean.getOssLicenseComb());
liBean.setLicenseName(bean.getLicenseName());
liBean.setLicenseText(selectedLicenseBean.getLicenseText());
liBean.setComponentId(selectedLicenseBean.getComponentId());
liBean.setGridId(selectedLicenseBean.getGridId());
if (bean.getLicenseName().toUpperCase().trim().equals(selectedLicenseName.toUpperCase().trim())) {
boolean isDup = false;
for (String licenseName : licenseNameList){
if (licenseName.toUpperCase().trim().equals(bean.getLicenseName().toUpperCase().trim())){
isDup = true;
}
}
if (isDup){
liBean.setExcludeYn(CoConstDef.FLAG_YES);
}else{
liBean.setExcludeYn(CoConstDef.FLAG_NO);
}
hasLicense = true;
} else {
liBean.setExcludeYn(CoConstDef.FLAG_YES);
}
licenseNameList.add(bean.getLicenseName());
licenseList.add(liBean);
}
if (!hasLicense) {
selectedLicenseBean.setOssLicenseComb("OR");
licenseList.add(selectedLicenseBean);
}
return licenseList;
}
public static List<ProjectIdentification> reMakeLicenseComponentListMultiToSingle(List<ProjectIdentification> list) {
if (list != null && !list.isEmpty()) {
List<ProjectIdentification> newLicenseList = new ArrayList<>();
for (ProjectIdentification bean : list) {
if (!CoConstDef.FLAG_YES.equals(bean.getExcludeYn())) {
if (!isEmpty(bean.getOssLicenseComb())) {
bean.setOssLicenseComb("");
}
newLicenseList.add(bean);
return newLicenseList;
}
}
}
return null;
}
@SuppressWarnings("deprecation")
public static List<String> getNoticeBinaryList(T2File noticeFile) {
List<String> noticeBinaryList = null;
if (noticeFile != null) {
noticeBinaryList = new ArrayList<>();
try {
String noticeFileName = noticeFile.getLogiNm();
String fullName = noticeFile.getLogiPath() + "/" + noticeFileName;
if ("xml".equalsIgnoreCase(FilenameUtils.getExtension(noticeFileName))) {
noticeBinaryList = CommonFunction.getAndroidNoticeBinaryXmlList(fullName);
} else {
noticeBinaryList = CommonFunction.getAndroidNoticeBinaryList(FileUtils.readFileToString(new File(fullName)));
}
} catch (Exception e) {
log.error(e.getMessage(), e);
return null;
}
}
return noticeBinaryList;
}
public static List<String> getExistsBinaryNames(T2File resultFile) {
List<String> existsBinaryName = null;
if (resultFile != null) {
existsBinaryName = new ArrayList<>();
try {
List<String> resultFileContents = FileUtils.readLines(new File(resultFile.getLogiPath() + "/" + resultFile.getLogiNm()), "UTF-8");
for (String s : resultFileContents) {
if (isEmpty(s)) {
continue;
}
if (avoidNull(s).startsWith("<Removed>")) {
} else {
String[] resultCols = s.split("\t", -1);
// 0 binary , 1 directory, 5 license
if (resultCols.length == 7) {
if (!isEmpty(resultCols[0])) {
if (!existsBinaryName.contains(resultCols[0])) {
existsBinaryName.add(resultCols[0]);
}
}
}
}
}
} catch (IOException e) {
log.error(e.getMessage(), e);
return null;
}
}
return existsBinaryName;
}
public static Map<String, Object> getAndroidResultFileInfo(T2File resultFileInfo, List<String> existsBinaryName) {
Map<String, Object> resultMap = new HashMap<>();
List<String> removedCheckList = new ArrayList<>();
List<OssComponents> addCheckList = new ArrayList<>();
List<String> existsResultTextBinaryNameList = new ArrayList<>();
OssComponents addComponent = null;
try {
List<String> resultFileContents =FileUtils.readLines(new File(resultFileInfo.getLogiPath() + "/" + resultFileInfo.getLogiNm()), "UTF-8");
boolean isFirst = true;
int idxBinaryName = -1;
int idxDirectory = -1;
int idxNoticeHtml = -1;
int idxOssName = -1;
int idxOssVersion = -1;
int idxLicense = -1;
int idxTlsh = -1;
int idxChecksum = -1;
for (String s : resultFileContents) {
if (isFirst) {
isFirst = false;
if (!isEmpty(s)) {
String[] resultCols = s.split("\t", -1);
int idx = 0;
for (String idxStr : resultCols) {
idxStr = avoidNull(idxStr).trim().toUpperCase();
switch (idxStr) {
case "BINARY NAME":
idxBinaryName = idx;
break;
case "SOURCE CODE PATH":
idxDirectory = idx;
break;
case "NOTICE.HTML":
idxNoticeHtml = idx;
break;
case "OSS NAME":
idxOssName = idx;
break;
case "OSS VERSION":
idxOssVersion = idx;
break;
case "LICENSE":
idxLicense = idx;
break;
case "TLSH":
idxTlsh = idx;
break;
case "CHECKSUM":
idxChecksum = idx;
break;
default:
break;
}
idx++;
}
}
continue;
}
if (isEmpty(s)) {
continue;
}
if (avoidNull(s).startsWith("<Removed>")) {
log.debug("Removed : " + s);
} else {
//0 binary , 1 directory, 5 license
if (idxBinaryName > -1){
String[] resultCols = s.split("\t", -1);
if (!isEmpty(resultCols[idxBinaryName])) {
/*
0:Binary/Library file
1:Directory
2:NOTICE.html
3:OSS Name
4:OSS Version
5:License
6:.mk File Path
7:
8: tlsh
9: checksum
*/
addComponent = new OssComponents();
addComponent.setBinaryName(resultCols[idxBinaryName]);
addComponent.setFilePath(resultCols[idxBinaryName]); // binary name์ ์๋ณธ ์ ๋ณด๋ฅผ ๋ฑ๋กํ๋ค.
if (idxDirectory > -1 && resultCols.length >= idxDirectory +1) {
addComponent.setSourceCodePath(resultCols[idxDirectory]);
}
if (idxNoticeHtml > -1 && resultCols.length >= idxNoticeHtml +1) {
addComponent.setBinaryNotice(resultCols[idxNoticeHtml]);
}
if (idxOssName > -1 && resultCols.length >= idxOssName +1) {
addComponent.setOssName(resultCols[idxOssName]);
}
if (idxOssVersion > -1 && resultCols.length >= idxOssVersion +1) {
addComponent.setOssVersion(resultCols[idxOssVersion]);
}
if (idxLicense > -1 && resultCols.length >= idxLicense +1) {
OssComponentsLicense license = new OssComponentsLicense();
license.setLicenseName(resultCols[idxLicense]);
addComponent.addOssComponentsLicense(license);
}
if (idxTlsh> -1 && resultCols.length >= idxTlsh +1) {
String _tlsh = avoidNull(resultCols[idxTlsh]);
if ("-".equals(_tlsh)) {
_tlsh = "0";
}
addComponent.setTlsh(_tlsh);
}
if (idxChecksum > -1 && resultCols.length >= idxChecksum +1) {
addComponent.setCheckSum(resultCols[idxChecksum]);
}
if (!existsBinaryName.contains(resultCols[idxBinaryName])) {
addCheckList.add(addComponent);
}
existsResultTextBinaryNameList.add(addComponent.getBinaryName());
}
}
}
}
resultMap.put("removedCheckList", removedCheckList);
resultMap.put("addCheckList", addCheckList);
resultMap.put("existsResultTextBinaryNameList", existsResultTextBinaryNameList);
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return resultMap;
}
public static String getLicenseUrlByName(String licenseName) {
if (CoCodeManager.LICENSE_INFO_UPPER.containsKey(avoidNull(licenseName).toUpperCase())) {
return avoidNull(CoCodeManager.LICENSE_INFO_UPPER.get(avoidNull(licenseName).toUpperCase()).getWebpage());
}
return "";
}
public static String getSelectedLicenseString(List<ProjectIdentification> list) {
String rtn = "";
if (list != null) {
for (ProjectIdentification license : list) {
if (!CoConstDef.FLAG_YES.equals(license.getExcludeYn())) {
if (!isEmpty(rtn)) {
rtn += ",";
}
rtn += license.getLicenseName();
}
}
}
return rtn;
}
public static boolean isEqualsOssMaster(OssMaster oldObject, OssMaster newObject) {
try {
BeanMap map = new BeanMap(oldObject);
PropertyUtilsBean propUtils = new PropertyUtilsBean();
for (Object propNameObject : map.keySet()) {
String propertyName = (String) propNameObject;
Object property1 = propUtils.getProperty(oldObject, propertyName);
Object property2 = propUtils.getProperty(newObject, propertyName);
if (property1 == null) {
continue;
}
if (property1.equals(property2)) {
} else {
return false;
}
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return true;
}
public static boolean isEqualsLicenseMaster(LicenseMaster oldObject, LicenseMaster newObject) {
try {
BeanMap map = new BeanMap(oldObject);
PropertyUtilsBean propUtils = new PropertyUtilsBean();
for (Object propNameObject : map.keySet()) {
String propertyName = (String) propNameObject;
Object property1 = propUtils.getProperty(oldObject, propertyName);
Object property2 = propUtils.getProperty(newObject, propertyName);
if (property1 == null) {
continue;
}
if (property1.equals(property2)) {
} else {
return false;
}
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return true;
}
public static boolean isEqualsProjectMaster(Project oldObject, Project newObject) {
try {
BeanMap map = new BeanMap(oldObject);
PropertyUtilsBean propUtils = new PropertyUtilsBean();
for (Object propNameObject : map.keySet()) {
String propertyName = (String) propNameObject;
Object property1 = propUtils.getProperty(oldObject, propertyName);
Object property2 = propUtils.getProperty(newObject, propertyName);
if (property1 == null) {
continue;
}
if (property1.equals(property2)) {
} else {
return false;
}
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
return true;
}
public static boolean existsLicenseName(List<ProjectIdentification> list) {
if (list != null) {
for (ProjectIdentification bean : list) {
// license detail ์์ด์ฝ ํ์ ์ฌ๋ถ๋ฅผ ์ํด ์ฌ๊ธฐ์ license id๋ฅผ ๊ฒ์ฆํ๋ค.
if (bean.getLicenseName() != null && CoCodeManager.LICENSE_INFO_UPPER.containsKey(avoidNull(bean.getLicenseName().toUpperCase().trim()))) {
return true;
}
}
}
return false;
}
public static String makeLicenseInternalUrl(LicenseMaster licenseMaster, boolean distributionFlag) {
if (licenseMaster != null) {
String filePath = appEnv.getProperty("internal.url.dir.path");
String licenseName = !isEmpty(licenseMaster.getShortIdentifier()) ? licenseMaster.getShortIdentifier() : !isEmpty(licenseMaster.getLicenseNameTemp()) ? licenseMaster.getLicenseNameTemp() : licenseMaster.getLicenseName();
if (!isEmpty(licenseName)) {
String fileName = licenseName.replaceAll(" ", "_").replaceAll("/", "_").replaceAll("\"", """) + ".html";
boolean DEFAULT_URL_FLAG = !CoConstDef.FLAG_YES.equals(CoCodeManager.getCodeExpString(CoConstDef.CD_SYSTEM_SETTING, CoConstDef.CD_NOTICE_INTERNAL_URL));
if (DEFAULT_URL_FLAG) {
return licenseMaster.getWebpage();
} else if (distributionFlag) {
String distributeUrl = CoCodeManager.getCodeExpString(CoConstDef.CD_DISTRIBUTE_CODE, CoConstDef.CD_DTL_DISTRIBUTE_LGE);
distributeUrl += filePath + "/" + fileName;
return distributeUrl;
} else {
String domain = licenseMaster.getDomain();
String fileUrl = domain + filePath + "/" + fileName;
return fileUrl;
}
}
}
return "";
}
public static String makeHtmlLinkTagWithText(String s) {
if (!isEmpty(s)) {
/* ์๋๊ณผ ๊ฐ์ด ์ฌ์ฉํ์ฌ๋ ๋์ง๋ง ๋ง์ฝ ์์ฑ์๊ฐ ์ง์ ํ๊ทธ๋ฅผ ์ด์ฉํ์ฌ
* ๋งํฌ๋ฅผ ๊ฑฐ๋๊ฒฝ์ฐ ๋งํฌ๊ฐ ์ด์ํ๊ฒ ์กํ๋ ๊ฒฝ์ฐ๋ฅผ ๋ง๊ธฐ์ํด
* < ๊ฐ์ ์๋๋งํฌ์์ฑ์์ ์ ์ธํ์์ต๋๋ค.
* ํ์ธํ๊ณ ์ถ์ผ์ ๋ถ์ ์๋ regex ๋ฅผ ์ฌ์ฉํด์ ๋งํฌ๋ฅผ ์์ฑํด๋ณด์ธ์
*/
//String regex = "([\\p{Alnum}]+)://([a-z0-9.\\p{Punct}\\_]+)";
String regex = "([\\p{Alnum}]+)://([a-z0-9.\\-&/%=?:@#$(),.+;~\\_]+)";
//String strHTML = "ํ๊ธ์ฌ๋ http://www.naver.com test-text";
Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(s);
return m.replaceAll("<a href='http://$2' class='urlLink2' target=_blank>http://$2</a>");
}
return s;
}
public static String checkLicenseUserGuide(List<ProjectIdentification> componentLicenseList) {
if (componentLicenseList != null) {
String guideStr = "";
for (ProjectIdentification bean : componentLicenseList) {
if (CoConstDef.FLAG_YES.equals(bean.getExcludeYn())) {
continue;
}
if (CoCodeManager.LICENSE_USER_GUIDE_LIST.contains(avoidNull(bean.getLicenseName()).toUpperCase())) {
LicenseMaster license = CoCodeManager.LICENSE_INFO_UPPER.get(bean.getLicenseName().trim().toUpperCase());
if (license != null && !isEmpty(license.getDescription())) {
if (!isEmpty(guideStr)) {
guideStr += "<br>";
}
guideStr += license.getDescription();
}
}
}
if (!isEmpty(guideStr)) {
return CommonFunction.makeHtmlLinkTagWithText(CommonFunction.lineReplaceToBR(guideStr));
}
}
return "";
}
public static String escapeToJS(String dataStr) {
return avoidNull(dataStr).replaceAll("\\", "\\\\").replaceAll("\'", "\\\'").replaceAll("\"", "\\\"").replaceAll("\r\n", "\\n").replaceAll("\n", "\\n").replaceAll("?", "\\?");
}
public static String makeValidMsgTohtml(Map<String, String> validMessageMap) {
String rtnStr = "<b>Please check your entry and try again.</b><br />";
if (validMessageMap != null) {
for (String key : validMessageMap.keySet()) {
if ("isValid".equalsIgnoreCase(key)) {
continue;
}
String msg = removeLineSeparator(validMessageMap.get(key));
if (key.indexOf(".") > -1) {
rtnStr += "<br />" + key.substring(0, key.indexOf(".")) + " : " + msg;
} else {
rtnStr += "<br />" + key + " : " + msg;
}
}
}
return rtnStr;
}
public static String makeValidMsgTohtml(Map<String, String> validMessageMap, List<ProjectIdentification> ossComponents) {
List<String> rtnStrList = new ArrayList<>();
String rtnStr = getMessage("msg.oss.check.ossName.format");
if (validMessageMap != null) {
for (String key : validMessageMap.keySet()) {
if (rtnStrList.size() == 10) {
break;
}
for (ProjectIdentification pi : ossComponents) {
if (pi.getGridId().equals(key.substring(key.indexOf(".") + 1, key.length()))) {
String replaceString = "";
if (pi.getOssName().contains(",")) {
replaceString = pi.getOssName().replace(",", ",");
}else if (pi.getOssName().contains("<")) {
replaceString = pi.getOssName().replace("<", "<");
}else if (pi.getOssName().contains(">")) {
replaceString = pi.getOssName().replace(">", ">");
}
if (!isEmpty(replaceString) && !rtnStrList.contains(replaceString)) {
rtnStrList.add(replaceString);
rtnStr += "<br />" + "- " + replaceString;
break;
}
}
}
}
}
return rtnStr;
}
public static Boolean booleanOssNameFormatForValidMsg(Map<String, String> validMessageMap) {
boolean validFlag = false;
if (validMessageMap != null) {
for (String key : validMessageMap.keySet()) {
if ("isValid".equalsIgnoreCase(key)) {
continue;
}
String msg = removeLineSeparator(validMessageMap.get(key));
if (key.indexOf(".") > -1) {
if (msg.contains("Formatting") && key.substring(0, key.indexOf(".")).equals("ossName")) {
validFlag = true;
break;
}
}
}
}
return validFlag;
}
public static String removeLineSeparator(String s) {
return avoidNull(s).replaceAll("\r\n", "").replaceAll("\n", "").replaceAll("<br>", "").replaceAll("<br/>", "").replaceAll("<br />", "");
}
@SuppressWarnings("unused")
public static Map<String, Object> remakeMutiLicenseComponents(List<ProjectIdentification> ossComponents,
List<List<ProjectIdentification>> ossComponentsLicense) {
// ๋์ ์ผ๋ก oss๋ฅผ ์ถ๊ฐํด์ผํ๋ ๊ฒฝ์ฐ
List<ProjectIdentification> ossComponentsAddList = new ArrayList<>();
int addedRowIdx = 1;
Map<String, Object> resultMap = new HashMap<>();
Map<String, List<ProjectIdentification>> licenseMap = new HashMap<>();
boolean isChanged = false;
if (ossComponents != null && ossComponentsLicense != null) {
if (ossComponentsLicense != null && !ossComponentsLicense.isEmpty()) {
for (List<ProjectIdentification> list : ossComponentsLicense) {
for (ProjectIdentification licenseBean : list) {
String componentId = isEmpty(licenseBean.getComponentId()) ? licenseBean.getGridId().split("-")[0] : licenseBean.getComponentId();
if (!isEmpty(componentId)) {
licenseMap.put(componentId, list);
break;
}
}
}
}
for (ProjectIdentification bean : ossComponents) {
//if (!"-".equals(bean.getOssName()) && !isEmpty(bean.getOssName()) && !StringUtil.contains(bean.getGridId(), CoConstDef.GRID_NEWROW_DEFAULT_PREFIX) && !isEmpty(bean.getComponentId())) {
if (!"-".equals(bean.getOssName()) && !isEmpty(bean.getOssName()) ) {
String key = bean.getOssName().toUpperCase().trim() + "_" + avoidNull(bean.getOssVersion()).trim().toUpperCase();
String componentId = isEmpty(bean.getComponentId()) ? bean.getGridId().split("-")[0] : bean.getComponentId();
if (CoCodeManager.OSS_INFO_UPPER.containsKey(key)) {
OssMaster ossMaster = CoCodeManager.OSS_INFO_UPPER.get(key);
if (CoConstDef.LICENSE_DIV_MULTI.equals(ossMaster.getLicenseDiv())) {
//boolean isDiff = false;
List<ProjectIdentification> licenseList = new ArrayList<>();
if (licenseMap.containsKey(componentId)) {
licenseList = licenseMap.get(componentId);
}
// licnese list๋ฅผ ์ฐพ๋๋ค. ์ง๊ธ์ ์ฌ์ฉํ์ง ์์ผ๋, multi => single๋ก ๋ณ๊ฒฝํ ๊ฒฝ์ฐ ์ฌ์ฉ์์
// ํด๋น license ์ ๋ณด๋ฅผ ์ ์ธํ list๋ฅผ ๋ง๋ ๋ค.
if (CoConstDef.LICENSE_DIV_SINGLE.equals(avoidNull(bean.getLicenseDiv(), CoConstDef.LICENSE_DIV_SINGLE))) {
// oss master๋ multi license์ด๊ณ , component๋ single license๋ก ์ ์๋ ๊ฒฝ์ฐ
// multi license์ ์ฒซ๋ฒ์งธ license๋ฅผ ์ ํํ ์ํ๋ก ์ ์ฉํ๋ค.
// oss master์ ํด๋น license๊ฐ ์๋ ๊ฒฝ์ฐ ๋ง์ง๋ง์ or ์กฐ๊ฑด์ผ๋ก ์ถ๊ฐํ๋ค.
ProjectIdentification paramBean = bean;
// ์๋ก๋ง๋ license list๋ฅผ ์ถ๊ฐํ๋ค.
if (StringUtil.contains(bean.getGridId(), CoConstDef.GRID_NEWROW_DEFAULT_PREFIX)){
licenseMap.put(bean.getGridId(), CommonFunction.reMakeLicenseComponentList(ossMaster.getOssLicenses(), paramBean));
}else{
licenseMap.replace(componentId, CommonFunction.reMakeLicenseComponentList(ossMaster.getOssLicenses(), paramBean));
}
bean.setLicenseDiv(CoConstDef.LICENSE_DIV_MULTI);
isChanged = true;
}
} else if (CoConstDef.LICENSE_DIV_SINGLE.equals(ossMaster.getLicenseDiv())
&& CoConstDef.LICENSE_DIV_MULTI.equals(avoidNull(bean.getLicenseDiv(), CoConstDef.LICENSE_DIV_SINGLE))) {
}
}
}
}
}
if (!ossComponentsAddList.isEmpty()) {
ossComponents.addAll(ossComponentsAddList);
}
resultMap.put("mainList", ossComponents);
if (isChanged) {
List<List<ProjectIdentification>> newOssComponentsLicense = new ArrayList<>();
for (List<ProjectIdentification> _tmp : licenseMap.values()) {
newOssComponentsLicense.add(_tmp);
}
resultMap.put("subList", newOssComponentsLicense);
} else {
resultMap.put("subList", ossComponentsLicense);
}
return resultMap;
}
//TODO : Deprecated
public static String makeSearchQuery(String schKeyword, String field) {
StringBuffer sb = new StringBuffer();
if (!isEmpty(schKeyword)) {
for (String s : schKeyword.split(" ")) {
if (!isEmpty(s)) {
if (sb.length() > 0) {
sb.append(" AND ");
}
sb.append(field + " LIKE '%"+s+"%'");
}
}
}
if (sb.length() > 0) {
sb.insert(0, " (");
sb.append(") ");
}
return sb.toString();
}
public static void setOssDownloadLocation(List<Map<String, Object>> binaryList) {
for (Map<String, Object> binaryMap : binaryList) {
String ossName = "";
String ossVersion = "";
String downloadlocation = "";
if (binaryMap.containsKey("ossName")) {
ossName = (String) binaryMap.get("ossName");
if (binaryMap.containsKey("ossVersion")) {
ossVersion = (String) binaryMap.get("ossVersion");
}
String key = (ossName + "_" + avoidNull(ossVersion)).toUpperCase();
if (CoCodeManager.OSS_INFO_UPPER.containsKey(key)){
downloadlocation = avoidNull(CoCodeManager.OSS_INFO_UPPER.get( (ossName + "_" + avoidNull(ossVersion)).toUpperCase() ).getDownloadLocation());
}
}
binaryMap.put("downloadlocation", downloadlocation);
}
}
public static String getPlatformName(String str) {
if (!isEmpty(str)) {
String arr[] = str.trim().split(" ");
if (arr.length > 1) {
String version = arr[arr.length -1];
if (StringUtil.isFormattedString(version, "[\\.0-9]+")) {
String _temp = "";
for (int i=0; i<arr.length -1; i++) {
if (!isEmpty(_temp)) {
_temp += " ";
}
_temp += arr[i];
}
str = _temp.trim();
}
}
}
return str;
}
public static String getPlatformVersion(String str) {
if (!isEmpty(str)) {
String arr[] = str.trim().split(" ");
if (arr.length > 1) {
String version = arr[arr.length -1];
if (StringUtil.isFormattedString(version, "[\\.0-9]+")) {
return version.trim();
}
}
}
return "";
}
@SuppressWarnings("unused")
public static String getObligationTypeWithAndLicense(List<OssLicense> andlicenseGroup) {
if (andlicenseGroup != null) {
boolean sourceCode = false;
boolean notice = false;
boolean needcheck = false;
for (OssLicense bean : andlicenseGroup) {
LicenseMaster license = CoCodeManager.LICENSE_INFO_BY_ID.get(bean.getLicenseId());
if (license != null) {
if (CoConstDef.FLAG_YES.equals(avoidNull(license.getObligationDisclosingSrcYn()))) {
sourceCode = true;
}
if (CoConstDef.FLAG_YES.equals(avoidNull(license.getObligationNotificationYn()))) {
notice = true;
}
}
}
if (sourceCode) {
return CoConstDef.CD_DTL_OBLIGATION_DISCLOSURE;
} else if (notice) {
return CoConstDef.CD_DTL_OBLIGATION_NOTICE;
}
}
return "";
}
@SuppressWarnings("unused")
public static List<String> getBinaryListBinBinaryTxt(T2File binaryTextFile) {
List<String> binaryList = Lists.newArrayList();
if (binaryTextFile != null) {
try {
List<String> resultFileContents =FileUtils.readLines(new File(binaryTextFile.getLogiPath() + "/" + binaryTextFile.getLogiNm()), "UTF-8");
boolean isFirst = true;
int idxBinaryName = -1;
int idxTlsh = -1;
int idxChecksum = -1;
for (String s : resultFileContents) {
if (isFirst) {
isFirst = false;
if (!isEmpty(s)) {
String[] resultCols = s.split("\t", -1);
int idx = 0;
for (String idxStr : resultCols) {
idxStr = avoidNull(idxStr).trim().toUpperCase();
switch (idxStr) {
case "BINARY NAME":
case "BINARY":
idxBinaryName = idx;
break;
case "TLSH":
idxTlsh = idx;
break;
case "CHECKSUM":
case "SHA1SUM":
idxChecksum = idx;
break;
default:
break;
}
idx++;
}
}
continue;
}
if (isEmpty(s)) {
continue;
}
//0 binary , 1 directory, 5 license
if (idxBinaryName > -1){
String[] resultCols = s.split("\t", -1);
if (!isEmpty(resultCols[idxBinaryName])) {
/*
0:Binary/Library file
1: checksum
2: tlsh
*/
binaryList.add(resultCols[idxBinaryName]);
}
}
}
} catch (Exception e) {
log.error(e.getMessage(), e);
}
}
return binaryList;
}
public static String setLicenseRestrictionList(List<ProjectIdentification> componentLicenseList) {
String returnStr = "";
if (componentLicenseList != null) {
String restrictionStr = "";
for (ProjectIdentification bean : componentLicenseList) {
if (bean.getLicenseName() != null) {
LicenseMaster license = CoCodeManager.LICENSE_INFO_UPPER.get(bean.getLicenseName().trim().toUpperCase());
if (license != null && !isEmpty(license.getRestriction()) && !CoConstDef.FLAG_YES.equals(bean.getExcludeYn())) {
restrictionStr += (isEmpty(restrictionStr)?"":",") + license.getRestriction();
}
}
}
String restrictionArr[] = restrictionStr.split(",");
List<String> restrictionList = new ArrayList<>();
List<String> distinctList = new ArrayList<String>();
// String ๋ฐฐ์ด -> String ๋ฆฌ์คํธ
for (int i = 0 ; i < restrictionArr.length ; i++){
restrictionList.add(restrictionArr[i]);
}
// ์ค๋ณต ์ ๊ฑฐ
for (String str : restrictionList){
if (!distinctList.contains(str)) {
distinctList.add(str);
}
}
for (String str : distinctList){
returnStr += (isEmpty(returnStr)?"":"\n") + CoCodeManager.getCodeString(CoConstDef.CD_LICENSE_RESTRICTION, str.trim().toUpperCase());
}
}
return returnStr;
}
@SuppressWarnings("unused")
public static String setLicenseRestrictionList(String restrictionStr) {
String returnStr = "";
if (!isEmpty(restrictionStr)) {
String restrictionArr[] = restrictionStr.split(",");
List<String> restrictionList = new ArrayList<>();
List<String> distinctList = new ArrayList<String>();
// String ๋ฐฐ์ด -> String ๋ฆฌ์คํธ
for (int i = 0 ; i < restrictionArr.length ; i++){
restrictionList.add(restrictionArr[i]);
}
for (String str : restrictionList){
returnStr += (isEmpty(returnStr)?"":"\n") + CoCodeManager.getCodeString(CoConstDef.CD_LICENSE_RESTRICTION, str.trim().toUpperCase());
}
}
return returnStr;
}
public static String setLicenseRestrictionListById(String licenseIdStr) {
String returnStr = "";
if (licenseIdStr != null) {
String restrictionStr = "";
String licenseIdArr[] = licenseIdStr.split(",");
for (int i = 0 ; i < licenseIdArr.length ; i++) {
LicenseMaster license = CoCodeManager.LICENSE_INFO_BY_ID.get(licenseIdArr[i]);
if (license != null && !isEmpty(license.getRestriction())) {
restrictionStr += (isEmpty(restrictionStr)?"":",") + license.getRestriction();
}
}
String restrictionArr[] = restrictionStr.split(",");
List<String> restrictionList = new ArrayList<>();
List<String> distinctList = new ArrayList<String>();
// String ๋ฐฐ์ด -> String ๋ฆฌ์คํธ
for (int i = 0 ; i < restrictionArr.length ; i++){
restrictionList.add(restrictionArr[i]);
}
// ์ค๋ณต ์ ๊ฑฐ
for (String str : restrictionList){
if (!distinctList.contains(str)) {
distinctList.add(str);
}
}
for (String str : distinctList){
returnStr += (isEmpty(returnStr)?"":"\n") + CoCodeManager.getCodeString(CoConstDef.CD_LICENSE_RESTRICTION, str.trim().toUpperCase());
}
}
return returnStr;
}
public static String getFilterToString(String filters) {
return getFilterToString(filters, null);
}
public static String getFilterToString(String filters, Map<String, String> ambiguousInfo) {
return getFilterToString(filters, ambiguousInfo, null);
}
public static String getFilterToString(String filters, Map<String, String> ambiguousInfo, Map<String, String> exceptionMap) {
return getFilterToString(filters, ambiguousInfo, exceptionMap, false);
}
@SuppressWarnings("unchecked")
public static String getFilterToString(String filters, Map<String, String> ambiguousInfo, Map<String, String> exceptionMap, boolean upperFlag) {
if (ambiguousInfo == null) {
ambiguousInfo = new HashMap<>();
}
String filterCondition = "";
String[] dateField = {"creationDate", "publDate", "modiDate", "regDt"};
if (exceptionMap == null) {
exceptionMap = new HashMap<>();
}
exceptionMap.put("copyrighttext", "copyright");
List<String> numberFormatColumns = new ArrayList<>();
numberFormatColumns.add("CVSS_SCORE");
if (!isEmpty(filters)) {
Type collectionType1 = new TypeToken<Map<String, Object>>() {}.getType();
Map<String, Object> filtersMap = (Map<String, Object>) fromJson(filters, collectionType1);
if (filters != null && filtersMap.containsKey("rules")) {
for (Map<String, String> ruleMap : (List<LinkedTreeMap<String, String>>)filtersMap.get("rules")) {
String field = ruleMap.get("field");
String op = ruleMap.get("op");
String data = ruleMap.get("data");
String startCondition = "";
String endCondition = "";
boolean isNumberFormat = numberFormatColumns.contains(StringUtil.convertToUnderScore(field).toUpperCase());
if (!isEmpty(field) && !isEmpty(data)) {
for ( String key : exceptionMap.keySet() ){
if (field.equalsIgnoreCase(key)) {
field = exceptionMap.get(key);
}
}
boolean dateB = false;
for (String dateF : dateField) {
if (field.equalsIgnoreCase(dateF)) {
dateB = true;
}
}
switch(op) {
case "eq":
if (!isNumberFormat) {
if (upperFlag){
startCondition = " = UPPER('";
endCondition = "')";
}else {
startCondition = " = '";
endCondition = "'";
}
} else {
startCondition = " = ";
}
break;
case "ne":
if (!isNumberFormat) {
startCondition = " <> '";
endCondition = "'";
} else {
startCondition = " <> ";
}
break;
case "bw":
startCondition = " LIKE '";
endCondition = "%'";
break;
case "bn":
startCondition = " NOT LIKE '";
endCondition = "%'";
break;
case "ew":
startCondition = " LIKE '%";
endCondition = "'";
break;
case "en":
startCondition = " NOT LIKE '%";
endCondition = "'";
break;
case "cn":
if (upperFlag){
startCondition = " LIKE UPPER('%";
endCondition = "%')";
}else{
startCondition = " LIKE '%";
endCondition = "%'";
}
break;
case "nc":
startCondition = " NOT LIKE '%";
endCondition = "%'";
break;
case "lt":
if (!isNumberFormat) {
startCondition = " < '";
endCondition = "'";
} else {
startCondition = " < ";
}
break;
case "le":
if (!isNumberFormat) {
startCondition = " <= '";
endCondition = "'";
} else {
startCondition = " <= ";
}
break;
case "gt":
if (!isNumberFormat) {
startCondition = " > '";
endCondition = "'";
} else {
startCondition = " > ";
}
break;
case "ge":
if (!isNumberFormat) {
startCondition = " >= '";
endCondition = "'";
} else {
startCondition = " >= ";
}
break;
default:
if (dateB) {
startCondition = " = '";
endCondition = "'";
}else{
startCondition = " LIKE '%";
endCondition = "%'";
}
break;
}
if (!upperFlag){
field = StringUtil.convertToUnderScore(field).toUpperCase();
}
if (ambiguousInfo.containsKey(field) && !isEmpty(ambiguousInfo.get(field))) {
field = ambiguousInfo.get(field) + "." + field;
}
// ์์ธ์กฐ๊ฑด
if (dateB) {
filterCondition += " AND " + "DATE_FORMAT(" + field + ", '%Y-%m-%d') " + startCondition + CommonFunction.formatDateSimple(data) + endCondition;
} else {
filterCondition += " AND " + field + startCondition + data + endCondition;
}
}
}
}
}
return filterCondition;
}
public static List<ProjectIdentification> replaceOssVersionNA(List<ProjectIdentification> obj) {
if (obj != null) {
for (ProjectIdentification bean : obj) {
if ("N/A".equals(bean.getOssVersion())) {
bean.setOssVersion("");
}
}
}
return obj;
}
public static ProjectIdentification findOssIdAndName(ProjectIdentification bean) {
if (bean != null && !isEmpty(bean.getOssName())) {
if ("N/A".equals(bean.getOssVersion())) {
bean.setOssVersion("");
}
String findKey = (bean.getOssName().trim() +"_" + avoidNull(bean.getOssVersion()).trim()).toUpperCase();
OssMaster masterBean = CoCodeManager.OSS_INFO_UPPER.get(findKey);
if (masterBean != null) {
bean.setOssId(masterBean.getOssId());
bean.setOssName(masterBean.getOssName());
}
}
return bean;
}
public static OssComponentsLicense findLicenseIdAndName(OssComponentsLicense bean) {
return null;
}
public static List<OssComponentsLicense> findOssLicenseIdAndName(String ossId,
List<OssComponentsLicense> ossComponentsLicenseList) {
// ๋จผ์ license Id๋ ์ฐพ์์ ์์ผ๋ฉด ๋ชจ๋ ์ค์ ํ๋ค.
if (ossComponentsLicenseList != null) {
for (OssComponentsLicense licenseBean : ossComponentsLicenseList) {
LicenseMaster licenseMaster = CoCodeManager.LICENSE_INFO_UPPER.get(avoidNull(licenseBean.getLicenseName(), "").trim().toUpperCase());
if (licenseMaster != null) {
licenseBean.setLicenseId(licenseMaster.getLicenseId());
licenseBean.setLicenseName(avoidNull(licenseMaster.getShortIdentifier(),licenseMaster.getLicenseName()));
// OSS_LICENSE ์ ์ค์ ๊ฐ์ด ์๋ ๊ฒฝ์ฐ ์ฐ์ ์ผ๋ก ์ค์ ํ์ง๋ง, ์๋ ๊ฒฝ์ฐ license master๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค์ ํ๊ธฐ ๋๋ฌธ์ ์ผ๋จ ์ฌ๊ธฐ์๋ master๊ธฐ์ค์ผ๋ก ์ค์
licenseBean.setLicenseText(licenseMaster.getLicenseText());
}
}
}
// oss์์ ์ถ๊ฐ์ค์ ํ license text ๋ฐ oss copyright ์ค์
if (!isEmpty(ossId)) {
OssMaster ossMaster = CoCodeManager.OSS_INFO_BY_ID.get(ossId);
if (ossMaster != null) {
// oss master์ ๋ฑ๋ก๋ licnese์์ ๊ธฐ์ค์ผ๋ก ์ฐพ๋๋ค (๊ธฐ๋ณธ์ ์ผ๋ก size๊ฐ ์ผ์น ํด์ผํจ, multi dual license์ ๊ฒฝ์ฐ)
int idx=0;
for (OssLicense ossLicense : ossMaster.getOssLicenses()) {
if (ossComponentsLicenseList != null
&&ossComponentsLicenseList.size() >= idx+1
&& ossLicense.getLicenseId().equals(ossComponentsLicenseList.get(idx).getLicenseId())) {
// license text
// oss_license์ ์กด์ฌํ๋ ๊ฒฝ์ฐ๋ง ์ค์
if (!isEmpty(ossLicense.getOssLicenseText())) {
ossComponentsLicenseList.get(idx).setLicenseText(ossLicense.getOssLicenseText());
}
// oss copyright
if (!isEmpty(ossLicense.getOssCopyright())) {
ossComponentsLicenseList.get(idx).setCopyrightText(ossLicense.getOssCopyright());
}
}
idx++;
}
}
}
return ossComponentsLicenseList;
}
public static List<List<ProjectIdentification>> setOssComponentLicense(List<ProjectIdentification> ossComponent) {
return setOssComponentLicense(ossComponent, false);
}
public static List<List<ProjectIdentification>> setOssComponentLicense(List<ProjectIdentification> ossComponent, boolean excludeFlag) {
List<List<ProjectIdentification>> ossComponentLicense = new ArrayList<List<ProjectIdentification>>();
for (ProjectIdentification pi : ossComponent) {
if (excludeFlag && CoConstDef.FLAG_YES.equals(pi.getExcludeYn()) && isEmpty(pi.getLicenseName())) {
continue;
}
String convertLicenseName = pi.getLicenseName();
if (convertLicenseName != null && convertLicenseName.contains("\n")) { // ์ฌ์ฉ์๊ฐ oss-report๋ฅผ ํตํด license ์ ๋ณด๋ฅผ ์
๋ ฅํ ๊ฒฝ์ฐ ๊ฐํ์ด ์์ case๊ฐ ์กด์ฌํ์ฌ ์ถ๊ฐํจ.
pi.setLicenseName(convertLicenseName.replace("\n", " "));
}
if (StringUtil.isEmpty(pi.getComponentId()) && StringUtil.contains(pi.getGridId(), CoConstDef.GRID_NEWROW_DEFAULT_PREFIX)) {
List<ProjectIdentification> licenseList = new ArrayList<ProjectIdentification>();
if (pi.getLicenseName().contains(",")) {
List<String> licenseNames = Arrays.asList(pi.getLicenseName().split(","));
pi.setLicenseDiv("M");
for (String nm : licenseNames) {
ProjectIdentification license = new ProjectIdentification();
nm = nm.trim(); // license ์ ๋ณด๋ฅผ ์
๋ ฅํ ๋ license ์ ๋ณด trim ์ฒ๋ฆฌํจ.
license.setGridId(pi.getGridId());
license.setExcludeYn(CoConstDef.FLAG_NO);
if (CoCodeManager.LICENSE_INFO_UPPER.containsKey(nm.toUpperCase())) {
LicenseMaster licenseMaster = CoCodeManager.LICENSE_INFO_UPPER.get(nm.toUpperCase());
license.setLicenseId(licenseMaster.getLicenseId());
license.setLicenseName(avoidNull(licenseMaster.getShortIdentifier(), licenseMaster.getLicenseNameTemp()));
} else {
license.setLicenseId("");
license.setLicenseName(nm);
}
licenseList.add(license);
}
} else {
licenseList.add(pi);
}
ossComponentLicense.add(licenseList);
} else {
List<ProjectIdentification> licenseList = new ArrayList<ProjectIdentification>();
if (pi.getLicenseName() != null && pi.getLicenseName().contains(",")) {
List<String> licenseNames = Arrays.asList(pi.getLicenseName().split(","));
pi.setLicenseDiv("M");
for (String nm : licenseNames) {
ProjectIdentification license = new ProjectIdentification();
nm = nm.trim(); // license ์ ๋ณด๋ฅผ ์
๋ ฅํ ๋ license ์ ๋ณด trim ์ฒ๋ฆฌํจ.
license.setComponentId(pi.getComponentId());
license.setGridId(pi.getGridId()+"-");
license.setExcludeYn(CoConstDef.FLAG_NO);
if (CoCodeManager.LICENSE_INFO_UPPER.containsKey(nm.toUpperCase())) {
LicenseMaster licenseMaster = CoCodeManager.LICENSE_INFO_UPPER.get(nm.toUpperCase());
license.setLicenseId(licenseMaster.getLicenseId());
license.setLicenseName(avoidNull(licenseMaster.getShortIdentifier(), licenseMaster.getLicenseNameTemp()));
} else {
license.setLicenseId("");
license.setLicenseName(nm);
}
licenseList.add(license);
}
} else {
licenseList.add(pi);
}
ossComponentLicense.add(licenseList);
}
}
return ossComponentLicense;
}
public static boolean checkLicense(String licenseName) {
String[] result = licenseName.split(",");
boolean resultBoolean = true;
for (String name : result) {
if (!CoCodeManager.LICENSE_INFO_UPPER.containsKey(name.toUpperCase())) {
resultBoolean = false;
break;
}
}
return resultBoolean;
}
public static T2CoValidationResult getAnalysisValidation(Map<String, Object> map, List<OssAnalysis> list){
T2CoOssValidator validator = new T2CoOssValidator();
validator.setAppendix("analysisList", list);
validator.setVALIDATION_TYPE(validator.VALID_OSSANALYSIS_LIST);
T2CoValidationResult vr = validator.validate(new HashMap<>());
Map<String, String> validMap = vr.getValidMessageMap();
Map<String, String> diffMap = vr.getDiffMessageMap();
map.put("validMap", validMap);
map.put("diffMap", diffMap);
return vr;
}
@SuppressWarnings("unchecked")
public static void setAnalysisResultList(Map<String, Object> map) {
List<OssAnalysis> analysisResultList = (List<OssAnalysis>) map.get("rows");
List<OssAnalysis> analysisList = (List<OssAnalysis>) map.get("analysisList");
List<OssAnalysis> changeAnalysisResultList = new ArrayList<OssAnalysis>();
Map<String, Object> valid = new HashMap<String, Object>();
getAnalysisValidation(valid, analysisList);
Map<String, String> errorMsg = (Map<String, String>) valid.get("validMap");
int gridSeq = 1;
List<String> deactivateOssList = ossService.getDeactivateOssList();
deactivateOssList.replaceAll(String::toUpperCase);
for (OssAnalysis bean : analysisResultList) {
OssAnalysis userData = analysisList
.stream()
.filter(e -> e.getComponentId().equals(bean.getGridId()))
.collect(Collectors.toList()).get(0); // ์ฌ์ฉ์ ์
๋ ฅ ์ ๋ณด
userData.setGroupId(userData.getGridId()); // groupId๋ user๊ฐ ์
๋ ฅํ row์ grid Id์.
if (CoConstDef.FLAG_YES.equals(userData.getCompleteYn()) && !isEmpty(userData.getReferenceOssId())) {
OssAnalysis successOssInfo = ossService.getAutoAnalysisSuccessOssInfo(userData.getReferenceOssId());
if (successOssInfo != null) {
if (!isEmpty(successOssInfo.getDownloadLocationGroup())) {
successOssInfo.setDownloadLocation(successOssInfo.getDownloadLocationGroup());
}
successOssInfo.setTitle("์ฌ์ฉ์ ๋ฑ๋ก ์ ๋ณด");
successOssInfo.setGroupId(userData.getGroupId());
successOssInfo.setGridId(userData.getGridId());
successOssInfo.setResult("true");
successOssInfo.setCompleteYn(userData.getCompleteYn());
successOssInfo.setReferenceOssId(userData.getReferenceOssId());
changeAnalysisResultList.add(successOssInfo);
continue;
}
}
userData.setTitle("์ฌ์ฉ์ ์์ฑ ์ ๋ณด");
String ossName = userData.getOssName();
String ossNameTemp = "";
boolean ossNicknameFlag = false;
String comment = bean.getComment();
if (!isEmpty(comment)) userData.setComment(comment);
if (bean.getResult().toUpperCase().equals("TRUE")) {
int ossNameCnt = errorMsg.entrySet()
.stream()
.filter(e -> e.getKey().indexOf(bean.getGridId()) > -1 && e.getKey().indexOf("ossName") > -1)
.collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()))
.size();
int ossVersionCnt = errorMsg.entrySet()
.stream()
.filter(e -> e.getKey().indexOf(bean.getGridId()) > -1 && e.getKey().indexOf("ossVersion") > -1)
.collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()))
.size();
String copyright = bean.getOssCopyright();
String askalonoLicense = bean.getAskalonoLicense().replaceAll("\\(\\d+\\)", "");
String scancodeLicense = bean.getScancodeLicense().replaceAll("\\(\\d+\\)", "");
String duplicateNickname = bean.getOssNickname();
String customOssName = "";
if (bean.getOssName().contains(";")) {
customOssName = bean.getOssName().split(";")[0];
} else {
customOssName = bean.getOssName();
}
if (customOssName.endsWith(".git")) {
customOssName = customOssName.substring(0, customOssName.length()-4);
}
if (ossNameCnt == 0 && ossVersionCnt > 0) { // ossVersion ๋์
// ์ฌ์ฉ์ ์์ฑ์ ๋ณด์ oss name์ด ์ทจํฉ์ ๋ณด์ nickname์ ๋ค์ด๊ฐ๋ case๋ฅผ ๋ฐฉ์งํจ.
if (!userData.getOssName().toUpperCase().equals(bean.getOssName().toUpperCase())) {
List<String> duplicateNicknameList = Arrays.asList(duplicateNickname.split(","));
List<String> nicknameList = new ArrayList<>();
for (String nick : duplicateNicknameList) {
String customNick = "";
if (nick.contains(";")) {
customNick = nick.split(";")[0];
} else {
customNick = nick;
}
if (customNick.endsWith(".git")) {
customNick = customNick.substring(0, customNick.length()-4);
}
if (!userData.getOssName().equalsIgnoreCase(customNick)) nicknameList.add(customNick);
}
if (nicknameList != null && !nicknameList.isEmpty()) duplicateNickname = String.join(",", nicknameList);
}
}
String downloadLocation = "";
if (bean.getDownloadLocation().contains(",")) {
List<String> downloadLocationSplitList = new ArrayList<>();
String[] downloadLocationSplit = bean.getDownloadLocation().split("[,]");
for (String download : downloadLocationSplit) {
boolean equalsFlag = false;
for (String customData : downloadLocationSplitList) {
if (download.equalsIgnoreCase(customData)) {
equalsFlag = true;
break;
}
}
if (!equalsFlag) {
downloadLocationSplitList.add(download);
}
}
if (downloadLocationSplitList != null && !downloadLocationSplitList.isEmpty()) {
String customDownloadLocation = "";
for (String customDownload : downloadLocationSplitList) {
customDownloadLocation += customDownload + ",";
}
downloadLocation = customDownloadLocation.substring(0, customDownloadLocation.length()-1);
}
} else {
downloadLocation = bean.getDownloadLocation();
}
OssAnalysis totalAnalysis = new OssAnalysis(userData.getGridId(), customOssName, bean.getOssVersion(), duplicateNickname
, avoidNull(bean.getConcludedLicense(), null), copyright, downloadLocation
, bean.getHomepage(), null, comment, bean.getResult(), "์ทจํฉ์ ๋ณด"); // ์ทจํฉ์ ๋ณด
OssAnalysis askalono = new OssAnalysis(userData.getGridId(), customOssName, bean.getOssVersion(), duplicateNickname
, askalonoLicense, null, downloadLocation
, bean.getHomepage(), null, comment, bean.getResult(), "License textํ์ผ ๋ถ์ ๊ฒฐ๊ณผ"); // License text ์ ๋ณด
OssAnalysis scancode = new OssAnalysis(userData.getGridId(), customOssName, bean.getOssVersion(), duplicateNickname
, scancodeLicense, copyright, downloadLocation
, bean.getHomepage(), null, comment, bean.getResult(), "Scancode ๋ถ์ ๊ฒฐ๊ณผ"); // scancode ์ ๋ณด
List<OssAnalysis> ossAnalysisByNickList = new ArrayList<>();
OssAnalysis ossInfoByNick = null;
int idx = 1;
OssMaster param = new OssMaster();
for (String nick : duplicateNickname.split(",")) {
if (CoCodeManager.OSS_INFO_UPPER_NAMES.containsKey(nick.toUpperCase())) {
String ossNameByNick = CoCodeManager.OSS_INFO_UPPER_NAMES.get(nick.toUpperCase());
param.setOssName(ossNameByNick);
List<OssMaster> ossInfoByNickList = ossService.getOssListByName(param);
if (ossInfoByNickList != null) {
int deactivateCnt = ossInfoByNickList.stream().filter(e -> e.getDeactivateFlag().equals(CoConstDef.FLAG_YES)).collect(Collectors.toList()).size();
if (deactivateCnt > 0) {
continue;
}
if (ossAnalysisByNickList.size() > 0) {
String checkDuplicateOssName = ossInfoByNickList.get(0).getOssName();
int checkDuplicateCnt = ossAnalysisByNickList.stream().filter(e -> e.getOssName().equalsIgnoreCase(checkDuplicateOssName)).collect(Collectors.toList()).size();
if (checkDuplicateCnt > 0) {
continue;
}
}
final Comparator<OssMaster> comp = Comparator.comparing((OssMaster o) -> o.getModifiedDate()).reversed();
ossInfoByNickList = ossInfoByNickList.stream().sorted(comp).collect(Collectors.toList());
List<OssLicense> liList = ossInfoByNickList.get(0).getOssLicenses();
String license = "";
for (OssLicense li : liList) {
if (!isEmpty(li.getLicenseId())) {
LicenseMaster lm = CoCodeManager.LICENSE_INFO_BY_ID.get(li.getLicenseId());
license += !isEmpty(lm.getShortIdentifier()) ? lm.getShortIdentifier() + "," : li.getLicenseName() + ",";
} else {
license += li.getLicenseName() + ",";
}
}
String analysisTitle = ossInfoByNickList.get(0).getOssName();
if (!isEmpty(ossInfoByNickList.get(0).getOssVersion())) {
analysisTitle += " (" + ossInfoByNickList.get(0).getOssVersion() + ")";
}
ossInfoByNick = new OssAnalysis(userData.getGridId(), ossInfoByNickList.get(0).getOssName(), bean.getOssVersion(), avoidNull(ossInfoByNickList.get(0).getOssNickname()).replaceAll("<br>", ",")
, license.substring(0, license.length()-1), ossInfoByNickList.get(0).getCopyright(), ossInfoByNickList.get(0).getDownloadLocation()
, ossInfoByNickList.get(0).getHomepage(), null, comment, "", analysisTitle + " ์ต์ ๋ฑ๋ก ์ ๋ณด"); // nick oss ์ต์ ์ ๋ณด
ossInfoByNick.setGridId(CoConstDef.GRID_NEWROW_DEFAULT_PREFIX + idx);
ossAnalysisByNickList.add(ossInfoByNick);
}
}
}
userData.setResult("true");
if (ossNameCnt == 0 && ossVersionCnt > 0) { // ossVersion ๋์
totalAnalysis.setGridId(""+gridSeq++);
askalono.setGridId(""+gridSeq++);
scancode.setGridId(""+gridSeq++);
OssAnalysis newestOssInfo = null;
OssAnalysis totalNewestOssInfo = null;
try {
// check if oss name is nickname
if (CoCodeManager.OSS_INFO_UPPER_NAMES.containsKey(userData.getOssName().toUpperCase())) {
ossNameTemp = CoCodeManager.OSS_INFO_UPPER_NAMES.get(userData.getOssName().toUpperCase());
}
if (!isEmpty(ossName) && !isEmpty(ossNameTemp) && !ossName.equals(ossNameTemp)) {
userData.setOssName(ossNameTemp);
ossNicknameFlag = true;
}
newestOssInfo = ossService.getNewestOssInfo(userData); // ์ฌ์ฉ์ ์ ๋ณด์ ossName๊ธฐ์ค ์ต์ ๋ฑ๋ก์ ๋ณด
if (newestOssInfo != null) {
newestOssInfo.setGridId(""+gridSeq++);
newestOssInfo.setOssVersion(!isEmpty(bean.getOssVersion()) ? bean.getOssVersion() : userData.getOssVersion());
newestOssInfo.setComment(comment);
}
if (userData.getOssName().toUpperCase().equals(totalAnalysis.getOssName().toUpperCase())) {
String newestMergeNickName = "";
if (newestOssInfo != null) {
newestMergeNickName = CommonFunction.mergeNickname(totalAnalysis, newestOssInfo.getOssNickname()); // ์ฌ์ฉ์ ์์ฑ ์ ๋ณด & ์ต์ ๋ฑ๋ก์ ๋ณด nickname Merge
newestOssInfo.setOssNickname(newestMergeNickName);
}else {
newestMergeNickName = CommonFunction.mergeNickname(totalAnalysis, null);
}
totalAnalysis.setOssNickname(newestMergeNickName);
askalono.setOssNickname(newestMergeNickName);
scancode.setOssNickname(newestMergeNickName);
userData.setOssNickname(newestMergeNickName);
} else {
totalNewestOssInfo = ossService.getNewestOssInfo(totalAnalysis); // ์ฌ์ฉ์ ์ ๋ณด์ ossName๊ธฐ์ค ์ต์ ๋ฑ๋ก์ ๋ณด
String totalNewestMergeNickName = "";
if (totalNewestOssInfo != null) {
totalNewestOssInfo.setGridId(""+gridSeq++);
totalNewestOssInfo.setOssVersion(userData.getOssVersion());
totalNewestMergeNickName = CommonFunction.mergeNickname(totalAnalysis, totalNewestOssInfo.getOssNickname()); // ์ฌ์ฉ์ ์์ฑ ์ ๋ณด & ์ต์ ๋ฑ๋ก์ ๋ณด nickname Merge
totalNewestOssInfo.setOssNickname(totalNewestMergeNickName);
}else {
totalNewestMergeNickName = CommonFunction.mergeNickname(totalAnalysis, null);
}
totalAnalysis.setOssNickname(totalNewestMergeNickName);
askalono.setOssNickname(totalNewestMergeNickName);
scancode.setOssNickname(totalNewestMergeNickName);
userData.setOssNickname(totalNewestMergeNickName);
}
} catch (Exception newestException) {
log.error(newestException.getMessage());
}
changeAnalysisResultList.add(totalAnalysis); // seq 1 : ์ทจํฉ ์ ๋ณด
if (ossAnalysisByNickList != null && !ossAnalysisByNickList.isEmpty()) {
for (OssAnalysis oa : ossAnalysisByNickList) {
if (totalNewestOssInfo != null) {
if (!totalNewestOssInfo.getOssName().equalsIgnoreCase(oa.getOssName()) && !totalNewestOssInfo.getOssVersion().equals(oa.getOssVersion())) {
changeAnalysisResultList.add(oa); // seq 2 : oss ์ต์ ๋ฑ๋ก ์ ๋ณด
}
} else {
if (newestOssInfo != null) {
if (!newestOssInfo.getOssName().equalsIgnoreCase(oa.getOssName()) && !newestOssInfo.getOssVersion().equals(oa.getOssVersion())) {
changeAnalysisResultList.add(oa); // seq 2 : oss ์ต์ ๋ฑ๋ก ์ ๋ณด
}
} else {
changeAnalysisResultList.add(oa); // seq 2 : oss ์ต์ ๋ฑ๋ก ์ ๋ณด
}
}
}
}
if (totalNewestOssInfo != null && !deactivateOssList.contains(totalNewestOssInfo.getOssName().toUpperCase())) {
changeAnalysisResultList.add(totalNewestOssInfo); // seq 3 : ์ทจํฉ์ ๋ณด ์ต์ ๋ฑ๋ก ์ ๋ณด
}
if (newestOssInfo != null && !deactivateOssList.contains(newestOssInfo.getOssName().toUpperCase())) {
changeAnalysisResultList.add(newestOssInfo); // seq 4 : ์ต์ ๋ฑ๋ก ์ ๋ณด
if (newestOssInfo.getOssName().toUpperCase().equals(userData.getOssName().toUpperCase())) {
if (newestOssInfo.getOssNickname() != null) {
userData.setOssNickname(CommonFunction.mergeNickname(userData, newestOssInfo.getOssNickname()));
}
if (userData.getOssNickname() != null) {
newestOssInfo.setOssNickname(CommonFunction.mergeNickname(newestOssInfo, userData.getOssNickname()));
}
}
}
if (ossNicknameFlag) {
userData.setOssName(ossName);
}
changeAnalysisResultList.add(askalono); // seq 5 : askalono ์ ๋ณด
changeAnalysisResultList.add(scancode); // seq 6 : scancode ์ ๋ณด
changeAnalysisResultList.add(userData); // seq 7 : ์ฌ์ฉ์ ์
๋ ฅ ์ ๋ณด
} else { // ossName ๋์
totalAnalysis.setGridId(""+gridSeq++);
OssAnalysis totalNewestOssInfo = ossService.getNewestOssInfo(totalAnalysis); // ์ฌ์ฉ์ ์ ๋ณด์ ossName๊ธฐ์ค ์ต์ ๋ฑ๋ก์ ๋ณด
if (totalNewestOssInfo != null) {
totalNewestOssInfo.setGridId(""+gridSeq++);
totalNewestOssInfo.setOssVersion(!isEmpty(bean.getOssVersion()) ? bean.getOssVersion() : userData.getOssVersion());
totalNewestOssInfo.setComment(comment);
String totalNewestMergeNickName = CommonFunction.mergeNickname(totalAnalysis, totalNewestOssInfo.getOssNickname()); // ์ฌ์ฉ์ ์์ฑ ์ ๋ณด & ์ต์ ๋ฑ๋ก์ ๋ณด nickname Merge
totalNewestOssInfo.setOssNickname(totalNewestMergeNickName);
totalAnalysis.setOssNickname(totalNewestMergeNickName);
askalono.setOssNickname(totalNewestMergeNickName);
scancode.setOssNickname(totalNewestMergeNickName);
userData.setOssNickname(totalNewestMergeNickName);
}
askalono.setGridId(""+gridSeq++);
scancode.setGridId(""+gridSeq++);
changeAnalysisResultList.add(totalAnalysis); // seq 1 : ์ทจํฉ ์ ๋ณด
if (ossAnalysisByNickList != null && !ossAnalysisByNickList.isEmpty()) {
for (OssAnalysis oa : ossAnalysisByNickList) {
if (totalNewestOssInfo != null) {
if (!totalNewestOssInfo.getOssName().equalsIgnoreCase(oa.getOssName()) && !totalNewestOssInfo.getOssVersion().equals(oa.getOssVersion())) {
changeAnalysisResultList.add(oa); // seq 2 : oss ์ต์ ๋ฑ๋ก ์ ๋ณด
}
} else {
changeAnalysisResultList.add(oa); // seq 2 : oss ์ต์ ๋ฑ๋ก ์ ๋ณด
}
}
}
if (totalNewestOssInfo != null && !deactivateOssList.contains(totalNewestOssInfo.getOssName().toUpperCase())) {
changeAnalysisResultList.add(totalNewestOssInfo); // seq 3 : ์ทจํฉ์ ๋ณด ์ต์ ๋ฑ๋ก ์ ๋ณด
}
changeAnalysisResultList.add(userData); // seq 4 : ์ฌ์ฉ์ ์
๋ ฅ ์ ๋ณด
changeAnalysisResultList.add(askalono); // seq 5 : askalono ์ ๋ณด
changeAnalysisResultList.add(scancode); // seq 6 : scancode ์ ๋ณด
}
} else {
userData.setResult("false");
changeAnalysisResultList.add(userData); // analysis result๊ฐ False์ด๋ฉด ์ฌ์ฉ์ ์
๋ ฅ์ ๋ณด๋ง ๋ณด๋ธ๋ค.
int ossNameCnt = errorMsg.entrySet()
.stream()
.filter(e -> e.getKey().indexOf(bean.getGridId()) > -1 && e.getKey().indexOf("ossName") > -1)
.collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()))
.size();
int ossVersionCnt = errorMsg.entrySet()
.stream()
.filter(e -> e.getKey().indexOf(bean.getGridId()) > -1 && e.getKey().indexOf("ossVersion") > -1)
.collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue()))
.size();
if (ossNameCnt == 0 && ossVersionCnt > 0){
try {
// check if oss name is nickname
if (CoCodeManager.OSS_INFO_UPPER_NAMES.containsKey(userData.getOssName().toUpperCase())) {
ossNameTemp = CoCodeManager.OSS_INFO_UPPER_NAMES.get(userData.getOssName().toUpperCase());
}
if (!isEmpty(ossName) && !isEmpty(ossNameTemp) && !ossName.equals(ossNameTemp)) {
userData.setOssName(ossNameTemp);
ossNicknameFlag = true;
}
OssAnalysis newestOssInfo = ossService.getNewestOssInfo(userData); // ์ฌ์ฉ์ ์ ๋ณด์ ossName๊ธฐ์ค ์ต์ ๋ฑ๋ก์ ๋ณด
if (newestOssInfo != null && !deactivateOssList.contains(newestOssInfo.getOssName().toUpperCase())) {
newestOssInfo.setOssVersion(!isEmpty(bean.getOssVersion()) ? bean.getOssVersion() : userData.getOssVersion());
newestOssInfo.setGridId(""+gridSeq++);
newestOssInfo.setComment(comment);
changeAnalysisResultList.add(newestOssInfo); // seq 2 : ์ต์ ๋ฑ๋ก ์ ๋ณด
}
if (ossNicknameFlag) {
userData.setOssName(ossName);
}
} catch (Exception newestException) {
log.error(newestException.getMessage());
}
}
}
}
changeAnalysisResultList = changeAnalysisResultList.stream().filter(distinctByKey(e -> (e.getTitle() + "|" + e.getOssName() + "|" + e.getOssVersion()).toUpperCase())).collect(Collectors.toList());
getAnalysisValidation(map, changeAnalysisResultList);
map.replace("rows", changeAnalysisResultList);
map.remove("analysisList"); // ๋ถ์๊ฒฐ๊ณผ Data์์๋ ํ์์๋ data์ด๋ฏ๋ก ์ ๊ฑฐ.
}
public static ArrayList<Object> checkXlsxFileLimit(List<UploadFile> list){
ArrayList<Object> result = new ArrayList<Object>();
for (UploadFile f : list) {
if (f.getSize() > CoConstDef.CD_XLSX_UPLOAD_FILE_SIZE_LIMIT && f.getFileExt().contains("xls")){
result.add("FILE_SIZE_LIMIT_OVER");
result.add("The excel file exceeded 5MB.<br>Please delete the blank row or unnecessary data, and then upload it.");
break;
}
}
return result;
}
public static ArrayList<Object> checkCsvFileLimit(List<UploadFile> list) {
ArrayList<Object> result = new ArrayList<Object>();
boolean nextCheck = false;
for (UploadFile f : list) {
if (f.getSize() > CoConstDef.CD_CSV_UPLOAD_FILE_SIZE_LIMIT && f.getFileExt().contains("csv")){
result.add("FILE_SIZE_LIMIT_OVER");
result.add("The file exceeded 5MB.<br>Please delete the blank row or unnecessary data, and then upload it.");
nextCheck = true;
break;
}
if (!nextCheck) {
boolean tabGubnBoolean = false;
String commaData = "";
Scanner sc = null;
try {
sc = new Scanner(new FileInputStream(new File(f.getFilePath() + "/" + f.getFileName())));
while (sc.hasNext()) {
String readLine = sc.nextLine();
if (!isEmpty(readLine) && !readLine.contains("\t")) {
tabGubnBoolean = true;
break;
}
}
} catch (Exception e) {
log.info(e.getMessage(), e);
} finally {
sc.close();
if (tabGubnBoolean) {
result.add("TAB_GUBN_ERROR");
result.add(commaData);
break;
}
}
}
}
return result;
}
public static File convertXMLToHTML(File XmlFile) {
return convertXMLToHTML(XmlFile, false);
}
public static File convertXMLToHTML(File XmlFile, boolean isDir) {
List<File> xmlFiles = new ArrayList<File>();
File outPath = null;
if (!isDir) {
if (XmlFile.exists()) {
String Path = XmlFile.getPath().split("\\.")[0];
outPath = new File(Path);
outPath.mkdirs(); // xml file์ upload/android_notice/projectId/* ์ ์ฌ๋ ค๋๊ธฐ ๋๋ฌธ์ dir๋ฅผ ์์ฑํด์ผ ํจ.
xmlFiles.add(XmlFile);
}
} else {
if (XmlFile.exists()) {
for (File f : XmlFile.listFiles()) {
xmlFiles.add((File) f);
}
}
outPath = XmlFile;
}
UUID randomUUID = UUID.randomUUID();
File outFile = new File(outPath + "/" + randomUUID + ".html");
LicenseHtmlGeneratorFromXml.generateHtml(xmlFiles, outFile);
return outFile;
}
public static String mergeNickname(OssAnalysis bean, String newestNickName) {
String mergeNickname = newestNickName;
if (!isEmpty(mergeNickname)) {
List<String> nicknameList = new ArrayList<String>();
if (!isEmpty(bean.getOssNickname())) { // nickname์ด ๋น๊ฐ์ด ์์ ๊ฒฝ์ฐ ๋ด์ง ์์.
nicknameList.addAll(Arrays.asList(bean.getOssNickname().split(",")));
nicknameList = nicknameList.stream().filter(e -> !e.equalsIgnoreCase(bean.getOssName())).collect(Collectors.toList());
}
nicknameList.addAll(Arrays.asList(newestNickName.split(",")));
mergeNickname = String.join(",", nicknameList.stream().sorted().filter(distinctByKey(p -> p.trim().toUpperCase())).collect(Collectors.toList()));
} else {
mergeNickname = bean.getOssNickname();
}
return mergeNickname;
}
public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
Map<Object, Boolean> seen = new ConcurrentHashMap<>();
return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}
public static <T> Predicate<T> distinctByKeys(Function<? super T, ?>... keyExtractors) {
final Map<List<?>, Boolean> seen = new ConcurrentHashMap<>();
return t -> {
final List<?> keys = Arrays.stream(keyExtractors)
.map(ke -> ke.apply(t))
.collect(Collectors.toList());
return seen.putIfAbsent(keys, Boolean.TRUE) == null;
};
}
public static String replaceSlashToUnderline(String target) {
return target.replaceAll("[/\\\\]", "_");
}
public static String VelocityTemplateToString(Map<String, Object> model) {
VelocityContext context = new VelocityContext();
Writer writer = new StringWriter();
VelocityEngine ve = new VelocityEngine();
Properties props = new Properties();
for (String key : model.keySet()) {
if (!"templateURL".equals(key)) {
context.put(key, model.get(key));
}
}
props.put("resource.loader", "class");
props.put("class.resource.loader.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
props.put("input.encoding", "UTF-8");
ve.init(props);
// Core Logic: Velocity engine decides which template should be loaded according to the model's template URL
// Refer to the 'template' directory for further information.
try {
Template template = ve.getTemplate((String) model.get("templateURL"));
template.merge(context, writer);
return writer.toString();
} catch (Exception e) {
log.error(e.getMessage());
}
return "";
}
public static String getNoticeFileName(String prjId, String prjName, String prjVersion, String dateStr, String fileType) {
return getNoticeFileName(prjId, prjName, prjVersion, null, dateStr, fileType);
}
public static String getNoticeFileName(String prjId, String prjName, String prjVersion, String fileName, String dateStr, String fileType) {
if (isEmpty(fileName)) {
fileName = "OSSNotice-";
fileName += prjId + "_" + prjName;
if (!isEmpty(prjVersion)) {
fileName += "_" + prjVersion;
}
}
// file๋ช
์ ์ฌ์ฉํ ์ ์๋ ํน์๋ฌธ์ ์ฒดํฌ
if (!FileUtil.isValidFileName(fileName)) {
fileName = FileUtil.makeValidFileName(fileName, "_");
}
fileName += "_" + dateStr;
if (isEmpty(fileType) || fileType == "html"){
fileName += ".html";
}else if (fileType == "text"){
fileName += ".txt";
} else {
fileName += fileType;
}
return fileName;
}
public static String getReviewReportFileName(String prjId, String prjName, String prjVersion, String dateStr, String fileType) {
return getReviewReportFileName(prjId, prjName, prjVersion, null, dateStr, fileType);
}
public static String getReviewReportFileName(String prjId, String prjName, String prjVersion, String fileName, String dateStr, String fileType) {
if (isEmpty(fileName)) {
fileName = "FOSSLight-Review-";
fileName += prjId + "_" + prjName;
if (!isEmpty(prjVersion)) {
fileName += "_" + prjVersion;
}
}
// file๋ช
์ ์ฌ์ฉํ ์ ์๋ ํน์๋ฌธ์ ์ฒดํฌ
if (!FileUtil.isValidFileName(fileName)) {
fileName = FileUtil.makeValidFileName(fileName, "_");
}
fileName += "_" + dateStr;
fileName += ".pdf";
return fileName;
}
public static String mergedString(String fromStr, String toStr, int compareTo, String separator) {
if (compareTo >= 0){
return fromStr + separator + toStr;
} else {
return toStr + separator + fromStr;
}
}
public static void removeAll(File removeAllFile) {
File[] allFiles = removeAllFile.listFiles();
if (allFiles != null) {
for (File file : allFiles) {
removeAll(file);
}
}
removeAllFile.delete();
}
public static String removeSpecialChar(String target, int limit) {
String match = "[^\uAC00-\uD7A3xfe0-9a-zA-Z\\s]";
target = target.replaceAll(match, "");
if (limit > 0) {
target = target.substring(0, limit);
}
return target;
}
// ๊ตฌ๋ถ์ ๋ฌธ์์ด ์์๋๋ก ์ค๋ณต ์ ๊ฑฐ
public static String removeDuplicateStringToken(String str, String token){
String removeDubString = "";
if (!StringUtil.isEmpty(str)){
String[] arr = StringUtil.split(str, token.trim());
LinkedHashSet<String> ls = new LinkedHashSet<>();
for (int i=0; i<arr.length; i++){
ls.add(arr[i]);
}
Iterator<String> it = ls.iterator();
while (it.hasNext()){
removeDubString +=it.next()+token.trim();
}
if (!StringUtil.isEmpty(removeDubString)){
removeDubString=removeDubString.substring(0, removeDubString.lastIndexOf(token.trim()));
}
}
return removeDubString;
}
public static void splitDate(String str, Map<String, Object> paramMap, String separator, String prefix) {
if (!isEmpty(str)) {
String[] strArr = str.split(separator);
paramMap.put(prefix+"From", strArr[0]);
paramMap.put(prefix+"To", strArr[1]);
}
}
public static String tabTitleSubStr(String code, String value) {
String tabData = CoCodeManager.getCodeString(code, value);
if (tabData.length() > 12) {
return tabData.substring(0, 11) + "...";
} else {
return tabData;
}
}
public static String getDiffItemCommentPartner(PartnerMaster beforeBean, PartnerMaster afterBean) {
String comment = "<p><strong>Division</strong><br />";
comment += "Before : " + CoCodeManager.getCodeString(CoConstDef.CD_USER_DIVISION, beforeBean.getDivision()) + "<br />";
comment += "After : <span style='background-color:yellow'>" + CoCodeManager.getCodeString(CoConstDef.CD_USER_DIVISION, afterBean.getDivision()) + "</span><br /></p>";
return comment;
}
public static String getDiffItemComment(Project beforeBean, Project afterBean) {
return getDiffItemComment(beforeBean, afterBean, false);
}
public static String getDiffItemComment(Project beforeBean, Project afterBean, boolean booleanFlag) {
String comment = "";
if (booleanFlag) {
// Project Name
if (!beforeBean.getPrjName().equals(afterBean.getPrjName())) {
comment += "<p><strong>Project Name</strong><br />";
comment += "Before : " + beforeBean.getPrjName() + "<br />";
comment += "After : " + afterBean.getPrjName() + "<br /></p>";
}
// Project Version
if (!beforeBean.getPrjVersion().equals(afterBean.getPrjVersion())) {
comment += "<p><strong>Project Version</strong><br />";
comment += "Before : " + beforeBean.getPrjVersion() + "<br />";
comment += "After : " + afterBean.getPrjVersion() + "<br /></p>";
}
// Operating System
if (!beforeBean.getOsType().equals(afterBean.getOsType())) {
comment += "<p><strong>Operating System</strong><br />";
comment += "Before : " + beforeBean.getOsType() + "<br />";
comment += "After : " + afterBean.getOsType() + "<br /></p>";
}
// Distribution Type
if (!beforeBean.getDistributionType().equals(afterBean.getDistributionType())) {
comment += "<p><strong>Distribution Type</strong><br />";
comment += "Before : " + beforeBean.getDistributionType() + "<br />";
comment += "After : " + afterBean.getDistributionType() + "<br /></p>";
}
if (!beforeBean.getNetworkServerType().equals(afterBean.getNetworkServerType())) {
comment += "<p><strong>Network Service only?</strong><br />";
comment += "Before : " + beforeBean.getNetworkServerType() + "<br />";
comment += "After : " + afterBean.getNetworkServerType() + "<br /></p>";
}
if (!beforeBean.getDistributeTarget().equals(afterBean.getDistributeTarget())) {
comment += "<p><strong>Distribution Site</strong><br />";
comment += "Before : " + beforeBean.getDistributeTarget() + "<br />";
comment += "After : " + afterBean.getDistributeTarget() + "<br /></p>";
}
if (!beforeBean.getNoticeType().equals(afterBean.getNoticeType())) {
comment += "<p><strong>OSS Notice</strong><br />";
comment += "Before : " + beforeBean.getNoticeType() + "<br />";
comment += "After : " + afterBean.getNoticeType() + "<br /></p>";
}
if (!beforeBean.getPriority().equals(afterBean.getPriority())) {
comment += "<p><strong>Priority</strong><br />";
comment += "Before : " + beforeBean.getPriority() + "<br />";
comment += "After : " + afterBean.getPriority() + "</p>";
}
String before = beforeBean.getComment().replaceAll("(\r\n|\r|\n|\n\r)", "");
String after = afterBean.getComment().replaceAll("(\r\n|\r|\n|\n\r)", "");
if (!before.equals(after)) {
comment += "<p><strong>Additional Information</strong><br />";
comment += "Before : " + beforeBean.getComment() + "<br />";
comment += "After : " + afterBean.getComment() + "</p>";
}
} else {
// Project Division
if (!beforeBean.getDivision().equals(afterBean.getDivision())) {
comment += "<p><strong>Division</strong><br />";
comment += "Before : " + CoCodeManager.getCodeString(CoConstDef.CD_USER_DIVISION, beforeBean.getDivision()) + "<br />";
comment += "After : <span style='background-color:yellow'>" + CoCodeManager.getCodeString(CoConstDef.CD_USER_DIVISION, afterBean.getDivision()) + "</span><br /></p>";
}
}
return comment;
}
public static void calcTotListSize(Map<String, Object> map) {
int totListSize = (int) map.get("totListSize");
int pageListSize = Integer.parseInt((String) map.get("rows"));
int curPage = Integer.parseInt((String) map.get("page"));
int blockSize = 10;
if (map.containsKey("blockSize")) {
blockSize = Integer.parseInt((String) map.get("blockSize"));
}
int totBlockSize = totListSize/pageListSize < 1 ? 1 : totListSize%pageListSize==0?totListSize/pageListSize:(totListSize/pageListSize)+1;
int startIndex = (curPage-1)*pageListSize;
int totBlockPage = (totBlockSize / blockSize);
if (totBlockSize != blockSize) {
totBlockPage++;
}
int blockPage = ((curPage-1) / blockSize) + 1;
int blockStart = ((blockPage-1) * blockSize) + 1;
int blockEnd = blockStart+blockSize-1;
if (blockEnd > totBlockSize) {
blockEnd = totBlockSize;
}
map.put("totBlockSize", totBlockSize);
map.put("startIndex", startIndex);
map.put("totBlockPage", totBlockPage);
map.put("blockStart", blockStart);
map.put("blockEnd", blockEnd);
map.put("pageListSize", pageListSize);
map.put("curPage", curPage);
}
public static String getProperty(String key){
try {
return appEnv.getProperty(key);
} catch (IllegalArgumentException e) {}
return "";
}
public static String emptyCheckProperty(String key) {
return emptyCheckProperty(key, key);
}
public static String emptyCheckProperty(String key, String defaultValue) {
return appEnv.containsProperty(key) ? getProperty(key) : defaultValue;
}
public static boolean propertyFlagCheck(String key, String checkFlag) {
String flag = avoidNull(getProperty(key), CoConstDef.FLAG_NO);
return flag.equals(checkFlag);
}
public static String appendProperty(String beforeKey, String afterKey) {
String beforeStr = emptyCheckProperty(beforeKey);
String afterStr = emptyCheckProperty(afterKey, "");
return beforeStr + afterStr;
}
public static String loginUserName() {
try {
return SecurityContextHolder.getContext().getAuthentication().getName();
} catch(Exception e) {
return "";
}
}
public static String getDomain(HttpServletRequest req) {
return req.getScheme() + "://" + req.getServerName() + ("LOCALHOST".equals(req.getServerName().toUpperCase()) ? ":" + req.getServerPort() + req.getContextPath() : "");
}
public static String makeJdbcUrl(String jdbcUrl) {
if (StringUtil.isEmpty(jdbcUrl)) {
return jdbcUrl;
}
if (!jdbcUrl.startsWith("jdbc:")) {
jdbcUrl = "jdbc:mysql://" + jdbcUrl;
}
if (!jdbcUrl.contains("serverTimezone")) {
jdbcUrl += (jdbcUrl.contains("?") ? "&" : "?") + "serverTimezone=UTC";
}
if (!jdbcUrl.contains("autoReconnect")) {
jdbcUrl += (jdbcUrl.contains("?") ? "&" : "?") + "autoReconnect=true";
}
return jdbcUrl;
}
public static String getOssDownloadLocation(String ossName, String ossVersion) {
if (!isEmpty(ossName) && CoCodeManager.OSS_INFO_UPPER.containsKey( (ossName + "_" + avoidNull(ossVersion)).toUpperCase() )) {
return avoidNull( CoCodeManager.OSS_INFO_UPPER.get( (ossName + "_" + avoidNull(ossVersion)).toUpperCase() ).getDownloadLocation() );
}
return "";
}
public static String httpCodePrint(int code){
String res = code + "";
switch(code){
case HttpURLConnection.HTTP_ACCEPTED: res = "HTTP_ACCEPTED"; break;
case HttpURLConnection.HTTP_BAD_GATEWAY: res = "HTTP_BAD_GATEWAY"; break;
case HttpURLConnection.HTTP_BAD_METHOD: res = "HTTP_BAD_METHOD"; break;
case HttpURLConnection.HTTP_BAD_REQUEST: res = "HTTP_BAD_REQUEST"; break;
case HttpURLConnection.HTTP_CLIENT_TIMEOUT: res = "HTTP_CLIENT_TIMEOUT"; break;
case HttpURLConnection.HTTP_CONFLICT: res = "HTTP_CONFLICT"; break;
case HttpURLConnection.HTTP_CREATED: res = "HTTP_CREATED"; break;
case HttpURLConnection.HTTP_ENTITY_TOO_LARGE: res = "HTTP_ENTITY_TOO_LARGE"; break;
case HttpURLConnection.HTTP_FORBIDDEN: res = "HTTP_FORBIDDEN"; break;
case HttpURLConnection.HTTP_GATEWAY_TIMEOUT: res = "HTTP_GATEWAY_TIMEOUT"; break;
case HttpURLConnection.HTTP_GONE: res = "HTTP_GONE"; break;
case HttpURLConnection.HTTP_INTERNAL_ERROR: res = "HTTP_INTERNAL_ERROR"; break;
case HttpURLConnection.HTTP_LENGTH_REQUIRED: res = "HTTP_LENGTH_REQUIRED"; break;
case HttpURLConnection.HTTP_MOVED_PERM: res = "HTTP_MOVED_PERM"; break;
case HttpURLConnection.HTTP_MOVED_TEMP: res = "HTTP_MOVED_TEMP"; break;
case HttpURLConnection.HTTP_MULT_CHOICE: res = "HTTP_MULT_CHOICE"; break;
case HttpURLConnection.HTTP_NO_CONTENT: res = "HTTP_NO_CONTENT"; break;
case HttpURLConnection.HTTP_NOT_ACCEPTABLE: res = "HTTP_NOT_ACCEPTABLE"; break;
case HttpURLConnection.HTTP_NOT_AUTHORITATIVE:res = "HTTP_NOT_AUTHORITATIVE"; break;
case HttpURLConnection.HTTP_NOT_FOUND: res = "HTTP_NOT_FOUND"; break;
case HttpURLConnection.HTTP_NOT_IMPLEMENTED: res = "HTTP_NOT_IMPLEMENTED"; break;
case HttpURLConnection.HTTP_NOT_MODIFIED: res = "HTTP_NOT_MODIFIED"; break;
case HttpURLConnection.HTTP_OK: res = "HTTP_OK"; break;
case HttpURLConnection.HTTP_PARTIAL: res = "HTTP_PARTIAL"; break;
case HttpURLConnection.HTTP_PAYMENT_REQUIRED: res = "HTTP_PAYMENT_REQUIRED"; break;
case HttpURLConnection.HTTP_PRECON_FAILED: res = "HTTP_PRECON_FAILED"; break;
case HttpURLConnection.HTTP_PROXY_AUTH: res = "HTTP_PROXY_AUTH"; break;
case HttpURLConnection.HTTP_REQ_TOO_LONG: res = "HTTP_REQ_TOO_LONG"; break;
case HttpURLConnection.HTTP_RESET: res = "HTTP_RESET"; break;
case HttpURLConnection.HTTP_SEE_OTHER: res = "HTTP_SEE_OTHER"; break;
case HttpURLConnection.HTTP_UNAUTHORIZED: res = "HTTP_UNAUTHORIZED"; break;
case HttpURLConnection.HTTP_UNAVAILABLE: res = "HTTP_UNAVAILABLE"; break;
case HttpURLConnection.HTTP_UNSUPPORTED_TYPE: res = "HTTP_UNSUPPORTED_TYPE"; break;
case HttpURLConnection.HTTP_USE_PROXY: res = "HTTP_USE_PROXY"; break;
case HttpURLConnection.HTTP_VERSION: res = "HTTP_VERSION"; break;
default: break;
}
return res;
}
public static Object convertStringToMap (String StringMap, String key) {
Gson gson = CommonFunction.getGsonBuiler();
Type type = new TypeToken<Map<String, Object>>(){}.getType();
Map<String, Object> resultMap = (Map<String, Object>) gson.fromJson(StringMap , type);
return resultMap.containsKey(key) ? resultMap.get(key) : resultMap;
}
public static String makeDuplicateErrorMessage(String prjId) {
String distributionDuplicateMsg = "";
distributionDuplicateMsg += getMessage("msg.distribute.description.duplicate");
distributionDuplicateMsg += getMessage("msg.distribute.origin.link", new String[]{prjId});
return distributionDuplicateMsg;
}
public static String convertCveIdToLink(String cveId) {
if (StringUtil.isEmpty(cveId)) {
return "";
}
return cveId.replaceAll("((cve|CVE)-[0-9]{4}-[0-9]{4,})",
"<a href='https://nvd.nist.gov/vuln/detail/$1' target='_blank'>$1<a/>");
}
public static List<ProjectIdentification> removeDuplicateLicense(List<ProjectIdentification> ossComponents) {
for (ProjectIdentification pri : ossComponents) {
if (pri.getLicenseName() != null && pri.getLicenseName().contains(",")) {
List<String> licenseNameList = Arrays.asList(pri.getLicenseName().split(","));
List<String> licenseNameNicknameCheckList = new ArrayList<>();
List<String> duplicateList = new ArrayList<>();
List<Integer> indexList = new ArrayList<>();
for (int j=0; j<licenseNameList.size(); j++) {
String licenseName = licenseNameList.get(j).trim();
if (CoCodeManager.LICENSE_INFO_UPPER.containsKey(licenseName.toUpperCase())) {
LicenseMaster licenseMaster = CoCodeManager.LICENSE_INFO_UPPER.get(licenseName.toUpperCase());
if (licenseMaster.getLicenseNicknameList() != null && !licenseMaster.getLicenseNicknameList().isEmpty()) {
boolean flag = false;
for (String s : licenseMaster.getLicenseNicknameList()) {
if (licenseName.equalsIgnoreCase(s)) {
String disp = avoidNull(licenseMaster.getShortIdentifier(), licenseMaster.getLicenseNameTemp());
licenseNameNicknameCheckList.add(disp);
flag = true;
break;
}
}
if (!flag) {
licenseNameNicknameCheckList.add(licenseName);
}
}else {
licenseNameNicknameCheckList.add(licenseName);
}
}else {
licenseNameNicknameCheckList.add(licenseName);
}
}
for (int i=0; i<licenseNameNicknameCheckList.size(); i++) {
if (!duplicateList.contains(licenseNameNicknameCheckList.get(i))) {
duplicateList.add(licenseNameNicknameCheckList.get(i));
indexList.add(i);
}
}
duplicateList = new ArrayList<>();
for (int i=0; i<indexList.size(); i++) {
duplicateList.add(licenseNameList.get(indexList.get(i)));
}
pri.setLicenseName(String.join(",", duplicateList));
}
}
return ossComponents;
}
/**
* Set Unclear Obligation Flag (Self-Check)
* @param list
* @param warningCodeMap
* @param errorCodeMap
* @return
*/
public static List<ProjectIdentification> identificationUnclearObligationCheck(List<ProjectIdentification> list, Map<String, String> errorCodeMap, Map<String, String> warningCodeMap) {
List<String> UNCLEAR_OBLIGATION_CODE_LIST = Arrays.asList(new String[] {
"LICENSE_NAME.REQUIRED" ,"LICENSE_NAME.UNCONFIRMED", "LICENSE_NAME.INCLUDE_MULTI_OPERATE", "LICENSE_NAME.NOLICENSE", "LICENSE_NAME.INCLUDE_DUAL_OPERATE"
});
List<String> UNCLEAR_OBLIGATION_CODE_NOTLICENSE_LIST = Arrays.asList(new String[] {
"OSS_NAME.REQUIRED", "OSS_NAME.UNCONFIRMED", "OSS_VERSION.UNCONFIRMED", "OSS_NAME.DEACTIVATED"
});
List<String> unclearObligationList = new ArrayList<>();
List<String> unclearObligationNotLicenseList = new ArrayList<>();
if (errorCodeMap != null) {
for (String key : errorCodeMap.keySet()) {
if (key.indexOf(".") > -1 && UNCLEAR_OBLIGATION_CODE_LIST.contains(errorCodeMap.get(key))) {
unclearObligationList.add(key.substring(key.indexOf(".") + 1, key.length()));
}
if (key.indexOf(".") > -1 && UNCLEAR_OBLIGATION_CODE_NOTLICENSE_LIST.contains(errorCodeMap.get(key))) {
unclearObligationNotLicenseList.add(key.substring(key.indexOf(".") + 1, key.length()));
}
}
}
if (warningCodeMap != null) {
for (String key : warningCodeMap.keySet()) {
if (key.indexOf(".") > -1 && UNCLEAR_OBLIGATION_CODE_LIST.contains(warningCodeMap.get(key))) {
unclearObligationList.add(key.substring(key.indexOf(".") + 1, key.length()));
}
if (key.indexOf(".") > -1 && UNCLEAR_OBLIGATION_CODE_NOTLICENSE_LIST.contains(warningCodeMap.get(key))) {
unclearObligationNotLicenseList.add(key.substring(key.indexOf(".") + 1, key.length()));
}
}
}
if (list != null) {
for (ProjectIdentification bean : list) {
if ("-".equals(bean.getOssName())
&& !unclearObligationList.contains(bean.getGridId())
&& isEmpty(bean.getObligationType())
&& !checkIncludeUnconfirmedLicense(bean.getComponentLicenseList())) {
String obligationType = CommonFunction.getObligationTypeWithSelectedLicense(bean);
if (!isEmpty(obligationType)) {
bean.setObligationType(obligationType);
continue;
}
}
// Check unconfirmed license, the actual message is (Declared : ~~), so check again registered license.
if (unclearObligationList.contains(bean.getGridId())
|| (!isEmpty(bean.getObligationType()) && (checkIncludeUnconfirmedLicense(bean.getComponentLicenseList()) || checkIncludeNotDeclaredLicense(bean.getOssName(), bean.getOssVersion(), bean.getComponentLicenseList())))) {
bean.setObligationGrayFlag(CoConstDef.FLAG_YES);
bean.setObligationMsg(getMessage("msg.project.obligation.unclear"));
}
if (unclearObligationNotLicenseList.contains(bean.getGridId())) {
if (isEmpty(bean.getObligationType())){
String obligationType = CommonFunction.getObligationTypeWithSelectedLicense(bean);
if (!isEmpty(obligationType)) {
bean.setObligationType(obligationType);
continue;
}
}
}
}
}
return list;
}
private static boolean checkIncludeNotDeclaredLicense(String ossName, String ossVer,
List<ProjectIdentification> licenseList) {
if (licenseList != null) {
List<String> licenseNameList = getAllAvailableLicenseUpperCaseName(ossName, ossVer);
for (ProjectIdentification license : licenseList) {
if (license.getLicenseName() != null) {
if (!licenseNameList.contains(license.getLicenseName().toUpperCase())) {
return true;
}
}
}
}
return false;
}
private static List<String> getAllAvailableLicenseUpperCaseName(String ossName, String ossVer) {
String key = (avoidNull(ossName).trim() + "_" + avoidNull(ossVer).trim()).toUpperCase();
List<String> licenseNameList = new ArrayList<>();
if (CoCodeManager.OSS_INFO_UPPER.containsKey(key)) {
OssMaster bean = CoCodeManager.OSS_INFO_UPPER.get(key);
for (OssLicense _temp : Optional.ofNullable(bean.getOssLicenses()).orElse(new ArrayList<>())) {
licenseNameList.add(_temp.getLicenseName().toUpperCase());
LicenseMaster _license = CoCodeManager.LICENSE_INFO_BY_ID.get(_temp.getLicenseId());
if (_license != null) {
for (String _nick : Optional.ofNullable(_license.getLicenseNicknameList()).orElse(new ArrayList<>())) {
licenseNameList.add(_nick.toUpperCase());
}
}
}
for (String _temp : Optional.ofNullable(bean.getDetectedLicenses()).orElse(new ArrayList<>())) {
licenseNameList.add(_temp.toUpperCase());
LicenseMaster _license = CoCodeManager.LICENSE_INFO_UPPER.get(_temp.toUpperCase());
if (_license != null) {
for (String _nick : Optional.ofNullable(_license.getLicenseNicknameList()).orElse(new ArrayList<>())) {
licenseNameList.add(_nick.toUpperCase());
}
}
}
}
return licenseNameList;
}
private static boolean checkIncludeUnconfirmedLicense(List<ProjectIdentification> licenseList) {
if (licenseList != null) {
for (ProjectIdentification bean : licenseList) {
if (!isEmpty(bean.getLicenseName()) && !CoCodeManager.LICENSE_INFO_UPPER.containsKey(bean.getLicenseName().toUpperCase())) {
return true;
}
}
}
return false;
}
public static List<ProjectIdentification> makeLicensePermissiveList(List<ProjectIdentification> licenses, String currentLicense) {
List<List<ProjectIdentification>> andCombLicenseList = new ArrayList<>();
for (ProjectIdentification bean : licenses) {
if (andCombLicenseList.size() == 0 || "OR".equals(bean.getOssLicenseComb())) {
andCombLicenseList.add(new ArrayList<>());
}
andCombLicenseList.get(andCombLicenseList.size()-1).add(bean);
}
List<ProjectIdentification> licenseList = new ArrayList<>();
int pmsCnt = 0;
int wcpCnt = 0;
int cpCnt = 0;
int pfCnt = 0;
int naCnt = 0;
for (List<ProjectIdentification> andList : andCombLicenseList) {
switch(getLicensePermissive(andList)) {
case CoConstDef.CD_LICENSE_TYPE_PMS:
if (pmsCnt == 0) {
licenseList = andList;
pmsCnt++;
}
break;
case CoConstDef.CD_LICENSE_TYPE_WCP:
if (pmsCnt == 0 && wcpCnt == 0) {
licenseList = andList;
wcpCnt++;
}
break;
case CoConstDef.CD_LICENSE_TYPE_CP:
if (pmsCnt == 0 && wcpCnt == 0 && cpCnt == 0) {
licenseList = andList;
cpCnt++;
}
break;
case CoConstDef.CD_LICENSE_TYPE_PF:
if (pmsCnt == 0 && wcpCnt == 0 && cpCnt == 0 && pfCnt == 0) {
licenseList = andList;
pfCnt++;
}
break;
case CoConstDef.CD_LICENSE_TYPE_NA:
if (pmsCnt == 0 && wcpCnt == 0 && cpCnt == 0 && pfCnt == 0 && naCnt == 0) {
licenseList = andList;
naCnt++;
}
break;
}
}
return licenseList;
}
public static List<String> checkUserPermissions(String userId, String[] prjIds, String gubn) {
List<String> notPermissionList = new ArrayList<>();
List<String> userIdList = null;
switch(gubn) {
case "project":
Project param = new Project();
for (int i=0; i<prjIds.length; i++) {
userIdList = new ArrayList<>();
Project bean = projectService.getProjectBasicInfo(prjIds[i]);
userIdList.add(bean.getCreator());
param.setPrjId(prjIds[i]);
List<Project> watcherList = projectService.getWatcherList(param);
if (watcherList != null) {
for (Project watcher : watcherList) {
if (!userIdList.contains(watcher.getPrjUserId())) userIdList.add(watcher.getPrjUserId());
}
}
if (!isEmpty(userId)) {
if (!userIdList.contains(userId)) {
notPermissionList.add(prjIds[i]);
}
} else {
notPermissionList = userIdList;
}
}
break;
case "partner":
PartnerMaster partner = new PartnerMaster();
for (int i=0; i<prjIds.length; i++) {
userIdList = new ArrayList<>();
partner.setPartnerId(prjIds[i]);
PartnerMaster bean = partnerService.getPartnerMasterOne(partner);
userIdList.add(bean.getCreator());
if (bean.getPartnerWatcher() != null) {
for (String watcher : bean.getPartnerWatcher().stream().map(e -> e.getUserId()).collect(Collectors.toList())) {
userIdList.add(watcher);
}
}
userIdList = userIdList.stream().distinct().collect(Collectors.toList());
if (!isEmpty(userId)) {
if (!userIdList.contains(userId)) {
notPermissionList.add(prjIds[i]);
}
} else {
notPermissionList = userIdList;
}
}
break;
}
Collections.sort(notPermissionList);
return notPermissionList;
}
public static void setSslWithCert() throws CertificateException, IOException, KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
// Load CAs from an InputStream
CertificateFactory cf = CertificateFactory.getInstance("X.509");
InputStream caInput = new BufferedInputStream(new FileInputStream(getProperty("lge.root.ca.file")));
Certificate ca;
try {
ca = cf.generateCertificate(caInput);
log.debug("ca=" + ((X509Certificate) ca).getSubjectDN());
} finally {
caInput.close();
}
// Create a KeyStore containing our trusted CAs
String keyStoreType = KeyStore.getDefaultType();
KeyStore keyStore = KeyStore.getInstance(keyStoreType);
keyStore.load(null, null);
keyStore.setCertificateEntry("ca", ca);
// Create a TrustManager that trusts the CAs in our KeyStore
String tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
TrustManagerFactory tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
tmf.init(keyStore);
// Create an SSLContext that uses our TrustManager
SSLContext context = SSLContext.getInstance("TLS");
context.init(null, tmf.getTrustManagers(), null);
SSLContext.setDefault(context);
}
public void setSslWithNoCert() throws NoSuchAlgorithmException, KeyManagementException {
SSLContext context = SSLContext.getInstance("TLS");
X509TrustManager tm;
tm = new X509TrustManager() {
public void checkClientTrusted(X509Certificate[] xcs, String string) throws CertificateException {}
public void checkServerTrusted(X509Certificate[] xcs, String string) throws CertificateException {}
public X509Certificate[] getAcceptedIssuers() {return new X509Certificate[0];}
};
context.init(null, new TrustManager[]{tm}, null);
SSLContext.setDefault(context);
}
public static String getConversionCveInfo(String referenceId, Map<String, OssMaster> ossInfoMap, ProjectIdentification identification, List<String> cvssScoreMaxVendorProductList, List<String> cvssScoreMaxList, boolean vulnFixedCheckFlag) {
List<String> rtnScoreList = new ArrayList<>();
List<String> cvssScoreList = null;
String ossName = identification.getOssName();
String refOssName = avoidNull(identification.getRefOssName(), identification.getOssName());
String ossVersion = avoidNull(identification.getOssVersion());
String standardScore = CoCodeManager.getCodeExpString(CoConstDef.CD_VULNERABILITY_MAILING_SCORE, CoConstDef.CD_VULNERABILITY_MAILING_SCORE_STANDARD);
OssMaster om = new OssMaster();
om.setPrjId(referenceId);
boolean vendorProductCheckFlag = false;
String ossId = null;
if (!isEmpty(ossName) && !ossName.equals("-")){
OssMaster bean = ossInfoMap.get((avoidNull(refOssName, ossName)+"_"+ossVersion).toUpperCase());
if (bean != null) ossId = bean.getOssId();
}
if (cvssScoreMaxVendorProductList != null && !cvssScoreMaxVendorProductList.isEmpty()) {
cvssScoreList = cvssScoreMaxVendorProductList;
} else {
cvssScoreList = cvssScoreMaxList;
vendorProductCheckFlag = true;
}
if (!cvssScoreList.isEmpty()) {
String[] cvssScoreMaxString = null;
for (String cvssScoreMaxStr : cvssScoreList) {
cvssScoreMaxString = cvssScoreMaxStr.split("\\@");
String vendorProductName = cvssScoreMaxString[2] + "-" + cvssScoreMaxString[0];
String existenceOssName = (cvssScoreMaxString[2] + "-" + cvssScoreMaxString[0] + "_" + ossVersion).toUpperCase();
String product = cvssScoreMaxString[0];
Float cvssScore = Float.valueOf(cvssScoreMaxString[3]);
om.setOssName(avoidNull(refOssName, ossName));
om.setOssVersion(ossVersion);
String[] ossNicknames = null;
if (!isEmpty(refOssName)) {
ossNicknames = ossService.getOssNickNameListByOssName(refOssName);
} else {
ossNicknames = ossService.getOssNickNameListByOssName(ossName);
}
if (ossNicknames != null) om.setOssNicknames(ossNicknames);
if (vulnFixedCheckFlag) {
om.setVulnerabilityCheckFlag(CoConstDef.FLAG_YES);
} else {
om.setVulnerabilityCheckFlag(null);
}
if (vendorProductCheckFlag) {
boolean existsVendorProductBooleanFlag = false;
OssMaster ossMaster = ossInfoMap.get(existenceOssName);
if (ossMaster != null && !ossMaster.getOssId().equals(ossId)) {
existsVendorProductBooleanFlag = true;
} else {
om.setSchOssName(vendorProductName);
List<String> existsVendorProeuctMatchOssIdList = ossService.checkExistsVendorProductMatchOss(om);
if (existsVendorProeuctMatchOssIdList != null && !existsVendorProeuctMatchOssIdList.isEmpty()) {
int idx = 0;
for (String matchOssId : existsVendorProeuctMatchOssIdList) {
if (!matchOssId.equals(ossId)) {
idx++;
}
}
if (existsVendorProeuctMatchOssIdList.size() == idx) existsVendorProductBooleanFlag = true;
}
}
om.setSchOssName(null);
om.setDashOssNameList(null);
om.setOssVersion(om.getOssVersion().isEmpty() ? "-" : om.getOssVersion());
if (existsVendorProductBooleanFlag || cvssScore >= Float.valueOf(standardScore)) {
om.setOssName(product);
om.setSchOssName(avoidNull(refOssName, ossName));
List<String> cveDataList2 = ossService.selectVulnInfoForOss(om);
if (existsVendorProductBooleanFlag) {
String checkNvdData = cvssScoreMaxString[3] + "@" + cvssScoreMaxString[4];
for (String cveData2 : cveDataList2) {
String[] cveData2Split = cveData2.split("\\@");
String chkNvdData = cveData2Split[3] + "@" + cveData2Split[4];
if (!checkNvdData.equals(chkNvdData)) {
rtnScoreList.add(cveData2);
}
}
} else {
rtnScoreList.addAll(cveDataList2);
}
} else {
rtnScoreList.add(cvssScoreMaxStr);
}
} else {
om.setOssName(product);
om.setSchOssName(avoidNull(refOssName, ossName));
om.setOssVersion(om.getOssVersion().isEmpty() ? "-" : om.getOssVersion());
List<String> cveDataList2 = ossService.selectVulnInfoForOss(om);
if (cveDataList2 != null && !cveDataList2.isEmpty()) rtnScoreList.addAll(cveDataList2);
}
}
if (!rtnScoreList.isEmpty()) {
rtnScoreList = rtnScoreList.stream().distinct().collect(Collectors.toList());
if (rtnScoreList.size() > 1) {
Collections.sort(rtnScoreList, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
if (new BigDecimal(o1.split("\\@")[3]).compareTo(new BigDecimal(o2.split("\\@")[3])) > 0) {
return -1;
}else {
return 1;
}
}
});
}
return rtnScoreList.get(0);
} else {
return null;
}
} else {
return null;
}
}
public static String getConversionCveInfoForList(List<String> cvssScoreMaxList) {
List<String> cvssScoreList = cvssScoreMaxList;
if (!cvssScoreList.isEmpty()) {
cvssScoreList = cvssScoreList.stream().distinct().collect(Collectors.toList());
if (cvssScoreList.size() > 1) {
Collections.sort(cvssScoreList, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
if (new BigDecimal(o1.split("\\@")[3]).compareTo(new BigDecimal(o2.split("\\@")[3])) > 0) {
return -1;
}else {
return 1;
}
}
});
}
return cvssScoreList.get(0);
} else {
return null;
}
}
public static String checkNvdInfoForProduct(Map<String, OssMaster> ossInfoMap, List<String> productCheckList) {
List<String> rtnScoreList = new ArrayList<>();
OssMaster om = new OssMaster();
String[] cvssScoreMaxString = null;
for (String cvssScoreMaxStr : productCheckList) {
cvssScoreMaxString = cvssScoreMaxStr.split("\\@");
if (!cvssScoreMaxString[2].isEmpty()) {
boolean cvssScoreCheckFlag = false;
String ossVersion = !cvssScoreMaxString[0].equals("-") ? cvssScoreMaxString[1] : "";
OssMaster bean = ossInfoMap.get((cvssScoreMaxString[0] + "_" + ossVersion).toUpperCase());
om.setSchOssName(cvssScoreMaxString[0] + "-" + cvssScoreMaxString[2]);
om.setOssVersion(ossVersion);
List<String> matchOssIdList = ossService.checkExistsVendorProductMatchOss(om);
if (matchOssIdList != null && !matchOssIdList.isEmpty()) {
for (String matchOssId : matchOssIdList) {
if (matchOssId.equals(bean.getOssId())) {
cvssScoreCheckFlag = true;
break;
}
}
}
if (!cvssScoreCheckFlag) {
rtnScoreList.add(cvssScoreMaxStr);
}
}
}
if (!rtnScoreList.isEmpty()) {
rtnScoreList = rtnScoreList.stream().distinct().collect(Collectors.toList());
if (rtnScoreList.size() > 1) {
Collections.sort(rtnScoreList, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
if (new BigDecimal(o1.split("\\@")[3]).compareTo(new BigDecimal(o2.split("\\@")[3])) > 0) {
return -1;
}else {
return 1;
}
}
});
}
return rtnScoreList.get(0);
} else {
return null;
}
}
public static String getMessageForVulDOC(HttpServletRequest request, String gubn) {
String vulDocMsg = null;
if (gubn.equals("inst")) {
String installLink = "<a target='_blank' href='http://collab.lge.com/main/x/jhbZeg' style='color:blue;'>VulDOC Privacy and Credential Analyzer - Install</a>";
String webLink = "<a target='_blank' href='http://collab.lge.com/main/x/Sb2ig' style='color:blue;'>VulDOC Privacy and Credential Analyzer - Web</a>";
String isInfo = "<a target='_blank' href='http://collab.lge.com/main/x/NyM_cg' style='color:blue;'>";
String lang = "";
Cookie[] cookies = request.getCookies();
for (Cookie cookie : cookies) {
if (cookie.getName().equals("lang")) {
lang = cookie.getValue();
break;
}
}
if (lang.equals("en-US")) {
isInfo += "sensitive or credential information<a>";
vulDocMsg = getMessage("msg.project.packaging.vuldoc.instructions" , new String[]{installLink, webLink, isInfo});
} else {
isInfo += "์ค์ ๋ฏผ๊ฐ ์ ๋ณด</a>";
vulDocMsg = getMessage("msg.project.packaging.vuldoc.instructions" , new String[]{installLink, webLink, isInfo});
}
} else {
String vulDocInfoLink = "<a target='_blank' href='http://collab.lge.com/main/display/SWSEC/%5B6%5D+Getting+Help+and+Support' style='color:blue;'>CSG Task</a>";
vulDocMsg = getMessage("msg.project.packaging.vuldoc.info" , new String[]{vulDocInfoLink});
}
return vulDocMsg;
}
@SuppressWarnings("unchecked")
public static void setDeduplicatedMessageInfo(Map<String, Object> result) {
Map<String, String> rtnMsgMapByValid = new HashMap<>();
Map<String, String> rtnMsgMapByValidAndDiff = new HashMap<>();
if (result.containsKey("infoData")) {
Map<String, String> infoDataMap = (Map<String, String>) result.get("infoData");
if (result.containsKey("validData")) {
Map<String, String> validDataMap = (Map<String, String>) result.get("validData");
for (String key : infoDataMap.keySet()) {
if (!validDataMap.containsKey(key)) {
rtnMsgMapByValid.put(key, infoDataMap.get(key));
}
}
}
if(result.containsKey("diffData")) {
Map<String, String> diffDataMap = (Map<String, String>) result.get("diffData");
if (!rtnMsgMapByValid.isEmpty()) {
for (String key : rtnMsgMapByValid.keySet()) {
if (!diffDataMap.containsKey(key)) {
rtnMsgMapByValidAndDiff.put(key, rtnMsgMapByValid.get(key));
}
}
} else {
for (String key : diffDataMap.keySet()) {
if (!diffDataMap.containsKey(key)) {
rtnMsgMapByValid.put(key, infoDataMap.get(key));
}
}
}
}
}
if (!rtnMsgMapByValidAndDiff.isEmpty()) {
result.put("infoData", rtnMsgMapByValidAndDiff);
} else {
result.put("infoData", rtnMsgMapByValid);
}
}
public static Object copyObject(Object obj, String gubn) {
if (gubn.equals("OM")) {
OssMaster bean = (OssMaster) obj;
OssMaster copiedBean = new OssMaster();
copiedBean.setOssId(bean.getOssId());
copiedBean.setOssName(bean.getOssName());
copiedBean.setOssVersion(bean.getOssVersion());
copiedBean.setLicenseName(bean.getLicenseName());
copiedBean.setOssLicenses(bean.getOssLicenses());
copiedBean.setDetectedLicenses(bean.getDetectedLicenses());
copiedBean.setOssNickname(bean.getOssNickname());
copiedBean.setOssNicknames(bean.getOssNicknames());
copiedBean.setDownloadLocation(bean.getDownloadLocation());
copiedBean.setDownloadLocations(bean.getDownloadLocations());
copiedBean.setHomepage(bean.getHomepage());
if (!isEmpty(bean.getLicenseDiv())) {
copiedBean.setMultiLicenseFlag(bean.getLicenseDiv());
copiedBean.setLicenseDiv(bean.getLicenseDiv());
}
if (!isEmpty(bean.getLicenseType())) {
copiedBean.setLicenseType(bean.getLicenseType());
}
if (!isEmpty(bean.getObligationType())) {
copiedBean.setObligation(bean.getObligationType());
}
if (!isEmpty(bean.getModifiedDate())) {
copiedBean.setModifiedDate(bean.getModifiedDate());
}
if (!isEmpty(bean.getModifier())) {
copiedBean.setModifier(bean.getModifier());
}
if (!isEmpty(bean.getCreatedDate())) {
copiedBean.setCreatedDate(bean.getCreatedDate());
}
if (!isEmpty(bean.getCreator())) {
copiedBean.setCreator(bean.getCreator());
}
copiedBean.setAttribution(bean.getAttribution());
copiedBean.setSummaryDescription(bean.getSummaryDescription());
copiedBean.setCopyright(bean.getCopyright());
return copiedBean;
} else {
return obj;
}
}
}
| 193,887 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ColumnNameDuplicateException.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/ColumnNameDuplicateException.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(value=HttpStatus.NOT_FOUND)
public class ColumnNameDuplicateException extends RuntimeException {
/**
*
*/
private static final long serialVersionUID = 1L;
private String message;
public ColumnNameDuplicateException(String message) {
this.message = message;
}
@Override
public String getMessage() {
return message;
}
}
| 618 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ColumnMissingException.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/ColumnMissingException.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(value=HttpStatus.NOT_FOUND)
public class ColumnMissingException extends RuntimeException {
/**
*
*/
private static final long serialVersionUID = 1L;
private String message;
public ColumnMissingException(String message) {
this.message = message;
}
@Override
public String getMessage() {
return message;
}
}
| 606 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
AjaxSessionTimeoutFilter.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/AjaxSessionTimeoutFilter.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.context.SecurityContextHolder;
public class AjaxSessionTimeoutFilter implements Filter {
private String ajaxHaeder = "AJAX";
private static final Logger log = LoggerFactory.getLogger(AjaxSessionTimeoutFilter.class.getName());
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
boolean ignoreCheck = "/system/user/saveAjax".equals(req.getRequestURI());
if (!ignoreCheck && isAjaxRequest(req)) {
// spring security check ํ์
// ์์๋ก ์๋์ฒดํฌ ์ถ๊ฐ
Authentication auth = SecurityContextHolder.getContext().getAuthentication();
if (auth == null || "anonymousUser".equalsIgnoreCase(auth.getName()) || !auth.isAuthenticated()) {
log.error("handle sendError: " + HttpServletResponse.SC_FORBIDDEN);
res.sendError(HttpServletResponse.SC_FORBIDDEN);
} else {
try {
chain.doFilter(req, res);
return;
} catch (AccessDeniedException e) {
log.error("sendError: " + HttpServletResponse.SC_FORBIDDEN);
res.sendError(HttpServletResponse.SC_FORBIDDEN);
} catch (AuthenticationException e) {
log.error("sendError: " + HttpServletResponse.SC_UNAUTHORIZED);
res.sendError(HttpServletResponse.SC_UNAUTHORIZED);
}
}
} else {
chain.doFilter(req, res);
return;
}
}
private boolean isAjaxRequest(HttpServletRequest req) {
return req.getHeader(ajaxHaeder) != null && req.getHeader(ajaxHaeder).equals(Boolean.TRUE.toString());
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
// TODO Auto-generated method stub
}
@Override
public void destroy() {
// TODO Auto-generated method stub
}
public void setAjaxHeader(String ajaxHeader) {
this.ajaxHaeder = ajaxHeader;
}
}
| 3,098 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
SearchType.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/SearchType.java | package oss.fosslight.common;
public enum SearchType {
OSS("OSS"),
PROJECT("PROJECT"),
LICENSE("LICENSE"),
SELF_CHECK("SELF_CHECK"),
THIRD_PARTY("THIRD_PARTY"),
VULNERABILITY("VULNERABILITY");
private final String name;
SearchType(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
| 373 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CorsFilter.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/CorsFilter.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class CorsFilter implements Filter {
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
HttpServletResponse response = (HttpServletResponse) res;
HttpServletRequest request = (HttpServletRequest) req;
response.setHeader("Access-Control-Allow-Origin", "*");
response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE");
response.setHeader("Access-Control-Max-Age", "3600");
response.setHeader("Access-Control-Allow-Headers", "*");
if ("OPTIONS".equalsIgnoreCase(request.getMethod())) {
response.setStatus(HttpServletResponse.SC_OK);
}else {
chain.doFilter(req, res);
}
}
@Override
public void init(FilterConfig filterConfig) {}
@Override
public void destroy() {}
}
| 1,562 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
Url.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/Url.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
public final class Url {
/** The Constant TILES_ROOT. */
public static final String TILES = "tiles";
public static final String TILES_ROOT = "tiles/admin";
public static final String TILES_AJAX_ROOT = "tiles/ajax";
public static final class SESSION {
public static final String PATH = "/session";
public static final String LOGIN = PATH + "/login";
public static final String LOGIN_JSP = TILES + PATH + "/login";
public static final String LOGIN_EXPIRED = PATH + "/loginExpired";
public static final String SESSION_SAVE_KEY_VAL = PATH + "KeyValSave/{sesKey}/**";
}
/**
* ๊ด๋ฆฌ์ ๋ฉ์ธ ํ๋ฉด.
*/
public static final class MAIN {
public static final String PATH = "/main";
/** ๋ฉ์ธ ํ์ด์ง: {@value #INDEX}. */
public static final String INDEX_EMPTY = "/";
public static final String INDEX = "/index";
public static final String INDEX_JSP = TILES + PATH + "/index";
}
public static final class AUTH {
public static final String LOGIN = "";
public static final String LOGIN_PROC = "";
public static final String LOGOUT = "/";
}
public static final class DASHBOARD {
public static final String PATH = "/dashboard";
public static final String LIST = PATH + "/list";
public static final String LIST_JSP = TILES_ROOT + PATH + "/list";
public static final String JOBSLIST = PATH + "/jobsListAjax";
public static final String COMMENTLIST = PATH + "/commentsListAjax";
public static final String OSSLIST = PATH + "/ossListAjax";
public static final String LICENSELIST = PATH + "/licenseListAjax";
public static final String READCONFIRM_ALL = PATH + "/readConfirmAll";
}
public static final class LICENSE {
public static final String PATH = "/license";
public static final String LIST = PATH + "/list";
public static final String LIST_JSP = TILES_ROOT + PATH + "/list";
public static final String EDIT = PATH + "/edit";
public static final String EDIT_JSP = TILES_ROOT + PATH + "/edit";
public static final String EDIT_ID = PATH + "/edit/{licenseId}";
public static final String LICENSE_VIEW_JSP = TILES_ROOT + PATH + "/view";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String VALIDATION = PATH + "/validation";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String DEL_AJAX = PATH + "/delAjax";
public static final String SAVE_COMMENT = PATH + "/saveComment";
public static final String DELETE_COMMENT = PATH + "/deleteComment";
public static final String LICENSE_TEXT = PATH + "/getLicenseText";
public static final String AUTOCOMPLETE_AJAX = PATH + "/autoCompleteAjax";
public static final String LICENSE_ID = PATH + "/getLicenseId";
/**Add LicenseBulkReg path*/
public static final String LICENSE_BULK_REG = PATH + "/licenseBulkReg";
public static final String BULK_REG_AJAX = PATH+"/bulkRegAjax";
public static final String LICENSE_BULK_REG_JSP = TILES_ROOT + PATH + "/licenseBulkReg";
public static final String CSV_FILE = PATH + "/csvFile";
public static final String BULK_VALIDATION = PATH + "/bulkValidation";
}
public static final class EXCELDOWNLOAD {
public static final String PATH = "/exceldownload";
public static final String EXCEL_POST = PATH + "/getExcelPost";
public static final String FILE = PATH + "/getFile";
public static final String EXCEL_POST_OSS = PATH + "/getExcelPostOss";
public static final String CHART_EXCEL = PATH + "/getChartExcel";
}
public static final class COMMENT {
public static final String PATH = "/comment";
public static final String COMMENT_LIST = PATH + "/getCommentList";
public static final String MORE_COMMENT_LIST = PATH + "/getMoreCommentList";
public static final String COMMENT_LIST_JSP = TILES_ROOT + PATH + "/list";
public static final String POPUP = PATH + "/popup/{rDiv}/{rId}";
public static final String POPUP_JSP = TILES_ROOT + PATH + "/popup";
public static final String DELETE_COMMENT = PATH + "/deleteComment";
public static final String UPDATE_COMMENT = PATH + "/updateComment";
public static final String COMMENT_INFO_ID = PATH + "/getCommentInfo/{commId}";
public static final String DIV_COMMENT_LIST = PATH + "/getDivCommentList";
}
public static final class PROCESSGUIDE {
public static final String PATH = "/system/processGuide";
public static final String PAGE = PATH + "";
public static final String PAGE_JSP = TILES_ROOT + PATH + "";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String PROCESS_GUIDE = PATH + "/getProcessGuide";
}
public static final class OSS {
public static final String PATH = "/oss";
public static final String LIST = PATH + "/list";
public static final String LIST_LINK = PATH + "/list/{ossName}";
public static final String LIST_JSP = TILES_ROOT + PATH + "/list";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String EDIT = PATH + "/edit";
public static final String EDIT_JSP = TILES_ROOT + PATH + "/edit";
public static final String EDIT_ID = PATH + "/edit/{ossId}";
public static final String VIEW_JSP = TILES_ROOT + PATH + "/view";
public static final String AUTOCOMPLETE_AJAX = PATH + "/autoCompleteAjax";
public static final String POPUPLIST_ID = PATH + "/ossPopupList/{ossId}";
public static final String COPY_ID = PATH + "/copy/{ossId}";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String DEL_AJAX = PATH + "/delAjax";
public static final String MULTI_DEL_AJAX = PATH + "/multiDelAjax";
public static final String DEL_OSS_VERSION_MERGE_AJAX = PATH + "/delOssWithVersionMeregeAjax";
public static final String URL_DUPLICATE_VALIDATION = PATH + "/urlDuplicateValidation";
public static final String VALIDATION = PATH + "/validation";
public static final String BULK_VALIDATION = PATH + "/bulkValidation";
public static final String CHECK_EXIST_OSS_CONF = PATH + "/checkExistOssConf";
public static final String CHECK_VD_DIFF = PATH + "/checkVdiff";
public static final String SAVE_COMMENT = PATH + "/saveComment";
public static final String DELETE_COMMENT = PATH + "/deleteComment";
public static final String OSS_MERGE_CHECK_LIST = PATH + "/ossMergeCheckList/{ossId}/{newOssId}";
public static final String SAVE_SESSION_OSS_INFO = PATH + "/saveSessionOssInfo";
public static final String OSS_LIST_BY_NAME = PATH + "/getOssListByName";
public static final String OSS_BULK_REG = PATH + "/ossBulkReg";
public static final String OSS_BULK_REG_JSP = TILES_ROOT + PATH + "/ossBulkReg";
public static final String BULK_REG_AJAX = PATH+"/bulkRegAjax";
//public static final String OSS_BULK_REG_AJAX = PATH + "/bulkRegAjax";
public static final String OSS_BULK_REG_AJAX = PATH + "/bulkRegAjax";
public static final String CSV_FILE = PATH + "/csvFile";
//public static final String OSS_BULK_REG_AJAX = PATH + "/getOssBulkRegAjax";
public static final String SAVE_OSS_BULK_REG = PATH + "/saveOssBulkReg";
public static final String OSS_POPUP = PATH + "/osspopup";
public static final String OSS_POPUP_JSP = TILES_ROOT + PATH + "/osspopup";
public static final String OSS_DETAIL_VIEW_AJAX = PATH + "/ossDetailViewAjax";
public static final String OSS_DETAILS_VIEW_AJAX_JSP = TILES_AJAX_ROOT + PATH + "/ossDetailview";
public static final String CHECK_EXISTS_OSS_BY_NAME = PATH + "/checkExistsOssByname";
public static final String CHECK_OSS_NAME = PATH + "/checkOssName";
public static final String CHECK_OSS_NAME_JSP = TILES_ROOT + PATH + "/checkOssNamepopup";
public static final String CHECK_OSS_NAME_AJAX = PATH + "/getCheckOssNameAjax/{targetName}";
public static final String SAVE_OSS_CHECK_NAME = PATH + "/saveOssCheckName/{targetName}";
public static final String SAVE_OSS_NICKNAME = PATH + "/saveOssNickname";
public static final String SAVE_OSS_URL_NICKNAME = PATH + "/saveOssURLNickName";
public static final String CHECK_OSS_LICENSE = PATH + "/checkOssLicense";
public static final String CHECK_OSS_LICENSE_JSP = TILES_ROOT + PATH + "/checkOssLicensepopup";
public static final String CHECK_OSS_LICENSE_AJAX = PATH + "/getCheckOssLicenseAjax/{targetName}";
public static final String SAVE_OSS_CHECK_LICENSE = PATH + "/saveOssCheckLicense/{targetName}";
public static final String SAVE_OSS_ANALYSIS_LIST = PATH + "/saveOssAnalysisList/{targetName}";
public static final String OSS_AUTO_ANALYSIS = PATH + "/ossAutoAnalysis";
public static final String OSS_AUTO_ANALYSIS_JSP = TILES_ROOT + PATH + "/ossAutoAnalysispopup";
public static final String AUTO_ANALYSIS_LIST = PATH + "/getAutoAnalysisList";
public static final String START_ANALYSIS = PATH + "/startAnalysis";
public static final String ANALYSIS_RESULT_LIST = PATH + "/getAnalysisResultList";
public static final String SET_SESSION_ANALYSIS_RESULT_DATA = PATH + "/setSessionAnalysisResultData";
public static final String SESSION_ANALYSIS_RESULT_DATA = PATH + "/getSessionAnalysisResultData";
public static final String SAVE_OSS_ANALYSIS_DATA = PATH + "/saveOssAnalysisData";
public static final String ANALYSIS_RESULT_DETAIL_ID = PATH + "/getAnalysisResultDetail/{groupId}";
public static final String ANALYSIS_RESULT_DETAIL_JSP = TILES_ROOT + PATH + "/ossAnalysisResultDetailpopup";
public static final String CHECK_LICENSE_TEXT_VALIDATION = "/checkLicenseText/valid";
public static final String START_CHECK_LICENSE_TEXT = "/checkLicenseText/start";
public static final String UPDATE_ANALYSIS_COMPLETE = PATH + "/updateAnalysisComplete";
public static final String OSS_SYNC_POPUP = PATH + "/osssyncpopup";
public static final String OSS_SYNC_POPUP_JSP = TILES_ROOT + PATH + "/osssyncpopup";
public static final String OSS_SYNC_DETAIL_VIEW_AJAX = PATH + "/ossSyncDetailViewAjax";
public static final String OSS_SYNC_DETAILS_VIEW_AJAX_JSP = TILES_AJAX_ROOT + PATH + "/ossSyncDetailview";
public static final String OSS_SYNC_UPDATE = PATH + "/ossSyncUpdate";
public static final String OSS_SYNC_LIST_VALIDATION = PATH + "/ossSyncListValidation";
public static final String OSS_BULK_EDIT_POPUP = PATH + "/ossBulkEditPopup";
public static final String OSS_BULK_EDIT_POPUP_JSP = TILES_ROOT + PATH + "/ossBulkEditPopup";
public static final String CHECK_OSS_VERSION_DIFF = PATH + "/checkOssVersionDiff";
public static final String CHECK_OSS_NAME_DIFF = PATH + "/checkOssNameDiff";
}
public static final class PROJECT {
public static final String PATH = "/project";
public static final String LIST = PATH + "/list";
public static final String LIST_JSP = TILES_ROOT + PATH + "/list";
public static final String EDIT = PATH + "/edit";
public static final String EDIT_JSP = TILES_ROOT + PATH + "/edit";
public static final String EDIT_ID = PATH + "/edit/{prjId}";
public static final String VIEW_ID = PATH + "/view/{prjId}";
public static final String VIEW_JSP = TILES_ROOT + PATH + "/view";
public static final String AUTOCOMPLETE_AJAX = PATH + "/autoCompleteAjax";
public static final String AUTOCOMPLETE_VERSION_AJAX = PATH + "/autoCompleteVersionAjax";
public static final String AUTOCOMPLETE_MODEL_AJAX = PATH + "/autoCompleteModelAjax";
public static final String AUTOCOMPLETE_ID_AJAX = PATH + "/autoCompleteIdAjax";
public static final String USER_ID_LIST = PATH + "/getUserIdList";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String DEL_AJAX = PATH + "/delAjax";
public static final String SAVE_3RD = PATH + "/save3rd";
public static final String SAVE_DEP = PATH + "/saveDep";
public static final String SAVE_SRC = PATH + "/saveSrc";
public static final String SAVE_BIN = PATH + "/saveBin";
public static final String SAVE_BINANDROID = PATH + "/saveBinAndroid";
public static final String DELETE_FILEANDROID = PATH + "/deleteFileAndroid";
public static final String SAVE_BOM = PATH + "/saveBom";
public static final String SAVE_BAT = PATH + "/saveBat";
public static final String IDENTIFICATION_GRID_ID_CD = PATH + "/identificationGrid/{prjId}/{code}";
public static final String MODELLIST_AJAX = PATH + "/modellistAjax";
public static final String CATEGORY_CODE_TOJSON = PATH + "/getCategoryCodeToJson";
public static final String OSS_NAMES = PATH + "/getOssNames";
public static final String OSS_VERSIONS = PATH + "/getOssVersions";
public static final String UPDATE_REVIEWER = PATH + "/updateReviewer";
public static final String UPDATE_REJECT = PATH + "/updateReject";
public static final String CATEGORY_CODE = PATH + "/getCategoryCode";
public static final String OSS_ID_LICENSES = PATH + "/getOssIdLicenses";
public static final String NICKNAME_CD = PATH + "/nickNameValid/{code}";
public static final String UPDATE_PROJECT_STATUS = PATH + "/updateProjectStatus";
public static final String IDENTIFICATION_ID_DIV = PATH + "/identification/{prjId}/{initDiv}";
public static final String IDENTIFICATION_JSP = TILES_ROOT + PATH + "/identification";
public static final String IDENTIFICATION_CD = PATH + "/identificationProject/{code}";
public static final String IDENTIFICATION_PROJECT_SEARCH_CD = PATH + "/identificationProjectSearch/{code}";
public static final String IDENTIFICATION_THIRD = PATH + "/identificationThird";
public static final String IDENTIFICATION_GRID_POST = PATH + "/identificationGridPost";
public static final String IDENTIFICATION_MERGED_GRID_ID_CD = PATH + "/identificationMergedGrid/{prjId}/{code}";
public static final String TRD_OSS = PATH + "/3rdOss";
public static final String ANDROID_SHEET_NAME = PATH + "/androidSheetName";
public static final String OSS_ID_CHECK = PATH + "/getOssIdCheck";
public static final String CHECK_CHANGE_DATA = PATH + "/getCheckChangeData";
public static final String CANCEL_FILE_DEL_SRC = PATH + "/cancelFileDelSrc";
public static final String FILE_INFO = PATH + "/getFileInfo";
public static final String TRD_MAP = PATH + "/get3rdMap";
public static final String ADD_WATCHER = PATH + "/addWatcher";
public static final String ADD_WATCHERS = PATH + "/addWatchers";
public static final String REMOVE_WATCHER = PATH + "/removeWatcher";
public static final String REMOVE_WATCHERS = PATH + "/removeWatchers";
public static final String COPY_WATCHER = PATH + "/copyWatcher";
public static final String SAVE_MODEL_AJAX = PATH + "/saveModelAjax";
public static final String UPDATE_PUBLIC_YN = PATH + "/updatePublicYn";
public static final String PROJECT_TO_ADD_LIST = PATH + "/projectToAddList";
public static final String ADD_LIST = PATH + "/getAddList";
public static final String PARTNER_LIST = PATH + "/getPartnerList";
public static final String BIN_CSV_FILE = PATH + "/binCsvFile";
public static final String CSV_FILE = PATH + "/csvFile";
public static final String SHEET_DATA = PATH + "/getSheetData";
public static final String SEND_COMMENT = PATH + "/sendComment";
public static final String ANALYSIS = PATH + "/analysis";
public static final String COPY_ID = PATH + "/copy/{prjId}";
public static final String ANDROID_FILE = PATH + "/androidFile";
public static final String ANDROID_APPLY = PATH + "/androidApply";
public static final String PARTNER_OSS_FROM_PROJECT = PATH + "/partnerOssFromProject";
public static final String COMMENTS_SAVE = PATH + "/commentsSave";
public static final String SAVE_COMMENT = PATH + "/saveComment";
public static final String COMMENTS_IGNORE = PATH + "/commentsIgnore";
public static final String MODEL_FILE = PATH + "/modelFile";
public static final String SUPPLEMENT_NOTICE_FILE = PATH + "/getSupplementNoticeFile";
public static final String BOM_COMPARE = PATH + "/bomCompare/{beforePrjId}/{afterPrjId}";
public static final String PAGE_JSP = TILES_ROOT + PATH + "/bomCompare";
public static final String BOM_COMPARE_LIST_AJAX = PATH + "/bomCompare/listAjax";
public static final String PROJECT_STATUS = PATH + "/getProjectStatus";
public static final String PROJECT_BINARY_FILE = PATH + "/getProjectBinaryFile";
public static final String PROJECT_BINARY_DB_SAVE = PATH + "/binaryDBSave";
public static final String MAKE_YAML = PATH + "/makeYaml/{code}";
public static final String PROJECT_DIVISION = PATH + "/updateProjectDivision";
public static final String UPDATE_COMMENT = PATH + "/updateComment";
public static final String DELETE_FILES = PATH + "/deleteFiles";
public static final String SECURITY = PATH + "/security/{prjId}";
public static final String SECURITY_GRID = PATH + "/securityGrid/{prjId}/{code}";
public static final String SECURITY_JSP = TILES_ROOT + PATH + "/security";
public static final String SAVE_SECURITY = PATH + "/saveSecurity";
public static final String CHECK_REQ_ENTRY_SECURITY = PATH + "/checkReqEntrySecurity";
public static final String SEC_BULK_EDIT_POPUP = PATH + "/secBulkEditPopup";
public static final String SEC_BULK_EDIT_POPUP_JSP = TILES_ROOT + PATH + "/secBulkEditPopup";
public static final String CHECK_MERGE_AND_SAVE = PATH + "/checkMergeAndSave";
public static final String CHECK_SELECT_DOWNLOAD_FILE = PATH + "/checkSelectDownloadFile/{code}";
public static final String AUTO_REVIEW = PATH + "/autoReview/{startNow}";
public static final String AUTO_REVIEW_STATUS = PATH + "/autoReviewStatus";
public static final String AUTO_REVIEW_STOP = PATH + "/autoReviewStop";
}
public static final class VERIFICATION {
public static final String PATH = "/project/verification";
public static final String PAGE_ID = PATH + "/{prjId}";
public static final String PAGE_DIV_ID = PATH + "/{initDiv}/{prjId}";
public static final String PAGE_JSP = TILES_ROOT + PATH + "";
public static final String REGIST_FILE = PATH + "/registFile";
public static final String UPLOAD_VERIFICATION = PATH + "/uploadVerification";
public static final String VERIFY = PATH + "/verify";
public static final String SAVE_PATH = PATH + "/savePath";
public static final String NOTICE_AJAX = PATH + "/noticeAjax";
public static final String REVIEW_REPORT_AJAX = PATH + "/reviewReportAjax";
public static final String DOWNLOAD_FILE = PATH + "/downloadFile";
public static final String WGET_URL = PATH + "/wgetUrl";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String SAVE_NOTICE_AJAX = PATH + "/saveNoticeAjax";
public static final String MAKE_NOTICE_PREVIEW = PATH + "/makeNoticePreview";
public static final String DOWNLOAD_NOTICE_PREVIEW = PATH + "/downloadNoticePreview";
public static final String MAKE_NOTICE_TEXT = PATH + "/makeNoticeText";
public static final String MAKE_NOTICE_SIMPLE = PATH + "/makeNoticeSimple";
public static final String MAKE_NOTICE_TEXT_SIMPLE = PATH + "/makeNoticeTextSimple";
public static final String REUSE_PROJECT_SEARCH = PATH +"/reuseProjectSearch";
public static final String REUSE_PROJECT_PACKAGING_SEARCH = PATH + "/reuseProjectPackagingSearch";
public static final String REUSE_PACKAGING_FILE = PATH + "/reusePackagingFile";
public static final String DOWNLOAD_PACKAGE = PATH + "/downloadPackage";
public static final String DOWNLOAD_NOTICE = PATH + "/downloadNotice";
public static final String DOWNLOAD_REVIEW_REPORT = PATH + "/downloadReviewReport";
public static final String SEND_COMMENT = PATH + "/sendComment";
public static final String DOWNLOAD_PACKAGING_MULTI = PATH + "/downloadPackageMulti";
public static final String DELETE_FILE = PATH + "/deleteFile";
}
// public static final class DISTRIBUTION {
// public static final String PATH = "/project/distribution";
//
// public static final String PAGE_ID = PATH + "/{prjId}";
// public static final String PAGE_JSP = TILES_ROOT + PATH + "";
//
// public static final String AVAILABLE_CHECK = PATH + "/availableCheck";
// public static final String SAVE_AJAX = PATH + "/saveAjax";
// public static final String DISTRIBUTE_ACT = PATH + "/distribute/{action}";
//
// public static final String ACTION_LOG_HIS_LIST = PATH + "/getActionLogHisList";
// public static final String ACTION_LOG_HIS_LIST_JSP = TILES_AJAX_ROOT + PATH + "/logHis";
//
// // complete ์ดํ packaging file upload, verify, distribution ์ฒ๋ฆฌ url
// public static final String REGIST_FILE = PATH + "/registFile";
// public static final String VERIFY = PATH + "/verify";
// }
public static final class PARTNER {
public static final String PATH = "/partner";
public static final String LIST = PATH + "/list";
public static final String LIST_JSP = TILES_ROOT + PATH + "/list";
public static final String EDIT = PATH + "/edit";
public static final String EDIT_JSP = TILES_ROOT + PATH + "/edit";
public static final String EDIT_ID = PATH + "/edit/{partnerId}";
public static final String VIEW_ID = PATH + "/view/{partnerId}";
public static final String VIEW_JSP = TILES_ROOT + PATH + "/view";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String CHANGE_DIVISION_AJAX = PATH + "/changeDivisionAjax";
public static final String DEL_AJAX = PATH + "/delAjax";
public static final String AUTOCOMPLETE_CONF_NM_AJAX = PATH + "/autoCompleteConfNmAjax";
public static final String AUTOCOMPLETE_CONF_ID_AJAX = PATH + "/autoCompleteConfIdAjax";
public static final String AUTOCOMPLETE_NM_AJAX = PATH + "/autoCompleteNmAjax";
public static final String AUTOCOMPLETE_SW_NM_AJAX = PATH + "/autoCompleteSwNmAjax";
public static final String AUTOCOMPLETE_CONF_SW_NM_AJAX = PATH + "/autoCompleteConfSwNmAjax";
public static final String USER_LIST = PATH + "/getUserList";
public static final String UPDATE_REVIEWER = PATH + "/updateReviewer";
public static final String AUTOCOMPLETE_SW_VER_AJAX = PATH + "/autoCompleteSwVerAjax";
public static final String AUTOCOMPLETE_CONF_SW_VER_AJAX = PATH + "/autoCompleteConfSwVerAjax";
public static final String ADD_WATCHER = PATH + "/addWatcher";
public static final String ADD_WATCHERS = PATH + "/addWatchers";
public static final String REMOVE_WATCHER = PATH + "/removeWatcher";
public static final String REMOVE_WATCHERS = PATH + "/removeWatchers";
public static final String COPY_WATCHER = PATH + "/copyWatcher";
public static final String UPDATE_PUBLIC_YN = PATH + "/updatePublicYn";
public static final String CHANGE_STATUS = PATH + "/changeStatus";
public static final String OSS_FILE = PATH + "/ossFile";
public static final String DOCUMENT_FILE = PATH + "/documentsFile";
public static final String SEND_COMMENT = PATH + "/sendComment";
public static final String SAVE_COMMENT = PATH + "/saveComment";
public static final String DELETE_COMMENT = PATH + "/deleteComment";
public static final String COMMENT_LIST = PATH + "/getCommentList";
public static final String SAMPLEDOWNLOAD = PATH + "/sampleDownload";
public static final String FILTERED_LIST = PATH + "/getFilteredList";
public static final String CHECK_STATUS = PATH + "/checkStatus/{partnerId}";
public static final String NOTICE_TEXT = PATH + "/noticeText";
public static final String SAVE_BINARY_DB = PATH + "/saveBinaryDB";
public static final String MAKE_YAML = PATH + "/makeYaml";
public static final String PARTNER_DIVISION = PATH + "/updatePartnerDivision";
public static final String UPDATE_DESCRIPTION = PATH + "/updateDescription";
public static final String CHECK_SELECT_DOWNLOAD_FILE = PATH + "/checkSelectDownloadFile";
}
public static final class USER {
public static final String PATH = "/system/user";
public static final String LIST = PATH + "";
public static final String LIST_JSP = TILES_ROOT + PATH + "";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String MOD_AJAX = PATH + "/modAjax";
public static final String DIVISION_LIST = PATH + "/getDivisionList";
public static final String CHECK_EMAIL = PATH + "/checkEmail";
public static final String AUTOCOMPLETE_CREATOR_AJAX = PATH + "/autoCompleteCreatorAjax";
public static final String AUTOCOMPLETE_REVIEWER_AJAX = PATH + "/autoCompleteReviewerAjax";
public static final String AUTOCOMPLETE_CREATOR_DIVISION_AJAX = PATH + "/autoCompleteCreatorDivisionAjax";
public static final String CHANGE_PASSWORD = PATH + "/changePassword";
public static final String RESET_PASSWORD = PATH + "/resetPassword";
public static final String UPDATE_USERNAME_DIVISION = PATH + "/updateUserNameAndDivision";
public static final String TOKEN_PROC = PATH + "/tokenProc/{procType}";
}
public static final class VULNERABILITY {
public static final String PATH = "/vulnerability";
public static final String LIST = PATH + "/list";
public static final String LIST_JSP = TILES_ROOT + PATH + "/list";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String CHECK_CVE_ID = PATH + "/checkCveId";
public static final String AUTOCOMPLETE_AJAX = PATH + "/AutoCompleteAjax";
public static final String VERSION_AUTOCOMPLETE_AJAX = PATH + "/VersionAutoCompleteAjax";
public static final String VULN_POPUP = PATH + "/vulnpopup";
public static final String VULN_POPUP_JSP = TILES_ROOT + PATH + "/vulnpopup";
public static final String VULN_LIST = PATH + "/getVulnList";
}
public static final class SELF_CHECK {
public static final String PATH = "/selfCheck";
public static final String LIST = PATH + "/list";
public static final String LIST_JSP = TILES_ROOT + PATH + "/list";
public static final String EDIT = PATH + "/edit";
public static final String EDIT_ID = PATH + "/edit/{prjId}";
public static final String EDIT_JSP = TILES_ROOT + PATH + "/edit";
public static final String VIEW_ID = PATH + "/view/{prjId}";
public static final String VIEW_JSP = TILES_ROOT + PATH + "/view";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String OSSGRID_ID_CD = PATH + "/ossGrid/{prjId}/{code}";
public static final String VIEW_AJAX = PATH + "/selfCheckViewAjax";
public static final String VIEW_AJAX_JSP = TILES_AJAX_ROOT + PATH + "/view";
public static final String LICENSE_POPUP = PATH + "/licensepopup";
public static final String LICENSE_POPUP_JSP = TILES_ROOT + PATH + "/licensepopup";
public static final String SEND_COMMENT = PATH + "/sendComment";
public static final String SAVE_SRC = PATH + "/saveSrc";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String DEL_AJAX = PATH + "/delAjax";
public static final String LICENSE_USERGUIDE_HTML_NM = PATH + "/getLicenseUserGuideHtml/{licenseName}";
public static final String ADD_WATCHER = PATH + "/addWatcher";
public static final String REMOVE_WATCHER = PATH + "/removeWatcher";
public static final String COPY_WATCHER = PATH + "/copyWatcher";
public static final String LICENSE_DATA = PATH + "/getLicenseData";
public static final String NOTICE_AJAX = PATH + "/noticeAjax";
public static final String MAKE_NOTICE_PREVIEW = PATH + "/makeNoticePreview";
public static final String DOWNLOAD_NOTICE_PREVIEW = PATH + "/downloadNoticePreview";
public static final String MAKE_NOTICE_TEXT = PATH + "/makeNoticeText";
public static final String MAKE_NOTICE_SIMPLE = PATH + "/makeNoticeSimple";
public static final String MAKE_NOTICE_TEXT_SIMPLE = PATH + "/makeNoticeTextSimple";
public static final String MAKE_YAML = PATH + "/makeYaml";
public static final String CHECK_SELECT_DOWNLOAD_FILE = PATH + "/checkSelectDownloadFile";
}
public static final class COMPLIANCE {
public static final String PATH = "/compliance";
public static final String MODEL_STATUS = PATH + "/modelStatus";
public static final String MODEL_STATUS_JSP = TILES_ROOT + PATH + "/modelStatus";
public static final String PARTNER_LIST_STATUS = PATH + "/3rdList";
public static final String PARTNER_LIST_STATUS_JSP = TILES_ROOT + PATH + "/3rdList";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String MODEL_LIST_AJAX = PATH + "/modelListAjax";
public static final String READ_MODEL_LIST = PATH + "/readModelList";
}
public static final class EXTERNAL {
public static final String PATH = "/external";
public static final String PAGE = PATH + "/external";
public static final String PAGE_JSP = TILES_ROOT + PATH + "/external";
public static final String REQUEST_FL_SCAN = PATH + "/request-fl-scan";
}
public static final class CODE {
public static final String PATH = "/system/code";
public static final String PAGE = PATH + "";
public static final String PAGE_JSP = TILES_ROOT + PATH + "";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String DETAIL_LIST_AJAX = PATH + "/detail/listAjax";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String DETAIL_SAVE_AJAX = PATH + "/detail/saveAjax";
public static final String AUTOCOMPLETE_NO_AJAX = PATH + "/autoCompleteNoAjax";
public static final String AUTOCOMPLETE_NM_AJAX = PATH + "/autoCompleteNmAjax";
}
public static final class HISTORY {
public static final String PATH = "/system/history";
public static final String LIST = PATH + "";
public static final String LIST_JSP = TILES_ROOT + PATH + "";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String EDIT_IDX = PATH + "/edit/{idx}";
public static final String EDIT_JSP = TILES_ROOT + PATH + "-edit";
}
public static final class NOTICE {
public static final String PATH = "/system/notice";
public static final String LIST = PATH + "";
public static final String LIST_JSP = TILES_ROOT + PATH + "";
public static final String LIST_AJAX = PATH + "/listAjax";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String PUBLISHED_NOTICE = PATH + "/getPublishedNotice";
}
public static final class CONFIGURATION {
public static final String PATH = "/configuration";
public static final String EDIT = PATH + "/edit";
public static final String EDIT_JSP = TILES_ROOT + PATH + "/edit";
public static final String SAVE_AJAX = PATH + "/saveAjax";
public static final String VIEW_SEARCH_CONDITION_AJAX = PATH + "/loadDefaultSearchCondition";
public static final String VIEW_SEARCH_CONDITION_JSP = TILES_AJAX_ROOT + PATH + "/searchConditionArea";
public static final String UPDATE_SEARCH_CONDITION_AJAX = PATH + "/updateDefaultSearchCondition";
}
public static final class SENT_MAIL {
public static final String PATH = "/system/sentMail";
public static final String PAGE = PATH + "";
public static final String PAGE_JSP = TILES_ROOT + PATH + "";
public static final String LIST_AJAX = PATH + "/listAjax";
}
public static final class VULNERABILITY_HISTORY {
public static final String PATH = "/system/vulnerabilityHistory";
public static final String PAGE = PATH + "";
public static final String PAGE_JSP = TILES_ROOT + PATH + "";
public static final String LIST_AJAX = PATH + "/listAjax";
}
public static final class BINARY_DATA_HISTORY {
public static final String PATH = "/system/binaryDataHistory";
public static final String PAGE = PATH + "";
public static final String PAGE_JSP = TILES_ROOT + PATH + "";
public static final String LIST_AJAX = PATH + "/listAjax";
}
public static final class DOWNLOAD {
public static final String PATH = "/download";
public static final String SEQ_FNAME = PATH + "/{seq}/{fName:.+}";
public static final String BATGUIREPORT_ID_CHECKSUM = PATH + "/batGuiReport/{batId}/{checkSum}";
}
public static final class STATISTICS {
public static final String PATH = "/statistics";
public static final String VIEW = PATH + "/view";
public static final String VIEW_JSP = TILES_ROOT + PATH + "/view";
public static final String DIVISIONAL_PROJECT_CHART = PATH + "/divisionProjectChart";
public static final String MOST_USED_CHART = PATH + "/mostUsedChart";
public static final String UPDATED_CHART = PATH + "/updatedChart";
public static final String TRDPARTY_RELATED_CHART = PATH + "/trdPartyRelatedChart";
public static final String USER_RELATED_CHART = PATH + "/userRelatedChart";
public static final String STATISTICS_POPUP = PATH + "/statisticspopup";
public static final String STATISTICS_POPUP_JSP = TILES_ROOT + PATH + "/statisticspopup";
}
public static final class SYSTEM_CONFIGURATION {
public static final String PATH = "/system/configuration";
public static final String PAGE = PATH + "";
public static final String PAGE_JSP = TILES_ROOT + PATH + "";
public static final String SAVE_AJAX = PATH + "/saveAjax";
}
public static final class MIGRATION {
public static final String PATH = "/migration";
public static final String COPY_OSS = PATH + "/copyOss";
public static final String OSDD_LICENSE = PATH + "/osddLicense";
public static final String EXCEL_TEST = PATH + "/excelTest";
public static final String NVD_RESET = PATH + "/nvdReset";
public static final String NVD_BULK_REG = PATH + "/nvdBulkReg";
public static final String NVD_MERGE = PATH + "/nvdMerge";
public static final String SELF_VULN = PATH + "/selfvuln";
public static final String DISTRIBUTION_MODEL_SYNC = PATH + "/distributeModelSync";
public static final String DISTRIBUTION_RUN_TIMEOUT = PATH + "/distributeRunTimeout";
public static final String REG_BINARY_DB = PATH + "/regBinaryDB";
public static final String OBLIGATION_RESET = PATH + "/obligationReset";
public static final String SET_BAT_RESULT = PATH + "/setbatResult";
public static final String NVD_DATA_SET = PATH + "/nvdDataSet";
public static final String DISTRIBUTE_GET_FILE_OBJECT = PATH + "/distributeGetFileObject";
}
public static final class SPDXDOWNLOAD {
public static final String PATH = "/spdxdownload";
public static final String SPDX_POST = PATH + "/getSPDXPost";
public static final String SELFCHECK_SPDX_POST = PATH + "/getSelfcheckSPDXPost";
public static final String FILE = PATH + "/getFile";
}
public static final class CYCLONEDXDOWNLOAD {
public static final String PATH = "/cyclonedxdownload";
public static final String CYCLONEDX_POST = PATH + "/getCycloneDXPost";
public static final String FILE = PATH + "/getFile";
}
public static final class IMAGE_VIEW {
public static final String PATH = "/imageView";
public static final String IMAGE = PATH + "/{imageName:.+}";
public static final String GUI_REPORT_ID_NM = PATH + "/guiReport/{batId}/{imageName:.+}";
}
public static final class IMAGE_UPLOAD {
public static final String PATH = "/imageupload";
public static final String UPLOAD = PATH + "/upload";
public static final String UPLOAD2 = PATH + "/upload2";
}
public static final class API {
public static final String PATH = "/api/v1";
/** 3RD PARTY */
/** API 3rd Party ์กฐํ */
public static final String FOSSLIGHT_API_PARTNER_SEARCH = "/partner_search";
/** API 3rd Party Add Watcher */
public static final String FOSSLIGHT_API_PARTNER_ADD_WATCHER = "/partner_watcher_add";
/** OSS */
/** API OSS List ์กฐํ */
public static final String FOSSLIGHT_API_OSS_SEARCH = "/oss_search";
/** API OSS List ์กฐํ */
public static final String FOSSLIGHT_API_OSS_REGISTER = "/oss_register";
/** API DOWNLOAD LOCATION ์กฐํ */
public static final String FOSSLIGHT_API_DOWNLOADLOCATION_SEARCH = "/downloadlocation_search";
public static final String FOSSLIGHT_API_AUTOANALYSIS_REGISTER = "/autoAnalysis_register";
/** LICENSE */
/** API License List ์กฐํ */
public static final String FOSSLIGHT_API_LICENSE_SEARCH = "/license_search";
/** PROJECT */
/** API create Project */
public static final String FOSSLIGHT_API_PROJECT_CREATE = "/create_project";
/** API Project List ์กฐํ */
public static final String FOSSLIGHT_API_PROJECT_SEARCH = "/prj_search";
/** API Project Model List ์กฐํ */
public static final String FOSSLIGHT_API_MODEL_SEARCH = "/model_search";
/** API Update Project Model */
public static final String FOSSLIGHT_API_MODEL_UPDATE = "/model_update";
/** API Update Project Model WITH FILE */
public static final String FOSSLIGHT_API_MODEL_UPDATE_UPLOAD_FILE = "/model_update_upload_file";
/** API Project BOM Tab Export */
public static final String FOSSLIGHT_API_PROJECT_BOM_EXPORT = "/prj_bom_export";
/** API Project BOM Tab Export JSON*/
public static final String FOSSLIGHT_API_PROJECT_BOM_EXPORT_JSON = "/prj_bom_export_json";
/** API BOM COMPARE */
public static final String FOSSLIGHT_API_PROJECT_BOM_COMPARE = "/prj_bom_compare";
/** API Project Add Watcher */
public static final String FOSSLIGHT_API_PROJECT_ADD_WATCHER = "/prj_watcher_add";
/** API Project Not applicable */
public static final String FOSSLIGHT_API_PROJECT_NOT_APPLICABLE = "/prj_not_applicable";
/** API OSS Report upload */
public static final String FOSSLIGHT_API_OSS_REPORT_DEP = "/oss_report_dep";
public static final String FOSSLIGHT_API_OSS_REPORT_SRC = "/oss_report_src";
public static final String FOSSLIGHT_API_OSS_REPORT_BIN = "/oss_report_bin";
public static final String FOSSLIGHT_API_OSS_REPORT_ANDROID = "/oss_report_android";
/** API Verification Packaging Upload */
public static final String FOSSLIGHT_API_PACKAGE_UPLOAD = "/package_upload";
/** VULNABILITY */
/** vulnerability info search */
public static final String FOSSLIGHT_API_VULNERABILITY_DATA = "/vulnerability_data";
/** vulnerability max score info search */
public static final String FOSSLIGHT_API_VULNERABILITY_MAX_DATA = "/vulnerability_max_data";
/** SELFCHECK */
/** create SelfCheck */
public static final String FOSSLIGHT_API_SELFCHECK_CREATE = "/create_selfcheck";
/** OSS Report upload */
public static final String FOSSLIGHT_API_OSS_REPORT_SELFCHECK = "/oss_report_selfcheck";
/** OSS Report upload */
public static final String FOSSLIGHT_API_EXPORT_SELFCHECK = "/export_selfcheck";
/** API SelfCheck Add Watcher */
public static final String FOSSLIGHT_API_SELFCHECK_ADD_WATCHER = "/selfcheck_watcher_add";
/** BINARY */
/** API Binary List ์กฐํ */
public static final String FOSSLIGHT_API_BINARY_SEARCH = "/binary_search";
/** CODE */
/** Code ์กฐํ */
public static final String FOSSLIGHT_API_CODE_SEARCH ="/code_search";
}
public static final class SEARCH {
public static final String PATH = "/searchFilter";
public static final String LICENSE = PATH + "/license";
public static final String OSS = PATH + "/oss";
public static final String PROJECT = PATH + "/project";
public static final String SELFCHECK = PATH + "/selfcheck";
public static final String PARTNER = PATH + "/partner";
public static final String VULNERABILITY = PATH + "/vulnerability";
}
}
| 39,847 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CoConstDef.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/common/CoConstDef.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.common;
import java.util.regex.Pattern;
public class CoConstDef {
/** Application์ ๊ธฐ๋ณธ ํจํค์ง ๋ช
: {@value #APP_DEFAULT_PACKAGE_NAME} */
public static final String APP_DEFAULT_PACKAGE_NAME = "oss.fosslight";
public final static String MAPPER_PACKAGE = APP_DEFAULT_PACKAGE_NAME+".repository";
public static final String JSP_PROPERTY_URL_PATTERN = "*.jsp";
//---------------------------------------------------------------------------------------------
// Tag Library Informations
//---------------------------------------------------------------------------------------------
public static final String COMM_TLD_URI = "/WEB-INF/tlds/common-taglibs.tld";
public static final String COMM_TLD_PATH = "/WEB-INF/tlds/common-taglibs.tld";
public static final boolean VALIDATION_USE_CAMELCASE = true;
public static final String ENCRYPT_DEFAULT_SALT_KEY = "Fosslight-System";
/** ์ ์ ๋ฆฌ์์ค ์ข
๋ฅ */
private final static String[] STATIC_RES = {"/js","/css","/images","/template", "/font", "/imageView", "/mobile", "/attach", "/sample"};
/**
* ์ ์ ๋ฆฌ์์ค ๋งคํ URL ํจํด ({@code CLASSPATH_RESOURCE_LOCATIONS}์ ์์ ๋ง์ถ ๊ฒ)
* @see #CLASSPATH_RESOURCE_LOCATIONS
*/
public final static String[] STATIC_RESOURCES_URL_PATTERNS = {
STATIC_RES[0]+"/**",
STATIC_RES[1]+"/**",
STATIC_RES[2]+"/**",
STATIC_RES[3]+"/**",
STATIC_RES[4]+"/**",
STATIC_RES[5]+"/**",
STATIC_RES[6]+"/**",
STATIC_RES[7]+"/**",
STATIC_RES[8]+"/**",
"/favicon.ico","/robots.txt"
};
/** ์ ์ ๋ฆฌ์์ค ๊ธฐ๋ณธ ํจํค์ง classpath */
private static final String STATIC_PATH = "classpath:/static";
/**
* ์ ์ ๋ฆฌ์์ค ์์น ({@code STATIC_RESOURCES_URL_PATTERN}์ ์์ ๋ง์ถ ๊ฒ)
* @see #STATIC_RESOURCES_URL_PATTERNS
*/
public final static String[] CLASSPATH_RESOURCE_LOCATIONS = {
STATIC_PATH+STATIC_RES[0]+"/",
STATIC_PATH+STATIC_RES[1]+"/",
STATIC_PATH+STATIC_RES[2]+"/",
STATIC_PATH+STATIC_RES[3]+"/",
STATIC_PATH+STATIC_RES[4]+"/",
STATIC_PATH+STATIC_RES[5]+"/",
STATIC_PATH+STATIC_RES[6]+"/",
STATIC_PATH+STATIC_RES[7]+"/",
STATIC_PATH+STATIC_RES[8]+"/",
STATIC_PATH+"/"
};
public static final String HEALTH_CHECK_URL = "/healthCheck";
/** Tiles definition xml path */
public final static String[] TILES_LAYOUT_XML_PATH = {
"WEB-INF/tiles.xml"
};
/** Runtime์์ JSP์ refresh ์ ์ฉ ์ฌ๋ถ : {@value #REFRESH_JSP_ON_RUNTIME} */
public final static boolean REFRESH_JSP_ON_RUNTIME = true;
public static final int DEFAULT_PAGE_NUMBER = 0;
public static final int DEFAULT_PAGE_SIZE = 10;
/** ๋ฒ์ฉ flag YN */
public static final String FLAG_YES = "Y";
public static final String FLAG_NO = "N";
public static final String NUM_ZERO = "0";
/** ๋ฒ์ฉ bit flag */
public static final int FLAG_A = 0x01;
public static final int FLAG_B = 0x02;
public static final int FLAG_C = 0x04;
public static final int FLAG_D = 0x08;
public static final int FLAG_E = 0x10;
public static final int FLAG_F = 0x20;
public static final int FLAG_G = 0x40;
public static final int FLAG_H = 0x80;
public static final int FLAG_I = 0x100;
public static final int FLAG_J = 0x200;
public static final int FLAG_K = 0x400;
/**
* System Setting Code List
*/
// System Setting
public static final String CD_SYSTEM_SETTING = "909";
public static final String CD_LDAP_USED_FLAG = "910";
public static final String CD_SMTP_USED_FLAG = "911";
public static final String CD_EXTERNAL_SERVICE_USED_FLAG = "940";
public static final String CD_EXTERNAL_ANALYSIS_USED_FLAG = "950";
public static final String CD_HIDE_EMAIL_FLAG = "960";
// Login Setting
public static final String CD_LOGIN_SETTING = "910";
public static final String CD_LDAP_SERVER_URL = "100";
public static final String CD_LDAP_DOMAIN = "200";
// public static final String CD_LDAP_INITIAL_CONTEXT_FACTORY = "300";
// public static final String CD_LDAP_ERROR_49 = "400";
// SMTP Setting
public static final String CD_SMTP_SETTING = "911";
public static final String CD_SMTP_SERVICE_HOST = "100";
public static final String CD_SMTP_EMAIL_ADDRESS = "101";
public static final String CD_SMTP_SERVICE_PORT = "200";
public static final String CD_SMTP_SERVICE_ENCODING = "300";
public static final String CD_SMTP_SERVICE_USERNAME = "400";
public static final String CD_SMTP_SERVICE_PASSWORD = "401";
// FOSSLight Hub Menu Info
public static final String CD_MENU_DASHBOARD = "001";
public static final String CD_MENU_STATISTICS = "002";
public static final String CD_MENU_PROJECT_LIST = "004";
public static final String CD_MENU_PARTNER_LIST = "005";
public static final String CD_MENU_BAT_LIST = "006";
public static final String CD_MENU_BINARY_DB = "007";
public static final String CD_MENU_COMPLIANCE_STATUS = "010";
public static final String CD_MENU_EXTERNAL_LINK = "011";
// Dashboard Notice
public static final String CD_DASHBOARD_DETAIL = "801";
// public static final String CD_DASHBOARD_NOTICE = "100";
// Project List Detail Setting
public static final String CD_PROJECT_DETAIL = "918";
public static final String CD_AUTO_ANALYSIS_FLAG = "100";
public static final String CD_NOTICE_FLAG = "101";
// Notice Info
public static final String CD_NOTICE_INFO = "927";
public static final String CD_NOTICE_HTML_STR = "HTML";
public static final String CD_DTL_NOTICE_HTML = "100";
public static final String CD_DTL_NOTICE_TEXT = "101";
public static final String CD_DTL_NOTICE_SPDX = "102";
public static final String CD_NOTICE_INTERNAL_URL = "970";
/** System Setting Code List End */
public static final String EMPTY_STRING = "";
/** ํ๋ฉดํ์ ๋ ์ง ํ์ (yyyy-MM-dd hh:mm:ss) */
public static final String DISP_FORMAT_DATE_ALL = "yyyy-MM-dd hh:mm:ss";
/** ํ๋ฉดํ์ ๋ ์ง ํ์ (yyyy-MM-dd) */
public static final String DISP_FORMAT_DATE_YYYYMMDD = "yyyy-MM-dd";
/** ๋ชจ๋ฐ์ผ ํ๋ฉดํ์ ๋ ์ง ํ์ (yyyy.MM.dd hh:mm:ss) */
public static final String DISP_MOBILE_FORMAT_DATE_ALL_DOT = "yyyy.MM.dd hh:mm:ss";
/** ๋ชจ๋ฐ์ผ ํ๋ฉดํ์ ๋ ์ง ํ์ (yyyy.MM.dd) */
public static final String DISP_MOBILE_FORMAT_DATE_YYYYMMDD_DOT = "yyyy.MM.dd";
/** ๋ฐ์ดํฐ ๋ฒ ์ด์ค ๋ ์ง ํ์ (yyyy-MM-dd hh:mm:ss) */
public static final String DATABASE_FORMAT_DATE_ALL = "yyyy-MM-dd HH:mm:ss";
/** ๋ฐ์ดํฐ ๋ฒ ์ด์ค ๋ ์ง ํ์ (yyyy-MM-dd hh:mm:ss.SSS) */
public static final String DATABASE_FORMAT_DATE_TIMESTAMP = "yyyy-MM-dd HH:mm:ss.SSS";
/** ํ๋ฉดํ์ ๋ ์ง ํ์ taglib์ฉ full format [yyyy-MM-dd hh:mm:ss] */
public static final String DISP_FORMAT_DATE_TAG_DEFAULT = "-- ::";
/** ํ๋ฉดํ์ ๋ ์ง ํ์ taglib์ฉ simple format [yyyy-MM-dd] */
public static final String DISP_FORMAT_DATE_TAG_SIMPLE = "--";
// Grid ๊ด๋ จ
public static final String GRID_OPERATION_ADD = "add";
public static final String GRID_OPERATION_EDIT = "edit";
public static final String GRID_OPERATION_DELETE = "del";
public static final String GRID_NEWROW_DEFAULT_PREFIX = "jqg";
/**๋ฒ์ฉ์ฝ๋์ ์ */
public static final String COMMON_SELECTED_ETC = "999";
/** Header Menu Codes (=menuId : ์ ์ ์์ฑ์ ๋๋ฉ๋ด์ ๋นํธ๊ฐ์ ๊ฐ์ ธ์ค๊ธฐ ์ํ ์ฝ๋) */
/** MAIN MENU > APP MAIN */
public static final String CD_DTL_MENU_MAIN_APP_MAIN = "800";
/** MAIN MENU > NOTICE */
public static final String CD_DTL_MENU_MAIN_NOTICE = "700";
/** DEFAULT MAIN MENU CODE */
public static final String[] DEFAULT_MENUS = {
CD_DTL_MENU_MAIN_APP_MAIN, // App ๋ฉ์ธ
CD_DTL_MENU_MAIN_NOTICE, // ๊ณต์ง์ฌํญ
};
/** AD login LDAP */
public static enum AD_LDAP_LOGIN {
LDAP_SERVER_URL(CoCodeManager.getCodeExpString(CoConstDef.CD_LOGIN_SETTING, CoConstDef.CD_LDAP_SERVER_URL)),
//LDAP_DOMAIN(CoCodeManager.getCodeExpString(CoConstDef.CD_LOGIN_SETTING, CoConstDef.CD_LDAP_DOMAIN)),
//INITIAL_CONTEXT_FACTORY(CoCodeManager.getCodeExpString(CoConstDef.CD_LOGIN_SETTING, CoConstDef.CD_LDAP_INITIAL_CONTEXT_FACTORY)),
// ERROR_49(CoCodeManager.getCodeExpString(CoConstDef.CD_LOGIN_SETTING, CoConstDef.CD_LDAP_ERROR_49)),
INITIAL_CONTEXT_FACTORY("com.sun.jndi.ldap.LdapCtxFactory");
private String value;
private AD_LDAP_LOGIN(String value) {this.value = value;}
public String getValue(){return this.value;}
}
public static final String PACKAGING_VERIFY_FILENAME_PROPRIETARY = "proprietaryCheckList.txt";
public static final String PACKAGING_VERIFY_FILENAME_FILE_LIST = "packageStructureInfo.txt";
/** ํ์ด์ง ์ค์ ์ฝ๋ */
public static final String CD_PAGENATION = "100";
/** BinaryDB Admin ์ ์ฉ ํ์ด์ง ์ค์ ์ฝ๋ */
public static final String CD_BINARYDB_PAGENATION = "906";
/** ํ์ด์ง Default ๊ฑด์ */
public static String DISP_PAGENATION_DEFAULT = CoCodeManager.getCodes(CD_PAGENATION).firstElement();
/** ํ์ด์ง ์ ํ ๊ฐ๋ฅ ๊ฑด์ (grid์์ ์ค์ ) */
public static String DISP_PAGENATION_LIST_STR = CommonFunction.arrayToString(CoCodeManager.getCodes(CD_PAGENATION));
/** ํ์ด์ง ์ ํ ๊ฐ๋ฅ ๊ฑด์ (grid์์ ์ค์ ) */
public static String DISP_BINARYDB_PAGENATION_LIST_STR = CommonFunction.arrayToString(CoCodeManager.getCodes(CD_BINARYDB_PAGENATION));
/** ํ์ด์ง์ด ์๋ GRID์ ์ต๋ ํ์ ๊ฑด์ */
public static String DISP_PAGENATION_MAX = "5000";
public static final String CD_LICENSE_DIV = "203";
public static final String LICENSE_DIV_MULTI = "M";
public static final String LICENSE_DIV_SINGLE = "S";
/** BAT ๋ถ์ ๊ฒฐ๊ณผ lgematching table์ ์กด์ฌํ๋ binary๊ฐ ์กด์ฌํ ๊ฒฝ์ฐ ํ์๋ช
*/
public static final String BAT_MATCHED_STR = "matched";
public static final String FILE_GUBUN_EDITOR_IMAGE = "E";
public static final String FILE_GUBUN_FILE_DOWNLOAD = "DL";
public static final String SESSION_KEY_UPLOAD_REPORT_PARTNER = "REPORT_PARTNER";
public static final String SESSION_KEY_UPLOAD_REPORT_PROJECT_DEP = "REPORT_PROJECT_DEP";
public static final String SESSION_KEY_UPLOAD_REPORT_PROJECT_SRC = "REPORT_PROJECT_SRC";
public static final String SESSION_KEY_UPLOAD_REPORT_PROJECT_BIN = "REPORT_PROJECT_BIN";
public static final String SESSION_KEY_UPLOAD_REPORT_PROJECT_ANDROID = "REPORT_PROJECT_ANDROID";
public static final String SESSION_KEY_UPLOAD_REPORT_PROJECT_BAT = "REPORT_PROJECT_BAT";
public static final String SESSION_KEY_UPLOAD_REPORT_BAT = "REPORT_BAT";
public static final String SESSION_KEY_UPLOAD_REPORT_SELFT_PROJECT = "REPORT_SELF_PROJECT";
public static final String SESSION_KEY_ANDROID_CHANGED_RESULTTEXT = "BINANDROID_CHANGED_RESULTTEXT";
public static final String SESSION_KEY_UPLOAD_REPORT_CHANGEDLICENSE = "REPORT_CHANGEDLICENSE";
public static final String SESSION_KEY_NEWOSS_DEFAULT_DATA = "NEWOSS_DEFAULT_DATA";
public static final String SESSION_KEY_NICKNAME_CHANGED = "NICKNAME_CHANGED";
public static final String SESSION_KEY_OSS_VERSION_CHANGED = "REPORT_OSSVERSION_CHANGED";
public static final String SESSION_KEY_PREFIX_DEFAULT_SEARCHVALUE = "PREFIX_DEFAULT_SEARCHVALUE_";
public static final String SESSION_KEY_ANALYSIS_RESULT_DATA = "ANALYSIS_RESULT_DATA";
/**
* Auto Fill OSS ๊ธฐ๋ฅ์์ ์ฌ์ฉํ๋ Dependency ํ์
๊ณผ url ํจํด ์ ์
*/
/* dependency url pattern code */
public static final Pattern GITHUB_PATTERN = Pattern.compile("((http|https)://github.com/([^/]+)/([^/]+))");
public static final Pattern NPM_PATTERN = Pattern.compile("((http|https)://www.npmjs.(org|com)/package/([^/]+))");
public static final Pattern PYPI_PATTERN = Pattern.compile("((http|https)://pypi.org/project/([^/]+))");
public static final Pattern MAVEN_CENTRAL_PATTERN = Pattern.compile("((http|https)://mvnrepository.com/artifact/([^/]+)/([^/]+)(/([^/]+))?)");
public static final Pattern MAVEN_GOOGLE_PATTERN = Pattern.compile("((http|https)://maven.google.com/web/index.html#([^:]+):([^:]+)(:[^:]+)?)");
public static final Pattern PUB_PATTERN = Pattern.compile("((http|https)://pub.dev/packages/([^/]+))");
public static final Pattern COCOAPODS_PATTERN = Pattern.compile("((http|https)://cocoapods.org/pods/([^/]+))");
/* nothing match */
public static final Pattern UNSUPPORTED_PATTERN = Pattern.compile("(?!)");
/**
* Co Code Master - ๋ํ ์ฝ๋ [S]
*/
// -------------- ์์คํ
๋ํ ์ฝ๋
/** ์์คํ
๊ณตํต ์์ ์ ์ */
public static final String CD_SYSTEM_CONSTANT_VALUE = "S100";
/** ์์คํ
๊ณตํต ์์ - ์์ธ ์ฝ๋ : ๋ฒ์ฉ 1Page๋น ํ์ ๋ ์ฝ๋ ์ */
public static final String CD_SYSTEM_CONSTANT_VALUE_PAGE_SIZE = "1";
/** ์์คํ
๊ณตํต ์์ - ์์ธ์ฝ๋ : ์
๋ก๋ ์ด๋ฏธ์ง ํ์ผ์ Max Width */
public static final String CD_SYSTEM_CONSTANT_VALUE_IMAGE_W_MAX = "2";
/** ์์คํ
๊ณตํต ์์ - ์์ธ์ฝ๋ : ์
๋ก๋ ์์ด์ฝ ์ด๋ฏธ์ง ํ์ผ์ Max Width */
public static final String CD_SYSTEM_CONSTANT_VALUE_ICON_IMAGE_W_MAX = "3";
/** ์์คํ
๊ณตํต ์์ - ์์ธ์ฝ๋ : ๊ฒ์๊ธ์ 'New' ๋ฑ์ง ํ์์ผ */
public static final String CD_SYSTEM_CONSTANT_VALUE_BOARD_BADGE_DAY_NEW = "004";
/** ์์คํ
๊ณตํต ์์ - ์์ธ์ฝ๋ : ๊ฒ์๊ธ์ '๋ง๊ฐ์๋ฐ' ๋ฑ์ง ํ์์ผ */
public static final String CD_SYSTEM_CONSTANT_VALUE_BOARD_BADGE_DAY_CLOSE = "005";
/** grid sort์ ์ซ์ํ cast๊ฐ ํ์ํ ์นผ๋ผ */
public static final String CD_SYSTEM_GRID_SORT_CAST = "101";
public static final String CD_FILE_ACCEPT = "120";
/** ์ฌ์
๋ถ ๋ถ๋ฅ ์ฝ๋ - 200 */
public static final String CD_USER_DIVISION = "200";
public static final String CD_USER_DIVISION_EMPTY = "999";
/** ํ๋ก์ ํธ ์ํ ์ฝ๋ - 205 */
public static final String CD_PROJECT_STATUS = "205";
public static final String CD_DTL_PROJECT_STATUS_PROGRESS = "PROG";
public static final String CD_DTL_PROJECT_STATUS_REQUEST = "REQ";
public static final String CD_DTL_PROJECT_STATUS_REVIEW = "REV";
public static final String CD_DTL_PROJECT_STATUS_COMPLETE = "COMP";
// public static final String CD_DTL_PROJECT_STATUS_DELAY = "DELAY";
public static final String CD_DTL_PROJECT_STATUS_DROP = "DROP";
/** status of project Identification and Packaging */
public static final String CD_IDENTIFICATION_STATUS ="206";
public static final String CD_DTL_IDENTIFICATION_STATUS_PROGRESS = "PROG";
public static final String CD_DTL_IDENTIFICATION_STATUS_REQUEST = "REQ";
public static final String CD_DTL_IDENTIFICATION_STATUS_REVIEW = "REV";
public static final String CD_DTL_IDENTIFICATION_STATUS_CONFIRM = "CONF";
public static final String CD_DTL_IDENTIFICATION_STATUS_NA = "NA";
/** ๋ถ๋ฅ ํ์
์ฝ๋ - 207 */
public static final String CD_DISTRIBUTION_TYPE = "207";
public static final String CD_GENERAL_MODEL = "10";
public static final String CD_NETWORK_SERVER = "60";
/** Verifycation Notice Type - 208 */
public static final String CD_NOTICE_TYPE = "208";
public static final String CD_NOTICE_TYPE_GENERAL = "10";
public static final String CD_NOTICE_TYPE_GENERAL_WITHOUT_OSS_VERSION = "70";
public static final String CD_NOTICE_TYPE_PLATFORM_GENERATED = "80";
public static final String CD_NOTICE_TYPE_NA = "99";
/** Verifycation Notice Type - General Model */
public static final String CD_DTL_NOTICE_TYPE_GENERAL = "10";
public static final String CD_DTL_NOTICE_TYPE_OTHER = "20";
public static final String CD_DTL_NOTICE_TYPE_MERGE = "30";
public static final String CD_DTL_NOTICE_TYPE_ACCOMPANIED = "40";
public static final String CD_DTL_NOTICE_TYPE_WITHOUTCOMPANYINFO = "50";
public static final String CD_DTL_NOTICE_TYPE_FULLOPTION = "60";
/** 3RD ํํฐ delivery form - 209 */
public static final String CD_PARTNER_DELIVERY_FORM = "209";
public static final String CD_DTL_PARTNER_DELIVERY_FORM_SRC = "SRC";
public static final String CD_DTL_PARTNER_DELIVERY_FORM_BIN = "BIN";
/** OSS Component DIVISION CODE */
public static final String CD_COMPONENT_DIVISION = "210";
public static final String CD_DTL_COMPONENT_ID_PARTNER = "10";
public static final String CD_DTL_COMPONENT_ID_SRC = "11";
public static final String CD_DTL_COMPONENT_ID_DEP = "16";
public static final String CD_DTL_COMPONENT_ID_BAT = "12";
public static final String CD_DTL_COMPONENT_ID_BOM = "13";
public static final String CD_DTL_COMPONENT_ID_ANDROID = "14";
public static final String CD_DTL_COMPONENT_ID_BIN = "15";
public static final String CD_DTL_COMPONENT_PARTNER = "20";
public static final String CD_DTL_COMPONENT_PARTNER_BAT = "22";
public static final String CD_DTL_COMPONENT_BAT = "30";
public static final String CD_DTL_COMPONENT_PACKAGING = "50";
/** 3rd party status */
public static final String CD_PARTNER_STATUS = "211";
public static final String CD_DTL_PARTNER_STATUS_PROGRESS = "PROG";
public static final String CD_DTL_PARTNER_STATUS_REQUEST = "REQ";
public static final String CD_DTL_PARTNER_STATUS_REVIEW = "REV";
public static final String CD_DTL_PARTNER_STATUS_CONFIRM = "CONF";
public static final String CD_DTL_SELF_COMPONENT_ID = "10";
public static final String CD_BAT_STATUS = "212";
public static final String CD_DTL_BAT_STATUS_READY = "1";
public static final String CD_DTL_BAT_STATUS_START = "10";
public static final String CD_DTL_BAT_STATUS_UPLOAD = "11";
public static final String CD_DTL_BAT_STATUS_UNPACKING = "20";
public static final String CD_DTL_BAT_STATUS_LEAF = "30";
public static final String CD_DTL_BAT_STATUS_AGGREGATE = "40";
public static final String CD_DTL_BAT_STATUS_POSTRUN = "50";
public static final String CD_DTL_BAT_STATUS_DONE = "60";
public static final String CD_DTL_BAT_STATUS_DONE_UNOCCUPIED = "70";
public static final String CD_DTL_BAT_STATUS_DONE_NOTDETECTED = "71";
public static final String CD_DTL_BAT_STATUS_CANCELED = "90";
public static final String CD_DTL_BAT_STATUS_ERROR = "99";
/** OS ํ์
์ฝ๋ - 213 */
public static final String CD_OS_TYPE = "213";
public static final String CD_OS_TYPE_ETC = "999";
/** Status of Distribute */
public static final String CD_DISTRIBUTE_STATUS = "215";
public static final String CD_DTL_DISTRIBUTE_STATUS_PROGRESS = "PROG";
public static final String CD_DTL_DISTRIBUTE_STATUS_RESERVE = "RSV";
public static final String CD_DTL_DISTRIBUTE_STATUS_PROCESS = "PROC";
public static final String CD_DTL_DISTRIBUTE_STATUS_DEPLOIDED = "DONE";
public static final String CD_DTL_DISTRIBUTE_STATUS_FAILED = "ERROR";
public static final String CD_DTL_DISTRIBUTE_STATUS_NA = "NA";
/** Site of Distribute */
public static final String CD_DISTRIBUTE_SITE_LGE = "LGE";
public static final String CD_DISTRIBUTE_SITE_SKS = "SKS";
public static final String CD_COMMENT_DIVISION = "214";
public static final String CD_DTL_COMMENT_PROJECT_USER = "09"; // ์ฝ๋ฉํธ ํตํจ
public static final String CD_DTL_COMMENT_PROJECT_HIS = "19"; // ์ฝ๋ฉํธ ํตํจ
public static final String CD_DTL_COMMENT_IDENTIFICAITON_HIS = "10";
public static final String CD_DTL_COMMENT_IDENTIFICATION_USER = "11";
public static final String CD_DTL_COMMENT_PACKAGING_HIS = "12";
public static final String CD_DTL_COMMENT_PACKAGING_USER = "13";
public static final String CD_DTL_COMMENT_DISTRIBUTION_HIS = "14"; // ์ฝ๋ฉํธ ํตํจ
public static final String CD_DTL_COMMENT_DISTRIBUTION_USER = "15"; // ์ฝ๋ฉํธ ํตํจ
public static final String CD_DTL_COMMENT_PARTNER_HIS = "20";
public static final String CD_DTL_COMMENT_PARTNER_USER = "21";
public static final String CD_DTL_COMMENT_LICENSE = "30";
public static final String CD_DTL_COMMENT_OSS = "40";
public static final String CD_DTL_COMMENT_SECURITY_HIS = "60";
/** License ํ์
๋ณ ๋ฐฑ๊ทธ๋ผ์ด๋ ์ - 216 */
public static final String CD_LICENSE_BACKGROUND = "216";
/** Multi or Dual license์ obligation type */
public static final String CD_OBLIGATION_TYPE = "217";
public static final String CD_DTL_OBLIGATION_NOTICE = "10";
public static final String CD_DTL_OBLIGATION_DISCLOSURE = "11";
public static final String CD_DTL_OBLIGATION_NEEDSCHECK = "90";
public static final String CD_DTL_OBLIGATION_NEEDSCHECK_SELECTED = "99"; // NEED CHECK์ ๋์ผํ๋, ์ฌ์ฉ์๊ฐ ์ ์ฉํ์ง ์์์ ์ ํํ ๊ฒฝ์ฐ
public static final String CD_DTL_OBLIGATION_NONE = "NONE"; // ๊ฒ์์กฐ๊ฑด์ผ๋ก๋ง ์ฌ์ฉ๋จ
/** Distribute Code - 218 */
public static final String CD_DISTRIBUTE_CODE = "218";
public static final String CD_DTL_DISTRIBUTE_LGE = "LGE";
public static final String CD_DTL_DISTRIBUTE_SKS = "SKS";
public static final String CD_DTL_DISTRIBUTE_NA = "NA";
public static final String DISTRIBUTE_CHECK_URL = "/pservice/osAvailCheck";
public static final String DISTRIBUTE_DEPLOY_URL = "/pservice/distribute";
public static final String DISTRIBUTE_DELETE_URL = "/pservice/deleteDescription";
public static final String DISTRIBUTE_CHECK_DELETE = "/pservice/descriptionDeletedCheck";
public static final String DISTRIBUTE_LICENSE_URL_UPDATE = "/pservice/uploadLicense";
public static final String DISTRIBUTE_LICENSE_URL_DELETE = "/pservice/deleteLicense";
public static final String DISTRIBUTE_AUTH_CALLED_URL = "/pservice/getLoginToken";
public static final String DISTRIBUTE_AUTH_URL = "/admin/login/loginWithToken";
public static final String DISTIRBUTE_DUPLICATE_CHECK_URL = "/pservice/getDescKey";
// public static final String DISTRIBUTE_LICENSE_URL = "/license/";
// public static final String DISTRIBUTE_MIGRATION_TEST = "/pservice/migTest";
/** Notice File Message Info - 219 */
public static final String CD_NOTICE_DEFAULT = "219";
public static final String CD_NOTICE_DEFAULT_SKS = "220";
public static final String CD_DTL_NOTICE_DEFAULT_FULLNAME = "1";
public static final String CD_DTL_NOTICE_DEFAULT_SHORTNAME = "2";
public static final String CD_DTL_NOTICE_DEFAULT_DISTRIBUTE_SITE = "3";
public static final String CD_DTL_NOTICE_DEFAULT_EMAIL = "4";
public static final String CD_DTL_NOTICE_DEFAULT_TEMPLATE = "5";
public static final String CD_DTL_NOTICE_TEXT_TEMPLATE = "6";
public static final String CD_DTL_NOTICE_DEFAULT_APPENDED = "7";
public static final String CD_DTL_SUPPLMENT_NOTICE_HTML_TEMPLATE = "8";
public static final String CD_DTL_SUPPLMENT_NOTICE_TXT_TEMPLATE = "9";
public static final String CD_DTL_SELFCHECK_NOTICE_DEFAULT_TEMPLATE = "10";
public static final String CD_DTL_SELFCHECK_NOTICE_TEXT_TEMPLATE = "11";
public static final String CD_NOTICE_DEFAULT_SOFTWARE_TYPE = "221";
public static final String CD_DTL_NOTICE_DEFAULT_SOFTWARE_TYPE_MODEL = "10";
public static final String CD_DTL_NOTICE_DEFAULT_SOFTWARE_TYPE_SOFTWARE = "20";
public static final String CD_BINARY_FILENAME_CONVERT = "222";
public static final String CD_DISTRIBUTION_HIS_TYPE = "223";
public static final String CD_DTL_DISTRIBUTION_HIS_DISTRIBUTE = "D";
public static final String CD_DTL_DISTRIBUTION_HIS_MODELONLY = "M";
public static final String CD_DTL_DISTRIBUTION_HIS_SYNCHRONIZED = "S";
public static final String CD_DTL_DISTRIBUTION_HIS_RESERVED = "R";
public static final String CD_DTL_DISTRIBUTION_HIS_RESERVED_MODEL = "RM";
public static final String CD_DTL_DISTRIBUTION_HIS_CANCELED = "C";
public static final String CD_DTL_DISTRIBUTION_HIS_REJECTED = "RJ";
public static final String CD_DTL_DISTRIBUTION_HIS_DELETED = "RJOSDD";
public static final String CD_DTL_DISTRIBUTION_HIS_SYNCHRONIZED_DESC = "CDOSD";
public static final String CD_DTL_DISTRIBUTION_HIS_SYNCHRONIZED_TYPE = "CSOSD";
public static final String CD_VERIFY_EXCEPTION_WORDS = "224";
public static final String CD_VERIFY_IGNORE_WORDS = "225";
/** Model ํ์
์ฝ๋ - 500 */
public static final String CD_MODEL_TYPE = "500";
/** Model ํ์
์ฝ๋ - 550 */
public static final String CD_MODEL_TYPE2 = "550";
/** External Link ์ฝ๋ - 600 */
public static final String CD_EXTERNAL_LINK = "600";
/** Mail Resource ํ์
์ฝ๋ */
public static final String CD_MAIL_TYPE = "102";
/** Mail Type [FOSSLight] OSS has been registered */
public static final String CD_MAIL_TYPE_OSS_REGIST = "10";
/** Mail Type [FOSSLight] OSS has been changed */
public static final String CD_MAIL_TYPE_OSS_UPDATE = "11";
/** Mail Type [FOSSLight] OSS add nickname has been updated */
public static final String CD_MAIL_TYPE_ADDNICKNAME_UPDATE = "750";
/** Mail Type [FOSSLight] OSS has been changed */
public static final String CD_MAIL_TYPE_OSS_UPDATE_TYPE = "12";
/** Mail Type [FOSSLight] OSS has been registered */
public static final String CD_MAIL_TYPE_OSS_REGIST_NEWVERSION = "13";
/** Mail Type [FOSSLight] OSS has been rename */
public static final String CD_MAIL_TYPE_OSS_CHANGE_NAME = "14";
/** Mail Type [FOSSLight] OSS has been removed */
public static final String CD_MAIL_TYPE_OSS_RENAME = "18";
/** Mail Type [FOSSLight] OSS has been removed */
public static final String CD_MAIL_TYPE_OSS_DELETE = "19";
public static final String CD_MAIL_TYPE_OSS_MODIFIED_COMMENT = "130";
/** Mail Type [FOSSLight] OSS bas been deactivated */
public static final String CD_MAIL_TYPE_OSS_DEACTIVATED = "813";
public static final String CD_MAIL_TYPE_OSS_ACTIVATED = "814";
/** Mail Type [FOSSLight] Open source license has been registered */
public static final String CD_MAIL_TYPE_LICENSE_REGIST = "20";
/** Mail Type [FOSSLight] Open source license has been changed */
public static final String CD_MAIL_TYPE_LICENSE_UPDATE = "21";
public static final String CD_MAIL_TYPE_LICENSE_UPDATE_TYPE = "22";
public static final String CD_MAIL_TYPE_LICENSE_RENAME = "23";
public static final String CD_MAIL_TYPE_LICENSE_MODIFIED_COMMENT = "230";
/** Mail Type [FOSSLight] Open source license has been removed */
public static final String CD_MAIL_TYPE_LICENSE_DELETE = "29";
public static final String CD_MAIL_TYPE_PROJECT_REVIEWER_ADD = "30"; // reviewer๊ฐ ์๋ ์ํ์์ ์๋ก์ด reviewer๋ฅผ ๋ฑ๋กํ case
public static final String CD_MAIL_TYPE_PROJECT_REVIEWER_CHANGED = "99"; // reviewer๊ฐ ์กด์ฌํ์ง๋ง ๋ค๋ฅธ reviewer๋ก ๋ณ๊ฒฝํ case
public static final String CD_MAIL_TYPE_PROJECT_DELETED = "31"; // ์ถ๊ฐ : PROJECT ์ญ์
public static final String CD_MAIL_TYPE_PROJECT_CHANGED = "32"; // ์ถ๊ฐ : PROJECT ๋ณ๊ฒฝ
public static final String CD_MAIL_TYPE_PROJECT_CREATED = "33"; // ์ถ๊ฐ : PROJECT ๋ณ๊ฒฝ
public static final String CD_MAIL_TYPE_PROJECT_COPIED = "37"; // ์ถ๊ฐ : PROJECT ๋ณต์ฌ
public static final String CD_MAIL_TYPE_PROJECT_ADDED_COMMENT = "34"; // Project Comemnt ์ถ๊ฐ
public static final String CD_MAIL_TYPE_PROJECT_MODIFIED_COMMENT = "340"; // Project Comemnt ์์
public static final String CD_MAIL_TYPE_PROJECT_COMPLETED = "35"; // Project complete
public static final String CD_MAIL_TYPE_PROJECT_DROPPED = "812"; // Project drop
public static final String CD_MAIL_TYPE_PROJECT_REOPENED = "36"; // Project reopen
public static final String CD_MAIL_TYPE_PROJECT_REQUESTTOOPEN_COMMENT = "38"; // Project RequestToOpen Comment ์ถ๊ฐ 2018-07-23 choye ์ถ๊ฐ
/** Project Request Review(Identification) */
public static final String CD_MAIL_TYPE_PROJECT_IDENTIFICATION_REQ_REVIEW = "40";
/** Project Identification confirm */
public static final String CD_MAIL_TYPE_PROJECT_IDENTIFICATION_CONF = "41";
/** Project Identification reject (not review) */
public static final String CD_MAIL_TYPE_PROJECT_IDENTIFICATION_CANCELED_CONF = "42";
/** Project Identification reject (not review) */
public static final String CD_MAIL_TYPE_PROJECT_IDENTIFICATION_ADDED_COMMENT = "43";
public static final String CD_MAIL_TYPE_PROJECT_IDENTIFICATION_MODIFIED_COMMENT = "430";
/** Project Identification reject (by review) */
public static final String CD_MAIL_TYPE_PROJECT_IDENTIFICATION_REJECT = "44";
/** Project Identification self reject */
public static final String CD_MAIL_TYPE_PROJECT_IDENTIFICATION_SELF_REJECT = "45";
public static final String CD_MAIL_TYPE_PROJECT_IDENTIFICATION_CONFIRMED_ONLY = "46";
public static final String CD_MAIL_TYPE_BIN_PROJECT_IDENTIFICATION_CONF = "100";
/* Project Identification Binary DB Check*/
public static final String CD_MAIL_TYPE_PROJECT_IDENTIFICATION_BINARY_DATA_COMMIT = "47";
/** Project Request Review(packaging) */
public static final String CD_MAIL_TYPE_PROJECT_PACKAGING_REQ_REVIEW = "50";
/** Project packaging confirm */
public static final String CD_MAIL_TYPE_PROJECT_PACKAGING_CONF = "51";
/** Project packaging canceled from confirm */
public static final String CD_MAIL_TYPE_PROJECT_PACKAGING_CANCELED_CONF = "52";
/** Project packaging commnets registered */
public static final String CD_MAIL_TYPE_PROJECT_PACKAGING_ADDED_COMMENT = "53";
public static final String CD_MAIL_TYPE_PROJECT_PACKAGING_MODIFIED_COMMENT = "530";
/** Project packaging reject (review) */
public static final String CD_MAIL_TYPE_PROJECT_PACKAGING_REJECT = "54";
/** Project packaging self reject */
public static final String CD_MAIL_TYPE_PROJECT_PACKAGING_SELF_REJECT = "55";
public static final String CD_MAIL_TYPE_PROJECT_PACKAGING_COMFIRMED_ONLY = "56";
/** Project distribute complete */
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_COMPLETE = "60";
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_RESERVED = "61";
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_CANCELED = "62";
public static final String CD_MAIL_TYPE_PROJECT_WATCHER_INVATED = "63";
public static final String CD_MAIL_TYPE_PROJECT_WATCHER_REGISTED = "64";
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_FAILED = "815";
/** changed USER Info */
public static final String CD_MAIL_TYPE_CHANGED_USER_INFO = "816";
public static final String CD_MAIL_TYPE_RESET_USER_PASSWORD = "817";
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_ADDED_COMMENT = "65";
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_MODIFIED_COMMENT = "650";
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_DELETED = "66"; // OSDD์์ DESCRIPTION์ด ์ญ์ ๋ ๊ฒฝ์ฐ
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_DIFF_FILE = "67"; // OSDD์์ DESCRIPTION์ด ์ญ์ ๋ ๊ฒฝ์ฐ
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_EDIT_FILE = "670";
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_EDIT_DESCRIPTION = "671";
public static final String CD_MAIL_TYPE_PROJECT_DISTRIBUTE_REJECT = "68";
/* Partner Binary DB Check*/
public static final String CD_MAIL_TYPE_PARTNER_BINARY_DATA_COMMIT = "470";
/** 3rd party reviewer changed */
public static final String CD_MAIL_TYPE_PARTER_REVIEWER_CHANGED = "70";
public static final String CD_MAIL_TYPE_PARTER_REVIEWER_TO_CHANGED = "701";
/** 3rd party changed */
public static final String CD_MAIL_TYPE_PARTNER_CHANGED = "700";
/** 3rd party reviewer changed */
public static final String CD_MAIL_TYPE_PARTER_REQ_REVIEW = "71";
/** 3rd party reviewer changed */
public static final String CD_MAIL_TYPE_PARTER_CONF = "72";
/** 3rd party reviewer changed */
public static final String CD_MAIL_TYPE_PARTER_CANCELED_CONF = "73";
/** 3rd party reviewer changed */
public static final String CD_MAIL_TYPE_PARTER_ADDED_COMMENT = "74";
public static final String CD_MAIL_TYPE_PARTER_MODIFIED_COMMENT = "740";
/** 3rd party Review๊ฒฐ๊ณผ Admin์ด rejectํ ๊ฒฝ์ฐ */
public static final String CD_MAIL_TYPE_PARTER_REJECT = "75";
/** 3rd party Request review๋ฅผ self rejectํ ๊ฒฝ์ฐ */
public static final String CD_MAIL_TYPE_PARTER_SELF_REJECT = "76";
public static final String CD_MAIL_TYPE_PARTER_DELETED = "77";
public static final String CD_MAIL_TYPE_PARTER_WATCHER_INVATED = "78";
public static final String CD_MAIL_TYPE_PARTER_WATCHER_REGISTED = "79";
/** Binary Analysis ์๋ฃ์*/
public static final String CD_MAIL_TYPE_BAT_COMPLETE = "80";
/** Binary Analysis ์คํจ์*/
public static final String CD_MAIL_TYPE_BAT_ERROR = "81";
public static final String CD_MAIL_TYPE_BAT_WATCHER_INVATED = "82";
public static final String CD_MAIL_TYPE_BAT_WATCHER_REGISTED = "83";
/** Self Check Watcher registed */
public static final String CD_MAIL_TYPE_SELFCHECK_PROJECT_WATCHER_INVATED = "84";
/** project oss ์์ ์๋ก์ด ์ทจ์ฝ์ ์ด ๋ฐ๊ฒฌ๋ ๊ฒฝ์ฐ*/
public static final String CD_MAIL_TYPE_VULNERABILITY_PROJECT = "90";
/** project oss ์์ ์ฌ์ฉํ์ง๋ ์์ง๋ง OSS master์ ๋ฑ๋ก๋์ด ์๋ ์คํ์์ค์์ ๋ก์ด ์ทจ์ฝ์ ์ด ๋ฐ๊ฒฌ๋ ๊ฒฝ์ฐ*/
public static final String CD_MAIL_TYPE_VULNERABILITY_OSS = "91";
/** vulnerability score๊ฐ 9.0 ์ด์์์ 9.0 ๋ฏธ๋ง์ผ๋ก ๋ณ๊ฒฝ๋ ๊ฒฝ์ฐ */
public static final String CD_MAIL_TYPE_VULNERABILITY_PROJECT_RECALCULATED = "92";
/** vulnerability score๊ฐ 9.0 ์ด์์์ 9.0 ๋ฏธ๋ง์ผ๋ก ๋ณ๊ฒฝ๋ ๊ฒฝ์ฐ - admin */
public static final String CD_MAIL_TYPE_VULNERABILITY_PROJECT_RECALCULATED_ALL = "93";
/** vulnerability score๊ฐ 9.0 ์ด์์์ ์ญ์ ๋์ด recalculated ๋์์ด ๋ ๊ฒฝ์ฐ */
public static final String CD_MAIL_TYPE_VULNERABILITY_PROJECT_REMOVE_RECALCULATED = "94";
/* nvd data ์ค vendor-product ๊ฐ ๋ค๋ฅธ ๊ฒฝ์ฐ */
public static final String CD_MAIL_TYPE_VULNERABILITY_NVDINFO_DIFF = "95";
public static final String CD_MAIL_TYPE_SYSTEM_ERROR = "99";
/** Mail Type์ฅ ๋ฐ๋ฅธ ๊ณตํต Components ๊ตฌ์ฑ */
public static final String CD_MAIL_COMPONENT = "103";
public static final String CD_MAIL_COMPONENT_OSSBASICINFO = "100";
public static final String CD_MAIL_COMPONENT_LICENSEBASICINFO = "101";
public static final String CD_MAIL_COMPONENT_PROJECT_BASICINFO = "200";
public static final String CD_MAIL_COMPONENT_PROJECT_BOMOSSINFO = "201";
public static final String CD_MAIL_COMPONENT_PROJECT_DISCROSEOSSINFO = "202";
public static final String CD_MAIL_COMPONENT_PROJECT_DISTRIBUTIONINFO = "203";
public static final String CD_MAIL_COMPONENT_PROJECT_MODELINFO = "204";
public static final String CD_MAIL_COMPONENT_PARTNER_BASICINFO = "205";
public static final String CD_MAIL_COMPONENT_BATRESULT = "206";
public static final String CD_MAIL_COMPONENT_VULNERABILITY_PRJ = "207";
public static final String CD_MAIL_COMPONENT_VULNERABILITY_OSS = "208";
public static final String CD_MAIL_COMPONENT_PARTNER_OSSLIST = "209";
public static final String CD_MAIL_COMPONENT_VULNERABILITY_RECALCULATED = "210";
public static final String CD_MAIL_COMPONENT_PACKAGING_REQUESTED_URL = "211";
public static final String CD_MAIL_COMPONENT_VULNERABILITY_PROJECT_RECALCULATED_ALL = "212";
public static final String CD_MAIL_COMPONENT_SELFCHECK_PROJECT_BASICINFO = "213";
public static final String CD_MAIL_COMPONENT_VULNERABILITY_REMOVE_RECALCULATED = "214";
public static final String CD_MAIL_COMPONENT_PARTNER_DISCLOSEOSSINFO = "215";
public static final String CD_MAIL_COMPONENT_PARTNER_NOT_DISCLOSEOSSINFO = "216";
/** MAIL ๋ชจ๋ ๋ณ KEY NAME */
public static final String CD_MAIL_COMPONENT_NAME = "104";
public static final String CD_MAIL_COMPONENT_TEMPLATE = "110";
public static final String CD_MAIL_DEFAULT_CONTENTS = "111";
// ์ด๋ฒคํธ ์ฝ๋ : TODO MAIL-SERVICE
public static final String EVENT_CODE_LICENSE = "300";
public static final String EVENT_CODE_OSS = "301";
public static final String EVENT_CODE_OSS_LICENSE = "302";
public static final String EVENT_CODE_PROJECT = "303";
public static final String EVENT_CODE_PROJECT_MODEL = "304";
public static final String EVENT_CODE_PROJECT_WATCHER = "305";
public static final String EVENT_CODE_PROJECT_STATUS = "306";
public static final String EVENT_CODE_PARTNER = "Partner";
public static final String EVENT_CODE_BOM = "BOM";
//์ก์
์ฝ๋ : TODO MAIL-SERVICE
public static final String ACTION_CODE_INSERT = "INSERT";
public static final String ACTION_CODE_UPDATE = "UPDATE";
public static final String ACTION_CODE_DELETE = "DELETE";
public static final String ACTION_CODE_PUBLISHED = "PUBLISHED";
public static final String ACTION_CODE_CANCELED = "CANCELED";
public static final String ACTION_CODE_NEEDED = "NEEDED";
public static final String ACTION_CODE_COMPLETED = "COMPLETED";
/** ์์คํ
๊ณตํต ์์ ์ ์ Enum */
public enum CD_SYSTEM_CONSTANT_VALUE {
/** ์์ธ์ฝ๋ : ๋ฒ์ฉ 1Page๋น ํ์ ๋ ์ฝ๋ ์ */
PAGE_SIZE(CD_SYSTEM_CONSTANT_VALUE_PAGE_SIZE),
/** ์์ธ์ฝ๋ : ์
๋ก๋ ์ด๋ฏธ์ง ํ์ผ์ Max Width */
IMAGE_W_MAX(CD_SYSTEM_CONSTANT_VALUE_IMAGE_W_MAX),
/** ์์ธ์ฝ๋ : ์
๋ก๋ ์์ด์ฝ ์ด๋ฏธ์ง ํ์ผ์ Max Width */
ICON_IMAGE_W_MAX(CD_SYSTEM_CONSTANT_VALUE_ICON_IMAGE_W_MAX),
/** ์์ธ์ฝ๋ : ๊ฒ์๊ธ์ 'New' ๋ฑ์ง ํ์์ผ */
BOARD_BADGE_DAY_NEW(CD_SYSTEM_CONSTANT_VALUE_BOARD_BADGE_DAY_NEW),
/** ์์ธ์ฝ๋ : ๊ฒ์๊ธ์ '๋ง๊ฐ์๋ฐ' ๋ฑ์ง ํ์์ผ */
BOARD_BADGE_DAY_CLOSE(CD_SYSTEM_CONSTANT_VALUE_BOARD_BADGE_DAY_CLOSE);
/** */
private String value;
private CD_SYSTEM_CONSTANT_VALUE(String value) {this.value = value;}
public String getValue(){return this.value;}
}
/** ๋ผ์ด์ผ์ค ํ์
์ฝ๋ **/
public static final String CD_LICENSE_TYPE = "201";
public static final String CD_LICENSE_TYPE_CP = "CP";
public static final String CD_LICENSE_TYPE_WCP = "WCP";
public static final String CD_LICENSE_TYPE_PMS = "PMS";
public static final String CD_LICENSE_TYPE_PF = "PF"; // Proprietary Free
public static final String CD_LICENSE_TYPE_NA = "NA"; // Proprietary
/** ๋ผ์ด์ผ์ค Restriction ์ฝ๋ **/
public static final String CD_LICENSE_RESTRICTION = "226";
public static final String CD_LICENSE_NETWORK_RESTRICTION = "2";
/** ์ฌ์ฉ์๋ณ Default Tab Menu ์ฝ๋ */
public static final String CD_DEFAULT_TAB = "701";
/** marquee contents */
public static final String CD_MARQUEE = "702";
public static final String CD_DTL_CONTENTS = "100";
/** regist domain */
public static final String CD_REGIST_DOMAIN = "703";
public static final String CD_DTL_DEFAULT_DOMAIN = "100";
public static final String CD_DTL_ECT_DOMAIN = "ETC";
/** ์ฌ์ฉ์๋ณ Default Locale List ์ฝ๋ **/
public static final String CD_DEFAULT_LOCALE = "704";
/** External Service Setting */
public static final String CD_EXTERNAL_SERVICE_SETTING = "705";
public static final String CD_DTL_GITHUB_TOKEN = "100";
/** External Analysis Setting */
public static final String CD_EXTERNAL_ANALYSIS_SETTING = "706";
public static final String CD_DTL_FL_SCANNER_URL = "101";
public static final String CD_DTL_ADMIN_TOKEN = "102";
/** Watcher Domain Setting */
public static final String CD_WATCHER_DOMAIN = "710";
// -------------- ์๋ธ๋ฉ๋ด ๋ํ ์ฝ๋
/** ๋๋ฉ๋ด */
public static final String CD_MENU_MAIN = "M001";
/** ์๋ธ๋ฉ๋ด - Main */
public static final String CD_MENU_SUB_MAIN = "M100";
/** ์๋ธ๋ฉ๋ด - ๊ฒ์ํ ๊ด๋ฆฌ */
public static final String CD_NEWS_SUB_BOARD = "M600";
/** ์บ ํ์ธ ์ฐธ์ฌ ๊ฒฝ๋ก ์ฝ๋ **/
public enum CAMPAIGN_ROUTE {
RECOMMEND ("01"), // ๊ธฐ์
๋ฐ ์ง์ธ ์ถ์ฒ
SNS ("02"), // SNS ์ฑ๋
NOTICE ("03"), // ๊ฐ์ข
ํํ์ด์ง ๊ณต์ง์ฌํญ
BROCHURE ("04"), // ๋ธ๋ก์
ํ๋ณด
ETC ("99"); // ๊ธฐํ
private String value;
private CAMPAIGN_ROUTE(String value) {this.value = value;};
public String getValue() {return this.value;};
}
//license guide
// public static final String CD_LICENSE_GUID = "400";
// public static final String CD_LICENSE_GUID_EXPORT = "401";
public static final String CD_SAMPLE_FILE = "121";
// Excel Download/Export
public static final String CD_EXCEL_DOWNLOAD = "901";
public static final String CD_MAX_ROW_COUNT = "100";
// Collab Info
public static final String CD_COLLAB_INFO = "902";
public static final String CD_HELP_URL = "100";
public static final String CD_PACKAGING_REQUESTED_URL = "101";
public static final String CD_SUPPLEMENT_NOTICE_HELP_URL = "102";
public static final String CD_CHECK_OSS_NAME_URL = "903";
// check LicenseText Server Info
public static final String CD_CHECK_LICENSETEXT_SERVER_INFO = "904";
public static final String CD_SERVER_URL = "100";
public static final String CD_DOWNLOAD_URL = "200";
public static final String CD_AUTO_ANALYSIS = "905";
public static final String CD_IDLE_TIME = "100";
public static final String CD_BAT_ERROR_STRING_LIST = "907";
public static final int CD_XLSX_UPLOAD_FILE_SIZE_LIMIT = 5248000;
public static final int CD_CSV_UPLOAD_FILE_SIZE_LIMIT = 5248000;
public static final String CD_ANDROID_NOTICE_XML = "20";
public static final String CD_CHECK_OSS_SELF = "SELF";
public static final String CD_CHECK_OSS_IDENTIFICATION = "IDENTIFICATION";
public static final String CD_CHECK_OSS_PARTNER = "PARTNER";
// Open API Token Proc
public static final String CD_TOKEN_CREATE_TYPE = "CREATE";
public static final String CD_TOKEN_DELETE_TYPE = "DELETE";
public static final String CD_MAIL_TOKEN_CREATE_TYPE = "800";
public static final String CD_MAIL_TOKEN_DELETE_TYPE = "801";
public static final String CD_TOKEN_END_DATE = "9999-12-31";
public static final String CD_MAIL_PACKAGING_UPLOAD_SUCCESS = "810";
public static final String CD_MAIL_PACKAGING_UPLOAD_FAILURE = "811";
public static final int CD_OPEN_API_CREATE_PROJECT_LIMIT = 3;
public static final int CD_OPEN_API_PACKAGE_FILE_LIMIT = 3;
// Open API return messsage(error)
public static final String CD_OPEN_API_MESSAGE = "908";
public static final String CD_OPEN_API_USER_NOTFOUND_MESSAGE = "200";
public static final String CD_OPEN_API_SIGNIN_FAILED_MESSAGE = "210";
// public static final String CD_OPEN_API_EMPTY_ROW_MESSAGE = "300"; // ์ฌ์ฉํ์ง ์์.
public static final String CD_OPEN_API_PARAMETER_ERROR_MESSAGE = "310";
public static final String CD_OPEN_API_CREATE_OVERFLOW_MESSAGE = "320";
public static final String CD_OPEN_API_DATA_VALIDERROR_MESSAGE = "330";
public static final String CD_OPEN_API_CREATE_PROJECT_DUPLICATE_MESSAGE = "340";
public static final String CD_OPEN_API_FILE_NOTEXISTS_MESSAGE = "400";
public static final String CD_OPEN_API_FILE_SIZEOVER_MESSAGE = "410";
public static final String CD_OPEN_API_EXT_UNSUPPORT_MESSAGE = "420";
public static final String CD_OPEN_API_UPLOAD_TARGET_ERROR_MESSAGE = "430";
public static final String CD_OPEN_API_FILE_DATA_EMPTY_MESSAGE = "440";
public static final String CD_OPEN_API_PERMISSION_ERROR_MESSAGE = "500";
public static final String CD_OPEN_API_COMMUNICATION_ERROR_MESSAGE = "900";
public static final String CD_OPEN_API_UNKNOWN_ERROR_MESSAGE = "999";
public static final String CD_COMMA_CHAR = ",";
public static final String CD_PLATFORM_GENERATED = "307";
public static final String CD_DTL_DEFAULT_PLATFORM = "1";
public static final String CD_PROJECT_PRIORITY = "308";
public static final String CD_PRIORITY_P0 = "10";
public static final String CD_PRIORITY_P2 = "30";
public static final String CD_DISTRIBUTE_ACT_IMMEDIATELY = "I";
public static final String CD_DISTRIBUTE_ACT_MODEL_ONLY = "M";
public static final String CD_DISTRIBUTE_ACT_DESCRIPTION_ONLY = "DD";
public static final String CD_DISTRIBUTE_ACT_SOFTWARE_ONLY = "DS";
public static final String CD_DISTRIBUTE_ACT_DESCRIPTION_SOFTWARE = "DA";
public static final String CD_DISTRIBUTE_ACT_PACKAGING = "DP";
public static final String CD_DISTRIBUTE_ACT_NOT_CHANGE = "DNC";
public static final String CD_LDAP_SEARCH_INFO = "931";
public static final String CD_DTL_LDAP_SEARCH_ID = "100";
public static final String CD_DTL_LDAP_SEARCH_PW = "200";
/* SPDX CODE */
public static final String CD_SPDX = "spdx";
public static final String CD_SPDX_RPF = "spdxRdf";
public static final String CD_SPDX_TAG = "spdxTag";
public static final String CD_SPDX_JSON = "spdxJson";
public static final String CD_SPDX_YAML = "spdxYaml";
/* SCORE CODE */
public static final String CD_VULNERABILITY_MAILING_SCORE = "750";
public static final String CD_VULNERABILITY_MAILING_SCORE_STANDARD = "100";
/* SECURITY SCORE CODE */
public static final String CD_SECURITY_VULNERABILITY_SCORE = "760";
public static final String CD_SECURITY_VULNERABILITY_DETAIL_SCORE = "100";
}
| 45,619 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
SecurityConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/SecurityConfig.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.PropertySources;
import org.springframework.security.authentication.AbstractAuthenticationToken;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.DefaultRedirectStrategy;
import org.springframework.security.web.RedirectStrategy;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler;
import org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.security.web.authentication.logout.SimpleUrlLogoutSuccessHandler;
import oss.fosslight.common.CoConstDef;
import oss.fosslight.common.Url;
import oss.fosslight.domain.T2Users;
import oss.fosslight.service.T2UserService;
import oss.fosslight.util.StringUtil;
@PropertySources(value = {@PropertySource(value=AppConstBean.APP_CONFIG_VALIDATION_PROPERTIES)})
@EnableWebSecurity
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Autowired private T2UserService userService;
@Autowired private CustomAuthenticationProvider customAuthenticationProvider;
@Autowired private CustomWebAuthenticationDetailsSource customWebAuthenticationDetailsSource;
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
auth.authenticationProvider(customAuthenticationProvider);
}
@Override
protected void configure(HttpSecurity http) throws Exception {
http
// replay ์ดํ์ ๋ง๊ธฐ ์ํ csrf ํ ํฐ์ ์์ฑ์ ๋นํ์ฑํ(disabled) ์ฒ๋ฆฌ
.csrf().disable()
// 'X-Frame-Options' to 'DENY' ๋์
.headers().frameOptions().disable().and()
.authorizeRequests().antMatchers(Url.USER.SAVE_AJAX).permitAll().and() // ์ฌ์ฉ์๊ฐ์
์์ฒญ์ฒ๋ฆฌ ์์ธ
.authorizeRequests().antMatchers(Url.USER.RESET_PASSWORD).permitAll().and() // ๋น๋ฐ๋ฒํธ ์ด๊ธฐํ ์์ฒญ์ฒ๋ฆฌ ์์ธ
.authorizeRequests().antMatchers("/*" + Url.USER.SAVE_AJAX).permitAll().and() // ์ฌ์ฉ์๊ฐ์
์์ฒญ์ฒ๋ฆฌ ์์ธ
.authorizeRequests().antMatchers(Url.VULNERABILITY.VULN_POPUP).permitAll().and() // vulnerability popup ํ๋ฉด ์์ธ
.authorizeRequests().antMatchers(Url.API.PATH+"/**").permitAll().and()
.authorizeRequests().antMatchers(Url.NOTICE.PUBLISHED_NOTICE).permitAll().and() // ๊ณต์ง์ฌํญ ์กฐํ ์์ฒญ์ฒ๋ฆฌ ์์ธ
// ์์ฒญ์ ๋ํ ๊ถํ ๋งคํ
.authorizeRequests().anyRequest().authenticated() // ๋ชจ๋ ์์ฒญ์ ๋ํด ๊ถํ ํ์ธ์ด ํ์
// set login page url
.and()
.formLogin()
.permitAll()
.loginPage(AppConstBean.SECURITY_LOGIN_PAGE)
.usernameParameter(AppConstBean.SECURITY_USERNAME_PARAMETER)
.passwordParameter(AppConstBean.SECURITY_PASSWORD_PARAMETER)
.authenticationDetailsSource(customWebAuthenticationDetailsSource)
.defaultSuccessUrl(AppConstBean.SECURITY_DEFAULT_SUCCESS_URL)
.loginProcessingUrl(AppConstBean.SECURITY_LOGIN_PROCESSING_URL)
.failureHandler(failureHandler())
.successHandler(successHandler())
.permitAll()
.and()
.logout()
.logoutUrl(AppConstBean.SECURITY_LOGOUT_URL)
.logoutSuccessHandler(logoutSuccessHandler())
.deleteCookies("JSESSIONID")
.invalidateHttpSession(true) // is Default True
;
}
public LogoutSuccessHandler logoutSuccessHandler() {
LogoutSuccessHandler successHandler = new CustomLogoutSuccessHandler();
return successHandler;
}
public CustomAuthenticationFailureHandler failureHandler() {
return new CustomAuthenticationFailureHandler();
}
public CustomAuthenticationSuccessHandler successHandler() {
CustomAuthenticationSuccessHandler successHandler = new CustomAuthenticationSuccessHandler(userService);
return successHandler;
}
@Override
public void configure(WebSecurity web) throws Exception {
// Security Debug
// web.debug(true);
web
.ignoring()
// static ๋ฆฌ์์ค ๊ฒฝ๋ก๋ webSecurity ๊ฒ์ฌ ์ ์ธ
.antMatchers( CoConstDef.STATIC_RESOURCES_URL_PATTERNS )
.antMatchers( CoConstDef.HEALTH_CHECK_URL )
;
web.ignoring().antMatchers("/v2/api-docs", "/swagger-resources/**",
"/swagger-ui.html", "/webjars/**", "/swagger/**");
super.configure(web);
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
private static class CustomAuthenticationSuccessHandler extends SimpleUrlAuthenticationSuccessHandler {
private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();
T2UserService userService = null;
public CustomAuthenticationSuccessHandler(T2UserService userService) {
this.userService = userService;
}
@Override
public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws ServletException, IOException {
// Security session์ ์ถ๊ฐ ์ ๋ณด(Cusom)๋ฅผ ์ ์ฅํ๋ค(Mapํํ)
SecurityContext sec = SecurityContextHolder.getContext();
AbstractAuthenticationToken auth = (AbstractAuthenticationToken)sec.getAuthentication();
//User Detail
T2Users user = new T2Users();
user.setUserId(auth.getName());
T2Users userInfo = userService.getUserAndAuthorities(user);
HashMap<String, Object> info = new HashMap<String, Object>();
if (StringUtil.isEmptyTrimmed(userInfo.getDivision())){
userInfo.setDivision(CoConstDef.CD_USER_DIVISION_EMPTY);
}
info.put("sessUserInfo", userInfo);
auth.setDetails(info);
// ajax ๋ก๊ทธ์ธ ์ฒดํฌ์์๋ง ์ฌ์ฉ
String accept = request.getHeader("accept");
String error = "false";
String message = "๋ก๊ทธ์ธ์ฑ๊ณตํ์์ต๋๋ค.";
String locale = userInfo.getDefaultLocale();
if (StringUtil.indexOf(accept, "json") > -1) {
response.setContentType("application/json");
response.setCharacterEncoding("utf-8");
String data = StringUtil.join(new String[] {
"{",
"\"response\" : { ",
"\"error\" : " + error + ", ",
"\"message\" : \"" + message + "\", ",
"\"locale\" : \"" + locale + "\"",
"}",
"}"
});
PrintWriter out = response.getWriter();
out.print(data);
out.flush();
out.close();
}
}
public void setRedirectStrategy(RedirectStrategy redirectStrategy) {
this.redirectStrategy = redirectStrategy;
}
protected RedirectStrategy getRedirectStrategy() {
return redirectStrategy;
}
}
private static class CustomAuthenticationFailureHandler extends SimpleUrlAuthenticationFailureHandler {
public static String DEFAULT_TARGET_PARAMETER = "spring-security-redirect-login-failure";
private String targetUrlParameter = DEFAULT_TARGET_PARAMETER;
@Override
public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
AuthenticationException exception) throws IOException, ServletException {
String accept = request.getHeader("accept");
String error = "true";
String message = "Invalid ID or password. Please try again.";
if (exception.getMessage().equals("enter email")) {
message = exception.getMessage();
}
if ( StringUtil.indexOf(accept, "html") > -1 ) {
String redirectUrl = request.getParameter(this.targetUrlParameter);
if (redirectUrl != null) {
super.logger.debug("Found redirect URL: " + redirectUrl);
getRedirectStrategy().sendRedirect(request, response, redirectUrl);
} else {
super.onAuthenticationFailure(request, response, exception);
}
} else if ( StringUtil.indexOf(accept, "xml") > -1 ) {
response.setContentType("application/xml");
response.setCharacterEncoding("utf-8");
String data = StringUtil.join(new String[] {
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
"<response>",
"<error>" , error , "</error>",
"<message>" , message , "</message>",
"</response>"
});
PrintWriter out = response.getWriter();
out.print(data);
out.flush();
out.close();
} else if ( StringUtil.indexOf(accept, "json") > -1 ) {
response.setContentType("application/json");
response.setCharacterEncoding("utf-8");
String data = StringUtil.join(new String[] {
" { \"response\" : {",
" \"error\" : " , error , ", ",
" \"message\" : \"", message , "\" ",
"} } "
});
PrintWriter out = response.getWriter();
out.print(data);
out.flush();
out.close();
}
}
}
public class CustomLogoutSuccessHandler extends SimpleUrlLogoutSuccessHandler implements LogoutSuccessHandler {
@Override
public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response,
Authentication authentication) throws IOException, ServletException {
// Default ํ์ด์ง๋ก ์ด๋
String loginSuccUrl = AppConstBean.SECURITY_LOGOUT_SUCCESS_URL;
response.sendRedirect(request.getContextPath() + loginSuccUrl);
}
}
}
| 10,679 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
AppConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/AppConfig.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import java.io.IOException;
import java.util.Properties;
import org.apache.velocity.app.VelocityEngine;
import org.apache.velocity.exception.VelocityException;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.PropertySources;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import lombok.extern.slf4j.Slf4j;
import oss.fosslight.common.CoConstDef;
import oss.fosslight.common.CommonFunction;
import oss.fosslight.util.StringUtil;
@Configuration
@ComponentScan(value=AppConstBean.APP_COMPONENT_SCAN_PACKAGE)
@PropertySources(value = {@PropertySource(value=AppConstBean.APP_CONFIG_PROPERTIES_PATH)})
@Slf4j
public class AppConfig {
@Bean(name={"mailSender"})
public JavaMailSenderImpl mailSender(){
JavaMailSenderImpl mailSenderImpl = new JavaMailSenderImpl();
String smtpUseFlag = CommonFunction.getProperty("mail.smtp.useflag");
if (CoConstDef.FLAG_YES.equals(smtpUseFlag)) {
try {
final String MAIL_SERVICE_HOST = CommonFunction.getProperty("mail.smtp.host");
final int MAIL_SERVICE_PORT = Integer.parseInt(StringUtil.avoidNull(CommonFunction.getProperty("mail.smtp.port"), "25"));
final String MAIL_SERVICE_ENCODING = StringUtil.avoidNull(CommonFunction.getProperty("mail.smtp.encoding"), "UTF-8");
final String MAIL_SERVICE_USERNAME = CommonFunction.getProperty("mail.smtp.username");
final String MAIL_SERVICE_PASSWORD = CommonFunction.getProperty("mail.smtp.password");
final boolean checkFlag = CommonFunction.propertyFlagCheck("checkFlag", CoConstDef.FLAG_YES);
final Properties MAIL_SERVICE_PROP = new Properties() {
private static final long serialVersionUID = 1L;
{
if (checkFlag) {
setProperty("mail.smtp.host", MAIL_SERVICE_HOST);
setProperty("mail.smtp.user", MAIL_SERVICE_USERNAME);
setProperty("mail.smtp.port", String.valueOf(MAIL_SERVICE_PORT));
} else {
setProperty("mail.smtp.auth", "true");
setProperty("mail.smtp.starttls.enable", "true");
setProperty("mail.smtp.ssl.trust", MAIL_SERVICE_HOST);
}
}
};
mailSenderImpl.setHost(MAIL_SERVICE_HOST);
mailSenderImpl.setPort(MAIL_SERVICE_PORT);
mailSenderImpl.setDefaultEncoding(MAIL_SERVICE_ENCODING);
mailSenderImpl.setJavaMailProperties(MAIL_SERVICE_PROP);
if (!checkFlag) {
mailSenderImpl.setUsername(MAIL_SERVICE_USERNAME);
mailSenderImpl.setPassword(MAIL_SERVICE_PASSWORD);
}
} catch (Exception e) {
log.error(e.getMessage());
}
}
return mailSenderImpl;
}
@Bean
public VelocityEngine getVelocityEngine() throws VelocityException, IOException {
VelocityEngine factory = new VelocityEngine();
Properties props = new Properties();
props.put("resource.loader", "class");
props.put("class.resource.loader.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
props.put("input.encoding", AppConstBean.APP_ENCODING);
props.put("output.encoding", AppConstBean.APP_ENCODING);
props.put("response.encoding", AppConstBean.APP_ENCODING);
factory.init(props);
return factory;
}
}
| 3,620 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ContainerConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/ContainerConfig.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import java.util.Collection;
import java.util.Collections;
import javax.servlet.descriptor.JspConfigDescriptor;
import javax.servlet.descriptor.JspPropertyGroupDescriptor;
import javax.servlet.descriptor.TaglibDescriptor;
import org.apache.catalina.Context;
import org.apache.tomcat.util.descriptor.web.JspPropertyGroup;
import org.apache.tomcat.util.descriptor.web.JspPropertyGroupDescriptorImpl;
import org.apache.tomcat.util.descriptor.web.TaglibDescriptorImpl;
import org.springframework.boot.web.embedded.tomcat.TomcatContextCustomizer;
import org.springframework.boot.web.embedded.tomcat.TomcatServletWebServerFactory;
import org.springframework.boot.web.server.WebServerFactoryCustomizer;
import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;
import org.springframework.context.annotation.Configuration;
import oss.fosslight.common.CoConstDef;
@Configuration
public class ContainerConfig implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
@Override
public void customize(ConfigurableServletWebServerFactory factory) {
((TomcatServletWebServerFactory)factory).addContextCustomizers(new TomcatContextCustomizer(){
JspConfigDescriptor jspConfigDescriptor = new JspConfigDescriptor() {
// set custom taglib
@Override
public Collection<TaglibDescriptor> getTaglibs() {
TaglibDescriptor descriptor = new TaglibDescriptorImpl(CoConstDef.COMM_TLD_URI, CoConstDef.COMM_TLD_PATH);
return Collections.singletonList(descriptor);
}
// set jsp pattern
@Override
public Collection<JspPropertyGroupDescriptor> getJspPropertyGroups() {
JspPropertyGroup group = new JspPropertyGroup();
group.addUrlPattern( CoConstDef.JSP_PROPERTY_URL_PATTERN );
group.setPageEncoding("UTF-8");
JspPropertyGroupDescriptor descriptor = new JspPropertyGroupDescriptorImpl(group);
return Collections.singletonList(descriptor);
}
};
@Override
public void customize(Context context) {
context.setJspConfigDescriptor(jspConfigDescriptor);
}
});
}
}
| 2,582 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
DatasourceConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/DatasourceConfig.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import oss.fosslight.common.CommonFunction;
@Configuration
public class DatasourceConfig {
@Autowired Environment env;
@Bean
public DataSource getDataSource() {
DataSourceBuilder<?> dataSourceBuilder = DataSourceBuilder.create();
dataSourceBuilder.driverClassName(env.getProperty("spring.datasource.driver-class-name", "com.mysql.cj.jdbc.Driver"));
String jdbcUrl = CommonFunction.makeJdbcUrl(env.getProperty("spring.datasource.url", "127.0.0.1:3306/fosslight"));
dataSourceBuilder.url(jdbcUrl);
dataSourceBuilder.username(env.getProperty("spring.datasource.username", "fosslight"));
dataSourceBuilder.password(env.getProperty("spring.datasource.password", "fosslight"));
return dataSourceBuilder.build();
}
}
| 1,206 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
TilesConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/TilesConfig.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.view.UrlBasedViewResolver;
import org.springframework.web.servlet.view.tiles3.TilesConfigurer;
import org.springframework.web.servlet.view.tiles3.TilesView;
import oss.fosslight.common.CoConstDef;
@Configuration
public class TilesConfig {
@Bean
public TilesConfigurer tilesConfigurer() {
final TilesConfigurer configurer = new TilesConfigurer();
configurer.setDefinitions( CoConstDef.TILES_LAYOUT_XML_PATH ); // tiles ์ค์ ํ์ผ์ด ์๋ ์์น
configurer.setCheckRefresh( CoConstDef.REFRESH_JSP_ON_RUNTIME ); // tiles ์ค์ ํ์ผ์ด runtime ์ค์ ๋ณ๊ฒฝ๋ ๊ฒฝ์ฐ ์ ์ฉ ์ฌ๋ถ
return configurer;
}
@Bean
public UrlBasedViewResolver urlViewResolver() {
UrlBasedViewResolver tilesViewResolver = new UrlBasedViewResolver();
tilesViewResolver.setViewClass(TilesView.class);
return tilesViewResolver;
}
}
| 1,117 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
AppConstBean.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/AppConstBean.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
/** **************************************************************************
* Web Application์ Config ๋ณ์ ์ ์ฅ์
*
************************************************************************** */
public class AppConstBean {
/** **************************************************************************
* Common Value
************************************************************************** */
public static final String APP_CONFIG_PROPERTIES_PATH = "classpath:application.properties"; // Application Properties Path
public static final String APP_CONFIG_VALIDATION_PROPERTIES = "classpath:messages/validation.properties";
public static final String APP_COMPONENT_SCAN_PACKAGE = "oss.fosslight"; // Component Scan Package (=Project Package)
/*
* Tiles์ "pageTitle" attribute์ ์ฌ์ฉ๋๋ฉฐ, "APP_NAME"์ AdviceController์์ @ModelAttribute("pageTitle")๋ก ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ถ๊ฐ๋๋ค.
* ๋ณ๊ฒฝ์ ์ํ ๊ฒฝ์ฐ Controller์์ model.addAttribute("pageTitle",StringValue); ์ ์
๋ ฅ๋ ๊ฐ์ด ์ค์ ๋๋ค.
*/
public static final String APP_NAME = "FOSSLight";
/** **************************************************************************
* App Config
************************************************************************** */
public static final String APP_ENCODING = "UTF-8"; // Web Application ์ธ์ฝ๋ฉ
/** **************************************************************************
* Web Config
************************************************************************** */
public static final String MESSAGE_SOURCE_DEFAULT_LOCALE = "ko"; // ๋ฉ์์ง ์์ค ๋ํดํธ ์ธ์ฝ๋ฉ
public static final String MESSAGE_SOURCE_DEFAULT_LOCALE_PARAM_NAME = "lang"; // ๋ฉ์์ง ์์ค ๋ณ๊ฒฝ ํ๋ผ๋ฏธํฐ ํค
public static final String RESOURCE_HANDLER = "/**"; // ๋ฆฌ์์ค URL ๋งตํ Path
public static final String RESOURCE_LOCATIONS = "/WEB-INF/resources/"; // ๋ฆฌ์์ค ๋ฌผ๋ฆฌ์ Path
public static final String VIEW_PREFIX = "/WEB-INF/views/"; // jsp Root Path
public static final String VIEW_SUFFIX = ".jsp"; // jsp file suffix
/** **************************************************************************
* Security Config
************************************************************************** */
public static final String SECURITY_ROLE_PREFIX = "";
public static final String SECURITY_ROLE_DEFAULT = "ROLE_USER"; // ์ฌ์ฉ์ ์ถ๊ฐ์ T2_AUTHORITIES์ ๊ธฐ๋ณธ์ผ๋ก ๋ค์ด๊ฐ๋ ์ญํ
public static final String SECURITY_LOGIN_PAGE = "/session/login";
public static final String SECURITY_LOGIN_PROCESSING_URL = "/session/login-proc";
public static final String SECURITY_LOGOUT_URL = "/session/logout-proc";
public static final String SECURITY_LOGOUT_SUCCESS_URL = "/";
public static final String SECURITY_USERNAME_PARAMETER = "un";
public static final String SECURITY_PASSWORD_PARAMETER = "up";
public static final String SECURITY_EMAIL_PARAMETER = "em";
public static final String SECURITY_DEFAULT_SUCCESS_URL = "/index";
}
| 3,284 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
HistoryConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/HistoryConfig.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import oss.fosslight.domain.History;
public interface HistoryConfig {
public static final String INSERT_ACTION = "INSERT";
public static final String DELETE_ACTION = "DELETE";
public static final String UPDATE_ACTION = "UPDATE";
public History work(Object param);
}
| 397 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CustomCacheEventLogger.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/CustomCacheEventLogger.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import org.ehcache.event.CacheEvent;
import org.ehcache.event.CacheEventListener;
import org.springframework.context.annotation.Profile;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Profile(value = {"dev"})
public class CustomCacheEventLogger implements CacheEventListener<Object, Object> {
@Override
public void onEvent(CacheEvent<?, ?> cacheEvent) {
log.debug("Cache event = {}, Key = {}, Old value = {}, New value = {}", cacheEvent.getType(),
cacheEvent.getKey(), cacheEvent.getOldValue(), cacheEvent.getNewValue());
}
}
| 658 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CustomWebAuthenticationDetailsSource.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/CustomWebAuthenticationDetailsSource.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import javax.servlet.http.HttpServletRequest;
import org.springframework.security.authentication.AuthenticationDetailsSource;
import org.springframework.security.web.authentication.WebAuthenticationDetails;
import org.springframework.stereotype.Component;
@Component
public class CustomWebAuthenticationDetailsSource implements AuthenticationDetailsSource<HttpServletRequest, WebAuthenticationDetails> {
@Override
public WebAuthenticationDetails buildDetails(HttpServletRequest context) {
return new CustomWebAuthenticationDetails(context);
}
}
| 679 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
WebClientConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/WebClientConfig.java | /*
* Copyright (c) 2021 Dongmin Kang
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import com.google.common.net.HttpHeaders;
import io.netty.channel.ChannelOption;
import io.netty.handler.timeout.ReadTimeoutHandler;
import io.netty.handler.timeout.WriteTimeoutHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.http.MediaType;
import org.springframework.http.client.reactive.ClientHttpConnector;
import org.springframework.http.client.reactive.ReactorClientHttpConnector;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.netty.http.client.HttpClient;
import java.util.concurrent.TimeUnit;
@Configuration
public class WebClientConfig {
@Autowired Environment env;
@Bean
public WebClient getWebClient() {
final int connectTimeOut = env.getProperty("rest.template.connect-timeout", Integer.class);
final int readTimeOut = env.getProperty("rest.template.read-timeout", Integer.class);
final int writeTimeOut = env.getProperty("rest.template.write-timeout", Integer.class);
HttpClient httpClient = HttpClient.create()
.tcpConfiguration(client ->
client.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, connectTimeOut)
.doOnConnected(conn -> conn
.addHandlerLast(new ReadTimeoutHandler(readTimeOut, TimeUnit.MILLISECONDS))
.addHandlerLast(new WriteTimeoutHandler(writeTimeOut, TimeUnit.MILLISECONDS))
)
);
ClientHttpConnector connector = new ReactorClientHttpConnector(httpClient.wiretap(true));
return WebClient.builder()
.clientConnector(connector)
.defaultHeaders(httpHeaders -> {
httpHeaders.add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
httpHeaders.add(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE);
})
.build();
}
} | 2,013 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CustomAuthenticationProvider.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/CustomAuthenticationProvider.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import static org.springframework.ldap.query.LdapQueryBuilder.query;
import java.util.*;
import javax.naming.NamingException;
import javax.naming.directory.Attributes;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ldap.core.AttributesMapper;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.core.support.LdapContextSource;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
import oss.fosslight.common.CoCodeManager;
import oss.fosslight.common.CoConstDef;
import oss.fosslight.common.CommonFunction;
import oss.fosslight.domain.T2Authorities;
import oss.fosslight.domain.T2Users;
import oss.fosslight.service.T2UserService;
import oss.fosslight.util.StringUtil;
@Component
@Slf4j
public class CustomAuthenticationProvider implements AuthenticationProvider {
@Autowired T2UserService userService;
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
String user_id = (String)authentication.getPrincipal();
String user_pw = (String)authentication.getCredentials();
CustomWebAuthenticationDetails customWebAuthenticationDetails = (CustomWebAuthenticationDetails)authentication.getDetails();
String email = customWebAuthenticationDetails.getEmail();
boolean loginSuccess = false;
Map<String, Object> rtnMap = new HashMap<>();
rtnMap.put("email", email);
String ldapFlag = CoCodeManager.getCodeExpString(CoConstDef.CD_SYSTEM_SETTING, CoConstDef.CD_LDAP_USED_FLAG);
List<String> customAccounts = Arrays.asList(CommonFunction.emptyCheckProperty("custom.accounts", "").split(","));
if (CoConstDef.FLAG_YES.equals(ldapFlag) && !customAccounts.contains(user_id)) {
rtnMap = checkByADUser(user_id, user_pw, rtnMap);
loginSuccess = (boolean) rtnMap.get("isAuthenticated");
} else {
loginSuccess = checkSystemUser(user_id, user_pw);
}
if (loginSuccess) {
List<GrantedAuthority> roles = new ArrayList<GrantedAuthority>();
T2Users user = new T2Users();
user.setUserId(user_id);
T2Users getUser = userService.getUserAndAuthorities(user);
for (T2Authorities auth : getUser.getAuthoritiesList()) {
roles.add(new SimpleGrantedAuthority(auth.getAuthority()));
}
return new UsernamePasswordAuthenticationToken(user_id, user_pw, roles);
} else {
if (rtnMap.containsKey("msg")) {
throw new BadCredentialsException((String) rtnMap.get("msg"));
} else {
throw new BadCredentialsException("Bad credentials");
}
}
}
private boolean checkSystemUser(String user_id, String user_pw) {
T2Users param = new T2Users();
param.setUserId(user_id);
return userService.checkPassword(user_pw, param);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private Map<String, Object> checkByADUser(String user_id, String user_pw, Map<String, Object> rtnMap) {
String rtnEmail = (String) rtnMap.get("email");
List<String[]> searchResult = null;
if (StringUtil.isNotEmpty(user_pw)) {
String ldapDomain = CoCodeManager.getCodeExpString(CoConstDef.CD_LOGIN_SETTING, CoConstDef.CD_LDAP_DOMAIN);
try {
LdapContextSource contextSource = new LdapContextSource();
contextSource.setUrl(CoConstDef.AD_LDAP_LOGIN.LDAP_SERVER_URL.getValue());
contextSource.setBase("OU=LGE Users, DC=LGE, DC=NET");
contextSource.setUserDn(user_id+ldapDomain);
contextSource.setPassword(user_pw);
CommonFunction.setSslWithCert();
contextSource.afterPropertiesSet();
LdapTemplate ldapTemplate = new LdapTemplate(contextSource);
ldapTemplate.afterPropertiesSet();
if (ldapTemplate.authenticate("", String.format("(cn=%s)", user_id), user_pw)) {
searchResult = ldapTemplate.search(query().where("cn").is(user_id), new AttributesMapper() {
public Object mapFromAttributes(Attributes attrs) throws NamingException {
return new String[]{(String)attrs.get("mail").get(), (String)attrs.get("displayname").get()};
}
});
rtnMap.put("isAuthenticated", true);
} else {
rtnMap.put("isAuthenticated", false);
return rtnMap;
}
} catch (Exception e) {
log.warn("ERROR Message :" + e.getMessage());
rtnMap.put("isAuthenticated", false);
return rtnMap;
}
// ์ฌ์ฉ์ ๊ฐ์
์ฌ๋ถ ์ฒดํฌ
if (!userService.existUserIdOrEmail(user_id)){
String userName = "";
String userEmail = "";
String userEmailCnt = "";
if (searchResult != null) {
int cnt = 1;
for(int i=0;i<searchResult.size();i++) {
String email = searchResult.get(i)[0];
String displayName = searchResult.get(i)[1];
if (StringUtil.isEmptyTrimmed(displayName)) {
userName = email.split("@")[0];
} else{
userName = displayName.replaceAll("\\("+email+"\\)", "").trim();
}
if (!StringUtil.isEmptyTrimmed(rtnEmail)) {
if (email.equals(rtnEmail.trim())) {
userEmail = email;
userEmailCnt = String.valueOf(cnt);
break;
} else {
userEmail= "";
userEmailCnt = String.valueOf(cnt);
}
} else {
userEmail = email;
userEmailCnt = String.valueOf(cnt++);
}
}
}
if (StringUtil.isEmptyTrimmed(userEmail) || StringUtil.isEmptyTrimmed(userName)) {
log.debug("Cannot find Ldap user information : " + user_id);
rtnMap.put("isAuthenticated", false);
return rtnMap;
}
if (Integer.parseInt(userEmailCnt) > 1 && StringUtil.isNotEmpty(userEmail)) {
log.debug("ldap user email duplicate : " + user_id);
rtnMap.put("isAuthenticated", false);
rtnMap.put("msg", "enter email");
return rtnMap;
}
T2Users vo = new T2Users();
vo.setUserId(user_id);
vo.setCreatedDateCurrentTime();
vo.setCreator(user_id);
vo.setModifier(user_id);
vo.setEmail(rtnEmail);
vo.setEmail(userEmail);
vo.setUserName(userName);
vo.setDivision(CoConstDef.CD_USER_DIVISION_EMPTY);
userService.addNewUsers(vo);
}
}
return rtnMap;
}
@Override
public boolean supports(Class<?> authentication) {
return true;
}
}
| 7,275 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
WebConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/WebConfig.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import java.util.List;
import java.util.Locale;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ResourceBundleMessageSource;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.web.PageableHandlerMethodArgumentResolver;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.ResourceHttpMessageConverter;
import org.springframework.http.converter.json.GsonHttpMessageConverter;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.i18n.CookieLocaleResolver;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.resource.PathResourceResolver;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import oss.fosslight.common.CoConstDef;
import oss.fosslight.interceptor.AjaxInterceptor;
import springfox.documentation.spring.web.json.Json;
@Configuration
@EnableWebMvc
@EnableCaching
@ComponentScan(value=AppConstBean.APP_COMPONENT_SCAN_PACKAGE)
public class WebConfig implements WebMvcConfigurer {
private final Gson gson = new GsonBuilder().registerTypeAdapter(Json.class, new SpringfoxJsonToGsonAdapter()).create();
private static class SpringfoxJsonToGsonAdapter implements JsonSerializer<Json> {
@SuppressWarnings("deprecation")
@Override
public JsonElement serialize(Json json, java.lang.reflect.Type typeOfSrc, JsonSerializationContext context) {
final JsonParser parser = new JsonParser();
return parser.parse(json.value());
}
}
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
GsonHttpMessageConverter gsonHttpMessageConverter = new GsonHttpMessageConverter();
gsonHttpMessageConverter.setGson(gson);
converters.add(gsonHttpMessageConverter);
converters.add(new ResourceHttpMessageConverter(true));
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(localeChangeInterceptor());
registry.addInterceptor(new AjaxInterceptor()).excludePathPatterns("/error", "/error/**","/viewer","/viewer/**");
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler( CoConstDef.STATIC_RESOURCES_URL_PATTERNS)
.addResourceLocations(CoConstDef.CLASSPATH_RESOURCE_LOCATIONS)
.setCachePeriod(60*60*24*7)// 60*60*24*7 => 1 week
.resourceChain(true)
.addResolver(new PathResourceResolver());
registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
}
@Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
PageableHandlerMethodArgumentResolver resolver = new PageableHandlerMethodArgumentResolver();
resolver.setFallbackPageable(PageRequest.of(CoConstDef.DEFAULT_PAGE_NUMBER, CoConstDef.DEFAULT_PAGE_SIZE));
argumentResolvers.add(resolver);
WebMvcConfigurer.super.addArgumentResolvers(argumentResolvers);
}
@Bean
public MessageSource messageSource() {
ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
// Search properties in "messages/message" below WEB-INF folder
messageSource.setBasename("messages/message");
messageSource.setDefaultEncoding("UTF-8");
// # -1 : never reload, 0 always reload
messageSource.setCacheSeconds(60);
return messageSource;
}
/*
localeResolver using cookie
*/
@Bean
public LocaleResolver localeResolver() {
CookieLocaleResolver localeResolver = new CookieLocaleResolver();
localeResolver.setDefaultLocale(Locale.ENGLISH);
localeResolver.setCookieName("lang");
return localeResolver;
}
/*
when ?lang="country code" input query, change locale language
*/
@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
localeChangeInterceptor.setParamName("lang");
return localeChangeInterceptor;
}
} | 5,025 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
SwaggerConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/SwaggerConfig.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
private static final Set<String> DEFAULT_PRODUCES_AND_CONSUMES = new HashSet<String>(Arrays.asList("application/json"));
@Bean
public Docket swaggerApi() {
return new Docket(DocumentationType.SWAGGER_2).apiInfo(swaggerInfo())
.consumes(DEFAULT_PRODUCES_AND_CONSUMES).produces(DEFAULT_PRODUCES_AND_CONSUMES).select()
.apis(RequestHandlerSelectors.basePackage(AppConstBean.APP_COMPONENT_SCAN_PACKAGE+".api.controller"))
.paths(PathSelectors.ant("/api/v1/**"))
.build()
.useDefaultResponseMessages(false); // ๊ธฐ๋ณธ์ผ๋ก ์ธํ
๋๋ 200,401,403,404 ๋ฉ์์ง๋ฅผ ํ์ ํ์ง ์์
}
private ApiInfo swaggerInfo() {
return new ApiInfoBuilder()
.title("FOSSLight Hub Open API")
.description("") // ์์คํ
์ค์ก์ด ํ์ํ ๊ฒฝ์ฐ ๊ธฐ์
.version("1")
.build();
}
}
| 1,721 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
StaticResourceConfig.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/StaticResourceConfig.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
@SuppressWarnings("deprecation")
@Configuration
public class StaticResourceConfig extends WebMvcConfigurerAdapter {
@Autowired Environment env;
private String rootPath;
private String publishPath;
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
rootPath = env.getProperty("root.dir");
publishPath = env.getProperty("internal.url.dir.path");
registry.addResourceHandler(publishPath+"/**").addResourceLocations("file:"+rootPath+publishPath+"/");
}
}
| 955 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CustomWebAuthenticationDetails.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/config/CustomWebAuthenticationDetails.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.config;
import javax.servlet.http.HttpServletRequest;
import org.springframework.security.web.authentication.WebAuthenticationDetails;
public class CustomWebAuthenticationDetails extends WebAuthenticationDetails {
private static final long serialVersionUID = -3984468376168493070L;
private final String email;
public CustomWebAuthenticationDetails(HttpServletRequest request) {
super(request);
email = request.getParameter(AppConstBean.SECURITY_EMAIL_PARAMETER);
}
public String getEmail() {
return email;
}
}
| 643 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ApiPartnerMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/ApiPartnerMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface ApiPartnerMapper {
int selectPartnerMasterCount(Map<String, Object> paramMap);
List<Map<String, Object>> selectPartnerMaster(Map<String, Object> paramMap);
int existsWatcherByEmail(@Param("partnerId") String partnerId, @Param("email") String email);
void insertWatcher(Map<String, Object> paramMap);
int existPartnertCnt(Map<String, Object> paramMap);
}
| 648 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CodeManagerMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/CodeManagerMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.CodeBean;
import oss.fosslight.domain.CodeDtlBean;
@Mapper
public interface CodeManagerMapper {
public List<CodeBean> getCodeList(CodeBean vo) throws Exception;
public int getCodeListTotCnt(CodeBean vo) throws Exception;
public CodeBean getCodeInfo(CodeBean vo) throws Exception;
public List<CodeDtlBean> getCodeDtlList(CodeBean vo) throws Exception;
public void insertCode(CodeBean vo) throws Exception;
public int updateCode(CodeBean vo) throws Exception;
public void insertCodeDtl(CodeDtlBean vo) throws Exception;
public int deleteCode(CodeBean vo) throws Exception;
public List<CodeDtlBean> getCodeListAll();
} | 902 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
CommentMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/CommentMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.CommentsHistory;
@Mapper
public interface CommentMapper {
public int registComment(CommentsHistory commentsHistory);
public List<CommentsHistory> getCommentList(CommentsHistory commentsHistory);
public int deleteComment(CommentsHistory commentsHistory);
public void deleteCommentByReferenceId(CommentsHistory param);
public CommentsHistory selectLastComment();
public String getContent(String comment);
public CommentsHistory getCommentInfo(String commId);
public void deleteCommentUserTemp(CommentsHistory bean);
public String getUserComment(CommentsHistory bean);
public List<CommentsHistory> getCommentListHis(CommentsHistory bean);
public int updateComment(CommentsHistory bean);
public int updateHistoryReadYn(CommentsHistory bean);
public List<CommentsHistory> getMoreCommentListHis(CommentsHistory bean);
public int getCommentListHisCnt(CommentsHistory bean);
} | 1,164 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
DashboardMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/DashboardMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.CommentsHistory;
import oss.fosslight.domain.LicenseMaster;
import oss.fosslight.domain.OssMaster;
import oss.fosslight.domain.Project;
@Mapper
public interface DashboardMapper {
List<Project> selectDashboardJobsList(Map<String, Object> param);
int selectDashboardJobsTotalCount(Map<String, Object> param);
List<CommentsHistory> selectDashboardCommentsList(Map<String, Object> param);
int selectDashboardCommentsTotalCount(Map<String, Object> param);
List<OssMaster> selectDashboardOssList(OssMaster ossMaster);
int selectDashboardOssTotalCount(OssMaster ossMaster);
List<LicenseMaster> selectDashboardLicenseList(LicenseMaster licenseMaster);
int selectDashboardLicenseTotalCount(LicenseMaster licenseMaster);
void readConfirmAll(CommentsHistory commentsHistory);
}
| 1,109 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ApiProjectMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/ApiProjectMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface ApiProjectMapper {
int selectProjectCount(Map<String, Object> paramMap);
Map<String, Object> selectVerificationCheck(@Param("prjId") String prjId);
int updatePackageFile(Map<String, Object> paramMap);
List<Map<String, Object>> selectProject(Map<String, Object> paramMap);
int selectProjectTotalCount(Map<String, Object> paramMap);
String findIdentificationMaxNvdInfo(String prjId);
List<Map<String, Object>> selectModelList(String prjId);
int getCreateProjectCnt(@Param("userId") String userId);
int checkProject(Map<String, Object> param);
int createProject(Map<String, Object> param);
int makeOssNotice(Map<String, Object> param);
List<Map<String, Object>> selectBomList(Map<String, Object> paramMap);
List<HashMap<String, Object>> selectBomLicense(@Param("componentId") String componentId);
int checkDistributionType(Map<String, Object> paramMap);
List<Map<String, Object>> selectVerifyOssList(Map<String, Object> project);
Map<String, Object> selectVerificationFile(String fileSeq);
void updatePackagingReuseMap(Map<String, Object> prjParam);
int checkPackagingFileId(@Param("prjId") String prjId, @Param("packageFileId") String packageFileId, @Param("packageFileId2") String packageFileId2, @Param("packageFileId3") String packageFileId3);
void updateVerifyFileCount(Map<String, Object> param);
void updateVerifyFilePath(Map<String, Object> param);
void updatePackageFile2(Map<String, Object> prjParam);
Map<String, Object> selectPackageFileList(@Param("prjId") String prjId);
List<String> selectComponentId(Map<String, Object> paramMap);
void deleteOssComponentsLicense(String string);
void deleteOssComponents(Map<String, Object> paramMap);
void registBomComponents(Map<String, Object> bean);
void registComponentLicense(Map<String, Object> licenseBean);
Map<String, Object> selectProjectMaster2(Map<String, Object> _tempPrjInfo);
void updateIdentifcationProgress(Map<String, Object> _tempPrjInfo);
List<HashMap<String, Object>> getLicenseInfoInit();
List<HashMap<String, Object>> getLicenseInfoInitNick();
List<HashMap<String, Object>> selectMergeBomList(Map<String, Object> paramMap);
List<HashMap<String, Object>> getRoleOutLicense();
Map<String, Object> selectProjectMaster(Map<String, Object> prjParam);
void updateReadmeContent(Map<String, Object> project);
void updateVerifyContents(Map<String, Object> project);
int existsWatcherByEmail(@Param("prjId") String prjId, @Param("email") String email);
void insertWatcher(Map<String, Object> paramMap);
void updateProjectSubStatus(Map<String, Object> param);
}
| 2,925 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
PartnerMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/PartnerMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import oss.fosslight.domain.CommentsHistory;
import oss.fosslight.domain.OssComponents;
import oss.fosslight.domain.OssComponentsLicense;
import oss.fosslight.domain.OssMaster;
import oss.fosslight.domain.PartnerMaster;
import oss.fosslight.domain.PartnerWatcher;
import oss.fosslight.domain.Project;
import oss.fosslight.domain.ProjectIdentification;
import oss.fosslight.domain.T2File;
import oss.fosslight.domain.T2Users;
@Mapper
public interface PartnerMapper {
public int selectPartnerMasterTotalCount(PartnerMaster partnerMaster);
public List<PartnerMaster> selectPartnerList(PartnerMaster partnerMaster);
public int updateReviewer(PartnerMaster vo);
public List<PartnerMaster> getPartnerNameList(PartnerMaster partnerMaster);
public void registPartnerMaster(PartnerMaster partnerMaster);
public void registPartnerWatcher(PartnerMaster partnerMaster);
public String selectpartnerLastId();
public PartnerMaster selectPartnerMaster(PartnerMaster partnerMaster);
public List<PartnerWatcher> selectPartnerWatcher(PartnerMaster partnerMaster);
public void deleteWatcher(PartnerMaster partnerMaster);
public void deleteMaster(PartnerMaster partnerMaster);
public void updateComment(CommentsHistory result);
public void deleteComment(CommentsHistory commentsHistory);
public OssComponents getOssComponents(OssComponents ossComponents);
public List<OssComponentsLicense> getOssLicense(String ossId);
public void deleteOssComponents(String partnerId);
public List<OssComponents> selectComponentId(String partnerId);
public void deleteOssComponentsLicense(OssComponents componentId);
public void insertOssComponents(OssComponents ossComponents);
public String selectLastComponentsId();
public String getLicenseId(OssComponentsLicense ossComponentsLicense);
public void insertOssComponentsLicense(OssComponentsLicense ossComponentsLicense);
public List<PartnerMaster> selectPartnerListExcel(PartnerMaster partner);
public int selectPartnerMasterTotalCountUser(PartnerMaster partnerMaster);
public List<PartnerMaster> selectPartnerListUser(PartnerMaster partnerMaster);
public int existPartnerData(PartnerMaster partnerMaster);
public List<T2Users> getUserList(T2Users t2Users);
public void changeStatus(PartnerMaster partnerMaster);
public List<PartnerMaster> getPartnerSwNmList(PartnerMaster partnerMaster);
public List<PartnerMaster> getPartnerSwVerList(PartnerMaster partnerMaster);
public List<ProjectIdentification> getPartnerOssAllList(OssComponents param);
public List<PartnerMaster> select3rdMapList(Project project);
public List<PartnerMaster> selectThirdPartyMapList(String prjId);
void updatePartnerMapList(PartnerMaster partnerMaster);
void deletePartnerMapList(PartnerMaster partnerMaster);
void insertPartnerMapList(PartnerMaster partnerMaster);
public List<PartnerMaster> selectPartnerDuplication(PartnerMaster partnerMaster);
public List<PartnerMaster> selectWatchersCheck(PartnerMaster partnerMaster);
public List<PartnerMaster> getWatcherListByEmail(String email);
public int checkWatcherAuth(PartnerMaster param);
int existsWatcherByEmail(PartnerMaster project);
void insertWatcher(PartnerMaster project);
int existsWatcherByUser(PartnerMaster project);
void removeWatcher(PartnerMaster project);
public List<String> getInvateWatcherList(String prjId);
void updatePublicYn(PartnerMaster partnerMaster);
void updateComponentsOssId(PartnerMaster partnerMaster);
List<PartnerMaster> copyWatcher(PartnerMaster project);
int existsWatcher(PartnerMaster project);
List<PartnerMaster> getProjectToAddList(OssComponents ossComponents);
List<T2File> selectDocumentsFile(String documentsFileId);
String selectDocumentsFileCnt(String documentsFileId);
public int selectPartnerStatusTotalCountUser(PartnerMaster partnerMaster);
public List<PartnerMaster> selectPartnerStatusUser(PartnerMaster partnerMaster);
List<PartnerMaster> selectOssRefPartnerList(OssMaster ossMaster);
int getOssAnalysisDataCnt(@Param("partnerId") String partnerId);
PartnerMaster getOssAnalysisData(@Param("partnerId") String partnerId);
String getReviewerEmail(@Param("partnerId") String partnerId, @Param("loginUser") String loginUser);
List<OssComponents> findBinAutoIdentificationWithBinaryText(String partnerId);
void insertBinaryOssComponents(ProjectIdentification projectIdentification);
void updateOssList(ProjectIdentification projectIdentification);
public int updateDivision(@Param("partnerId") String partnerId, @Param("division") String division);
void updateDescription(PartnerMaster partnerMaster);
public List<PartnerMaster> getPartnerIdList(PartnerMaster partnerMaster);
public List<OssComponents> selectOssComponentsSbomList(PartnerMaster partnerMaster);
public List<OssComponents> selectOssComponentsSbomListClassAppend(PartnerMaster partnerMaster);
public List<OssComponents> checkSelectDownloadFile(PartnerMaster partnerMaster);
int existsWatcherByUserDivistion(PartnerMaster project);
void updateWatcherDivision(PartnerMaster project);
} | 5,502 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
SentMailMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/SentMailMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.CoMail;
@Mapper
public interface SentMailMapper {
int selectSentMailTotalCount(CoMail vo);
List<CoMail> selectSentMailList(CoMail vo);
}
| 388 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
BinaryDataMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/BinaryDataMapper.java | package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import oss.fosslight.domain.BinaryData;
@Mapper
public interface BinaryDataMapper {
int countBinaryList(BinaryData vo);
List<BinaryData> getBinaryList(BinaryData vo);
int deleteBinaryData(String bianryDataId);
int updateBinaryData(BinaryData bean);
int insertBinaryData(BinaryData bean);
int insertBinaryDataLog(BinaryData logBean);
int countExistsBinaryName(String fileName);
List<BinaryData> getBinaryListWithNameAndChecksum(@Param("fileName")String fileName, @Param("checkSum")String checkSum);
int deleteBinaryListWithNameAndChecksum(@Param("fileName")String fileName, @Param("checkSum")String checkSum);
List<BinaryData> getBinaryTlshListWithoutChecksum(@Param("fileName")String fileName, @Param("checkSum")String checkSum);
int updateTlshCheckSumToZero(@Param("fileName")String fileName, @Param("checkSum")String checkSum, @Param("ossName")String ossName, @Param("ossVersion")String ossVersion);
List<BinaryData> selectBinaryDataListWithBinaryName(String binaryName);
} | 1,155 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
T2UserMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/T2UserMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import oss.fosslight.domain.T2Users;
@Mapper
public interface T2UserMapper {
public List<T2Users> getAllUsers(T2Users member); // ์ฌ์ฉ์ ๋ชฉ๋ก์ ๊ฐ์ ธ์ต๋๋ค.
public T2Users getUser(T2Users member); // ํน์ ์ฌ์ฉ์ ์ ๋ณด๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
public List<T2Users> getAuthorityUsers(String role); // ํน์ ๊ถํ ์ฌ์ฉ์ ๋ชฉ๋ก์ ๊ฐ์ ธ์ต๋๋ค.
public T2Users getPassword(T2Users member);
public int selectDuplicateId(String userId); // ID์ค๋ณต์ฌ๋ถ ์ฒดํฌ
public int insertUsers(T2Users member); // ์ฌ์ฉ์ ๋ฑ๋ก
public int selectUserTotalCount(T2Users member); // ๋ฆฌ์คํธ ์ด๊ฐ์
public int changeEnabled(T2Users member); // ์ฌ์ดํธ ์ฌ์ฉ์ฌ๋ถ ๋ณ๊ฒฝ
public int updateUsers(T2Users member); // ์ฌ์ฉ์ ์์
public List<T2Users> selectUserList();
public List<T2Users> selectParamUserList(T2Users t2Users);
public String selectAuthority(String userId);
public void insertAuthority(T2Users vo);
public void updateAuthorities(T2Users t2Users);
public String checkDuplicateId(T2Users vo);
public List<T2Users> selectReviwer(@Param("adminYn") String adminYn, @Param("ldapFlag") String ldapFlag);
public List<T2Users> selectAdminUser();
public List<T2Users> selectAllUsersDivision();
public List<T2Users> selectCheckEmail(String email);
public void updateProjectWatcherUserInfo(T2Users bean);
public void updateBatWatcherUserInfo(T2Users bean);
public void updatePartnerWatcherUserInfo(T2Users bean);
public List<T2Users> getUserListByName(String name);
public int procToken(T2Users bean);
public int existUserIdOrEmail(String userId);
public void updateStatisticsMostUsedInfo(T2Users t2Users);
public int updateUserNameDivision(T2Users userInfo);
} | 2,148 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
T2SecuredResourcesRoleMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/T2SecuredResourcesRoleMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.T2SecuredResourcesRole;
@Mapper
public interface T2SecuredResourcesRoleMapper {
public int insertSecuredResourcesRoleTypeList(List<T2SecuredResourcesRole> securedResourcesRoles);
public int deleteSecuredResourcesRoleByAuthority(String authority);
public int deleteSecuredResourcesRoleByResourceId(String resourceId);
} | 572 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
SearchMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/SearchMapper.java | /*
* Copyright (c) 2021 Suram Kim
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface SearchMapper {
String selectProjectSearchFilter(String userId);
String selectOssSearchFilter(String userId);
String selectLicenseSearchFilter(String userId);
String selectSearchFilter(@Param(value = "type") String type, @Param(value = "userId") String userId);
void upsertSearchFilter(@Param(value = "jsonfilter") String jsonfilter, @Param(value = "userId") String userId, @Param(value = "type") String type);
String selectPartnerSearchFilter(String userId);
String selectSelfCheckSearchFilter(String userId);
}
| 772 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ApiSelfCheckMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/ApiSelfCheckMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.Map;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface ApiSelfCheckMapper {
int createSelfCheck(Map<String, Object> param);
int getCreateProjectCnt(@Param("userId") String userId);
int selectProjectCount(Map<String, Object> paramMap);
Map<String, Object> selectProjectMaster(@Param("prjId") String prjId);
int existsWatcherByEmail(@Param("prjId") String prjId, @Param("email") String email);
void insertWatcher(Map<String, Object> paramMap);
}
| 668 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
MailManagerMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/MailManagerMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.BinaryMaster;
import oss.fosslight.domain.CoMail;
import oss.fosslight.domain.LicenseMaster;
import oss.fosslight.domain.OssMaster;
import oss.fosslight.domain.PartnerMaster;
import oss.fosslight.domain.Project;
@Mapper
public interface MailManagerMapper {
// ์ด๋ฉ์ผ ์ ์ก ์ด๋ ฅ ๋ฑ๋ก
public void insertEmailHistory(CoMail mailVo);
// ์ด๋ฉ์ผ ์ ์ก ์ํ ๋ณ๊ฒฝ
public void updateSendStatus(CoMail mailVo);
// ์ด๋ฉ์ผ ์๋ฌ ๋ฌธ๊ตฌ ์์ฑ
public void updateErrorMsg(CoMail mailVo);
// Send Mail Run Timeout
public void updateSendMailRunTimeout(CoMail mailVo);
// ์ฌ์ฉ์ ID๋ก ์ด๋ฉ์ผ ์ฃผ์ ์กฐํ
public List<String> selectMailAddrFromIds(Map<String, String[]> toIds);
public List<String> selectAdminMailAddr();
public Project getProjectInfo(String prjId);
public List<String> setProjectWatcherMailList(String prjId);
public PartnerMaster getPartnerInfo(String partnerId);
public List<String> setPartnerWatcherMailList(String partnerId);
public OssMaster getOssInfoById(String ossId);
public LicenseMaster getLicenseInfoById(String licenseId);
public Project getProjectInfoById(String prjId);
public Project getSelfCheckProjectInfoById(String prjId);
public BinaryMaster getBinaryInfo(String batId);
public String getDistributeReservedUser(String prjId);
public List<String> binaryWatcherMailList(String batId);
public List<Map<String, Object>> getTempMail();
public void deleteTempMail(String mailSeq);
public List<String> setProjectWatcherMailListNotCheckDivision(String paramPrjId);
} | 1,881 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
T2RolesMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/T2RolesMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.T2Roles;
@Mapper
public interface T2RolesMapper {
public List<T2Roles> getAllRoles();
public List<T2Roles> getAllRolesAndSecuredResourcesRole();
public T2Roles getRoles(T2Roles roles);
public T2Roles getRolesAndSecuredResourcesRole(T2Roles roles);
public int updateRoles(T2Roles roles);
public int insertRoles(T2Roles roles);
public int deleteRolesByAuthority(String authority);
} | 654 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
LicenseMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/LicenseMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import java.util.Set;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.LicenseMaster;
import oss.fosslight.domain.OssMaster;
import oss.fosslight.domain.Project;
@Mapper
public interface LicenseMapper {
int selectLicenseMasterTotalCount(LicenseMaster licenseMaster);
List<LicenseMaster> selectLicenseList(LicenseMaster licenseMaster);
LicenseMaster selectLicenseOne(LicenseMaster licenseMaster);
List<LicenseMaster> selectLicenseNicknameList(LicenseMaster licenseMaster); //๋ผ์ด์ผ์ค ๋๋ค์ ๋ชฉ๋ก
List<LicenseMaster> getLicenseInfoInit();
List<LicenseMaster> getLicenseInfoInitNick();
List<LicenseMaster> getRoleOutLicense();
List<OssMaster> checkExistsUsedOss(String licenseId);
LicenseMaster checkExistsLicense(LicenseMaster param);
int deleteLicenseMaster(LicenseMaster licenseMaster); //ํน์ ๋ผ์ด์ผ์ค ์ญ์
int deleteLicenseNickname(LicenseMaster licenseMaster); //ํน์ ๋ผ์ด์ผ์ค ๋๋ค์ ์ ์ฒด ์ญ์
String existNetworkServerLicense(String licenseId);
int insertNetworkServerLicense(String licenseId);
int deleteNetworkServerLicense(String licenseId);
List<String> getOssListWithLicenseForTypeCheck(String licenseId);
void insertLicenseMaster(LicenseMaster licenseMaster); //๋ผ์ด์ผ์ค ๋ฑ๋ก
int insertLicenseNickname(LicenseMaster licenseMaster); //๋ผ์ด์ผ์ค ๋๋ค์ ๋ฑ๋ก
int updateLicenseMaster(LicenseMaster param);
List<LicenseMaster> selectLicenseNameList(); //๋ผ์ด์ผ์ค ๋๋ค์ ๋ชฉ๋ก
List<Project> getLicenseChangeForUserList(String licenseId);
void insertLicenseWebPages(LicenseMaster licenseMaster);
int existsLicenseWebPages(LicenseMaster licenseMaster);
void deleteLicenseWebPages(LicenseMaster licenseMaster);
List<LicenseMaster> selectLicenseWebPageList(LicenseMaster licenseMaster);
// for cache query
Set<String> getLicenseNames();
Set<String> getLicenseShortNames();
Set<String> getLicenseNickNames();
LicenseMaster getLicenseInfoWithName(String licenseName);
LicenseMaster getLicenseInfoWithId(String licenseId);
void updateLicenseMasterForRestriction(LicenseMaster licenseMaster);
}
| 2,429 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ConfigurationMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/ConfigurationMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.Configuration;
@Mapper
public interface ConfigurationMapper {
void updateDefaultTab(Configuration configuration);
void updateDefaultLocale(Configuration configuration);
}
| 392 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
NoticeMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/NoticeMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.Notice;
@Mapper
public interface NoticeMapper {
public List<Notice> selectNoticeList(Notice vo) throws Exception;
public int selectNoticeTotalCount(Notice vo) throws Exception;
public void insertNotice(Notice vo) throws Exception;
public void updateNotice(Notice vo) throws Exception;
public void deleteNotice(Notice vo) throws Exception;
public int selectPublishedNoticeCount(Notice vo) throws Exception;
public List<Notice> selectPublishedNotice(Notice vo) throws Exception;
}
| 754 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
ApiFileMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/ApiFileMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface ApiFileMapper {
Map<String, Object> getFileInfo(Map<String, Object> paramT2File);
List<Map<String, Object>> selectPackagingFileInfo(String prjId);
int getPackgingReuseCnt(String rtnFileName);
int updateFileDelYnKessan(Map<String, Object> delFile);
Map<String, Object> selectFileInfo(String fileId);
List<Map<String, Object>> getReusePackagingInfo();
int updateReuseChkFileDelYnByFilePathNm(Map<String, Object> delFile);
List<Map<String, Object>> getPackgingReuseCntToList(String prjId);
int updateFileDelYnByFilePathNm(Map<String, Object> delFile);
void setReusePackagingFileHidden(@Param("refPrjId") String refPrjId, @Param("logiPath") String logiPath, @Param("getName") String logiNm);
}
| 1,001 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
HistoryMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/HistoryMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.History;
@Mapper
public interface HistoryMapper {
// ์ด๋ ฅ ๋ฐ์ดํฐ ์
๋ ฅ
public void insertHistoryData(History history);
// ์ด๋ ฅ ๋ฐ์ดํฐ ์ด ๊ฐ์ ์กฐํ
public int selectHistoryDataTotalCount(History history);
// ์ด๋ ฅ ๋ฐ์ดํฐ ์กฐํ
public List<History> selectHistoryData(History history);
// ์ด๋ ฅ ๋ฐ์ดํฐ ์กฐํ
public History selectOneHistoryData(History history);
// ์ด์ ์ด๋ ฅ ๋ฐ์ดํฐ ์กฐํ
public History selectOneHistoryBeforeData(History history);
}
| 756 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
BinaryDataHistoryMapper.java | /FileExtraction/Java_unseen/fosslight_fosslight/src/main/java/oss/fosslight/repository/BinaryDataHistoryMapper.java | /*
* Copyright (c) 2021 LG Electronics Inc.
* SPDX-License-Identifier: AGPL-3.0-only
*/
package oss.fosslight.repository;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import oss.fosslight.domain.BinaryAnalysisResult;
@Mapper
public interface BinaryDataHistoryMapper {
int selectBinaryDataHistoryTotalCount(BinaryAnalysisResult bean);
List<BinaryAnalysisResult> selectBinaryDataHistoryList(BinaryAnalysisResult bean);
}
| 475 | Java | .java | fosslight/fosslight | 172 | 114 | 89 | 2021-04-29T09:49:47Z | 2024-05-09T06:51:21Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.