Exemple #1
0
function ClearFeatureSource($featureService, $dataSourceId, $featureName)
{
    $deleteCmd = new MgDeleteFeatures($featureName, "KEY > 0");
    $commands = new MgFeatureCommandCollection();
    $commands->Add($deleteCmd);
    $featureService->UpdateFeatures($dataSourceId, $commands, false);
}
Exemple #2
0
 function ShowSpatialFilter()
 {
     $result = true;
     $sdfResId = new MgResourceIdentifier('Session:' . $this->args['SESSION'] . '//Filter.FeatureSource');
     $resourceService = $this->site->CreateService(MgServiceType::ResourceService);
     $featureService = $this->site->CreateService(MgServiceType::FeatureService);
     $updateCommands = new MgFeatureCommandCollection();
     $map = new MgMap();
     $map->Open($resourceService, $this->args['MAPNAME']);
     $layer = null;
     $layers = $map->GetLayers();
     if ($layers->Contains('_QuerySpatialFilter')) {
         $layer = $layers->GetItem('_QuerySpatialFilter');
         $updateCommands->Add(new MgDeleteFeatures('Filter', "ID like '%'"));
     } else {
         // Create the Feature Source (SDF)
         $sdfSchema = $this->CreateFilterSchema();
         $sdfParams = new MgCreateSdfParams('MAPCS', $map->GetMapSRS(), $sdfSchema);
         $featureService->CreateFeatureSource($sdfResId, $sdfParams);
         // Create the Layer
         $layerResId = new MgResourceIdentifier('Session:' . $this->args['SESSION'] . '//Filter.LayerDefinition');
         $layerDefinition = file_get_contents("templates/filterlayerdefinition.xml");
         $layerDefinition = sprintf($layerDefinition, $sdfResId->ToString());
         $byteSource = new MgByteSource($layerDefinition, strlen($layerDefinition));
         $resourceService->SetResource($layerResId, $byteSource->GetReader(), null);
         $layer = new MgLayer($layerResId, $resourceService);
         $layer->SetName('_QuerySpatialFilter');
         $layer->SetLegendLabel('_QuerySpatialFilter');
         $layer->SetDisplayInLegend(false);
         $layer->SetSelectable(false);
         $layers->Insert(0, $layer);
     }
     // Make the layer visible
     $layer->SetVisible(true);
     $map->Save($resourceService);
     // Add the geometry to the filter feature source
     $polygon = $this->CreatePolygonFromGeomText($this->args['GEOMTEXT']);
     $agfWriter = new MgAgfReaderWriter();
     $byteReader = $agfWriter->Write($polygon);
     $propertyValues = new MgPropertyCollection();
     $propertyValues->Add(new MgGeometryProperty('Geometry', $byteReader));
     $updateCommands->Add(new MgInsertFeatures('Filter', $propertyValues));
     $featureService->UpdateFeatures($sdfResId, $updateCommands, false);
     return $result;
 }
 public function DeleteFeatures($resId, $schemaName, $className, $format)
 {
     //Check for unsupported representations
     $fmt = $this->ValidateRepresentation($format, array("xml", "json"));
     $mimeType = $this->GetMimeTypeForFormat($fmt);
     $trans = null;
     try {
         $sessionId = "";
         if ($resId->GetRepositoryType() == MgRepositoryType::Session) {
             $sessionId = $resId->GetRepositoryName();
         }
         $this->EnsureAuthenticationForSite($sessionId, false, $mimeType);
         $siteConn = new MgSiteConnection();
         $siteConn->Open($this->userInfo);
         $site = $siteConn->GetSite();
         $this->VerifyWhitelist($resId->ToString(), $mimeType, "DELETEFEATURES", $fmt, $site, $this->userName);
         $resSvc = $siteConn->CreateService(MgServiceType::ResourceService);
         $perms = self::CheckPermissions($resSvc, $resId);
         //Not a session-based resource, must check for appropriate flag in header before we continue
         if ($sessionId === "") {
             if ($perms->AllowDelete === false) {
                 $e = new Exception();
                 $this->OutputException("Forbidden", $this->app->localizer->getText("E_OPERATION_NOT_ALLOWED"), $this->app->localizer->getText("E_FEATURE_SOURCE_NOT_CONFIGURED_TO_ALLOW_UPDATES", $resId->ToString()), $e->getTraceAsString(), 403, $mimeType);
             }
         }
         $featSvc = $siteConn->CreateService(MgServiceType::FeatureService);
         $classDef = $featSvc->GetClassDefinition($resId, $schemaName, $className);
         $commands = new MgFeatureCommandCollection();
         $filter = $this->app->request->params("filter");
         if ($filter == null) {
             $filter = "";
         }
         $deleteCmd = new MgDeleteFeatures("{$schemaName}:{$className}", $filter);
         $commands->Add($deleteCmd);
         if ($perms->UseTransaction === true) {
             $trans = $featSvc->BeginTransaction($resId);
         }
         //HACK: Due to #2252, we can't call UpdateFeatures() with NULL MgTransaction, so to workaround
         //that we call the original UpdateFeatures() overload with useTransaction = false if we find a
         //NULL MgTransaction
         if ($trans == null) {
             $result = $featSvc->UpdateFeatures($resId, $commands, false);
         } else {
             $result = $featSvc->UpdateFeatures($resId, $commands, $trans);
         }
         if ($trans != null) {
             $trans->Commit();
         }
         $this->OutputUpdateFeaturesResult($commands, $result, $classDef, $fmt == "json");
     } catch (MgException $ex) {
         if ($trans != null) {
             $trans->Rollback();
         }
         $this->OnException($ex, $mimeType);
     }
 }
Exemple #4
0
     $featureSchema = new MgFeatureSchema("SHP_Schema", "Line schema");
     // Add the feature schema to the class definition
     $featureSchema->GetClasses()->Add($classDefinition);
     // Create the feature source
     $wkt = $map->GetMapSRS();
     $sdfParams = new MgCreateSdfParams("spatial context", $wkt, $featureSchema);
     $featureService->CreateFeatureSource($resourceIdentifier, $sdfParams);
 }
 // Add the line to the feature source
 $batchPropertyCollection = new MgBatchPropertyCollection();
 $propertyCollection = MakeLine("Line A", $x0, $y0, $x1, $y1);
 $batchPropertyCollection->Add($propertyCollection);
 // Add the batch property collection to the feature source
 $cmd = new MgInsertFeatures($layerName, $batchPropertyCollection);
 $featureCommandCollection = new MgFeatureCommandCollection();
 $featureCommandCollection->Add($cmd);
 // Execute the "add" commands
 $featureService->UpdateFeatures($resourceIdentifier, $featureCommandCollection, false);
 //---------------------------------------------------//
 $layerExists = DoesLayerExist($layerName, $map);
 if (!$layerExists) {
     // Create a new layer which uses that feature source
     // Create a line rule to stylize the lines
     $ruleLegendLabel = 'Lines Rule';
     $filter = '';
     $color = 'FF0000FF';
     $factory = new LayerDefinitionFactory();
     $lineRule = $factory->CreateLineRule($ruleLegendLabel, $filter, $color);
     // Create a line type style
     $lineTypeStyle = $factory->CreateLineTypeStyle($lineRule);
     // Create a scale range
Exemple #5
0
    $bufferProps->Add($nameProp);
    $x = 120 + $i / $count;
    $y = 100 + $i / $count;
    //$wktText = "POLYGON ((20 20, 20 100, {$x} {$y}, 140 20, 20 20))";
    //$geom = $wkt->Read($wktText);
    $coord = $fact->CreateCoordinateXY($x, $y);
    $geom = $fact->CreatePoint($coord);
    $geomReader = $agf->Write($geom);
    $geomProp = new MgGeometryProperty("GEOM", $geomReader);
    $bufferProps->Add($geomProp);
    $batchProp->Add($bufferProps);
}
echo "Created geometries via wkt\n";
$cmd = new MgInsertFeatures("Buffer", $batchProp);
$cmdColl = new MgFeatureCommandCollection();
$cmdColl->Add($cmd);
try {
    $svc->CreateFeatureSource($id, $params);
    $startTime = microtime(true);
    $props = $svc->UpdateFeatures($id, $cmdColl, false);
    $endTime = microtime(true);
    $diffTime = $endTime - $startTime;
    $reader = $props->GetItem(0)->GetValue();
    while ($reader->ReadNext() == true) {
        $key = $reader->GetInt32("KEY");
    }
    $reader->Close();
    // Now select a few of the feature and make sure we get everything back correctly.
    $query = new MgFeatureQueryOptions();
    $query->AddFeatureProperty("NAME");
    $query->AddFeatureProperty("KEY");
Exemple #6
0
 function UpdateMarkup()
 {
     $featureService = $this->site->CreateService(MgServiceType::FeatureService);
     $featureSourceId = $this->GetFeatureSource();
     //HACK: Another leaky abstraction. SHP will always choose FeatId, so once again
     //use the class definition to determine the identity property name
     $clsDef = $this->GetClassDefinition();
     $idProps = $clsDef->GetIdentityProperties();
     $keyProp = $idProps->GetItem(0);
     $idName = $keyProp->GetName();
     $propertyValues = new MgPropertyCollection();
     $propertyValues->Add(new MgStringProperty('Text', trim($this->args['UPDATETEXT'])));
     $commands = new MgFeatureCommandCollection();
     $commands->Add(new MgUpdateFeatures('Markup', $propertyValues, $this->BuildFeatureFilter($idName)));
     $result = $featureService->UpdateFeatures($featureSourceId, $commands, false);
     MarkupEditor::CleanupReaders($result);
 }
Exemple #7
0
 function UploadMarkup()
 {
     $locale = "en";
     if (array_key_exists("LOCALE", $this->args)) {
         $locale = $this->args["LOCALE"];
     }
     $uploadFileParts = pathinfo($_FILES["UPLOADFILE"]["name"]);
     $fdoProvider = $this->GetProviderFromExtension($uploadFileParts["extension"]);
     if ($fdoProvider == null) {
         throw new Exception(GetLocalizedString("REDLINEUPLOADUNKNOWNPROVIDER", $locale));
     }
     $resourceService = $this->site->CreateService(MgServiceType::ResourceService);
     $featureService = $this->site->CreateService(MgServiceType::FeatureService);
     $bs = new MgByteSource($_FILES["UPLOADFILE"]["tmp_name"]);
     $br = $bs->GetReader();
     //Use file name to drive all parameters
     $baseName = $uploadFileParts["filename"];
     $this->UniqueMarkupName($baseName);
     //Guard against potential duplicates
     $ext = $uploadFileParts["extension"];
     $markupLayerResId = new MgResourceIdentifier($this->GetResourceIdPrefix() . $baseName . ".LayerDefinition");
     $markupFsId = new MgResourceIdentifier($this->GetResourceIdPrefix() . $baseName . '.FeatureSource');
     //Set up feature source document
     $dataName = $baseName . "." . $ext;
     $fileParam = "File";
     $shpFileParts = array();
     if (strcmp($fdoProvider, "OSGeo.SHP") == 0) {
         $dataName = null;
         $fileParam = "DefaultFileLocation";
         $zip = new ZipArchive();
         if ($zip->open($_FILES["UPLOADFILE"]["tmp_name"]) === TRUE) {
             for ($i = 0; $i < $zip->numFiles; $i++) {
                 $stat = $zip->statIndex($i);
                 $filePath = tempnam(sys_get_temp_dir(), "upload");
                 //Dump to temp file
                 file_put_contents($filePath, $zip->getFromIndex($i));
                 //Stash for later upload and cleanup
                 $entry = $stat["name"];
                 $shpFileParts[$entry] = $filePath;
                 if (substr($entry, strlen($entry) - strlen(".shp")) == ".shp") {
                     $dataName = $entry;
                 }
             }
             //Abort if we can't find a .shp file. This is not a valid zip file
             if ($dataName == null) {
                 throw new Exception(GetLocalizedString("REDLINEUPLOADSHPZIPERROR", $locale));
             }
         } else {
             throw new Exception(GetLocalizedString("REDLINEUPLOADSHPZIPERROR", $locale));
         }
     }
     $extraXml = "";
     if (strcmp($fdoProvider, "OSGeo.SDF") == 0) {
         //Need to set ReadOnly = false for SDF
         $extraXml = "<Parameter><Name>ReadOnly</Name><Value>FALSE</Value></Parameter>";
     }
     $fsXml = sprintf(file_get_contents("templates/markupfeaturesource.xml"), $fdoProvider, $fileParam, $dataName, $extraXml);
     $bs2 = new MgByteSource($fsXml, strlen($fsXml));
     $resourceService->SetResource($markupFsId, $bs2->GetReader(), null);
     if (count($shpFileParts) > 0) {
         foreach ($shpFileParts as $name => $path) {
             $bs3 = new MgByteSource($path);
             $resourceService->SetResourceData($markupFsId, $name, "File", $bs3->GetReader());
             //Cleanup
             unlink($path);
         }
     } else {
         //Not a SHP file
         $resourceService->SetResourceData($markupFsId, $dataName, "File", $bs->GetReader());
     }
     //Query the geometry types
     $schemas = $featureService->DescribeSchema($markupFsId, "", null);
     $schema = $schemas->GetItem(0);
     $classes = $schema->GetClasses();
     $klass = $classes->GetItem(0);
     $geomProp = $klass->GetDefaultGeometryPropertyName();
     $clsProps = $klass->GetProperties();
     $className = $schema->GetName() . ":" . $klass->GetName();
     $geomTypes = -1;
     if ($clsProps->IndexOf($geomProp) >= 0) {
         $geom = $clsProps->GetItem($geomProp);
         $geomTypes = $geom->GetGeometryTypes();
         //Since we're here. Validate the schema requirements. If this was created by this widget previously
         //it will be valid
         $idProps = $klass->GetIdentityProperties();
         if ($idProps->GetCount() != 1) {
             throw new Exception(GetLocalizedString("REDLINEUPLOADINVALIDSCHEMA", $locale));
         } else {
             //Must be auto-generated (implying numerical as well)
             $keyProp = $idProps->GetItem(0);
             if (!$keyProp->IsAutoGenerated()) {
                 throw new Exception(GetLocalizedString("REDLINEUPLOADINVALIDSCHEMA", $locale));
             }
         }
         if ($clsProps->IndexOf("Text") < 0) {
             throw new Exception(GetLocalizedString("REDLINEUPLOADINVALIDSCHEMA", $locale));
         }
     } else {
         throw new Exception(GetLocalizedString("REDLINEUPLOADINVALIDSCHEMA", $locale));
     }
     //Set up default style args
     $this->args["MARKUPNAME"] = $baseName;
     $this->args["MARKERCOLOR"] = DefaultStyle::MARKER_COLOR;
     $this->args["MARKERTYPE"] = DefaultStyle::MARKER_TYPE;
     $this->args["MARKERSIZEUNITS"] = DefaultStyle::MARKER_SIZE_UNITS;
     $this->args["MARKERSIZE"] = DefaultStyle::MARKER_SIZE;
     $this->args["LINECOLOR"] = DefaultStyle::LINE_COLOR;
     $this->args["LINEPATTERN"] = DefaultStyle::LINE_PATTERN;
     $this->args["LINESIZEUNITS"] = DefaultStyle::LINE_SIZE_UNITS;
     $this->args["LINETHICKNESS"] = DefaultStyle::LINE_THICKNESS;
     $this->args["FILLPATTERN"] = DefaultStyle::FILL_PATTERN;
     $this->args["FILLTRANSPARENCY"] = DefaultStyle::FILL_TRANSPARENCY;
     $this->args["FILLFORECOLOR"] = DefaultStyle::FILL_FORE_COLOR;
     $this->args["FILLBACKCOLOR"] = DefaultStyle::FILL_BACK_COLOR;
     $this->args["FILLBACKTRANS"] = DefaultStyle::FILL_BACK_TRANS;
     $this->args["BORDERPATTERN"] = DefaultStyle::BORDER_PATTERN;
     $this->args["BORDERSIZEUNITS"] = DefaultStyle::BORDER_SIZE_UNITS;
     $this->args["BORDERCOLOR"] = DefaultStyle::BORDER_COLOR;
     $this->args["BORDERTHICKNESS"] = DefaultStyle::BORDER_THICKNESS;
     $this->args["LABELSIZEUNITS"] = DefaultStyle::LABEL_SIZE_UNITS;
     $this->args["LABELFONTSIZE"] = DefaultStyle::LABEL_FONT_SIZE;
     //Omission is considered false, which is the default. If you ever change
     //the default style values, uncomment the matching "true" values
     //$this->args["LABELBOLD"] = DefaultStyle::LABEL_BOLD;
     //$this->args["LABELITALIC"] = DefaultStyle::LABEL_ITALIC;
     //$this->args["LABELUNDERLINE"] = DefaultStyle::LABEL_UNDERLINE;
     $this->args["LABELFORECOLOR"] = DefaultStyle::LABEL_FORE_COLOR;
     $this->args["LABELBACKCOLOR"] = DefaultStyle::LABEL_BACK_COLOR;
     $this->args["LABELBACKSTYLE"] = DefaultStyle::LABEL_BACK_STYLE;
     $markupLayerDefinition = $this->CreateMarkupLayerDefinitionContent($markupFsId->ToString(), $className);
     $layerBs = new MgByteSource($markupLayerDefinition, strlen($markupLayerDefinition));
     //Save to new resource or overwrite existing
     $resourceService->SetResource($markupLayerResId, $layerBs->GetReader(), null);
     //Add to markup registry
     $cmds = new MgFeatureCommandCollection();
     $props = new MgPropertyCollection();
     $props->Add(new MgStringProperty("ResourceId", $markupFsId->ToString()));
     $props->Add(new MgStringProperty("LayerDefinition", $markupLayerResId->ToString()));
     $props->Add(new MgStringProperty("Name", $markupLayerResId->GetName()));
     $props->Add(new MgStringProperty("FdoProvider", $fdoProvider));
     $props->Add(new MgInt32Property("GeometryTypes", $geomTypes));
     $insertCmd = new MgInsertFeatures("Default:MarkupRegistry", $props);
     $cmds->Add($insertCmd);
     $res = $featureService->UpdateFeatures($this->markupRegistryId, $cmds, false);
     MarkupManager::CleanupReaders($res);
     //Add to map
     $this->args["MARKUPLAYER"] = $markupLayerResId->ToString();
     $this->OpenMarkup();
 }
Exemple #8
0
             $geometryFactory = new MgGeometryFactory();
             $mergedGeometries = $geometryFactory->CreateMultiGeometry($inputGeometries);
             // Add buffer features to the temporary feature source.
             // Create multiple concentric buffers to show area.
             // If the stylization for the layer draws the features
             // partially transparent, the concentric rings will be
             // progressively darker towards the center.
             // The stylization is set in the layer template file, which
             // is used in function CreateBufferLayer().
             $commands = new MgFeatureCommandCollection();
             for ($bufferRing = 0; $bufferRing < $bufferRingCount; $bufferRing++) {
                 $bufferDist = $srs->ConvertMetersToCoordinateSystemUnits($bufferRingSize * ($bufferRing + 1));
                 $bufferGeometry = $mergedGeometries->Buffer($bufferDist, $srsMeasure);
                 $properties = new MgPropertyCollection();
                 $properties->Add(new MgGeometryProperty('BufferGeometry', $agfReaderWriter->Write($bufferGeometry)));
                 $commands->Add(new MgInsertFeatures('BufferClass', $properties));
             }
             // Old way, pre MapGuide OS 2.0
             //$featureService->UpdateFeatures($bufferFeatureResId, $commands, false);
             // New way, post MapGuide OS 2.0
             $bufferLayer->UpdateFeatures($commands);
             $bufferLayer->SetVisible(true);
             $bufferLayer->ForceRefresh();
             $bufferLayer->SetDisplayInLegend(true);
             $map->Save();
         }
     }
 } else {
     echo 'No selected layers';
 }
 echo '</p>';
Exemple #9
0
 $src = new MgByteSource("NewSdfInt.LayerDefinition");
 $rid = new MgResourceIdentifier("Library://TrevorWekel/NewSdfInt.LayerDefinition");
 $rsvc->SetResource($rid, $src->GetReader(), null);
 $src = new MgByteSource("NewSdfString.LayerDefinition");
 $rid = new MgResourceIdentifier("Library://TrevorWekel/NewSdfString.LayerDefinition");
 $rsvc->SetResource($rid, $src->GetReader(), null);
 echo "Deleting existing feature source\n";
 $rsvc->DeleteResource($id);
 echo "Creating new feature source\n";
 $fsvc->CreateFeatureSource($id, $params);
 // We need to add some data to the sdf before using it.  The spatial context
 // reader must have an extent.
 $cmdColl = new MgFeatureCommandCollection();
 for ($i = 1; $i <= 20; $i++) {
     $insert = $intFeature->InsertCommand($i);
     $cmdColl->Add($insert);
 }
 echo "Updating features\n";
 $fsvc->UpdateFeatures($id, $cmdColl, false);
 $mapId = new MgResourceIdentifier("Library://TrevorWekel/NewSdf.MapDefinition");
 $map = new MgMap();
 $map->Create($rsvc, $mapId, "NewMap");
 echo "Building Selection from Add()\n";
 $sel = new MgSelection($map);
 $slayer = $map->GetLayers()->GetItem(0);
 $sel->AddFeatureIdInt32($slayer, "IntKey", 1);
 $sel->AddFeatureIdInt32($slayer, "IntKey", 10);
 $sel->AddFeatureIdInt32($slayer, "IntKey", 20);
 echo "XML FeatureSet is\n" . $sel->ToXml() . "\n";
 echo "\nString Filter: " . $sel->GenerateFilter($slayer, "StringKey") . "\n\n";
 echo "Building Selection from XML\n";
Exemple #10
0
                // If the layer exists and is visible, then display the
                // previous results.
                EmitAddressResults($featureService, $addressMarkerDataResId, $mgSessionId);
            }
        }
        // Insert the results of the Geo-Code into the temporary
        // feature source and ensure the address marker layer
        // is visible.
        $geometryReaderWriter = new MgAgfReaderWriter();
        $geometryFactory = new MgGeometryFactory();
        $addrPoint = $geometryFactory->CreatePoint($geometryFactory->CreateCoordinateXY((double) $long, (double) $lat));
        $properties = new MgPropertyCollection();
        $properties->Add(new MgStringProperty('Address', $address1));
        $properties->Add(new MgGeometryProperty('Location', $geometryReaderWriter->Write($addrPoint)));
        $commands = new MgFeatureCommandCollection();
        $commands->Add(new MgInsertFeatures('AddressMarker', $properties));
        $featureService->UpdateFeatures($addressMarkerDataResId, $commands, false);
        $addressLayer->SetVisible(true);
        $addressLayer->ForceRefresh();
        $map->Save($resourceService);
        $success = true;
    } else {
        echo '<tr><td>Address not found: ' . $address . '<hr></td></tr>';
        $success = false;
    }
} catch (MgException $e) {
    echo $e->GetExceptionMessage();
    echo '<br>';
    echo $e->GetDetails();
}
?>
 /**
  * Handles DELETE requests for this adapter. Overridable. Does nothing if not overridden.
  */
 public function HandleDelete($single)
 {
     $trans = null;
     try {
         $tokens = explode(":", $this->className);
         $schemaName = $tokens[0];
         $className = $tokens[1];
         $classDef = $this->featSvc->GetClassDefinition($this->featureSourceId, $schemaName, $className);
         $commands = new MgFeatureCommandCollection();
         if ($single === true) {
             if ($this->featureId == null) {
                 throw new Exception($this->app->localizer->getText("E_NO_FEATURE_ID_SET"));
             }
             $idType = MgPropertyType::String;
             $tokens = explode(":", $this->className);
             $clsDef = $this->featSvc->GetClassDefinition($this->featureSourceId, $tokens[0], $tokens[1]);
             if ($this->featureIdProp == null) {
                 $idProps = $clsDef->GetIdentityProperties();
                 if ($idProps->GetCount() == 0) {
                     throw new Exception($this->app->localizer->getText("E_CANNOT_DELETE_NO_ID_PROPS", $this->className, $this->featureSourceId->ToString()));
                 } else {
                     if ($idProps->GetCount() > 1) {
                         throw new Exception($this->app->localizer->getText("E_CANNOT_DELETE_MULTIPLE_ID_PROPS", $this->className, $this->featureSourceId->ToString()));
                     } else {
                         $idProp = $idProps->GetItem(0);
                         $this->featureIdProp = $idProp->GetName();
                         $idType = $idProp->GetDataType();
                     }
                 }
             } else {
                 $props = $clsDef->GetProperties();
                 $iidx = $props->IndexOf($this->featureIdProp);
                 if ($iidx >= 0) {
                     $propDef = $props->GetItem($iidx);
                     if ($propDef->GetPropertyType() != MgFeaturePropertyType::DataProperty) {
                         throw new Exception($this->app->localizer->getText("E_ID_PROP_NOT_DATA", $this->featureIdProp));
                     }
                 } else {
                     throw new Exception($this->app->localizer->getText("E_ID_PROP_NOT_FOUND", $this->featureIdProp));
                 }
             }
             if ($idType == MgPropertyType::String) {
                 $filter = $this->featureIdProp . " = '" . $this->featureId . "'";
             } else {
                 $filter = $this->featureIdProp . " = " . $this->featureId;
             }
         } else {
             $filter = $this->app->request->params("filter");
             if ($filter == null) {
                 $filter = "";
             }
         }
         $deleteCmd = new MgDeleteFeatures("{$schemaName}:{$className}", $filter);
         $commands->Add($deleteCmd);
         if ($this->useTransaction) {
             $trans = $this->featSvc->BeginTransaction($this->featureSourceId);
         }
         //HACK: Due to #2252, we can't call UpdateFeatures() with NULL MgTransaction, so to workaround
         //that we call the original UpdateFeatures() overload with useTransaction = false if we find a
         //NULL MgTransaction
         if ($trans == null) {
             $result = $this->featSvc->UpdateFeatures($this->featureSourceId, $commands, false);
         } else {
             $result = $this->featSvc->UpdateFeatures($this->featureSourceId, $commands, $trans);
         }
         if ($trans != null) {
             $trans->Commit();
         }
         $this->OutputUpdateFeaturesResult($commands, $result, $classDef);
     } catch (MgException $ex) {
         if ($trans != null) {
             $trans->Rollback();
         }
         $this->OnException($ex);
     }
 }
Exemple #12
0
function ClearDataSource($featureSrvc, $dataSourceId, $featureName)
{
    $deleteCmd = new MgDeleteFeatures($featureName, "ID >= 0");
    $commands = new MgFeatureCommandCollection();
    $commands->Add($deleteCmd);
    $featureSrvc->UpdateFeatures($dataSourceId, $commands, false);
}
Exemple #13
0
     } else {
         $srsXform = null;
     }
     while ($featureReader->ReadNext()) {
         $oGeomAgf = $featureReader->GetGeometry($geomPropName);
         $oGeom = $agfRW->Read($oGeomAgf);
         $wktReaderWriter = new MgWktReaderWriter();
         $agfTextPoint = $wktReaderWriter->Write($oGeom);
         //echo "<!-- wkt: ".$agfTextPoint." -->\n";
         if (!$merge) {
             /* use measure to accomodate differences in SRS */
             $oNewGeom = $oGeom->Buffer($dist, $measure);
             $geomProp = new MgGeometryProperty("GEOM", $agfRW->Write($oNewGeom));
             $oPropertyColl = new MgPropertyCollection();
             $oPropertyColl->Add($geomProp);
             $oCommandsColl->Add(new MgInsertFeatures($schemaName . ':' . $layerName, $oPropertyColl));
         } else {
             if ($srsXform == null) {
                 $oNewGeom = $oGeom;
             } else {
                 $oNewGeom = $oGeom->Transform($srsXform);
             }
             $inputGeometries->Add($oNewGeom);
         }
     }
     $featureReader->Close();
 }
 if ($merge) {
     if ($inputGeometries->GetCount() > 0) {
         $dist = $srsMap->ConvertMetersToCoordinateSystemUnits($distance);
         if (!$arbitraryMapSrs) {
Exemple #14
0
</head>

<?php 
include '../utilityfunctions.php';
$mgSessionId = $_SERVER['REQUEST_METHOD'] == "POST" ? $_POST['SESSION'] : $_GET['SESSION'];
try {
    // Initialize the Web Extensions and connect to the Server using
    // the Web Extensions session identifier stored in PHP session state.
    MgInitializeWebTier($configFilePath);
    $userInfo = new MgUserInformation($mgSessionId);
    $siteConnection = new MgSiteConnection();
    $siteConnection->Open($userInfo);
    $featureService = $siteConnection->CreateService(MgServiceType::FeatureService);
    $addressMarkerDataResId = new MgResourceIdentifier("Session:" . $mgSessionId . "//AddressMarker.FeatureSource");
    $commands = new MgFeatureCommandCollection();
    $commands->Add(new MgDeleteFeatures('AddressMarker', "ID like '%'"));
    $featureService->UpdateFeatures($addressMarkerDataResId, $commands, false);
    // Create a ReserviceService object and use it to open the Map
    // object from the sessions repository. Use the Map object to hide
    // the "ParcelMarker" layer and then save the updated Map back to
    // the session.
    $resourceService = $siteConnection->CreateService(MgServiceType::ResourceService);
    $map = new MgMap();
    $map->Open($resourceService, 'Sheboygan');
    $layer = GetLayerByName($map, 'AddressMarker');
    $layer->SetVisible(false);
    $layer->ForceRefresh();
    $map->Save($resourceService);
} catch (MgException $e) {
    echo $e->GetExceptionMessage();
    echo $e->GetDetails();