source: exist/trunk/xquery/mdip2moles.xq @ 4653

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/exist/trunk/xquery/mdip2moles.xq@4653
Revision 4653, 12.4 KB checked in by sdonegan, 12 years ago (diff)

Updated for consistency with other xquery transforms and adjusted so can provide decent MOLES which can then be turned into decent DIFs (previous mdip2moles couldnt!).

Line 
1(: Version for one MDIP per dgMetadata instance :)
2(: Note algoritm for creating non-pre-existing organisations :)
3(: dgPersons are not created as one can't tell automatically which are people and which are orgs, and orgs are simpler :) 
4(: Not producing valid MOLES as still got to work out parameter vocabulary namespaces in the subject field :) 
5
6import module namespace voclib='http://ndg.nerc.ac.uk/xquery/lib/vocab' at 'vocab_xquery_lib.xquery';
7import module namespace inputParse='http://ndg.nerc.ac.uk/xquery/lib/inputParse' at 'inputParse_xquery_lib.xquery';
8
9declare default element namespace 'http://ndg.nerc.ac.uk/moles';
10declare namespace xsi='http://www.w3.org/2001/XMLSchema-instance';
11declare namespace mdip='http://www.oceannet.org/mdip/xml';
12declare namespace gco='http://www.isotc211.org/2005/gco';
13
14declare variable collection($targetCollection) as xs:string := 'TargetCollection';
15declare variable $input_repository as xs:string := 'RepositoryID';
16declare variable $input_repository_local as xs:string := 'repository_localid';
17declare variable $input_DatasetIdentifier as xs:string := 'Input_Entry_ID';
18(:declare variable $input_DatasetIdentifier as xs:string := 'MRMLN00400000061';:)
19declare variable $output_local_id as xs:string := 'LocalID';
20
21(:declare variable collection($targetCollection) := doc("AMRMLN00400000061.xml");:)
22
23for $MDIP in collection($targetCollection)/mdip:Metadata[mdip:DatasetIdentifier=$input_DatasetIdentifier]
24return
25element dgMetadata {
26        element dgMetadataRecord {
27                element dgMetadataID {
28                        element schemeIdentifier {'NDG-B0'},
29                        element repositoryIdentifier {$input_repository},
30                        if ($output_local_id != 'Output_LocalID') then
31                                element localIdentifier {$output_local_id}
32                        else
33                                element localIdentifier {encode-for-uri(data($MDIP/mdip:DatasetIdentifier))}
34                },
35                element dgMetadataDescription {
36                        element metadataDescriptionID {
37                                element schemeIdentifier {'NDG-B0'},
38                                element repositoryIdentifier {$input_repository},
39                                if ($output_local_id != 'Output_LocalID') then
40                                        element localIdentifier {concat('generated_desc-', $output_local_id)}
41                                else
42                                        element localIdentifier {concat('generated_desc-', encode-for-uri(string($MDIP/mdip:DatasetIdentifier)))}
43                        },
44                        element metadataDescriptionLastUpdated {current-date()}                 ,
45                        element abstract {
46                                element abstractText {string($MDIP/mdip:Abstract)}
47                        }
48                },
49                element name {string($MDIP/mdip:Title)},
50                element abbreviation {string($MDIP/mdip:Title)},
51                element dgDataEntity {
52                        element dgDataSetType {''},
53                        element dgDataSummary {
54                                for $parameter in $MDIP/mdip:Subject[SubjectVocab=$voclib:bodc_parameter_discovery_vocab]
55                                return
56                                        element dgParameterSummary {
57                                                element dgParameterValue {
58                                                        element dgValueDataParameter {
59                                                                element Value {''},
60                                                                element dgStandardUnit {
61                                                                        element dgValidTerm {'dummy'},
62                                                                        element dgValidTermID {
63                                                                                element ParentListID {$voclib:unknown_vocab_id},
64                                                                                element TermID {encode-for-uri('dummy unit')}
65                                                                        }
66                                                                }
67                                                        }
68                                                },
69                                                element dgStdParameterMeasured {
70                                                element dgValidTerm {string($parameter/mdip:SubjectName)},
71                                                                element dgValidTermID {
72                                                                        element ParentListID {string($parameter/mdip:SubjectVocab)},
73                                                                        element TermID {string($parameter/mdip:SubjectCode)}
74                                                                }
75                                                },
76                                                element ParameterName {string($parameter/mdip:SubjectName)},
77                                                element ParameterAbbreviation {string($parameter/mdip:SubjectName)}
78                                        },
79                                element dgDataCoverage {
80                                                element dgSpatialCoverage {
81                                                        element BoundingBox {
82                                                        element LimitNorth {data(inputParse:fix-coord($MDIP/mdip:NorthCoOrdinate))},
83                                                        element LimitSouth {data(inputParse:fix-coord($MDIP/mdip:SouthCoOrdinate))},
84                                                        element LimitWest {data(inputParse:fix-coord($MDIP/mdip:WestCoOrdinate))},
85                                                        element LimitEast {data(inputParse:fix-coord($MDIP/mdip:EastCoOrdinate))}
86                                                        },
87                                                        for $location in $MDIP/mdip:Extent
88                                                        return
89                                                                element dgArea {
90                                                                        element dgValidTerm {string($location/mdip:ExtentName)},
91                                                                        element dgValidTermID {
92                                                                                element ParentListID {string($location/mdip:ExtentVocab)},
93                                                                                element TermID {string($location/mdip:ExtentCode)}
94                                                                        }
95                                                                },
96                                                        for $location in $MDIP/mdip:VerticalExtent
97                                                        return
98                                                                element dgVerticalExtent {
99                                                                        element dgVerticalExtentBaseRef {
100                                                                                element dgValidTerm {if (exists($location/VerticalDatum)) then $location/VerticalDatum else 'default'},
101                                                                                element dgValidTermID {
102                                                                                        element ParentListID {'$voclib:unknown_vocab_id'},
103                                                                                        element TermID {encode-for-uri(string($location/mdip:VerticalDatum))}
104                                                                                }
105                                                                        },
106                                                                        if (exists($location/mdip:Minimum) and exists($location/mdip:Maximum)) then
107                                                                                element dgVerticalExtentRange{
108                                                                                        element dgVerticalExtentRangeMin {data($location/mdip:Minimum)},
109                                                                                        element dgVerticalExtentRangeMax {data($location/mdip:Maximum)}
110                                                                                }
111                                                                        else
112                                                                                element dgVerticalExtentLevel{
113                                                                                        if (exists($location/mdip:Minimum)) then element dgVerticalExtentLevelValue {data($location/mdip:Minimum)}
114                                                                                        else element dgVerticalExtentLevelValue {data($location/mdip:Maximum)}
115                                                                                }
116                                                                }
117                                                } (: /dgSpatialCoverage :),
118                                                element dgTemporalCoverage {
119                                                (: didn't bother trying to validate the Dates as the example is naff to start with :)
120                                                        for $date in $MDIP/mdip:Date
121                                                        return
122                                                                if (exists($MDIP/mdip:Date/mdip:DatasetStartDate) and exists($MDIP/mdip:Date/mdip:DatasetEndDate) ) then
123                                                                        element DateRange {
124                                                                                element DateRangeStart {data($MDIP/mdip:Date/mdip:DatasetStartDate)},
125                                                                                element DateRangeEnd {data($MDIP/mdip:Date/mdip:DatasetEndDate)}
126                                                                        }
127                                                                else if (exists($MDIP/mdip:Date/mdip:DatasetStartDate)) then  element DateSingle {data($MDIP/mdip:Date/mdip:DatasetStartDate)}
128                                                                else element DateSingle {data($MDIP/mdip:Date/mdip:DatasetEndDate)}
129                                                                } (: /dgTemporalCoverage :)
130                                                        } (: /dgDataCoverage :),
131                                        if (exists($MDIP/mdip:DatasetRefDate)) then
132                                                element dgDatasetProvenance {element dgDataPublicationDate {data($MDIP/mdip:DatasetRefDate)}}
133                                        else ()
134                        } (: /dgDataSummary :),
135                        element dgDataRoles {
136                                if (exists($MDIP/mdip:Originator)) then
137                                        element dgDataCreator {
138                                                element dgMetadataID {
139                                                        element schemeIdentifier {'NDG-B0'},
140                                                        element repositoryIdentifier {$input_repository},
141                                                        if ($output_local_id != 'Output_LocalID') then
142                                                                element localIdentifier {concat('generated_creator-', $output_local_id)}
143                                                        else
144                                                                element localIdentifier {concat('generated_creator-', encode-for-uri(string($MDIP/mdip:DatasetIdentifier)))}
145                                                },
146                                                element roleName {'Data Creator'},
147                                                element abbreviation {'Creator'},
148                                                for $creator in $MDIP/mdip:Originator
149                                                return
150                                                element dgRoleHolder {
151                                                        element dgOrganisationID {
152                                                                element schemeIdentifier {'NDG-B0'},
153                                                                element repositoryIdentifier {$input_repository},
154                                                                if ($output_local_id != 'Output_LocalID') then
155                                                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id))}
156                                                                else
157                                                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)))}
158                                                        },
159                                                element startDate {current-date()}
160                                                }
161                                        }
162                                else if (exists($MDIP/mdip:Originating_Center)) then
163                                        element dgDataCreator {
164                                                element dgMetadataID {
165                                                        element schemeIdentifier {'NDG-B0'},
166                                                        element repositoryIdentifier {$input_repository},
167                                                        if ($output_local_id != 'Output_LocalID') then
168                                                                element localIdentifier {concat('generated_creator-', $output_local_id)}
169                                                        else
170                                                                element localIdentifier {concat('generated_creator-', encode-for-uri(string($MDIP/mdip:DatasetIdentifier)))}
171                                                },
172                                                element roleName {'Data Creator'},
173                                                element abbreviation {'Creator'},
174                                                for $creator in $MDIP/mdip:Originating_Center
175                                                return
176                                                element dgRoleHolder {
177                                                        element dgOrganisationID {
178                                                                element schemeIdentifier {'NDG-B0'},
179                                                                element repositoryIdentifier {$input_repository},
180                                                                if ($output_local_id != 'Output_LocalID') then
181                                                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id))}
182                                                                else
183                                                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)))}
184                                                        },
185                                                element startDate {current-date()}
186                                                }
187                                        }
188                                else (),
189                                element dgDataCurator {
190                                        element dgMetadataID {
191                                                element schemeIdentifier {'NDG-B0'},
192                                                element repositoryIdentifier {$input_repository},
193                                                if ($output_local_id != 'Output_LocalID') then
194                                                        element localIdentifier {concat('generated_curator-', $output_local_id)}
195                                                else
196                                                        element localIdentifier {concat('generated_curator-', encode-for-uri(string($MDIP/mdip:DatasetIdentifier)))}
197                                        },
198                                        element roleName {'Data Curator'},
199                                        element abbreviation {'Curator'},
200                                        element dgRoleHolder {
201                                                element dgOrganisationID {
202                                                        element schemeIdentifier {'NDG-B0'},
203                                                        element repositoryIdentifier {$input_repository},
204                                                        element localIdentifier {$input_repository_local}
205                                                },
206                                        element startDate {current-date()}
207                                        }
208                                }
209                        } (: /dgDataRoles :)
210                } (: /dgDataEntity :),
211                element dgStructuredKeyword {
212                        element dgValidTerm {'d2b converted record'},
213                        element dgValidTermID {
214                                element ParentListID {$voclib:unknown_vocab_id},
215                                element TermID {'d2b'}
216                        }
217                },
218                for $structuredKeywords in $MDIP/mdip:TopicCategory
219                return
220                        element dgStructuredKeyword {
221                                element dgValidTerm {string($structuredKeywords/mdip:TopicCategory)},
222                                element dgValidTermID {
223                                        element ParentListID {data($structuredKeywords/mdip:TopicCategoryVocab)},
224                                        element TermID {data($structuredKeywords/mdip:TopicCategoryCode)}
225                                }
226                        },
227                for $structuredKeywords in $MDIP/mdip:Subject
228                return
229                        element dgStructuredKeyword {
230                                element dgValidTerm {string($structuredKeywords/mdip:SubjectName)},
231                                element dgValidTermID {
232                                        element ParentListID {data($structuredKeywords/mdip:SubjectVocab)},
233                                        element TermID {data($structuredKeywords/mdip:SubjectCode)}
234                                }
235                        },
236                for $structuredKeywords in $MDIP/mdip:Target
237                return
238                        element dgStructuredKeyword {
239                        element dgValidTerm {string($structuredKeywords/mdip:TargetName)},
240                        element dgValidTermID {
241                        element ParentListID {data($structuredKeywords/mdip:TargetVocab)},
242                        element TermID {data($structuredKeywords/mdip:TargetCode)}
243                        }
244                        },
245                        if (exists($MDIP/mdip:DateOfUpdateOfMetadata)) then
246                        element dgMetadataProvenance {
247                                if (exists($MDIP/mdip:DateOfUpdateOfMetadata)) then
248                                        element RecordCreation {
249                                                element CreatedDate {
250                                                        if (string($MDIP/mdip:DateOfUpdateOfMetadata) castable as xs:date) then
251                                                                string($MDIP/mdip:DateOfUpdateOfMetadata) cast as xs:date
252                                                        else (current-date())
253                                                },
254                                        element CreatedBy {$input_repository}
255                                        }
256                                else
257                                        element RecordCreation {
258                                                element CreatedDate {current-date()},
259                                                element CreatedBy {'MOLES Import'}
260                                        }
261                        } (: dgMetadataProvenance :)
262                else ()
263        } (: </dgMetadataRecord>:),
264        for $creator in $MDIP/mdip:Distributor
265        return
266                element dgOrganisation {
267                (: needs expansion... :)
268                        element dgMetadataID {
269                                element schemeIdentifier {'NDG-B0'},
270                                element repositoryIdentifier {$input_repository},
271                                if ($output_local_id != 'Output_LocalID') then
272                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id))}
273                                else
274                                        element localIdentifier {encode-for-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)))}
275                        },
276                        element name {data($creator/mdip:DistributorName/mdip:DistributorNameName)},
277                        element abbreviation {data($creator/mdip:DistributorName/mdip:DistributorNameCode)},
278                        element contactDetails {
279                            element eMail {data($creator/mdip:Email)},
280                            element URI {data($creator/../mdip:OnlineResource)}                 
281                        }
282                }
283}
284(:    </dgMetadata> :)
Note: See TracBrowser for help on using the repository browser.