First Commit

.classpath

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" output="target/classes" path="src">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry exported="true" kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry exported="true" kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="target/classes"/>
+</classpath>

.project

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>officialjournal-extractor</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,12 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.source=1.8

.settings/org.eclipse.m2e.core.prefs

@@ -0,0 +1,4 @@
+activeProfiles=
+eclipse.preferences.version=1
+resolveWorkspaceProjects=true
+version=1

pom.xml

@@ -0,0 +1,43 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>corg.develop.officialjournal</groupId>
+  <artifactId>extractor</artifactId>
+  <version>1.0</version>
+  <build>
+    <sourceDirectory>src</sourceDirectory>
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.3</version>
+        <configuration>
+          <source>1.8</source>
+          <target>1.8</target>
+        </configuration>
+      </plugin>
+      
+      
+    </plugins>
+  </build>
+  <dependencies>
+  <dependency>
+  	<groupId>com.develop</groupId>
+  	<artifactId>doDatabase</artifactId>
+  	<version>0.0.1-SNAPSHOT</version>
+  </dependency>
+  <dependency>
+  	<groupId>org.graphstream</groupId>
+  	<artifactId>gs-core</artifactId>
+  	<version>1.2</version>
+  </dependency>
+  <dependency>
+  	<groupId>org.jgrapht</groupId>
+  	<artifactId>jgrapht-core</artifactId>
+  	<version>0.9.2</version>
+  </dependency>
+  <dependency>
+  	<groupId>org.jgrapht</groupId>
+  	<artifactId>jgrapht-ext</artifactId>
+  	<version>0.9.1</version>
+  </dependency>
+  </dependencies>
+</project>

src/graph/StartExtractorDO.java

@@ -0,0 +1,47 @@
+package graph;
+
+import java.util.Properties;
+
+import graph.extractor.ExtractorGraph;
+import graph.input.file.InputFolder;
+import graph.input.file.InputSTJ;
+import graph.output.database.DatabaseOutput;
+import graph.properties.ExtractorProperties;
+
+public class StartExtractorDO {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+				
+		/**Starts all properties*/
+		Properties exctractorProperites = new ExtractorProperties();
+		InputFolder folder = new InputFolder(exctractorProperites);
+		
+		/**Extractor**/
+		ExtractorGraph exctractorGraph = new ExtractorGraph();
+		
+		
+		/**Add the inputs*/
+			exctractorGraph.addInput(new InputSTJ(folder));
+		/***/
+		
+		
+			
+		/**Do the process on this part all the most CPU will be usage*/
+		exctractorGraph.process();
+		
+		/**add the Output*/
+			exctractorGraph.addOutPut(new DatabaseOutput());
+			//exctractorGraph.addOutPut(new ScreenOutput());
+		/******/
+			
+			
+			
+		/**Shows the result*/
+		exctractorGraph.outPut();
+		
+		
+		
+	}
+
+}

src/graph/extractor/ExtractorGraph.java

@@ -0,0 +1,78 @@
+package graph.extractor;
+
+
+import java.util.ArrayList;
+import java.util.List;
+
+import graph.extractor.graph.builder.BuilderFactory;
+import graph.input.file.InputFactory;
+import graph.output.OutPutFactory;
+
+public class ExtractorGraph {
+	
+	
+	List<InputFactory> inputs = new ArrayList<InputFactory>();
+//	List<DOProcess> allProcess = new ArrayList<DOProcess>();
+	List<OutPutFactory> outputs = new ArrayList<OutPutFactory>();
+	BuilderFactory builder;
+	
+	
+	
+	public void addInput(InputFactory input) {
+		// TODO Auto-generated method stub
+		this.inputs.add(input);
+		
+		
+	}
+
+	public void process() {
+		
+		
+		for(InputFactory input: this.inputs  )
+		{
+			builder= input.getBuilder();
+			builder.cacheFilesToMemory(input);
+			 
+		}
+		
+		// TODO Auto-generated method stub
+		
+	}
+
+	public void addOutPut(OutPutFactory output) {
+		
+		this.outputs.add(output);
+		
+	}
+
+	
+	public void outPut() {
+		
+		
+		for(OutPutFactory output: this.outputs)
+		{
+			builder.extractAllProcesses(output);
+			output.print();
+			
+		}
+		
+
+	}
+
+}
+//File file = new File("/home/ailton/Monografia/file.txt");
+//try{
+//
+//	
+//FileWriter fw = new FileWriter(file);
+//for( DOProcess process : this.allProcess )
+//{
+//	fw.write(process.toString());
+//}
+//}catch
+//(Exception e)
+//{
+//	e.printStackTrace();
+//}
+
+//

src/graph/extractor/graph/builder/BuilderFactory.java

@@ -0,0 +1,128 @@
+package graph.extractor.graph.builder;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import entity.DOProcess;
+import graph.input.file.InputFactory;
+import graph.output.OutPutFactory;
+
+public abstract class BuilderFactory {
+
+	protected List<DOProcess> processes;
+	protected InputFactory input;
+
+	public BuilderFactory(){
+		this.processes = new ArrayList<DOProcess>();
+
+	}
+
+	public void cacheFilesToMemory(InputFactory input){
+		this.input = input;
+	}
+
+
+	public void extractAllProcesses(OutPutFactory output){
+
+		File DoFolder = input.getDOFolder();
+		List<File> allDateFiles = new ArrayList<File>( input.getFilesFromDate(DoFolder));
+		long originalSize = allDateFiles.size();
+		
+		
+		while(allDateFiles.size() > 0)
+		{
+			try{
+				Random rand = new Random();
+				
+				int randNumber = Math.abs(rand.nextInt(allDateFiles.size()));
+				File oneDayOfDO = allDateFiles.get(randNumber);
+				
+				List<String> allProcess  = input.getAllProcess(oneDayOfDO);
+				
+				System.out.println("Processando dia "+oneDayOfDO.getName() + "---> " + allProcess.size() +" processos");
+				System.out.println("Processados " +(originalSize - allDateFiles.size())+" de " + originalSize+" diarios");
+				for(String oneProcess: allProcess)
+				{
+					DOProcess process = this.extractProcess(oneProcess);
+					if(process != null)
+					{
+						process.setProcessDate(oneDayOfDO.getName());
+						this.processes.add(process);
+					}
+				}
+				output.buildOutput(this.processes);
+				
+				this.moveDoneFiles(oneDayOfDO);
+				this.processes.clear();
+				allProcess.clear();
+				allDateFiles.remove(oneDayOfDO);
+				
+			}catch(Exception e)
+			{
+				e.printStackTrace();
+			}
+			
+			System.out.println( "Completado " +(originalSize - allDateFiles.size())+" de " + originalSize +". Faltam "+ allDateFiles.size() +" Processos");
+			System.out.println("\n\n\n\n");
+			
+
+		}
+
+	/*	for(File oneDayOfDO : allDateFiles )
+		{
+			List<String> allProcess  = input.getAllProcess(oneDayOfDO);
+
+			for(String oneProcess: allProcess)
+			{
+				DOProcess process = this.extractProcess(oneProcess);
+				if(process != null)
+				{
+					process.setProcessDate(oneDayOfDO.getName());
+					this.processes.add(process);	
+				}
+			}
+
+			output.buildOutput(this.processes);
+			this.processes.clear();
+			allProcess.clear();
+		}*/
+
+
+
+	}
+
+	private void moveDoneFiles(File oneDayOfDO) {
+		
+		try{
+			
+		
+		List<File> files = input.getFilesFromDate(oneDayOfDO);
+		
+		
+		
+		for(File file: files)
+		{
+			File doneFolder = new File("/home/ailton/Monografia/done/"+file.getName());
+			Files.move(file.toPath(), doneFolder.toPath());
+			
+		}}catch(Exception e)
+		{
+			e.printStackTrace();
+		}
+		
+		
+	}
+
+	public List<DOProcess> getAllProcess()
+	{
+		return this.processes;
+	}
+
+	protected abstract DOProcess extractProcess(String process);
+
+
+
+}

src/graph/extractor/graph/builder/STJBuilder.java

@@ -0,0 +1,229 @@
+package graph.extractor.graph.builder;
+
+import entity.DOProcess;
+import entity.Entity;
+import entity.Judge;
+import entity.Lawyer;
+import entity.ProcessTypes;
+import entity.TYPES;
+
+public class STJBuilder extends BuilderFactory{
+
+
+
+	private Entity getEntity(String canditate)
+	{
+		Entity entity = new Entity();
+
+		try{
+
+
+			if(canditate.contains(":") && !canditate.contains("Distribuição automática"))
+			{
+				String type = canditate.split(":")[0].trim();
+				entity.setType(type);
+
+
+				if(type.equals("RELATORA") || type.equals("RELATOR"))		
+				{
+					entity.setType(TYPES.JUDGE);
+				}
+				if(type.contains("ADVOGAD") )
+				{
+					entity.setType(TYPES.LAWYER);
+				}
+
+				entity.setName(canditate.split(":")[1].trim());
+
+			}
+			else
+			{
+				entity.setName(canditate);
+				entity.setType(TYPES.OTHERINFO);
+
+
+			}
+		}catch(Exception e)
+		{
+			//			System.out.println(canditate);
+		}
+
+		return entity;
+
+	}
+
+
+
+	@Override
+	protected DOProcess extractProcess(String process) {
+
+		
+		DOProcess proc = new DOProcess();
+		
+		proc.setOrign("DJ_STJ");
+		
+		String vecProcesses[] = process.split("\n");
+		int index = 0;
+		String firstLine = vecProcesses[index];
+
+		/**Extract information from the first line**/
+		try{
+			if(firstLine.equals(""))
+			{
+				index++;
+				firstLine = vecProcesses[index];
+			}
+
+			if(!firstLine.contains("class='np'"))
+			{
+				index++;
+				firstLine = firstLine +vecProcesses[index];
+				
+			}
+			
+			if(!firstLine.contains("class='np'"))
+			{
+				return null;
+				
+			}
+			
+			
+
+			String processType = firstLine.toLowerCase().split("nº")[0].toLowerCase();
+			firstLine = firstLine.substring(processType.length());
+			ProcessTypes procType = new ProcessTypes(processType);
+			proc.setProcessType(procType);
+			
+			
+			
+			String processIndex = firstLine.split("<NP1><B class='np'>")[0].trim();
+			firstLine = firstLine.split("<NP1><B class='np'>")[1].trim();
+			proc.setProcessIndex(processIndex);
+
+			String state =  firstLine.split("\\(")[0].trim();
+			firstLine = firstLine.split("\\(")[1].trim();
+			proc.setState(state);
+
+			String processNumber =  firstLine.split("\\)")[0].trim();
+			firstLine = firstLine.split("\\)")[1].trim();
+			proc.setProcessNumber(processNumber);
+
+
+			if(!firstLine.trim().equals("</B></NP1>"))
+			{
+
+				firstLine = firstLine.split("</B></NP1>")[1].trim();
+				Entity entity= this.getEntity(firstLine);
+
+				switch (entity.getType()) {
+				case TYPES.JUDGE:
+					proc.addJudge(new Judge(entity.getName()));
+					break;
+				case TYPES.OTHERINFO:
+					proc.addOtherInfo(entity.getName());
+					break;
+				case TYPES.LAWYER:
+					proc.addLawyer(new Lawyer(entity.getName()));
+					break;
+
+				default:
+					proc.addEntity(entity);
+					break;
+				}
+
+
+			}
+
+
+
+
+		}catch(Exception e)
+		{
+			System.out.println("Error on this process");
+			System.out.println(vecProcesses[0]);
+			System.out.println(proc);
+			System.out.println();
+			return null;
+		}
+
+
+		
+		/***next lines*/
+		try{
+			index++;
+			
+			String line = vecProcesses[index];
+
+			while( index < vecProcesses.length-1 && !this.isVerdict(line)  )
+			{
+
+				Entity entity= this.getEntity(line);
+				switch (entity.getType()) {
+				case TYPES.JUDGE:
+					proc.addJudge(new Judge(entity.getName()));
+					break;
+				case TYPES.OTHERINFO:
+					proc.addOtherInfo(entity.getName());
+					break;
+				case TYPES.LAWYER:
+					proc.addLawyer(new Lawyer(entity.getName()));
+					break;
+
+
+				default:
+					proc.addEntity(entity);
+					break;
+				}
+
+				index++;
+				line = vecProcesses[index];
+			}
+
+			StringBuilder sb = new StringBuilder();
+
+			for(int i=index; i< vecProcesses.length; i++ )
+			{
+				sb.append(vecProcesses[i] +"\n");
+
+			}
+
+			proc.setVerdict(sb.toString());
+
+
+
+
+		}catch(Exception e)
+		{
+
+			e.printStackTrace();
+		}
+
+		return proc;
+
+	}
+
+
+
+	private boolean isVerdict(String line) {
+		line = line.trim().toLowerCase();
+
+		if(line.equals("despacho"))
+		{
+
+			return true;
+		}
+		if(line.equals("decisão"))
+		{
+
+			return true;
+		}
+		
+		if(line.contains("A Turma, por unanimidade"))
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+}

src/graph/graph.properties

@@ -0,0 +1,4 @@
+
+
+mainFolder = /home/ailton/Monografia/data
+

src/graph/input/file/InputFactory.java

@@ -0,0 +1,53 @@
+package graph.input.file;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import graph.extractor.graph.builder.BuilderFactory;
+
+public abstract class InputFactory {
+	
+	protected InputFolder folder;
+	
+	
+	
+	public InputFactory(InputFolder folder)
+	{
+		this.folder = folder;
+		
+	}
+	
+	/**Date will be in day month year without separator*/
+	
+	public List<File> getFilesFromDate(File date)
+	{
+		List<File> DOs = new ArrayList<File>();
+		if(date.isDirectory())
+		{
+			DOs = Arrays.asList( date.listFiles());
+		}
+		return DOs;
+		
+	}
+	
+	
+	
+	public List<String> getAllProcess(File oneDayOfDO)
+	{
+		
+		List<File>  AllFilesOfthatDay = this.getFilesFromDate(oneDayOfDO);
+		List<String> allProcess  =  this.readProcess(AllFilesOfthatDay);
+		return allProcess;
+		
+	}
+	
+	
+	public abstract List<String> readProcess(List<File> filesOfProcess);
+	public abstract File getDOFolder();
+	public abstract BuilderFactory getBuilder();
+	
+	
+
+}

src/graph/input/file/InputFolder.java

@@ -0,0 +1,47 @@
+package graph.input.file;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Properties;
+
+public class InputFolder {
+	
+	private String mainFolder;
+	private List<String> typesOfDO;
+	private File folder;
+
+	public InputFolder(Properties properties){
+		
+		this.mainFolder = properties.getProperty("mainFolder");
+		
+		this.setTypesOfDO();
+	}
+	
+	public List<String> readTypesOfDO()
+	{
+		this.folder= new File(mainFolder);
+		List<String> typesOfDO = Arrays.asList(this.folder.list());
+		return typesOfDO;
+		
+	}
+
+	public void setTypesOfDO() {
+		this.typesOfDO = this.readTypesOfDO();
+	}
+	
+	public List<String> getTypesOfDO()
+	{
+		return this.typesOfDO;
+	}
+	
+	public File getFolder()
+	{
+		return this.folder;
+	}
+	
+	
+	
+	
+	
+}

src/graph/input/file/InputSTJ.java

@@ -0,0 +1,105 @@
+package graph.input.file;
+
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+
+import graph.extractor.graph.builder.BuilderFactory;
+import graph.extractor.graph.builder.STJBuilder;
+
+public class InputSTJ extends InputFactory{
+
+	public InputSTJ(InputFolder folders) {
+		super(folders);
+		// TODO Auto-generated constructor stub
+	}
+
+	@Override
+	public List<String> readProcess(List<File> filesOfProcess) {
+		// TODO Auto-generated method stub
+
+		int index = 1;
+		List <String> process = new ArrayList<String>();
+		boolean isProcess = false;
+		StringBuilder temporaryProcess = new StringBuilder();
+		filesOfProcess.sort(null);
+		for(File file: filesOfProcess )
+		{
+
+
+			try {
+				InputStreamReader stream = new InputStreamReader(new FileInputStream(file), "ISO-8859-1");
+				@SuppressWarnings("resource")
+				BufferedReader bf = new BufferedReader(stream);
+				String line= bf.readLine();
+
+				while(line != null){
+
+					if(isProcess)
+					{
+						temporaryProcess.append(line+"\n");
+
+					}
+
+					String marker = "("+index+")";
+					if( line.equals(marker))
+					{	
+						isProcess = true;
+						index++;
+						if(temporaryProcess.length() > 10)
+						{
+							temporaryProcess.setLength(temporaryProcess.length()-marker.length()-2);
+							process.add(temporaryProcess.toString());
+							temporaryProcess.setLength(0);
+
+						}
+					}
+					line = bf.readLine();
+					if(line != null && line.equals(""))
+					{
+						line = bf.readLine();
+					}
+
+
+				}
+
+
+			} catch ( IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+
+
+		}
+
+		return process;
+	}
+
+
+	@Override
+	public File getDOFolder() {
+		// TODO Auto-generated method stub
+
+		File folder = new File(this.folder.getFolder() +"/stj");
+		return folder;
+
+
+
+	}
+
+	@Override
+	public BuilderFactory getBuilder() {
+		// TODO Auto-generated method stub
+		return new STJBuilder();
+	}
+
+
+
+
+
+}

src/graph/output/OutPutFactory.java

@@ -0,0 +1,20 @@
+package graph.output;
+
+import java.util.List;
+
+import entity.DOProcess;
+
+
+public abstract class OutPutFactory {
+	
+	
+	
+	public abstract void insertToOutPut(DOProcess process );
+	
+	
+	public abstract void buildOutput(List<DOProcess> allProcess);
+	
+	public abstract void print();
+	
+
+}

src/graph/output/database/DatabaseOutput.java

@@ -0,0 +1,90 @@
+package graph.output.database;
+
+import java.util.List;
+import java.util.Random;
+
+import dao.DAOGeneralProcess;
+import entity.DOProcess;
+import graph.output.OutPutFactory;
+
+public class DatabaseOutput extends OutPutFactory {
+
+	
+	DAOGeneralProcess dao = new DAOGeneralProcess();
+	public int runned;
+	
+	public DatabaseOutput() {
+		// TODO Auto-generated constructor stub
+		
+		
+		
+	}
+	
+	
+	
+	@Override
+	public void insertToOutPut(DOProcess process) {
+		// TODO Auto-generated method stu
+		int run = dao.insertDOProcess(process);
+		runned = runned + run;
+		
+		
+	}
+
+	@Override
+	public void buildOutput(List<DOProcess> allProcess) {
+		
+		long processSize = allProcess.size();
+		
+		int counter  = 0;
+		this.runned = 0;
+		
+		
+		while(allProcess.size() > 0)
+		{
+			try{
+				Random rand = new Random();
+				int randNumber = Math.abs(rand.nextInt(allProcess.size()));
+				DOProcess process= allProcess.get(randNumber);
+				this.insertToOutPut(process);
+				counter++;
+				try{
+					if(counter% (processSize/100) ==0 || counter >= processSize -10)
+						System.out.println("Concluido "+ counter+ " de "+ processSize);
+					
+					if((runned) % (processSize/100) ==1) 
+						System.out.println("Atualizou " + runned );
+					
+				}catch(Exception e)
+				{
+					
+				}
+				
+				allProcess.remove(process);
+				
+			}catch(Exception e)
+			{
+				e.printStackTrace();
+			}
+			
+			
+			
+
+		}
+		System.out.println("Foram atualizados " +runned+". Skip: " + (processSize-runned));
+
+		System.gc();
+		
+		
+		
+	}
+
+	
+	
+	@Override
+	public void print() {
+		// TODO Auto-generated method stub
+		
+	}
+
+}

src/graph/output/graph/JGraphOutput.java

@@ -0,0 +1,117 @@
+package graph.output.graph;
+
+
+
+import java.awt.*;
+
+
+import javax.swing.*;
+
+
+import org.jgraph.JGraph;
+import org.jgrapht.*;
+import org.jgrapht.ext.*;
+
+import org.jgrapht.graph.*;
+
+import entity.DOProcess;
+import entity.Entity;
+
+/**
+ * A demo applet that shows how to use JGraph to visualize JGraphT graphs.
+ *
+ * @author Barak Naveh
+ * @since Aug 3, 2003
+ */
+public class JGraphOutput    extends JApplet
+{
+    //~ Static fields/initializers ---------------------------------------------
+
+    private static final long serialVersionUID = 3256444702936019250L;
+    private static final Color DEFAULT_BG_COLOR = Color.decode("#FAFBFF");
+    private static final Dimension DEFAULT_SIZE = new Dimension(800, 800);
+
+    //~ Instance fields --------------------------------------------------------
+
+    //
+    private JGraphModelAdapter<Entity, DOProcess> jgAdapter;
+
+    //~ Methods ----------------------------------------------------------------
+
+    /**
+     * An alternative starting point for this demo, to also allow running this
+     * applet as an application.
+     *
+     * @param args ignored.
+     */
+    public JGraphOutput(UndirectedGraph<Entity, DOProcess> graph)
+    {
+    	
+        this.init(graph);
+
+        JFrame frame = new JFrame();
+        frame.getContentPane().add(this);
+        frame.setTitle("JGraphT Adapter to JGraph Demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.pack();
+        frame.setVisible(true);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void init(UndirectedGraph<Entity, DOProcess> graph)
+    { 
+        // create a JGraphT graphq
+        ListenableGraph<Entity, DOProcess> g =new ListenableUndirectedGraph<Entity, DOProcess>(graph);
+
+        // create a visualization using JGraph, via an adapter
+        jgAdapter =  new JGraphModelAdapter<Entity,DOProcess>(g);
+        
+        JGraph jgraph = new JGraph(jgAdapter);
+
+        adjustDisplaySettings(jgraph);
+        getContentPane().add(jgraph);
+        resize(DEFAULT_SIZE);
+       
+     
+    }
+
+    private void adjustDisplaySettings(JGraph jg)
+    {
+        jg.setPreferredSize(DEFAULT_SIZE);
+
+        Color c = DEFAULT_BG_COLOR;
+        String colorStr = null;
+
+        try {
+            colorStr = getParameter("bgcolor");
+        } catch (Exception e) {
+        }
+
+        if (colorStr != null) {
+            c = Color.decode(colorStr);
+        }
+
+        jg.setBackground(c);
+    }
+
+//    @SuppressWarnings("unchecked") // FIXME hb 28-nov-05: See FIXME below
+//    private void positionVertexAt(Object vertex, int x, int y)
+//    {
+//        DefaultGraphCell cell = jgAdapter.getVertexCell(vertex);
+//        AttributeMap attr = cell.getAttributes();
+//        Rectangle2D bounds = GraphConstants.getBounds(attr);
+//
+//        Rectangle2D newBounds = new Rectangle2D.Double(x,y,bounds.getWidth(),bounds.getHeight());
+//
+//        GraphConstants.setBounds(attr, newBounds);
+//
+//        // TODO: Clean up generics once JGraph goes generic
+//        org.jgraph.graph.AttributeMap cellAttr = new AttributeMap();
+//        cellAttr.put(cell, attr);
+//        jgAdapter.edit(cellAttr, null, null, null);
+//    }
+
+
+}

src/graph/output/screen/ScreenOutput.java

@@ -0,0 +1,156 @@
+package graph.output.screen;
+
+
+import java.util.List;
+
+import org.graphstream.graph.Graph;
+import org.graphstream.graph.Node;
+import org.graphstream.graph.implementations.SingleGraph;
+
+import entity.DOProcess;
+import entity.Judge;
+import entity.Lawyer;
+import entity.TYPES;
+import graph.output.OutPutFactory;
+
+public class ScreenOutput extends OutPutFactory{
+
+
+	protected String styleSheet =
+			"node {" +
+					"	fill-color: black;" +
+					"}" +
+					"node.marked {" +
+					"	fill-color: red;" +
+					"}";
+
+	protected Graph graph;
+
+	public ScreenOutput() {
+		graph = new SingleGraph("Processos X Juizes");
+
+		graph.addAttribute("ui.stylesheet", styleSheet);
+		graph.setAutoCreate(true);
+		graph.setStrict(false);
+		graph.display();
+
+
+	}
+
+
+
+	@Override
+	public void insertToOutPut(DOProcess process) {
+
+
+		if(process.getJudges().size() > 0)
+		{
+
+			Judge judge = process.getJudge();
+			if(!judge.getName().equals(TYPES.NAMEDEFAULT))
+			{
+				Node judgeNode;
+
+				if( graph.getNode(judge.getName()) == null )
+				{
+					judgeNode = graph.addNode(judge.getName());
+					judgeNode.setAttribute("ui.class", "marked");
+					judgeNode.addAttribute("ui.label", judge.getName());
+
+				}
+				else
+				{
+					judgeNode = graph.getNode(judge.getName());
+				}
+
+				Integer ID = new Integer(0);
+				for(Lawyer laywer: process.getLawyer())
+				{
+
+
+					if(!laywer.getName().equals(TYPES.NAMEDEFAULT))
+					{
+
+						Node lawyerNode;
+						if( graph.getNode(laywer.getName()) == null )
+						{
+							lawyerNode= graph.addNode(laywer.getName());
+							lawyerNode.addAttribute("ui.label", laywer.getName());
+
+						}
+						else
+						{
+							lawyerNode= graph.getNode(laywer.getName());
+
+						}
+
+						graph.addEdge(process.getProcessNumber()+ID.toString(), judgeNode, lawyerNode);
+						ID++;
+
+					}
+
+
+
+				}
+			}
+		}
+
+
+
+
+	}
+	
+	
+	
+
+	
+	
+	
+
+
+
+
+	@Override
+	public void buildOutput(List<DOProcess> allProcess) {
+
+		for( DOProcess process : allProcess )
+		{
+			try {
+				if(process.getVerdict().length() > 100)	
+				{
+					//System.out.println(process.getVerdict());
+					this.insertToOutPut(process);
+					Thread.sleep(300);
+					System.out.println(process.getVerdict());
+				}
+				else
+				{
+					//System.out.println(process.getVerdict());
+				}
+
+			} catch (InterruptedException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+
+
+		}
+
+
+	}
+
+
+
+
+
+
+
+	@Override
+	public void print() {
+		// TODO Auto-generated method stub
+
+	}
+
+
+
+}

src/graph/properties/ExtractorProperties.java

@@ -0,0 +1,33 @@
+package graph.properties;
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Properties;
+
+public class ExtractorProperties extends Properties{
+	
+	 
+	
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1L;
+
+	public ExtractorProperties()
+	{
+		
+			FileReader propertiesFile;
+			try {
+				propertiesFile = new FileReader("graph.properties");
+				this.load(propertiesFile);
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				System.out.println("File graph.properties not found set on hardcode");
+				this.setProperty("mainFolder","/home/ailton/Monografia/data");
+				
+			}
+		
+	}
+	
+
+}