Semantic MediaWiki: SemanticMediaWiki/includes/export/SMW

00001 <?php
00014 class SMWExporter {
00015         static protected $m_exporturl = false;
00016         static protected $m_ent_wiki = false;
00017         static protected $m_ent_property = false;
00018         static protected $m_ent_wikiurl = false;
00019 
00023         static public function initBaseURIs() {
00024                 if ( self::$m_exporturl !== false ) return;
00025                 global $wgContLang, $wgServer, $wgArticlePath;
00026 
00027                 global $smwgNamespace; // complete namespace for URIs (with protocol, usually http://)
00028                 if ( '' == $smwgNamespace ) {
00029                         $resolver = SpecialPage::getTitleFor( 'URIResolver' );
00030                         $smwgNamespace = $resolver->getFullURL() . '/';
00031                 } elseif ( $smwgNamespace[0] == '.' ) {
00032                         $resolver = SpecialPage::getTitleFor( 'URIResolver' );
00033                         $smwgNamespace = "http://" . substr( $smwgNamespace, 1 ) . $resolver->getLocalURL() . '/';
00034                 }
00035 
00036                 // The article name must be the last part of wiki URLs for proper OWL/RDF export:
00037                 self::$m_ent_wikiurl  = $wgServer . str_replace( '$1', '', $wgArticlePath );
00038                 self::$m_ent_wiki     = $smwgNamespace;
00039                 self::$m_ent_property = self::$m_ent_wiki . self::encodeURI( urlencode( str_replace( ' ', '_', $wgContLang->getNsText( SMW_NS_PROPERTY ) . ':' ) ) );
00040                 $title = SpecialPage::getTitleFor( 'ExportRDF' );
00041                 self::$m_exporturl    = self::$m_ent_wikiurl . $title->getPrefixedURL();
00042         }
00043 
00050         static public function makeExportData( SMWSemanticData $semdata ) {
00051                 self::initBaseURIs();
00052                 $subject = $semdata->getSubject();
00053                 if ( $subject->getNamespace() == SMW_NS_PROPERTY ) {
00054                         $types = $semdata->getPropertyValues( new SMWDIProperty( '_TYPE' ) );
00055                 } else {
00056                         $types = array();
00057                 }
00058                 $result = self::makeExportDataForSubject( $subject, end( $types ) );
00059                 foreach ( $semdata->getProperties() as $property ) {
00060                         self::addPropertyValues( $property, $semdata->getPropertyValues( $property ), $result, $subject );
00061                 }
00062                 return $result;
00063         }
00064         
00079         static public function makeExportDataForSubject( SMWDIWikiPage $diWikiPage, $typesvalueforproperty = null, $addStubData = false ) {
00080                 global $wgContLang;
00081                 $wikiPageExpElement = self::getDataItemExpElement( $diWikiPage );
00082                 $result = new SMWExpData( $wikiPageExpElement );
00083 
00084                 if ( $diWikiPage->getSubobjectName() !== '' ) {
00085                         $result->addPropertyObjectValue( self::getSpecialNsResource( 'rdf', 'type' ), self::getSpecialNsResource( 'swivt', 'Subject' ) );
00086                         $masterPage = new SMWDIWikiPage( $diWikiPage->getDBkey(), $diWikiPage->getNamespace(), $diWikiPage->getInterwiki() );
00087                         $masterExpElement = self::getDataItemExpElement( $masterPage );
00088                         $result->addPropertyObjectValue( self::getSpecialNsResource( 'swivt', 'masterPage' ), $masterExpElement );
00089                         // Add a sortkey: subobjects do not get this during parsing (they are no pages),
00090                         // but it is needed to query for them (e.g., to get a defined order for result pages)
00091                         $subObjectLabel = $diWikiPage->getDBkey() . '#' . $diWikiPage->getSubobjectName();
00092                         $sortkey = new SMWExpLiteral( str_replace( '_', ' ', $subObjectLabel ) );
00093                         $result->addPropertyObjectValue( self::getSpecialPropertyResource( '_SKEY' ), $sortkey );
00094                 } else {
00095                         $pageTitle = str_replace( '_', ' ', $diWikiPage->getDBkey() );
00096                         if ( $diWikiPage->getNamespace() !== 0 ) {
00097                                 $prefixedSubjectTitle = $wgContLang->getNsText( $diWikiPage->getNamespace()) . ":" . $pageTitle;
00098                         } else {
00099                                 $prefixedSubjectTitle = $pageTitle;
00100                         }
00101                         $prefixedSubjectUrl = wfUrlencode( str_replace( ' ', '_', $prefixedSubjectTitle ) );
00102 
00103                         switch ( $diWikiPage->getNamespace() ) {
00104                                 case NS_CATEGORY: case SMW_NS_CONCEPT:
00105                                         $maintype_pe = self::getSpecialNsResource( 'owl', 'Class' );
00106                                         $label = $pageTitle;
00107                                 break;
00108                                 case SMW_NS_PROPERTY:
00109                                         if ( $typesvalueforproperty == null ) {
00110                                                 $types = smwfGetStore()->getPropertyValues( $diWikiPage, new SMWDIProperty( '_TYPE' ) );
00111                                                 $typesvalueforproperty = end( $types );
00112                                         }
00113                                         $maintype_pe = self::getSpecialNsResource( 'owl', self::getOWLPropertyType( $typesvalueforproperty ) );
00114                                         $label = $pageTitle;
00115                                 break;
00116                                 default:
00117                                         $label = $prefixedSubjectTitle;
00118                                         $maintype_pe = self::getSpecialNsResource( 'swivt', 'Subject' );
00119                         }
00120 
00121                         $result->addPropertyObjectValue( self::getSpecialNsResource( 'rdf', 'type' ), $maintype_pe );
00122 
00123                         if ( !$wikiPageExpElement->isBlankNode() ) {
00124                                 $ed = new SMWExpLiteral( $label );
00125                                 $result->addPropertyObjectValue( self::getSpecialNsResource( 'rdfs', 'label' ), $ed );
00126                                 $ed = new SMWExpResource( self::getNamespaceUri( 'wikiurl' ) . $prefixedSubjectUrl );
00127                                 $result->addPropertyObjectValue( self::getSpecialNsResource( 'swivt', 'page' ), $ed );
00128                                 $ed = new SMWExpResource( self::$m_exporturl . '/' . $prefixedSubjectUrl );
00129                                 $result->addPropertyObjectValue( self::getSpecialNsResource( 'rdfs', 'isDefinedBy' ), $ed );
00130                                 $ed = new SMWExpLiteral( $diWikiPage->getNamespace(), 'http://www.w3.org/2001/XMLSchema#integer' );
00131                                 $result->addPropertyObjectValue( self::getSpecialNsResource( 'swivt', 'wikiNamespace' ), $ed );
00132                                 if ( $addStubData ) {
00133                                         // Add a default sort key; for pages that exist in the wiki,
00134                                         // this is set during parsing
00135                                         $defaultSortkey = new SMWExpLiteral( str_replace( '_', ' ', $diWikiPage->getDBkey() ) );
00136                                         $result->addPropertyObjectValue( self::getSpecialPropertyResource( '_SKEY' ), $defaultSortkey );
00137                                 }
00138                         }
00139                 }
00140 
00141                 return $result;
00142         }
00143         
00153         static public function addPropertyValues( SMWDIProperty $property, array $dataItems, SMWExpData &$expData ) {
00154                 if ( $property->isUserDefined() ) {
00155                         $pe = self::getResourceElementForProperty( $property );
00156                         $peHelper = self::getResourceElementForProperty( $property, true );
00157 
00158                         foreach ( $dataItems as $dataItem ) {
00159                                 $ed = self::getDataItemExpElement( $dataItem );
00160                                 if ( !is_null( $ed ) ) {
00161                                         $expData->addPropertyObjectValue( $pe, $ed );
00162                                 }
00163 
00164                                 $edHelper = self::getDataItemHelperExpElement( $dataItem );
00165                                 if ( !is_null( $edHelper ) ) {
00166                                         $expData->addPropertyObjectValue( $peHelper, $edHelper );
00167                                 }
00168                         }
00169                 } else { // pre-defined property, only exported if known
00170                         $diSubject = $expData->getSubject()->getDataItem();
00171                         // subject wikipage required for disambiguating special properties:
00172                         if ( is_null( $diSubject ) ||
00173                              $diSubject->getDIType() != SMWDataItem::TYPE_WIKIPAGE ) {
00174                                 return;
00175                         }
00176 
00177                         $pe = self::getSpecialPropertyResource( $property->getKey(), $diSubject->getNamespace() );
00178                         if ( is_null( $pe ) ) return; // unknown special property, not exported
00179                         // have helper property ready before entering the for loop, even if not needed:
00180                         $peHelper = self::getResourceElementForProperty( $property, true );
00181 
00182                         $filterNamespace = ( $property->getKey() == '_REDI' || $property->getKey() == '_URI' );
00183 
00184                         foreach ( $dataItems as $dataItem ) {
00185                                 // Basic namespace filtering to ensure that types match for redirects etc.
00187                                 if ( $filterNamespace && !( $dataItem instanceof SMWDIUri ) &&
00188                                      ( !( $dataItem instanceof SMWDIWikiPage ) ||
00189                                         ( $dataItem->getNamespace() != $diSubject->getNamespace() ) ) ) {
00190                                         continue;
00191                                 }
00192 
00193                                 $ed = self::getDataItemExpElement( $dataItem );
00194 
00195                                 if ( !is_null( $ed ) ) {
00196                                         if ( $property->getKey() == '_CONC' &&
00197                                              $ed->getSubject()->getUri() === '' ) {
00198                                                 // equivalent to anonymous class -> simplify description
00199                                                 foreach ( $ed->getProperties() as $subp ) {
00200                                                         if ( $subp->getUri() != self::getSpecialNsResource( 'rdf', 'type' )->getUri() ) {
00201                                                                 foreach ( $ed->getValues( $subp ) as $subval ) {
00202                                                                         $expData->addPropertyObjectValue( $subp, $subval );
00203                                                                 }
00204                                                         }
00205                                                 }
00206                                         } elseif ( $property->getKey() == '_REDI' ) {
00207                                                 $expData->addPropertyObjectValue( $pe, $ed );
00208                                                 $peUri = self::getSpecialPropertyResource( '_URI' );
00209                                                 $expData->addPropertyObjectValue( $peUri, $ed );
00210                                         } else {
00211                                                 $expData->addPropertyObjectValue( $pe, $ed );
00212                                         }
00213                                 }
00214 
00215                                 $edHelper = self::getDataItemHelperExpElement( $dataItem );
00216                                 if ( !is_null( $edHelper ) ) {
00217                                         $expData->addPropertyObjectValue( $peHelper, $edHelper );
00218                                 }
00219                         }
00220                 }
00221         }
00222 
00235         static public function getResourceElementForProperty( SMWDIProperty $diProperty, $helperProperty = false ) {
00236                 $diWikiPage = $diProperty->getDiWikiPage();
00237                 if ( is_null( $diWikiPage ) ) {
00238                         throw new Exception( 'SMWExporter::getResourceElementForProperty() can only be used for non-inverse, user-defined properties.' );
00239                 } elseif ( $helperProperty ) {
00240                         return self::getResourceElementForWikiPage( $diWikiPage, 'aux' );
00241                 } else {
00242                         return self::getResourceElementForWikiPage( $diWikiPage );
00243                 }
00244         }
00245 
00259         static public function getResourceElementForWikiPage( SMWDIWikiPage $diWikiPage, $modifier = '' ) {
00260                 global $wgContLang;
00261 
00262                 if ( $diWikiPage->getNamespace() == NS_MEDIA ) { // special handling for linking media files directly (object only)
00263                         $title = Title::makeTitle( $diWikiPage->getNamespace(), $diWikiPage->getDBkey() ) ;
00264                         $file = wfFindFile( $title );
00265                         if ( $file !== false ) {
00266                                 return new SMWExpResource( $file->getFullURL() );
00267                         } // else: Medialink to non-existing file :-/ fall through
00268                 }
00269 
00270                 if ( $diWikiPage->getSubobjectName() !== '' ) {
00271                         $modifier = $diWikiPage->getSubobjectName();
00272                 }
00273 
00274                 if ( $modifier === '' ) {
00275                         $importProperty = new SMWDIProperty( '_IMPO' );
00276                         $importDis = smwfGetStore()->getPropertyValues( $diWikiPage, $importProperty );
00277                         $importURI = ( count( $importDis ) > 0 );
00278                 } else {
00279                         $importURI = false;
00280                 }
00281 
00282                 if ( $importURI ) {
00283                         $importValue = SMWDataValueFactory::newDataItemValue( current( $importDis ), $importProperty );
00284                         $namespace = $importValue->getNS();
00285                         $namespaceId = $importValue->getNSID();
00286                         $localName = $importValue->getLocalName();
00287                 } else {
00288                         $localName = '';
00289                         if ( $diWikiPage->getNamespace() == SMW_NS_PROPERTY ) {
00290                                 $namespace = self::getNamespaceUri( 'property' );
00291                                 $namespaceId = 'property';
00292                                 $localName = self::encodeURI( rawurlencode( $diWikiPage->getDBkey() ) );
00293                         }
00294                         if ( ( $localName === '' ) ||
00295                              ( in_array( $localName{0}, array( '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ) ) ) ) {
00296                                 $namespace = self::getNamespaceUri( 'wiki' );
00297                                 $namespaceId = 'wiki';
00298                                 if ( $diWikiPage->getNamespace() !== 0 ) {
00299                                         $localName = str_replace( ' ', '_', $wgContLang->getNSText( $diWikiPage->getNamespace() ) ) . ':' . $diWikiPage->getDBkey();
00300                                 } else {
00301                                         $localName = $diWikiPage->getDBkey();
00302                                 }
00303                                 $localName = self::encodeURI( wfUrlencode( $localName ) );
00304                         }
00305                         if ( $modifier !== '' ) {
00306                                 $localName .=  '-23' . $modifier;
00307                         }
00308                 }
00309 
00310                 return new SMWExpNsResource( $localName, $namespace, $namespaceId, $diWikiPage );
00311         }
00312 
00320         static public function findDataItemForExpElement( SMWExpElement $expElement ) {
00321                 global $wgContLang;
00322 
00323                 $dataItem = null;
00324                 if ( $expElement instanceof SMWExpResource ) {
00325                         $uri = $expElement->getUri();
00326                         $wikiNamespace = self::getNamespaceUri( 'wiki' );
00327                         if ( strpos( $uri, $wikiNamespace ) === 0 ) {
00328                                 $localName = substr( $uri, strlen( $wikiNamespace ) );
00329                                 $dbKey = urldecode( self::decodeURI( $localName ) );
00330 
00331                                 $parts = explode( '-23', $dbKey, 2 );
00332                                 if ( count( $parts ) == 2 ) {
00333                                         $subobjectname = $parts[1];
00334                                 } else {
00335                                         $subobjectname = '';
00336                                 }
00337 
00338                                 $parts = explode( ':', $dbKey, 2 );
00339                                 if ( count( $parts ) == 1 ) {
00340                                         $dataItem = new SMWDIWikiPage( $dbKey, NS_MAIN, '', $subobjectname );
00341                                 } else {
00342                                         // try the by far most common cases directly before using Title
00343                                         $namespaceName = str_replace( '_', ' ', $parts[0] );
00344                                         $namespaceId = -1;
00345                                         foreach ( array( SMW_NS_PROPERTY, NS_CATEGORY, NS_USER, NS_HELP ) as $nsId ) {
00346                                                 if ( $namespaceName == $wgContLang->getNsText( $nsId ) ) {
00347                                                         $namespaceId = $nsId;
00348                                                         break;
00349                                                 }
00350                                         }
00351                                         
00352                                         if ( $namespaceId != -1 ) {
00353                                                 $dataItem = new SMWDIWikiPage( $parts[1], $namespaceId, '', $subobjectname );
00354                                         } else {
00355                                                 $title = Title::newFromDBkey( $dbKey );
00356                                                 
00357                                                 if ( !is_null( $title ) ) {
00358                                                         $dataItem = new SMWDIWikiPage( $title->getDBkey(), $title->getNamespace(), $title->getInterwiki(), $subobjectname );
00359                                                 }
00360                                         }
00361                                 }
00362                         } // else: not in wiki namespace -- TODO: this could be an imported URI
00363                 } else {
00364                         // TODO (currently not needed, but will be useful for displaying external SPARQL results)
00365                 }
00366                 return $dataItem;
00367         }
00368 
00374         static public function getOWLPropertyType( $type = '' ) {
00375                 if ( $type instanceof SMWDIWikiPage ) {
00376                         $type = SMWDataValueFactory::findTypeID( str_replace( '_', ' ', $type->getDBkey() ) );
00377                 } elseif ( $type == false ) {
00378                         $type = '';
00379                 } // else keep $type
00380                 switch ( $type ) {
00381                         case '_anu': return 'AnnotationProperty';
00382                         case '': case '_wpg': case '_wpp': case '_wpc': case '_wpf':
00383                         case '_uri': case '_ema': case '_tel': case '_rec': case '__typ':
00384                         case '__red': case '__spf': case '__spu':
00385                                 return 'ObjectProperty';
00386                         default: return 'DatatypeProperty';
00387                 }
00388         }
00389 
00401         static public function getSpecialPropertyResource( $propertyKey, $forNamespace = NS_MAIN ) {
00402                 switch ( $propertyKey ) {
00403                         case '_INST': 
00404                                 return self::getSpecialNsResource( 'rdf', 'type' );
00405                         case '_SUBC':
00406                                 return self::getSpecialNsResource( 'rdfs', 'subClassOf' );
00407                         case '_CONC':
00408                                 return self::getSpecialNsResource( 'owl', 'equivalentClass' );
00409                         case '_URI':
00410                                 if ( $forNamespace == NS_CATEGORY || $forNamespace == SMW_NS_CONCEPT ) {
00411                                         return self::getSpecialNsResource( 'owl', 'equivalentClass' );
00412                                 } elseif ( $forNamespace == SMW_NS_PROPERTY ) {
00413                                         return self::getSpecialNsResource( 'owl', 'equivalentProperty' );
00414                                 } else {
00415                                         return self::getSpecialNsResource( 'owl', 'sameAs' );
00416                                 }
00417                         case '_REDI':
00418                                 return self::getSpecialNsResource( 'swivt', 'redirectsTo' );
00419                         case '_SUBP':
00420                                 if ( $forNamespace == SMW_NS_PROPERTY ) {
00421                                         return self::getSpecialNsResource( 'rdfs', 'subPropertyOf' );
00422                                 } else {
00423                                         return null;
00424                                 }
00425                         case '_MDAT':
00426                                 return self::getSpecialNsResource( 'swivt', 'wikiPageModificationDate' );
00427                         case '_CDAT':
00428                                 return self::getSpecialNsResource( 'swivt', 'wikiPageCreationDate' );
00429                         case '_LEDT':
00430                                 return self::getSpecialNsResource( 'swivt', 'wikiPageLastEditor' );
00431                         case '_NEWP':
00432                                 return self::getSpecialNsResource( 'swivt', 'wikiPageIsNew' );
00433                         case '_SKEY':
00434                                 return self::getSpecialNsResource( 'swivt', 'wikiPageSortKey' );
00435                         case '_TYPE':
00436                                 return self::getSpecialNsResource( 'swivt', 'type' );
00437                         default:
00438                                 return self::getSpecialNsResource( 'swivt', 'specialProperty' . $propertyKey );
00439                 }
00440         }
00441 
00442 
00452         static public function getSpecialNsResource( $namespaceId, $localName ) {
00453                 $namespace = self::getNamespaceUri( $namespaceId );
00454                 if ( $namespace !== '' ) {
00455                         return new SMWExpNsResource( $localName, $namespace, $namespaceId );
00456                 } else {
00457                         throw new InvalidArgumentException( "The vocabulary '$namespaceId' is not a known special vocabulary." );
00458                 }
00459         }
00460 
00465         static public function encodeURI( $uri ) {
00466                 $uri = str_replace( '-', '-2D', $uri );
00467                 // $uri = str_replace( '_', '-5F', $uri); //not necessary
00468                 $uri = str_replace( array( ':', '"', '#', '&', "'", '+', '!', '%' ),
00469                                     array( '-3A', '-22', '-23', '-26', '-27', '-2B', '-21', '-' ),
00470                                     $uri );
00471                 return $uri;
00472         }
00473 
00478         static public function decodeURI( $uri ) {
00479                 $uri = str_replace( array( '-3A', '-22', '-23', '-26', '-27', '-2B', '-21', '-' ),
00480                                     array( ':', '"', '#', '&', "'", '+', '!', '%' ),
00481                                    $uri );
00482                 $uri = str_replace( '%2D', '-', $uri );
00483                 return $uri;
00484         }
00485 
00497         static public function expandURI( $uri ) {
00498                 self::initBaseURIs();
00499                 $uri = str_replace( array( '&wiki;', '&wikiurl;', '&property;', '&owl;', '&rdf;', '&rdfs;', '&swivt;', '&export;' ),
00500                                     array( self::$m_ent_wiki, self::$m_ent_wikiurl, self::$m_ent_property, 'http://www.w3.org/2002/07/owl#', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#', 'http://www.w3.org/2000/01/rdf-schema#', 'http://semantic-mediawiki.org/swivt/1.0#',
00501                                     self::$m_exporturl ),
00502                                     $uri );
00503                 return $uri;
00504         }
00505 
00513         static public function getNamespaceUri( $shortName ) {
00514                 self::initBaseURIs();
00515                 switch ( $shortName ) {
00516                         case 'wiki':     return self::$m_ent_wiki;
00517                         case 'wikiurl':  return self::$m_ent_wikiurl;
00518                         case 'property': return self::$m_ent_property;
00519                         case 'export':   return self::$m_exporturl;
00520                         case 'owl':      return 'http://www.w3.org/2002/07/owl#';
00521                         case 'rdf':      return 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
00522                         case 'rdfs':     return 'http://www.w3.org/2000/01/rdf-schema#';
00523                         case 'swivt':    return 'http://semantic-mediawiki.org/swivt/1.0#';
00524                         case 'xsd':      return 'http://www.w3.org/2001/XMLSchema#';
00525                         default: return '';
00526                 }
00527         }
00528 
00536         static public function getOntologyExpData( $ontologyuri ) {
00537                 $data = new SMWExpData( new SMWExpResource( $ontologyuri ) );
00538                 $ed = self::getSpecialNsResource( 'owl', 'Ontology' );
00539                 $data->addPropertyObjectValue( self::getSpecialNsResource( 'rdf', 'type' ), $ed );
00540                 $ed = new SMWExpLiteral( date( DATE_W3C ), 'http://www.w3.org/2001/XMLSchema#dateTime' );
00541                 $data->addPropertyObjectValue( self::getSpecialNsResource( 'swivt', 'creationDate' ), $ed );
00542                 $ed = new SMWExpResource( 'http://semantic-mediawiki.org/swivt/1.0' );
00543                 $data->addPropertyObjectValue( self::getSpecialNsResource( 'owl', 'imports' ), $ed );
00544                 return $data;
00545         }
00546 
00557         static public function getDataItemExpElement( SMWDataItem $dataItem ) {
00558                 switch ( $dataItem->getDIType() ) {
00559                         case SMWDataItem::TYPE_NUMBER:
00560                                 $lit = new SMWExpLiteral( $dataItem->getNumber(), 'http://www.w3.org/2001/XMLSchema#double', $dataItem );
00561                                 return $lit;
00562                         case SMWDataItem::TYPE_STRING: case SMWDataItem::TYPE_BLOB:
00563                                 $lit = new SMWExpLiteral( smwfHTMLtoUTF8( $dataItem->getString() ), 'http://www.w3.org/2001/XMLSchema#string', $dataItem );
00564                                 return $lit;
00565                         case SMWDataItem::TYPE_BOOLEAN:
00566                                 $xsdvalue =  $dataItem->getBoolean() ? 'true' : 'false';
00567                                 $lit = new SMWExpLiteral( $xsdvalue, 'http://www.w3.org/2001/XMLSchema#boolean', $dataItem );
00568                                 return $lit;
00569                         case SMWDataItem::TYPE_URI:
00570                                 $res = new SMWExpResource( $dataItem->getURI(), $dataItem );
00571                                 return $res;
00572                         case SMWDataItem::TYPE_TIME:
00573                                 $gregorianTime = $dataItem->getForCalendarModel( SMWDITime::CM_GREGORIAN );
00574                                 if ( $gregorianTime->getYear() > 0 ) {
00575                                         $xsdvalue = str_pad( $gregorianTime->getYear(), 4, "0", STR_PAD_LEFT );
00576                                 } else {
00577                                         $xsdvalue = '-' . str_pad( 1 - $gregorianTime->getYear(), 4, "0", STR_PAD_LEFT );
00578                                 }
00579                                 $xsdtype = 'http://www.w3.org/2001/XMLSchema#gYear';
00580                                 if ( $gregorianTime->getPrecision() >= SMWDITime::PREC_YM ) {
00581                                         $xsdtype = 'http://www.w3.org/2001/XMLSchema#gYearMonth';
00582                                         $xsdvalue .= '-' . str_pad( $gregorianTime->getMonth(), 2, "0", STR_PAD_LEFT );
00583                                         if ( $gregorianTime->getPrecision() >= SMWDITime::PREC_YMD ) {
00584                                                 $xsdtype = 'http://www.w3.org/2001/XMLSchema#date';
00585                                                 $xsdvalue .= '-' . str_pad( $gregorianTime->getDay(), 2, "0", STR_PAD_LEFT );
00586                                                 if ( $gregorianTime->getPrecision() == SMWDITime::PREC_YMDT ) {
00587                                                         $xsdtype = 'http://www.w3.org/2001/XMLSchema#dateTime';
00588                                                         $xsdvalue .= 'T' .
00589                                                              sprintf( "%02d", $gregorianTime->getHour() ) . ':' .
00590                                                              sprintf( "%02d", $gregorianTime->getMinute()) . ':' .
00591                                                              sprintf( "%02d", $gregorianTime->getSecond() );
00592                                                 }
00593                                         }
00594                                 }
00595                                 $xsdvalue .= 'Z';
00596                                 $lit = new SMWExpLiteral( $xsdvalue, $xsdtype, $gregorianTime );
00597                                 return $lit;
00598                         case SMWDataItem::TYPE_GEO:
00600                                 return null;
00601                         case SMWDataItem::TYPE_CONTAINER:
00602                                 return self::makeExportData( $dataItem->getSemanticData() );
00603                         case SMWDataItem::TYPE_WIKIPAGE:
00604                                 return self::getResourceElementForWikiPage( $dataItem );
00605                         case SMWDataItem::TYPE_CONCEPT:
00607                                 return null;
00608                         case SMWDataItem::TYPE_PROPERTY:
00609                                 return self::getResourceElementForProperty( $dataItem );
00610                 }
00611         }
00612 
00640         static public function getDataItemHelperExpElement( SMWDataItem $dataItem ) {
00641                 if ( $dataItem->getDIType() == SMWDataItem::TYPE_TIME ) {
00642                         $lit = new SMWExpLiteral( $dataItem->getSortKey(), 'http://www.w3.org/2001/XMLSchema#double', $dataItem );
00643                         return $lit;
00644                 } else {
00645                         return null;
00646                 }
00647         }
00648 
00656         static public function hasHelperExpElement( $dataItemType ) {
00657                 return ( $dataItemType == SMWDataItem::TYPE_TIME );
00658         }
00659 
00660 }
SemanticMediaWiki/includes/export/SMW_Exporter.php
