function GetOpenMarkup()
{
$openMarkup = array();
$resourceService = $this->site->CreateService(MgServiceType::ResourceService);
$map = new MgMap();
$map->Open($resourceService, $this->args['MAPNAME']);
$layerGroups = $map->GetLayerGroups();
if ($layerGroups->Contains('_Markup')) {
$layers = $map->GetLayers();
for ($i = 0; $i < $layers->GetCount(); $i++) {
$layer = $layers->GetItem($i);
if ($layer->GetGroup() != null and $layer->GetGroup()->GetName() == '_Markup') {
$openMarkup[$this->GetResourceIdPrefix() . $layer->GetLegendLabel() . '.LayerDefinition'] = $layer->GetLegendLabel();
}
}
asort($openMarkup);
}
return $openMarkup;
}
public function GetTileXYZ($resId, $groupName, $x, $y, $z, $type, $layerNames = NULL)
{
$fmt = $this->ValidateRepresentation($type, array("json", "png", "png8", "jpg", "gif"));
$path = self::GetTilePath($this->app, $resId, $groupName, $z, $x, $y, $type, $layerNames);
clearstatcache();
$dir = dirname($path);
$lockPath = "{$dir}/lock_" . $y . ".lck";
$attempts = 0;
while (!@is_dir($dir)) {
try {
mkdir($dir, 0777, true);
} catch (Exception $e) {
//Another tile request may have already created this since
$attempts++;
//Bail after MAX_RETRY_ATTEMPTS
if ($attempts >= self::MAX_RETRY_ATTEMPTS) {
$this->ServerError($this->app->localizer->getText("E_FAILED_TO_CREATE_DIR_AFTER_N_ATTEMPTS", $attempts), $this->GetMimeTypeForFormat($type));
}
}
}
//If there's a dangling lock file, attempt to remove it
if (file_exists($lockPath)) {
unlink($lockPath);
}
$fpLockFile = fopen($lockPath, "a+");
//Message of any exception caught will be set to this variable
$tileError = null;
$requestId = rand();
$this->app->log->debug("({$requestId}) Checking if {$path} exists");
$attempts = 0;
while (!file_exists($path)) {
//Bail after MAX_RETRY_ATTEMPTS
if ($attempts >= self::MAX_RETRY_ATTEMPTS) {
$this->ServerError($this->app->localizer->getText("E_FAILED_TO_GENERATE_TILE_AFTER_N_ATTEMPTS", $attempts), $this->GetMimeTypeForFormat($type));
}
$attempts++;
$this->app->log->debug("({$requestId}) {$path} does not exist. Locking for writing");
$bLocked = false;
flock($fpLockFile, LOCK_EX);
fwrite($fpLockFile, ".");
$bLocked = true;
$this->app->log->debug("({$requestId}) Acquired lock for {$path}. Checking if path exists again.");
//check once more to see if the cache file was created while waiting for
//the lock
clearstatcache();
if (!file_exists($path)) {
try {
$this->app->log->debug("({$requestId}) Rendering tile to {$path}");
$bOldPath = true;
if ($type != "json") {
//if this is MGOS 3.0 and we're dealing with a tile set, we invoke GETTILEIMAGE as that we can pass in Tile Set Definition
//resource ids without issues. We cannot create MgMaps from Tile Set Definitions that are not using the default tile provider.
//
//The given tile set is assumed to be using the XYZ provider, the case where the Tile Set Definition is using the default provider
//is not handled
if ($this->app->MG_VERSION[0] >= 3 && $resId->GetResourceType() == "TileSetDefinition") {
$bOldPath = false;
$sessionId = "";
if ($resId->GetRepositoryType() === MgRepositoryType::Session && $this->app->request->get("session") == null) {
$sessionId = $resId->GetRepositoryName();
}
$resIdStr = $resId->ToString();
$that = $this;
$this->EnsureAuthenticationForHttp(function ($req, $param) use($that, $resIdStr, $groupName, $x, $y, $z, $requestId, $path) {
$param->AddParameter("OPERATION", "GETTILEIMAGE");
$param->AddParameter("VERSION", "1.2.0");
$param->AddParameter("MAPDEFINITION", $resIdStr);
$param->AddParameter("BASEMAPLAYERGROUPNAME", $groupName);
$param->AddParameter("SCALEINDEX", $z);
$param->AddParameter("TILEROW", $x);
$param->AddParameter("TILECOL", $y);
$that->app->log->debug("({$requestId}) Executing GETTILEIMAGE");
$that->ExecuteHttpRequest($req, function ($result, $status) use($path) {
if ($status == 200) {
//Need to dump the rendered tile to the specified path so the caching stuff below can still do its thing
$resultObj = $result->GetResultObject();
$sink = new MgByteSink($resultObj);
$sink->ToFile($path);
}
});
}, true, "", $sessionId);
//Tile access can be anonymous, so allow for it if credentials/session specified, but if this is a session-based Map Definition, use the session id as the nominated one
}
}
//Pre MGOS 3.0 code path
if ($bOldPath) {
$this->app->log->debug("({$requestId}) Going down old code path");
$this->EnsureAuthenticationForSite("", true);
$siteConn = new MgSiteConnection();
$siteConn->Open($this->userInfo);
$map = new MgMap($siteConn);
$map->Create($resId, "VectorTileMap");
$renderSvc = $siteConn->CreateService(MgServiceType::RenderingService);
$groups = $map->GetLayerGroups();
$baseGroup = $groups->GetItem($groupName);
//Will throw MgObjectNotFoundException -> 404 if no such group exists
$factory = new MgCoordinateSystemFactory();
$mapCsWkt = $map->GetMapSRS();
$mapCs = $factory->Create($mapCsWkt);
$mapExtent = $map->GetMapExtent();
$mapExLL = $mapExtent->GetLowerLeftCoordinate();
$mapExUR = $mapExtent->GetUpperRightCoordinate();
$metersPerUnit = $mapCs->ConvertCoordinateSystemUnitsToMeters(1.0);
$this->app->log->debug("({$requestId}) Calc bounds from XYZ");
//XYZ to lat/lon math. From this we can convert to the bounds in the map's CS
//
//Source: http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
$n = pow(2, $z);
$lonMin = $x / $n * 360.0 - 180.0;
$latMin = rad2deg(atan(sinh(pi() * (1 - 2 * $y / $n))));
$lonMax = ($x + 1) / $n * 360.0 - 180.0;
$latMax = rad2deg(atan(sinh(pi() * (1 - 2 * ($y + 1) / $n))));
$boundsMinX = min($lonMin, $lonMax);
$boundsMinY = min($latMin, $latMax);
$boundsMaxX = max($lonMax, $lonMin);
$boundsMaxY = max($latMax, $latMin);
if ($mapCs->GetCsCode() != "LL84") {
$llCs = $factory->CreateFromCode("LL84");
$trans = $factory->GetTransform($llCs, $mapCs);
$ul = $trans->Transform($lonMin, $latMin);
$lr = $trans->Transform($lonMax, $latMax);
$boundsMinX = min($lr->GetX(), $ul->GetX());
$boundsMinY = min($lr->GetY(), $ul->GetY());
$boundsMaxX = max($lr->GetX(), $ul->GetX());
$boundsMaxY = max($lr->GetY(), $ul->GetY());
}
//Set all layers under group to be visible
$layers = $map->GetLayers();
$layerCount = $layers->GetCount();
$groupCount = $groups->GetCount();
//Turn all groups that are not the given group to be hidden
for ($i = 0; $i < $groupCount; $i++) {
$group = $groups->GetItem($i);
if ($group->GetName() != $groupName) {
$group->SetVisible(false);
} else {
$group->SetVisible(true);
}
}
for ($i = 0; $i < $layerCount; $i++) {
$layer = $layers->GetItem($i);
$group = $layer->GetGroup();
if (null == $group) {
continue;
}
if ($group->GetName() != $groupName && $layer->GetLayerType() == MgLayerType::Dynamic) {
$layer->SetVisible(false);
continue;
}
if ($layer->GetLayerType() == MgLayerType::Dynamic) {
$layer->SetVisible(true);
}
}
if ($type == "json") {
//error_log("($requestId) Render vector tile");
$this->PutVectorTileXYZ($map, $groupName, $siteConn, $metersPerUnit, $factory, $path, $boundsMinX, $boundsMinY, $boundsMaxX, $boundsMaxY, $layerNames);
} else {
$format = strtoupper($type);
//error_log("($requestId) Render image tile");
$this->PutTileImageXYZ($map, $groupName, $renderSvc, $path, $format, $boundsMinX, $boundsMinY, $boundsMaxX, $boundsMaxY, $layerNames, $requestId);
}
}
} catch (MgException $ex) {
if ($bLocked) {
$this->app->log->debug("({$requestId}) MgException caught " . $ex->GetDetails() . "\n" . $ex->getTraceAsString() . "\n. Releasing lock for {$path}");
$tileError = $ex->GetExceptionMessage();
flock($fpLockFile, LOCK_UN);
$bLocked = false;
}
if ($ex instanceof MgResourceNotFoundException || $ex instanceof MgObjectNotFoundException) {
$this->NotFound($ex->GetExceptionMessage(), $this->GetMimeTypeForFormat($fmt));
} else {
if ($ex instanceof MgConnectionFailedException) {
$this->ServiceUnavailable($ex->GetExceptionMessage(), $this->GetMimeTypeForFormat($fmt));
}
}
} catch (Exception $ex) {
if ($bLocked) {
$tileError = get_class($ex) . " - " . $ex->getMessage();
$this->app->log->debug("({$requestId}) Exception caught ({$tileError}). Releasing lock for {$path}");
flock($fpLockFile, LOCK_UN);
$bLocked = false;
}
}
}
if ($bLocked) {
$this->app->log->debug("({$requestId}) Releasing lock for {$path}");
flock($fpLockFile, LOCK_UN);
$bLocked = false;
}
}
//An exception occurred, try to clean up lock before bailing
if ($tileError != null) {
try {
fclose($fpLockFile);
unlink($lockPath);
} catch (Exception $ex) {
$this->app->log->debug("({$requestId}) Failed to delete lock file. Perhaps another concurrent request to the same tile is happening?");
}
throw new Exception($tileError);
}
$modTime = filemtime($path);
$this->app->lastModified($modTime);
$this->app->log->debug("({$requestId}) Acquiring shared lock for {$path}");
//acquire shared lock for reading to prevent a problem that could occur
//if a tile exists but is only partially generated.
flock($fpLockFile, LOCK_SH);
$this->app->log->debug("({$requestId}) Outputting {$path}");
$ext = strtoupper(pathinfo($path, PATHINFO_EXTENSION));
$mimeType = "";
switch ($ext) {
case "PNG":
//MgImageFormats::Png:
$mimeType = MgMimeType::Png;
break;
case "GIF":
//MgImageFormats::Gif:
$mimeType = MgMimeType::Gif;
break;
case "JPG":
//MgImageFormats::Jpeg:
$mimeType = MgMimeType::Jpeg;
break;
case "JSON":
$mimeType = MgMimeType::Json;
break;
}
$this->app->response->header("Content-Type", $mimeType);
$this->app->expires("+6 months");
$this->app->response->header("Cache-Control", "max-age=31536000, must-revalidate");
$this->app->response->setBody(file_get_contents($path));
$this->app->log->debug("({$requestId}) Releasing shared lock for {$path}");
//Release lock
flock($fpLockFile, LOCK_UN);
//Try to delete the lock file
try {
fclose($fpLockFile);
unlink($lockPath);
} catch (Exception $ex) {
$this->app->log->debug("({$requestId}) Failed to delete lock file. Perhaps another concurrent request to the same tile is happening?");
}
}
echo $oMax->GetY() . "],";
$layers = $map->GetLayers();
echo "layers:[";
$layerSep = '';
for ($i = 0; $i < $layers->GetCount(); $i++) {
$layer = $layers->GetItem($i);
//only output layers that are part of the 'Normal Group' and
//not the base map group used for tile maps.
echo $layerSep . '{';
OutputLayerInfo($layer, $resourceService, $featureService);
echo '}';
$layerSep = ',';
}
echo "],";
//Get layer groups as xml
$groups = $map->GetLayerGroups();
echo "groups:[";
$groupSep = '';
for ($i = 0; $i < $groups->GetCount(); $i++) {
$group = $groups->GetItem($i);
echo $groupSep . '{';
OutputGroupInfo($group);
echo '}';
$groupSep = ',';
}
echo "],";
//FiniteDisplayScales for tiled maps
echo "FiniteDisplayScales:[";
for ($i = 0; $i < $map->GetFiniteDisplayScaleCount(); $i++) {
if ($i > 0) {
echo ",";
public function UpdateMapLayersAndGroups($sessionId, $mapName, $format)
{
//Check for unsupported representations
$fmt = $this->ValidateRepresentation($format, array("xml", "json"));
try {
$this->EnsureAuthenticationForSite($sessionId);
$siteConn = new MgSiteConnection();
$siteConn->Open($this->userInfo);
$resSvc = $siteConn->CreateService(MgServiceType::ResourceService);
$map = new MgMap($siteConn);
$map->Open($mapName);
if ($fmt == "json") {
$body = $this->app->request->getBody();
$json = json_decode($body);
if ($json == NULL) {
throw new Exception($this->app->localizer->getText("E_MALFORMED_JSON_BODY"));
}
} else {
$body = $this->app->request->getBody();
$jsonStr = MgUtils::Xml2Json($body);
$json = json_decode($jsonStr);
}
if (!isset($json->UpdateMap)) {
throw new Exception($this->app->localizer->getText("E_MALFORMED_JSON_BODY"));
}
/*
Expected structure
/UpdateMap
/Operation [1...n]
/Type - [AddLayer|UpdateLayer|RemoveLayer|AddGroup|UpdateGroup|RemoveGroup]
/Name
/ResourceId
/SetLegendLabel
/SetDisplayInLegend
/SetExpandInLegend
/SetVisible
/SetSelectable
/InsertAt
*/
$layers = $map->GetLayers();
$groups = $map->GetLayerGroups();
$um = $json->UpdateMap;
$updateStats = new stdClass();
$updateStats->AddedLayers = 0;
$updateStats->UpdatedLayers = 0;
$updateStats->RemovedLayers = 0;
$updateStats->AddedGroups = 0;
$updateStats->UpdatedGroups = 0;
$updateStats->RemovedGroups = 0;
$this->app->log->debug("Operations found: " . count($um->Operation));
for ($i = 0; $i < count($um->Operation); $i++) {
$op = $um->Operation[$i];
switch ($op->Type) {
case "AddLayer":
$resId = new MgResourceIdentifier($op->ResourceId);
$layer = new MgLayer($resId, $resSvc);
$layer->SetName($op->Name);
self::ApplyCommonLayerProperties($layer, $op, $groups);
if (isset($op->InsertAt)) {
$layers->Insert(intval($op->InsertAt), $layer);
} else {
$layers->Add($layer);
}
$this->app->log->debug("Add Layer: " . $op->Name);
$updateStats->AddedLayers++;
break;
case "UpdateLayer":
$layer = $layers->GetItem($op->Name);
if (self::ApplyCommonLayerProperties($layer, $op, $groups)) {
$this->app->log->debug("Updated Layer: " . $op->Name);
$updateStats->UpdatedLayers++;
}
break;
case "RemoveLayer":
$layer = $layers->GetItem($op->Name);
if ($layers->Remove($layer)) {
$this->app->log->debug("Removed Layer: " . $op->Name);
$updateStats->RemovedLayers++;
}
break;
case "AddGroup":
$group = new MgLayerGroup($op->Name);
self::ApplyCommonGroupProperties($group, $op, $groups);
if (isset($op->InsertAt)) {
$groups->Insert(intval($op->InsertAt), $group);
} else {
$groups->Add($group);
}
$this->app->log->debug("Add Group: " . $op->Name);
$updateStats->AddedGroups++;
break;
case "UpdateGroup":
$gidx = $groups->IndexOf($op->Name);
if ($gidx < 0) {
if ($op->AddIfNotExists) {
$group = new MgLayerGroup($op->Name);
self::ApplyCommonGroupProperties($group, $op, $groups);
if (isset($op->InsertAt)) {
$groups->Insert(intval($op->InsertAt), $group);
} else {
$groups->Add($group);
}
$this->app->log->debug("Add Group: " . $op->Name);
$updateStats->AddedGroups++;
} else {
throw new Exception($this->app->localizer->getText("E_GROUP_NOT_FOUND", $op->Name));
}
} else {
$group = $groups->GetItem($gidx);
if (self::ApplyCommonGroupProperties($group, $op, $groups)) {
$this->app->log->debug("Updated Group: " . $op->Name);
$updateStats->UpdatedGroups++;
}
}
break;
case "RemoveGroup":
$group = $groups->GetItem($op->Name);
if ($groups->Remove($group)) {
$this->app->log->debug("Removed Group: " . $op->Name);
$updateStats->RemovedGroups++;
}
break;
}
}
if ($updateStats->AddedLayers > 0 || $updateStats->UpdatedLayers > 0 || $updateStats->RemovedLayers > 0 || $updateStats->AddedGroups > 0 || $updateStats->UpdatedGroups > 0 || $updateStats->RemovedGroups > 0) {
$map->Save();
}
$response = "<UpdateMapResult>";
$response .= "<AddedLayers>";
$response .= $updateStats->AddedLayers;
$response .= "</AddedLayers>";
$response .= "<UpdatedLayers>";
$response .= $updateStats->UpdatedLayers;
$response .= "</UpdatedLayers>";
$response .= "<RemovedLayers>";
$response .= $updateStats->RemovedLayers;
$response .= "</RemovedLayers>";
$response .= "<AddedGroups>";
$response .= $updateStats->AddedGroups;
$response .= "</AddedGroups>";
$response .= "<UpdatedGroups>";
$response .= $updateStats->UpdatedGroups;
$response .= "</UpdatedGroups>";
$response .= "<RemovedGroups>";
$response .= $updateStats->RemovedGroups;
$response .= "</RemovedGroups>";
$response .= "</UpdateMapResult>";
$bs = new MgByteSource($response, strlen($response));
$bs->SetMimeType(MgMimeType::Xml);
$br = $bs->GetReader();
if ($format == "json") {
$this->OutputXmlByteReaderAsJson($br);
} else {
$this->OutputByteReader($br);
}
} catch (MgException $ex) {
$this->OnException($ex, $this->GetMimeTypeForFormat($format));
}
}
