source: TI07-MOLES/trunk/MDIP/XQueries/MDIP2MOLES.xquery @ 2367

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI07-MOLES/trunk/MDIP/XQueries/MDIP2MOLES.xquery
Revision 2367, 12.6 KB checked in by ko23, 12 years ago (diff)

Fix of #679

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