Update to index

src/graph/extractor/ExtractorGraph.java

@@ -60,19 +60,3 @@ public class ExtractorGraph {
 	}
 
 }
-//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

@@ -1,12 +1,17 @@
 package graph.extractor.graph.builder;
 
 import java.io.File;
+import java.io.IOException;
 import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
 
-import entity.DOProcess;
+import org.apache.lucene.index.IndexWriter;
+
+import dao.connection.LuceneConnector;
+import dao.entity.DOProcess;
+import dao.lucene.tables.DAOJudge;
 import graph.input.file.InputFactory;
 import graph.output.OutPutFactory;
 
@@ -52,10 +57,12 @@ public abstract class BuilderFactory {
 						process.setProcessDate(oneDayOfDO.getName());
 						this.processes.add(process);
 					}
+					
+					
 				}
 				output.buildOutput(this.processes);
 				
-				this.moveDoneFiles(oneDayOfDO);
+				//this.moveDoneFiles(oneDayOfDO);
 				this.processes.clear();
 				allProcess.clear();
 				allDateFiles.remove(oneDayOfDO);
@@ -70,26 +77,16 @@ public abstract class BuilderFactory {
 			
 
 		}
-
-	/*	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();
-		}*/
-
+		DAOJudge daoJudge = DAOJudge.getInstance();
+		daoJudge.store();
+		try {
+			LuceneConnector.getIndexDisk().commit();
+		} catch (IOException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		
+		
 
 
 	}

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

@@ -1,45 +1,213 @@
 package graph.extractor.graph.builder;
 
-import entity.DOProcess;
-import entity.Entity;
-import entity.Judge;
-import entity.Lawyer;
-import entity.ProcessTypes;
-import entity.TYPES;
+
+
+import dao.entity.DOProcess;
+import dao.entity.Entity;
+import dao.entity.Judge;
+import dao.entity.Lawyer;
+import dao.entity.ProcessTypes;
+import dao.entity.TYPES;
 
 public class STJBuilder extends BuilderFactory{
 
+	private static boolean nextLawyer =false;
+	
+	private String normalizeJudgeName(String judgeName)
+	{
+		
+		if(judgeName.contains("(") && !judgeName.startsWith("(") )
+		{
 
+			try{
 
-	private Entity getEntity(String canditate)
+				judgeName = judgeName.split("\\(")[0].trim();
+			}catch(Exception e)
+			{
+				e.printStackTrace();
+			}
+		}
+		if(judgeName.contains("PRESIDENTE DA"))
+		{
+			
+			judgeName = TYPES.NAMEDEFAULT;
+		}
+		if(judgeName.equals("PROCESSO NÃO DISTRIBUÍDO"))
+		{
+			judgeName = TYPES.NAMEDEFAULT;
+		}
+		
+		
+		return judgeName;
+	}
+	
+	
+	private String normalizeEntityName(String entityName)
 	{
-		Entity entity = new Entity();
+		String originalEntityName = entityName.trim();
+		
+		if(entityName.contains("(PRESO)"))
+		{
+			entityName = entityName.split("(PRESO)")[0].trim();
+		}
+		if(entityName.contains("E OUTRO"))
+		{
+			entityName = entityName.split("E OUTRO")[0].trim();
+		}
+		if(entityName.endsWith(" E"))
+		{
+			entityName = entityName.split(" E")[0].trim();
+		}
+		if(entityName.endsWith("\\("))
+		{
+			entityName = entityName.split("\\(")[0].trim();
+		}
+		
+		
+		if(entityName.length() > 0)
+			return entityName;
+		else
+			return TYPES.NAMEDEFAULT;
+		
+	}
+	
+	
+	private Lawyer normalizeLawyerName(Lawyer lawyer)
+	{
+		
+		//String originalEntityName = entityName.trim();
+		String nameNormalized = lawyer.getName().replaceAll("\\r|\\n", " ").trim();
+
 
 		try{
+			
+			
 
+			if(nameNormalized.contains("-"))
+			{
 
+				if(nameNormalized.charAt(nameNormalized.length()-1) != '-')
+				{
+					lawyer.setOABNumber(nameNormalized.split("-")[1].trim());
+				}
+				nameNormalized = nameNormalized.split("-")[0].trim();
+			}
+			
+			if(nameNormalized.contains("E OUTRO"))
+			{
+				nameNormalized = nameNormalized.split("E OUTRO")[0].trim();
+			}
+			
+			if(nameNormalized.contains("DEFENSORIA") ||nameNormalized.contains("PROCURADORIA"))
+			{
+				nameNormalized = TYPES.NAMEDEFAULT;
+			}
+			
+			
+		}
+		catch(Exception e)
+		{
+			
+			System.out.println("lawyer error:  " + lawyer);
+		}
+
+
+
+		
+		
+		
+		if(nameNormalized.contains("EM CAUSA")  )
+		{
+			nameNormalized = nameNormalized.split("EM CAUSA")[0].trim();
+			nameNormalized = nameNormalized.substring(0, nameNormalized.length() -1).trim();
+			
+		}
+			
+		if(nameNormalized.equals("E OUTRO(S)"))
+		{
+			nameNormalized = TYPES.NAMEDEFAULT;
+		}
+			
+		
+		if(nameNormalized.endsWith(" E"))
+		{
+			nameNormalized = nameNormalized.split(" E")[0].trim();
+		}
+		
+		if(nameNormalized.equals(""))
+		{
+			lawyer.setName(lawyer.getName());
+		}
+		else
+		{
+			lawyer.setName(nameNormalized);
+		}
+		
+		return lawyer;
+		
+		
+				
+
+		
+	}
+	
+
+	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);
+				entity.setName(this.normalizeEntityName(canditate.split(":")[1].trim()));
 
 
 				if(type.equals("RELATORA") || type.equals("RELATOR"))		
 				{
 					entity.setType(TYPES.JUDGE);
+					entity.setName(this.normalizeJudgeName(canditate.split(":")[1].trim()));
+					
+					
 				}
-				if(type.contains("ADVOGAD") )
+				if(type.contains("ADVOGAD") || type.contains("PROCURADOR") )
 				{
+				
+					
+					entity = this.normalizeLawyerName(new Lawyer(canditate.split(":")[1].trim()) );
 					entity.setType(TYPES.LAWYER);
+					if(type.contains("ADVOGADOS") )
+						nextLawyer = true;
+
 				}
 
-				entity.setName(canditate.split(":")[1].trim());
+				
 
 			}
 			else
 			{
-				entity.setName(canditate);
-				entity.setType(TYPES.OTHERINFO);
+				if(nextLawyer)
+				{
+					nextLawyer = false;
+					entity.setType(TYPES.LAWYER);
+					entity.setName(canditate);
+
+				}
+				else{
+
+
+					entity.setName(canditate);
+					entity.setType(TYPES.OTHERINFO);
+				}
+
+
+
 
 
 			}
@@ -57,11 +225,25 @@ public class STJBuilder extends BuilderFactory{
 	@Override
 	protected DOProcess extractProcess(String process) {
 
-		
+
 		DOProcess proc = new DOProcess();
-		
+
+//		try{
+//			File file = new File("/home/ailton/Monografia/log");
+//			FileWriter fileWriter = new FileWriter(file, true);
+//			PrintWriter out = new PrintWriter(fileWriter);
+//			out.println(process);
+//			out.println();
+//			out.close();
+//
+//		}catch(Exception e)
+//		{
+//			e.printStackTrace();
+//		}
+
+
 		proc.setOrign("DJ_STJ");
-		
+
 		String vecProcesses[] = process.split("\n");
 		int index = 0;
 		String firstLine = vecProcesses[index];
@@ -78,24 +260,24 @@ public class STJBuilder extends BuilderFactory{
 			{
 				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);
@@ -147,33 +329,38 @@ public class STJBuilder extends BuilderFactory{
 		}
 
 
-		
+
 		/***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.setJudge(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;
+				
+				if(entity.getName() != null)
+				{
+					switch (entity.getType()) {
+					case TYPES.JUDGE:
+						proc.setJudge(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];
@@ -204,7 +391,39 @@ public class STJBuilder extends BuilderFactory{
 
 
 
+	private double getLowerCasePCT(String line)
+	{
+		int lowerCaseLetters = 0;
+		for (int i = 0; i < line.length(); i++) 
+		{
+			char ch = line.charAt(i);
+
+			//If ch is in lowercase, then incrementing lowerCaseLetters
+
+			if(Character.isLowerCase(ch))
+			{
+
+				lowerCaseLetters++;
+			}
+		}
+		if( line.length() > 0)
+			return 100*lowerCaseLetters/line.length();
+		
+		return lowerCaseLetters;
+		
+
+	}
+
+
+
 	private boolean isVerdict(String line) {
+
+
+		//System.out.println(line + " "+ this.getLowerCasePCT(line));
+
+		if(this.getLowerCasePCT(line) > 65)
+			return true;
+		
 		line = line.trim().toLowerCase();
 
 		if(line.equals("despacho"))
@@ -217,7 +436,13 @@ public class STJBuilder extends BuilderFactory{
 
 			return true;
 		}
-		
+		if(line.equals("ementa"))
+		{
+
+			return true;
+		}
+
+
 		if(line.contains("A Turma, por unanimidade"))
 		{
 			return true;

src/graph/output/OutPutFactory.java

@@ -2,7 +2,7 @@ package graph.output;
 
 import java.util.List;
 
-import entity.DOProcess;
+import dao.entity.DOProcess;
 
 
 public abstract class OutPutFactory {

src/graph/output/database/DatabaseOutput.java

@@ -1,16 +1,21 @@
 package graph.output.database;
 
+import java.io.IOException;
 import java.util.List;
 import java.util.Random;
 
-import dao.lucene.relation.DAOGeneralProcess;
-import entity.DOProcess;
+import dao.connection.LuceneConnector;
+import dao.entity.DOProcess;
+import dao.lucene.relations.DAOGeneralProcess;
+import dao.lucene.tables.DAOEntity;
+import dao.lucene.tables.DAOJudge;
+import dao.lucene.tables.DAOLawyer;
 import graph.output.OutPutFactory;
 
 public class DatabaseOutput extends OutPutFactory {
 
 	
-	DAOGeneralProcess dao = new DAOGeneralProcess();
+	DAOGeneralProcess dao =  DAOGeneralProcess.getInstance();
 	public int runned;
 	
 	public DatabaseOutput() {
@@ -38,7 +43,9 @@ public class DatabaseOutput extends OutPutFactory {
 		
 		int counter  = 0;
 		this.runned = 0;
-		
+		DAOJudge daoJudge = DAOJudge.getInstance();
+		DAOEntity daoEntity = DAOEntity.getInstance();
+		DAOLawyer daoLawyer = DAOLawyer.getInstance();
 		
 		while(allProcess.size() > 0)
 		{
@@ -46,18 +53,26 @@ public class DatabaseOutput extends OutPutFactory {
 				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)
+					if(counter% (processSize/50) ==0 || counter >= processSize -10)
+					{
+						
 						System.out.println("Concluido "+ counter+ " de "+ processSize);
+					}
+						
+					
+//					if((runned) % (processSize/50) ==1) 
+//						System.out.println("Atualizou " + runned );
+					
+					
 					
-					if((runned) % (processSize/100) ==1) 
-						System.out.println("Atualizou " + runned );
 					
 				}catch(Exception e)
 				{
-					
+					e.printStackTrace();
 				}
 				
 				allProcess.remove(process);
@@ -71,6 +86,8 @@ public class DatabaseOutput extends OutPutFactory {
 			
 
 		}
+		
+		
 		System.out.println("Foram atualizados " +runned+". Skip: " + (processSize-runned));
 
 		System.gc();

src/graph/output/graph/JGraphOutput.java

@@ -14,8 +14,8 @@ import org.jgrapht.ext.*;
 
 import org.jgrapht.graph.*;
 
-import entity.DOProcess;
-import entity.Entity;
+import dao.entity.DOProcess;
+import dao.entity.Entity;
 
 /**
  * A demo applet that shows how to use JGraph to visualize JGraphT graphs.

src/graph/output/screen/ScreenOutput.java

@@ -7,10 +7,10 @@ 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 dao.entity.DOProcess;
+import dao.entity.Judge;
+import dao.entity.Lawyer;
+import dao.entity.TYPES;
 import graph.output.OutPutFactory;
 
 public class ScreenOutput extends OutPutFactory{