|
3
|
1 package org.mpi.openmind.scripts;
|
|
|
2
|
|
|
3 import java.io.File;
|
|
|
4 import java.io.FileOutputStream;
|
|
|
5 import java.io.IOException;
|
|
|
6 import java.io.OutputStream;
|
|
|
7 import java.net.URI;
|
|
|
8 import java.net.URISyntaxException;
|
|
|
9 import java.util.ArrayList;
|
|
|
10 import java.util.HashMap;
|
|
|
11 import java.util.List;
|
|
|
12 import java.util.Map;
|
|
|
13
|
|
|
14 import org.apache.commons.lang.StringUtils;
|
|
|
15 import org.jrdf.JRDFFactory;
|
|
|
16 import org.jrdf.SortedMemoryJRDFFactory;
|
|
|
17 import org.jrdf.graph.Graph;
|
|
|
18 import org.jrdf.graph.GraphElementFactory;
|
|
|
19 import org.jrdf.graph.Resource;
|
|
|
20 import org.jrdf.writer.RdfWriter;
|
|
|
21 import org.jrdf.writer.Writer;
|
|
|
22 import org.jrdf.writer.ntriples.NTriplesWriterImpl;
|
|
|
23 import org.mpi.openmind.cache.WrapperService;
|
|
|
24 import org.mpi.openmind.repository.bo.Attribute;
|
|
|
25 import org.mpi.openmind.repository.bo.Entity;
|
|
|
26 import org.mpi.openmind.repository.bo.Relation;
|
|
|
27 import org.mpi.openmind.repository.services.ServiceRegistry;
|
|
|
28
|
|
|
29 public class RDFGenerator {
|
|
|
30
|
|
|
31 //private OntologyService os;
|
|
|
32 private WrapperService os;
|
|
|
33 private String fileName;
|
|
|
34 private JRDFFactory jrdfFactory;
|
|
|
35 private Graph graph;
|
|
|
36 private GraphElementFactory elementFactory;
|
|
|
37
|
|
|
38 public String mpiwg = "http://www.mpiwg.de/ismi/";
|
|
|
39
|
|
|
40 private Map<String, URI> attURIMap = new HashMap<String, URI>();
|
|
|
41 private Map<String, URI> relURIMap = new HashMap<String, URI>();
|
|
|
42
|
|
|
43
|
|
|
44 public RDFGenerator(WrapperService os, String fileName){
|
|
|
45 this.os = os;
|
|
|
46 this.fileName = fileName;
|
|
|
47
|
|
|
48 this.jrdfFactory = SortedMemoryJRDFFactory.getFactory();
|
|
|
49 this.graph = jrdfFactory.getGraph();
|
|
|
50 this.elementFactory = graph.getElementFactory();
|
|
|
51 }
|
|
|
52
|
|
|
53 public void execute(long ... texts) throws Exception{
|
|
|
54 List<Entity> textList = null;
|
|
|
55 if(texts.length > 0){
|
|
|
56 textList = new ArrayList<Entity>();
|
|
|
57 for(int i=0; i < texts.length; i++){
|
|
|
58 textList.add(os.getLightweightEntityById(texts[i]));
|
|
|
59 }
|
|
|
60 }else{
|
|
|
61 textList = os.getLightweightAssertions("TEXT", null, 100);
|
|
|
62 }
|
|
|
63
|
|
|
64 int count = 0;
|
|
|
65 for(Entity text : textList){
|
|
|
66 System.out.println(count + ")\t" + text.toString());
|
|
|
67
|
|
|
68 if (text.isLightweight()) {
|
|
|
69 text = os.getEntityContent(text);
|
|
|
70 }
|
|
|
71
|
|
|
72 Resource textResource = createResource(text);
|
|
|
73
|
|
|
74 for(Relation rel : text.getTargetRelations("is_exemplar_of", "WITNESS")){
|
|
|
75 createWitnessResource(
|
|
|
76 os.getEntityById(rel.getSourceId())).
|
|
|
77 addValue(getRelURI("is_exemplar_of"),
|
|
|
78 textResource
|
|
|
79 );
|
|
|
80 }
|
|
|
81 System.out.println();
|
|
|
82 count++;
|
|
|
83 }
|
|
|
84
|
|
|
85 long start = System.currentTimeMillis();
|
|
|
86
|
|
|
87 Writer.writeRdfXml(new File(fileName), graph);
|
|
|
88 //Writer.writeNTriples(new File(fileName), graph);
|
|
|
89 /*
|
|
|
90 try {
|
|
|
91 System.out.println(tryWriteNTriple(graph));
|
|
|
92 } catch (Exception e) {
|
|
|
93 // TODO Auto-generated catch block
|
|
|
94 e.printStackTrace();
|
|
|
95 }*/
|
|
|
96
|
|
|
97 System.out.println("Time writting [ms]=" + (System.currentTimeMillis() - start));
|
|
|
98 System.out.println("OK");
|
|
|
99 System.exit(0);
|
|
|
100 }
|
|
|
101
|
|
|
102 public static String tryWriteNTriple(Graph graph) throws Exception {
|
|
|
103 OutputStream output = new OutputStream()
|
|
|
104 {
|
|
|
105 private StringBuilder string = new StringBuilder();
|
|
|
106 @Override
|
|
|
107 public void write(int b) throws IOException {
|
|
|
108 this.string.append((char) b );
|
|
|
109 }
|
|
|
110
|
|
|
111 //Netbeans IDE automatically overrides this toString()
|
|
|
112 public String toString(){
|
|
|
113 return this.string.toString();
|
|
|
114 }
|
|
|
115 };
|
|
|
116 try {
|
|
|
117 final RdfWriter writer = new NTriplesWriterImpl();
|
|
|
118 try {
|
|
|
119 writer.write(graph, output);
|
|
|
120 } finally {
|
|
|
121 writer.close();
|
|
|
122 }
|
|
|
123 }finally {
|
|
|
124 output.close();
|
|
|
125 }
|
|
|
126 return output.toString();
|
|
|
127 }
|
|
|
128
|
|
|
129 private Resource createWitnessResource(Entity witness) throws Exception{
|
|
|
130 System.out.print("W");
|
|
|
131 Resource witnessResource = createResource(witness);
|
|
|
132
|
|
|
133 for(Relation rel : witness.getSourceRelations("is_part_of", "CODEX")){
|
|
|
134 witnessResource.addValue(getRelURI("is_part_of"), createCodexResource(os.getEntityById(rel.getTargetId())));
|
|
|
135 }
|
|
|
136 return witnessResource;
|
|
|
137 }
|
|
|
138
|
|
|
139 private Resource createCodexResource(Entity codex) throws Exception{
|
|
|
140 System.out.print("C");
|
|
|
141 Resource codexResource = createResource(codex);
|
|
|
142
|
|
|
143 for(Relation rel : codex.getSourceRelations("is_part_of", "COLLECTION")){
|
|
|
144 codexResource.addValue(getRelURI("is_part_of"), createCollectionResource(os.getEntityById(rel.getTargetId())));
|
|
|
145 }
|
|
|
146 return codexResource;
|
|
|
147 }
|
|
|
148
|
|
|
149 private Resource createCollectionResource(Entity collection) throws Exception{
|
|
|
150 System.out.print("L");
|
|
|
151 Resource collectionResource = createResource(collection);
|
|
|
152
|
|
|
153 for(Relation rel : collection.getSourceRelations("is_part_of", "REPOSITORY")){
|
|
|
154 collectionResource.addValue(getRelURI("is_part_of"), createRepositoryResource(os.getEntityById(rel.getTargetId())));
|
|
|
155 }
|
|
|
156 return collectionResource;
|
|
|
157 }
|
|
|
158
|
|
|
159 private Resource createRepositoryResource(Entity repository) throws Exception{
|
|
|
160 System.out.print("R");
|
|
|
161 Resource repositoryResource = createResource(repository);
|
|
|
162
|
|
|
163 for(Relation rel : repository.getSourceRelations("is_in", "PLACE")){
|
|
|
164 repositoryResource.addValue(getRelURI("is_in"), createResource(os.getEntityById(rel.getTargetId())));
|
|
|
165 System.out.print("P");
|
|
|
166 }
|
|
|
167 return repositoryResource;
|
|
|
168 }
|
|
|
169
|
|
|
170
|
|
|
171 /**
|
|
|
172 * generate the resource from an entity and for each attribute will be generated a Literal
|
|
|
173 * @param entity
|
|
|
174 * @return
|
|
|
175 */
|
|
|
176 private Resource createResource(Entity entity) throws Exception{
|
|
|
177 if (entity.isLightweight()) {
|
|
|
178 entity = os.getEntityContent(entity);
|
|
|
179 }
|
|
|
180 URI textURI = URI.create(mpiwg + entity.getObjectClass() + "/" + entity.getId());
|
|
|
181 Resource resource = elementFactory.createResource(textURI);
|
|
|
182 att2Literals(entity, resource);
|
|
|
183
|
|
|
184 //addtype
|
|
|
185 resource.addValue(getRDFType(), entity.getObjectClass());
|
|
|
186 //resource.addValue(getRDFType(), "http://www.europeana.eu/schemas/edm/ProvidedCHO");
|
|
|
187 //resource.addValue(getEDMType(), "TEXT");
|
|
|
188
|
|
|
189 return resource;
|
|
|
190 }
|
|
|
191
|
|
|
192 private URI rdfType;
|
|
|
193 private URI edmType;
|
|
|
194 private URI getRDFType(){
|
|
|
195 if(rdfType == null){
|
|
|
196 try {
|
|
|
197 rdfType = new URI("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
|
|
|
198 } catch (URISyntaxException e) {
|
|
|
199 e.printStackTrace();
|
|
|
200 }
|
|
|
201 }
|
|
|
202 return rdfType;
|
|
|
203 }
|
|
|
204
|
|
|
205 private URI getEDMType(){
|
|
|
206 if(rdfType == null){
|
|
|
207 try {
|
|
|
208 rdfType = new URI("http://www.europeana.eu/schemas/edm/type");
|
|
|
209 } catch (URISyntaxException e) {
|
|
|
210 e.printStackTrace();
|
|
|
211 }
|
|
|
212 }
|
|
|
213 return rdfType;
|
|
|
214 }
|
|
|
215
|
|
|
216
|
|
|
217
|
|
|
218
|
|
|
219 private void att2Literals(Entity entity, Resource resource){
|
|
|
220 for(Attribute att : entity.getAttributes()){
|
|
|
221 if(StringUtils.isNotEmpty(att.getValue())){
|
|
|
222 resource.addValue(getAttURI(att.getObjectClass()), att.getValue());
|
|
|
223 }
|
|
|
224 }
|
|
|
225 }
|
|
|
226
|
|
|
227
|
|
|
228 private URI getRelURI(String relName){
|
|
|
229 URI uri = relURIMap.get(relName);
|
|
|
230 if(uri == null){
|
|
|
231 String uriName = attNameToURIName(relName);
|
|
|
232 uri = URI.create(mpiwg + uriName);
|
|
|
233 relURIMap.put(relName, uri);
|
|
|
234 }
|
|
|
235 return uri;
|
|
|
236 }
|
|
|
237
|
|
|
238 private URI getAttURI(String attName){
|
|
|
239 URI uri = attURIMap.get(attName);
|
|
|
240 if(uri == null){
|
|
|
241 String uriName = attNameToURIName(attName);
|
|
|
242 uri = URI.create(mpiwg + uriName);
|
|
|
243 attURIMap.put(attName, uri);
|
|
|
244 }
|
|
|
245 return uri;
|
|
|
246 }
|
|
|
247
|
|
|
248 private static String attNameToURIName(String attName){
|
|
|
249 String[] words = attName.split("_");
|
|
|
250 if(words.length > 1){
|
|
|
251 StringBuilder sb = new StringBuilder(words[0]);
|
|
|
252 for(int i = 1; i < words.length; i++){
|
|
|
253 sb.append(Character.toUpperCase(words[i].charAt(0)));
|
|
|
254 sb.append(words[i].substring(1));
|
|
|
255 }
|
|
|
256
|
|
|
257 return sb.toString();
|
|
|
258 }else{
|
|
|
259 return attName;
|
|
|
260 }
|
|
|
261 }
|
|
|
262
|
|
|
263
|
|
|
264
|
|
|
265 public static void main(String[] args) {
|
|
|
266 //System.out.println(attNameToURIName("diagrams_and_illustrations"));
|
|
|
267 //System.out.println(attNameToURIName("hola"));
|
|
|
268 //System.out.println(attNameToURIName("diagrams_and"));
|
|
|
269
|
|
|
270 ServiceRegistry services = new ServiceRegistry();
|
|
|
271 RDFGenerator rdfGenerator =
|
|
|
272 new RDFGenerator(
|
|
|
273 services.getWrapper(),
|
|
|
274 "/Users/jurzua/Projects/DM2E/Silk/ismi/ismi_data_source.xml");
|
|
|
275 //"/Users/jurzua/Projects/workspace/EDM/ISMI/rdf/rdf_text_id_415640.xml");
|
|
|
276 //rdfGenerator.execute(415640);
|
|
|
277 try {
|
|
|
278 rdfGenerator.execute(415640, 447023, 40979, 458950, 202603);
|
|
|
279 } catch (Exception e) {
|
|
|
280 e.printStackTrace();
|
|
|
281 }
|
|
|
282 }
|
|
|
283
|
|
|
284 }
|
