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

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

Second element Address case fixed

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
6declare default element namespace 'http://ndg.nerc.ac.uk/moles';
7declare namespace xsi='http://www.w3.org/2001/XMLSchema-instance';
8declare namespace mdip='http://www.dassh.ac.uk';
9declare namespace gco='http://www.isotc211.org/2005/gco';
10declare namespace f='http://ndg.nerc.ac.uk/moles/localfunctions';
11declare variable $input_collection as xs:string {'TargetCollection'};
12
13declare variable $input_repository as xs:string {'Input_Repository_Code'};
14declare variable $input_repository_local as xs:string {'Input_Repository_LocalID'};
15declare variable $input_DatasetIdentifier as xs:string {'Input_Entry_ID'};
16declare variable $output_local_id as xs:string {'Output_LocalID'};
17
18declare variable $unknown_vocab_id as xs:string {'http://vocab.ndg.nerc.ac.uk/null'};
19
20declare variable $bodc_parameter_discovery_vocab as xs:string {'http://vocab.ndg.nerc.ac.uk/P021'};
21
22declare variable $cf_standard_names as xs:string {'http://www.cgd.ucar.edu/cms/eaton/cf-metadata/standard_name.html'};
23
24(: declare variable $gcmd_science_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/gcmd_parameters.html'}; :)
25declare variable $gcmd_science_valids as xs:string {'http://vocab.ndg.nerc.ac.uk/P041'};
26declare variable $gcmd_project_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/projects.html'};
27declare variable $gcmd_location_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/locations.html'};
28declare variable $gcmd_paleotemporal_valids as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/paleotemporal.html'};
29declare variable $gcmd_iso_topic_list as xs:string {'http://gcmd.gsfc.nasa.gov/Resources/valids/iso_topic_list.html'};
30
31declare variable $iho_s23_list as xs:string {'http://vocab.ndg.nerc.ac.uk/C161'};
32
33(: declare variable $iso_topic_list as xs:string {'http://www.isotc211.org/2005/resources/Codelist/gmxCodelists.xml#MD_TopicCategoryCode'}; :)
34declare variable $iso_topic_list as xs:string {'http://vocab.ndg.nerc.ac.uk/P051'};
35declare variable $ISO_639-2_ns as xs:string{'UKGemini_Langauge_Categories'};
36declare variable $ISO_3166_ns as xs:string{'UKGemini_Land_Area_Categories'};
37
38declare variable $ndg_data_provider_vocab as xs:string {'http://vocab.ndg.nerc.ac.uk/N010'};
39declare variable $ndg_vertical_extent_base as xs:string {'http://vocab.ndg.nerc.ac.uk/null'};
40
41declare function f:fix-coord($e as element()) as element()
42(: Parse a non-decimal co-ordinate element,  parse to see if it's possible to convert to
43    a decimal co-ordinate, and do so, else return the rubbish provided :)
44{
45if ($e castable as xs:decimal) then 
46        $e
47else
48        let $value := substring(data($e), 1, string-length($e)-1)
49        let $point := lower-case(data($e))
50        return
51        if ($value  castable as xs:decimal) then 
52                if (ends-with($point, 'n')) then
53                        element {name($e)} {$value}
54                else if (ends-with($point, 's')) then
55                        element {name($e)} {concat('-', $value)}
56                else if (ends-with($point, 'e')) then
57                        element {name($e)} {$value}
58                else if (ends-with($point, 'w')) then
59                        element {name($e)} {concat('-', $value)}
60                else $e
61        else  $e
62} ;
63
64declare function f:spot-vocab($vocab_root as xs:string, $vocab_uri as xs:string) as xs:boolean
65(: See if the vocab pointed if from the vocab pointed at by the vocab_root :)
66{
67if ($vocab_root = substring($vocab_uri, 1, string-length($vocab_root))) then 
68        true()
69else
70        false()
71} ;
72
73for $MDIP in collection($input_collection)/mdip:Metadata[mdip:DatasetIdentifier=$input_DatasetIdentifier]
74return
75element dgMetadata {
76        element dgMetadataRecord {
77                element dgMetadataID {
78                        element schemeIdentifier {'NDG-B0'},
79                        element repositoryIdentifier {$input_repository},
80                        if ($output_local_id != 'Output_LocalID') then
81                                element localIdentifier {$output_local_id}
82                        else
83                                element localIdentifier {escape-uri(data($MDIP/mdip:DatasetIdentifier), true())}
84                },
85                element dgMetadataDescription {
86                        element metadataDescriptionID {
87                                element schemeIdentifier {'NDG-B0'},
88                                element repositoryIdentifier {$input_repository},
89                                if ($output_local_id != 'Output_LocalID') then
90                                        element localIdentifier {concat('generated_desc-', $output_local_id)}
91                                else
92                                        element localIdentifier {concat('generated_desc-', escape-uri(string($MDIP/mdip:DatasetIdentifier), true()))}
93                        },
94                        element metadataDescriptionLastUpdated {current-date()}                 ,
95                        element abstract {
96                                element abstractText {string($MDIP/mdip:Abstract)}
97                        }
98                },
99                element name {string($MDIP/mdip:Title)},
100                element abbreviation {string($MDIP/mdip:Title)},
101                element dgDataEntity {
102                        element dgDataSetType {''},
103                        element dgDataSummary {
104                                for $parameter in $MDIP/mdip:Subject[SubjectVocab=$bodc_parameter_discovery_vocab]
105                                return
106                                        element dgParameterSummary {
107                                                element dgParameterValue {
108                                                        element dgValueDataParameter {
109                                                                element Value {''},
110                                                                element dgStandardUnit {
111                                                                        element dgValidTerm {'dummy'},
112                                                                        element dgValidTermID {
113                                                                                element ParentListID {$unknown_vocab_id},
114                                                                                element TermID {escape-uri('dummy unit', true())}
115                                                                        }
116                                                                }
117                                                        }
118                                                },
119                                                element dgStdParameterMeasured {
120                                                element dgValidTerm {string($parameter/mdip:SubjectName)},
121                                                                element dgValidTermID {
122                                                                        element ParentListID {string($parameter/mdip:SubjectVocab)},
123                                                                        element TermID {string($parameter/mdip:SubjectCode)}
124                                                                }
125                                                },
126                                                element ParameterName {string($parameter/mdip:SubjectName)},
127                                                element ParameterAbbreviation {string($parameter/mdip:SubjectName)}
128                                        },
129                                element dgDataCoverage {
130                                                element dgSpatialCoverage {
131                                                        element BoundingBox {
132                                                                element LimitNorth {data(f:fix-coord($MDIP/mdip:NorthCoOrdinate))},
133                                                                element LimitSouth {data(f:fix-coord($MDIP/mdip:SouthCoOrdinate))},
134                                                                element LimitWest {data(f:fix-coord($MDIP/mdip:WestCoOrdinate))},
135                                                                element LimitEast {data(f:fix-coord($MDIP/mdip:EastCoOrdinate))}
136                                                        },
137                                                        for $location in $MDIP/mdip:Extent
138                                                        return
139                                                                element dgArea {
140                                                                        element dgValidTerm {string($location/mdip:ExtentName)},
141                                                                        element dgValidTermID {
142                                                                                element ParentListID {string($location/mdip:ExtentVocab)},
143                                                                                element TermID {string($location/mdip:ExtentCode)}
144                                                                        }
145                                                                },
146                                                        for $location in $MDIP/mdip:VerticalExtent
147                                                        return
148                                                                element dgVerticalExtent {
149                                                                        element dgVerticalExtentBaseRef {
150                                                                                element dgValidTerm {if (exists($location/VerticalDatum)) then $location/VerticalDatum else 'default'},
151                                                                                element dgValidTermID {
152                                                                                        element ParentListID {'$unknown_vocab_id'},
153                                                                                        element TermID {escape-uri(string($location/mdip:VerticalDatum), true())}
154                                                                                }
155                                                                        },
156                                                                        if (exists($location/mdip:Minimum) and exists($location/mdip:Maximum)) then
157                                                                                element dgVerticalExtentRange{
158                                                                                        element dgVerticalExtentRangeMin {data($location/mdip:Minimum)},
159                                                                                        element dgVerticalExtentRangeMax {data($location/mdip:Maximum)}
160                                                                                }
161                                                                        else
162                                                                                element dgVerticalExtentLevel{
163                                                                                        if (exists($location/mdip:Minimum)) then element dgVerticalExtentLevelValue {data($location/mdip:Minimum)}
164                                                                                        else element dgVerticalExtentLevelValue {data($location/mdip:Maximum)}
165                                                                                }
166                                                                }
167                                                } (: /dgSpatialCoverage :),
168                                                element dgTemporalCoverage { (: didn't bother trying to validate the Dates as the example is naff to start with :)
169                                                        for $date in $MDIP/mdip:Date
170                                                        return
171                                                                if (exists($MDIP/mdip:Date/mdip:DatasetStartDate) and exists($MDIP/mdip:Date/mdip:DatasetEndDate) ) then
172                                                                        element DateRange {
173                                                                                element DateRangeStart {data($MDIP/mdip:Date/mdip:DatasetStartDate)},
174                                                                                element DateRangeEnd {data($MDIP/mdip:Date/mdip:DatasetEndDate)}
175                                                                        }
176                                                                else if (exists($MDIP/mdip:Date/mdip:DatasetStartDate)) then  element DataSingle {data($MDIP/mdip:Date/mdip:DatasetStartDate)}
177                                                                else element DataSingle {data($MDIP/mdip:Date/mdip:DatasetEndDate)}
178                                                }
179                                        } (: /dgDataCoverage :),
180                                        if (exists($MDIP/mdip:DatasetRefDate)) then
181                                                element dgDatasetProvenance {element dgDataPublicationDate {data($MDIP/mdip:DatasetRefDate)}}
182                                        else ()
183                        } (: /dgDataSummary :),
184                        element dgDataRoles {
185                                if (exists($MDIP/mdip:Originator)) then
186                                        element dgDataCreator {
187                                                element dgMetadataID {
188                                                        element schemeIdentifier {'NDG-B0'},
189                                                        element repositoryIdentifier {$input_repository},
190                                                        if ($output_local_id != 'Output_LocalID') then
191                                                                element localIdentifier {concat('generated_creator-', $output_local_id)}
192                                                        else
193                                                                element localIdentifier {concat('generated_creator-', escape-uri(string($MDIP/mdip:DatasetIdentifier), true()))}
194                                                },
195                                                element roleName {'Data Creator'},
196                                                element abbreviation {'Creator'},
197                                                for $creator in $MDIP/mdip:Data_Set_Citation/mdip:Dataset_Creator
198                                                return
199                                                element dgRoleHolder {
200                                                        element dgOrganisationID {
201                                                                element schemeIdentifier {'NDG-B0'},
202                                                                element repositoryIdentifier {$input_repository},
203                                                                if ($output_local_id != 'Output_LocalID') then
204                                                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id), true())}
205                                                                else
206                                                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)), true())}
207                                                        },
208                                                element startDate {current-date()}
209                                                }
210                                        }
211                                else if (exists($MDIP/mdip:Originating_Center)) then
212                                        element dgDataCreator {
213                                                element dgMetadataID {
214                                                        element schemeIdentifier {'NDG-B0'},
215                                                        element repositoryIdentifier {$input_repository},
216                                                        if ($output_local_id != 'Output_LocalID') then
217                                                                element localIdentifier {concat('generated_creator-', $output_local_id)}
218                                                        else
219                                                                element localIdentifier {concat('generated_creator-', escape-uri(string($MDIP/mdip:DatasetIdentifier), true()))}
220                                                },
221                                                element roleName {'Data Creator'},
222                                                element abbreviation {'Creator'},
223                                                for $creator in $MDIP/mdip:Originating_Center
224                                                return
225                                                element dgRoleHolder {
226                                                        element dgOrganisationID {
227                                                                element schemeIdentifier {'NDG-B0'},
228                                                                element repositoryIdentifier {$input_repository},
229                                                                if ($output_local_id != 'Output_LocalID') then
230                                                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id), true())}
231                                                                else
232                                                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)), true())}
233                                                        },
234                                                element startDate {current-date()}
235                                                }
236                                        }
237                                else (),
238                                element dgDataCurator {
239                                        element dgMetadataID {
240                                                element schemeIdentifier {'NDG-B0'},
241                                                element repositoryIdentifier {$input_repository},
242                                                if ($output_local_id != 'Output_LocalID') then
243                                                        element localIdentifier {concat('generated_curator-', $output_local_id)}
244                                                else
245                                                        element localIdentifier {concat('generated_curator-', escape-uri(string($MDIP/mdip:DatasetIdentifier), true()))}
246                                        },
247                                        element roleName {'Data Curator'},
248                                        element abbreviation {'Curator'},
249                                        element dgRoleHolder {
250                                                element dgOrganisationID {
251                                                        element schemeIdentifier {'NDG-B0'},
252                                                        element repositoryIdentifier {$input_repository},
253                                                        element localIdentifier {$input_repository_local}
254                                                },
255                                        element startDate {current-date()}
256                                        }
257                                }
258                        } (: /dgDataRoles :)
259                } (: /dgDataEntity :),
260                element dgStructuredKeyword {
261                        element dgValidTerm {'d2b converted record'},
262                        element dgValidTermID {
263                                element ParentListID {$unknown_vocab_id},
264                                element TermID {'d2b'}
265                        }
266                },
267                for $structuredKeywords in $MDIP/mdip:TopicCategory
268                return
269                        element dgStructuredKeyword {
270                                element dgValidTerm {string($structuredKeywords/mdip:TopicCategory)},
271                                element dgValidTermID {
272                                        element ParentListID {data($structuredKeywords/mdip:TopicCategoryVocab)},
273                                        element TermID {data($structuredKeywords/mdip:TopicCategoryCode)}
274                                }
275                        },
276                for $structuredKeywords in $MDIP/mdip:Subject
277                return
278                        element dgStructuredKeyword {
279                                element dgValidTerm {string($structuredKeywords/mdip:SubjectName)},
280                                element dgValidTermID {
281                                        element ParentListID {data($structuredKeywords/mdip:SubjectVocab)},
282                                        element TermID {data($structuredKeywords/mdip:SubjectCode)}
283                                }
284                        },
285                if (exists($MDIP/mdip:DIF_Creation_Date) or exists($MDIP/mdip:Last_DIF_Revision_Date)) then
286                        element dgMetadataProvenance {
287                                if (exists($MDIP/mdip:DIF_Creation_Date)) then
288                                        element RecordCreation {
289                                                element CreatedDate {
290                                                        if (string($MDIP/mdip:DIF_Creation_Date) castable as xs:date) then
291                                                                string($MDIP/mdip:DIF_Creation_Date) cast as xs:date
292                                                        else (current-date())
293                                                },
294                                        element CreatedBy {$input_repository}
295                                        }
296                                else
297                                        element RecordCreation {
298                                                element CreatedDate {current-date()},
299                                                element CreatedBy {'MOLES Import'}
300                                        },
301                                if (exists($MDIP/mdip:Last_DIF_Revision_Date)) then
302                                        element RecordUpdate {
303                                                element UpdateDate {
304                                                        if (string($MDIP/mdip:Last_DIF_Revision_Date) castable as xs:dateTime) then
305                                                                string($MDIP/mdip:Last_DIF_Revision_Date) cast as xs:dateTime
306                                                        else (current-dateTime())
307                                                },
308                                                element UpdatedBy {$input_repository}
309                                        }
310                                else ()
311                        }
312                else ()
313        } (: </dgMetadataRecord>:),
314        for $creator in $MDIP/mdip:Originator
315        return
316                element dgOrganisation { (: needs expansion... :)
317                        element dgMetadataID {
318                                element schemeIdentifier {'NDG-B0'},
319                                element repositoryIdentifier {$input_repository},
320                                if ($output_local_id != 'Output_LocalID') then
321                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', $output_local_id), true())}
322                                else
323                                        element localIdentifier {escape-uri(concat('generated_orgcit-', string($creator/mdip:OriginatorName), '-', data($MDIP/mdip:DatasetIdentifier)), true())}
324                        },
325                        element name {data($creator/mdip:OriginatorName)},
326                        element abbreviation {data($creator/mdip:OriginatorName)},
327                        element contactDetails {''}
328                }
329} (:    </dgMetadata> :)
Note: See TracBrowser for help on using the repository browser.