ProvidedCHO.scala 8.37 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
 * rico2edm
 * Copyright (C) 2021  UB Basel
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 */


21
package ch.memobase.rico2edm.edm.subjects
22

23
import ch.memobase.rico2edm.edm.EDMRdf4jModel
24
import ch.memobase.rico2edm.rdf.vocabularies.{EDMVocab, OreVocab}
25
26
27
import org.eclipse.rdf4j.model.Model
import org.eclipse.rdf4j.model.impl.SimpleValueFactory
import org.eclipse.rdf4j.model.util.Values.iri
28
import org.eclipse.rdf4j.model.vocabulary.{DC, DCTERMS, RDF, SKOS}
29
30
31
32
33

class ProvidedCHO (val id: String)  {

  import org.eclipse.rdf4j.model.util.Values.iri
  //import org.eclipse.rdf4j.model.util.Values.literal
34
  private val model = EDMRdf4jModel.getModelWithEDMNamespaces
35
  model.add(iri(id),RDF.TYPE, EDMVocab.ProvidedCHO)
36
37
38
39
40
41
42
43
44
45
46
47
48

  private val factory = SimpleValueFactory.getInstance()

  def addDescription(desc: Option[String]): Unit =
    desc.map(t => model.add(iri(id),DC.DESCRIPTION,factory.createLiteral(t)))

  def addTitel(title: Option[String]): Unit = {
    title.map(t => model.add(iri(id),DC.TITLE,factory.createLiteral(t)))
  }

  def addCreationDate(createDate:Option[String]): Unit =
    createDate.map(t => model.add(iri(id),DC.DATE,factory.createLiteral(t)))

49
50
  def addCreator(creator:Option[String]): Unit =
    creator.map(t => model.add(iri(id),DC.CREATOR,factory.createLiteral(t)))
51
52
53
54
55


  def addContributor(contributor:Option[String]): Unit =
    contributor.map(t => model.add(iri(id),DC.CONTRIBUTOR,factory.createLiteral(t)))

56
57
  def addIdentifier(identifier:Option[String]): Unit =
    identifier.map(t => model.add(iri(id),DC.IDENTIFIER,factory.createLiteral(t)))
58

59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
  def addLanguage(language:Option[String]): Unit =
    language.map(t => model.add(iri(id),DC.LANGUAGE,factory.createLiteral(t)))

  def addPublisher(publisher:Option[String]): Unit =
    publisher.map(t => model.add(iri(id),DC.PUBLISHER,factory.createLiteral(t)))

  def addRights(rights:Option[String]): Unit =
    rights.map(t => model.add(iri(id),DC.RIGHTS,factory.createLiteral(t)))

  def addSource(source:Option[String]): Unit =
    source.map(t => model.add(iri(id),DC.SOURCE,factory.createLiteral(t)))

  def addSubject(subject:Option[String]): Unit =
    subject.map(t => model.add(iri(id),DC.SUBJECT,factory.createLiteral(t)))

  def addGenre(genre:Option[String]): Unit =
    genre.map(t => model.add(iri(id),DC.TYPE,factory.createLiteral(t)))
76

77
78
79
  def addDcTermsCreated(dctermsCreated:Option[String]): Unit =
    dctermsCreated.map(t => model.add(iri(id),DCTERMS.CREATED,factory.createLiteral(t)))

80
81
  def addDcTermsExtent(dctermsExtent:Option[String]): Unit =
    dctermsExtent.map(t => model.add(iri(id),DCTERMS.EXTENT,factory.createLiteral(t)))
82

83
84
85
86
87
88
89
90
91
92
93
  def addDcTermsIssued(dctermsIssued:Option[String]): Unit =
    dctermsIssued.map(t => model.add(iri(id),DCTERMS.ISSUED,factory.createLiteral(t)))

  def addDcTermsMedium(medium:Option[String]): Unit =
    medium.map(t => model.add(iri(id),DCTERMS.MEDIUM,factory.createLiteral(t)))

  def addDcTermsSpatial(spatial:Option[String]): Unit =
    spatial.map(t => model.add(iri(id),DCTERMS.SPATIAL,factory.createLiteral(t)))

  def addDcTermsTemporal(temporal:Option[String]): Unit =
    temporal.map(t => model.add(iri(id),DCTERMS.TEMPORAL,factory.createLiteral(t)))
94

95
96
97
98
  def addEdmType(edmtype:Option[String]): Unit =
    edmtype.map(t => model.add(iri(id),EDMVocab.TYPE,factory.createLiteral(t)))


99
100
101
102
  def getModel: Model = model

}

103
class WebResource (private val id: String) {
104
  private val model = EDMRdf4jModel.getModelWithEDMNamespaces
105
106
107
  private val factory = SimpleValueFactory.getInstance()


108
109
110
111
112
113
114
115
116
  def addRights(edmRights:Option[String]): Unit =
    edmRights.map(t => model.add(iri(id),EDMVocab.RIGHTS,factory.createLiteral(t)))

  def addDcTermsExtent(dctermsExtent:Option[String]): Unit =
    dctermsExtent.map(t => model.add(iri(id),DCTERMS.EXTENT,factory.createLiteral(t)))

  def addDcFormat(dcFormat:Option[String]): Unit =
    dcFormat.map(t => model.add(iri(id),DC.FORMAT,factory.createLiteral(t)))

117
118
119
120
121
122
123
124

  model.add(iri(id),RDF.TYPE, EDMVocab.WebResource)

  def getModel: Model = model

}


125
126
127
128
129
130
131
132
133
object WebResource {

  def apply (shortID: String): WebResource =
    new WebResource(s"https://media.memobase.ch/memo/${shortID}/master")

}


class Aggregation(private val id: String) {
134
  private val model = EDMRdf4jModel.getModelWithEDMNamespaces
135
136
  model.add(iri(id),RDF.TYPE, OreVocab.AGGREGATION)

137
138
  private val identValue = "^https.*".r

139
140
141
142
  private val factory = SimpleValueFactory.getInstance()

  def addSkosPrefLabel(skospreflabel:Option[String]): Unit =
    skospreflabel.map(t => model.add(iri(id),SKOS.PREF_LABEL,factory.createLiteral(t)))
143

144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
  def addAggregatedCHO(edmAggregatedCHO: Option[String]): Unit = {
    edmAggregatedCHO.map(a => model.add(iri(id),EDMVocab.AGGREGATED_CHO,factory.createLiteral(a)))
  }

  def addIsShownAt(edmIsShownAt: Option[String]): Unit = {
    edmIsShownAt.map(a => {
      if (identValue.matches(edmIsShownAt.get)) {
        model.add(iri(id),EDMVocab.IS_SHOWN_AT,factory.createLiteral(a))
      } else {
        model.add(iri(id),EDMVocab.IS_SHOWN_AT,factory.createLiteral(
          s"https://memobase.ch/object/${a}"))

      }
    })
  }


Günter Hipler's avatar
Günter Hipler committed
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
  def addIsShownBy(edmIsShownBy: Option[String]): Unit = {
    edmIsShownBy.map(a => {
      if (identValue.matches(edmIsShownBy.get)) {
        model.add(iri(id),EDMVocab.IS_SHOWN_BY,factory.createLiteral(a))
      } else {
        model.add(iri(id),EDMVocab.IS_SHOWN_BY,factory.createLiteral(
          s"https://media.memobase.ch/memo/${a}/master"))
      }
    })
  }

  def addEDMObjectFoto(edmObjectFoto: Option[String]): Unit = {
    edmObjectFoto.map(a => {
      if (identValue.matches(edmObjectFoto.get)) {
        model.add(iri(id),EDMVocab.OBJECT,factory.createLiteral(a))
      } else {
        model.add(iri(id),EDMVocab.OBJECT,factory.createLiteral(
          s"https://media.memobase.ch/memo/${a}/master"))
      }
    })
  }

183
184
185
186
187
188
189
  def addProvider(edmProvider: Option[String]): Unit = {
    edmProvider.map(a =>
        model.add(iri(id),EDMVocab.PROVIDER,factory.createLiteral(a))
    )
  }


Günter Hipler's avatar
Günter Hipler committed
190
191
192
193
194
195
196
197
198
199
200
  def addEDMObjectNoFoto(edmObjectNoFoto: Option[String]): Unit = {
    edmObjectNoFoto.map(a => {
      if (identValue.matches(edmObjectNoFoto.get)) {
        model.add(iri(id),EDMVocab.OBJECT,factory.createLiteral(a))
      } else {
        model.add(iri(id),EDMVocab.OBJECT,factory.createLiteral(
          s"https://media.memobase.ch/memo/${a}-poster"))
      }
    })
  }

201
202
203
  def addRights(edmRights:Option[String]): Unit =
    edmRights.map(t => model.add(iri(id),EDMVocab.RIGHTS,factory.createLiteral(t)))

204

205
206
207
208
  def getModel: Model = model

}

209

210
211
object Aggregation {

212
  def apply (shortID: String): Aggregation = new Aggregation(s"https://memobase.ch/object/${shortID}")
213
214
215

}

216

217
class Concept(val id: String) {
218
  private val model = EDMRdf4jModel.getModelWithEDMNamespaces
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
  model.add(iri(id),RDF.TYPE, SKOS.CONCEPT)

  private val factory = SimpleValueFactory.getInstance()

  def addSkosPrefLabel(skospreflabel:Option[String]): Unit =
    skospreflabel.map(t => model.add(iri(id),SKOS.PREF_LABEL,factory.createLiteral(t)))

  def getModel: Model = model

}


class TimeSpan(val id: String) {

  //not used so far in Silvia mapping
234
  private val model = EDMRdf4jModel.getModelWithEDMNamespaces
235
236
237
238
239
240
241
242
243
244
245
246
247
  model.add(iri(id),RDF.TYPE, EDMVocab.TIMESPAN)
  private val factory = SimpleValueFactory.getInstance()

  def addSkosPrefLabel(skospreflabel:Option[String]): Unit =
    skospreflabel.map(t => model.add(iri(id),SKOS.PREF_LABEL,factory.createLiteral(t)))

  def getModel: Model = model

}

class Place(val id: String) {

  //not used so far in Silvia mapping
248
  private val model = EDMRdf4jModel.getModelWithEDMNamespaces
249
250
251
252
253
254
255
256
257
258
259
260
  model.add(iri(id),RDF.TYPE, EDMVocab.PLACE)
  private val factory = SimpleValueFactory.getInstance()

  def addSkosPrefLabel(skospreflabel:Option[String]): Unit =
    skospreflabel.map(t => model.add(iri(id),SKOS.PREF_LABEL,factory.createLiteral(t)))

  def getModel: Model = model

}