File "initgroups.phtml"
Full path: /www/map/mapserver-extensions/pmapper-4.2.0/incphp/initgroups.phtml
File size: 19.14 KiB (19604 bytes)
MIME-type: text/x-php
Charset: utf-8
<?php
/******************************************************************************
*
* Purpose: initialize groups and glayers and save definitions in session
* Author: Armin Burger
*
******************************************************************************
*
* Copyright (c) 2003-2006 Armin Burger
*
* This file is part of p.mapper.
*
* p.mapper is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version. See the COPYING file.
*
* p.mapper is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with p.mapper; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
******************************************************************************/
require_once("group.phtml");
class Init_groups
{
var $map;
var $allGroups;
var $gLanguage;
var $map2unicode;
var $existsXYLayer = 0;
var $ini;
function Init_groups($map, $allGroups, $gLanguage, $ini)
{
$this->map = $map;
$this->allGroups = $allGroups;
$this->gLanguage = $gLanguage;
$this->ini = $ini;
$this->map2unicode = is_array($ini) ? $ini['locale']['map2unicode'] : $ini;
}
protected function defineLists()
{
$initGroups = array();
$groupOrder = $this->allGroups;
$mapGroupsNames = $this->map->getAllGroupNames();
$mapLayers = $this->map->getAllLayerNames();
//printDebug($mapLayers);
// Create array for groups in map file
foreach ($mapGroupsNames as $mgn) {
$mapGroups[$mgn] = $this->map->getLayersIndexByGroup($mgn);
}
//Add layers as groups if not assigned to any group
foreach($mapLayers as $l) {
$layer = $this->map->getLayerByName($l);
$layIdx = $layer->index;
$layGrp = $layer->group;
if ($layGrp == "") {
$mapGroups[$l] = array($layIdx);
}
}
// Sort group array according to order of $groupOrder
foreach($groupOrder as $g) {
if (isset($mapGroups[$g]) && count($mapGroups[$g]) > 0) {
$initGroups[$g] = $mapGroups[$g];
} else {
error_log("Could not create group '$g' defined in groupOrder in 'config.ini'. Check if name is correct.", 0);
}
}
return $initGroups;
}
/**
* Initialize GROUPS
* set group and layer properties
*
*/
public function createGroupList()
{
$initGroups = $this->defineLists();
$grouplist = array();
foreach ($initGroups as $grpName=>$layerList) {
$grouplist[$grpName] = $this->createGroup($grpName, $layerList);
}
// Save everything in session
$_SESSION["existsXYLayer"] = $this->existsXYLayer;
$_SESSION["grouplist"] = $grouplist;
}
public function createGroup($grpName, $layerList)
{
$group = new GROUP($grpName);
$i = 1;
// Loop through LAYERS of current group
foreach ($layerList as $layIdx) {
// Get layer info from map file
$mapLay = $this->map->getLayer($layIdx);
$mapLayName = $mapLay->name;
$mapLayType = $mapLay->type;
$mapLayConnType = $mapLay->connectiontype;
//error_log("$mapLayName - $mapLayConnType");
// Write layer properties to glayer object
$glayer = new GLAYER($mapLayName);
$glayer->setLayerIdx($layIdx);
$glayer->setLayerType($mapLayType);
// Add result field list
if ($mapLayType <= 4 && $mapLayConnType != MS_WMS) { // result fields only for queryable layers point (0), line (1), polygon (2), annotation (4)
$selFields0 = $this->_initResultFields($this->map, $mapLay, $mapLayType);
// Trim spaces
if (is_array($selFields0)) {
if (count($selFields0) > 0) {
//pm_logDebug(3, $selFields0, "P.MAPPER-DEBUG: initgroups.phtml/createGroup()->selFields0");
$selFields = array();
foreach ($selFields0 as $sf0) {
// If field name starts with '&' then translate
$sf = (substr(trim($sf0), 0, 1) == '&' ? _p(trim($sf0)) : trim($sf0));
$selFields[] = $sf;
}
$glayer->setResFields($selFields);
}
}
}
// add to categories array if defined in map file
if ($category = $this->getLayerMetaTag($mapLay, "CATEGORY")) {
$this->_initCategories($mapLayName, $category);
}
// Add hyperlink fields
if ($this->_getHyperFieldList($mapLay)) {
$glayer->setHyperFields($this->_getHyperFieldList($mapLay));
}
// Add JOIN properties if defined
if ($this->_getJoinProperties($mapLay)) {
$glayer->setTableJoin($this->_getJoinProperties($mapLay));
}
// Add classes
$numclasses = $mapLay->numclasses;
$classes = array();
for ($cl=0; $cl < $numclasses; $cl++) {
$class = $mapLay->getClass($cl);
$className = $this->mapStringEncode($class->name);
if (strlen($className) > 0) {
$classname = _p(trim($className));
$classes[] = $classname; //str_replace("'", "\\'", $classname);
}
}
$glayer->setClasses($classes);
// Check/Set labelitems if defined
if ($mapLay->labelitem) {
$labelItem = $mapLay->labelitem{0} == "@" ? _p(substr($mapLay->labelitem, 1)) : $mapLay->labelitem;
$glayer->setLabelItem($labelItem);
}
// Check/Set layer transparency (opacity)
if (floatval($_SESSION['MS_VERSION']) >= 5) {
$glayer->setOpacity($mapLay->opacity);
} else {
$glayer->setOpacity($mapLay->transparency);
}
// Check if layer is XY layer
if ($XYLayerPropStr = $this->getLayerMetaTag($mapLay, "XYLAYER_PROPERTIES")) {
$glayer->setXYLayerAttribute();
$XYLayerPropList = $this->_getXYLayerPropList($XYLayerPropStr);
$glayer->setXYLayerProperties($XYLayerPropList);
pm_logDebug(3, $XYLayerPropList, "P.MAPPER-DEBUG: initgroups.phtml/_createGroups() - XYLayerProperties for layer $mapLayName");
// Set in sessionid that XYLayer exists
$this->existsXYLayer = 1;
}
//Check for skipLegend
// 1: only for TOC_TREE, 2: always skip legend
$skipLegend = $this->getLayerMetaTag($mapLay, "SKIP_LEGEND");
$glayer->setSkipLegend($skipLegend);
// Layer Encoding
$glayer->setLayerEncoding($this->getLayerMetaTag($mapLay, "LAYER_ENCODING"));
// DB properties
if ($mapLayConnType == 6) {
$glayer->setLayerDbProperties($this->pgLayerParseData($mapLay));
}
if ($mapLayConnType == 8) {
$glayer->setLayerDbProperties($this->oraGetDbProperties($mapLay));
}
// now add layer to group
$group->addLayer($glayer);
// set group description and result headers, process only for 1st layer of group
if ($i == 1) {
// Set group description
$description = $this->_initDescription($mapLay);
$group->setDescription($description);
// Set result group headers
if ($mapLayType <= 4) {
$selHeadersList = $this->_initResultHeaders($this->map, $mapLay, $mapLayType, $this->gLanguage);
$group->setResHeaders($selHeadersList[0]);
$group->setResStdHeaders($selHeadersList[1]);
}
$i = 0;
}
}
return $group;
}
/**
* init fields used for query result
*/
function _initResultFields($map, $mapLay, $mapLayType) {
if ($metaString = $this->getLayerMetaTag($mapLay, "RESULT_FIELDS")) {
$metaList = array();
$metaList0 = explode(",", $metaString);
foreach ($metaList0 as $i) {
$i = trim($i);
// Check for locale-specific field
if ($i{0} == "@") {
// From hash
if (strpos($i, ":")) {
$fldDict = array();
$flocaleList = explode("@", $i);
foreach ($flocaleList as $fldDef) {
$fo = explode(":", $fldDef);
if (isset($fo[1])) {
$fldDict[$fo[0]] = $fo[1];
}
}
if (array_key_exists($this->gLanguage, $fldDict)) {
$resultField = $fldDict[$this->gLanguage];
} else {
$resultField = $fldDict['default'];
}
// via translation from language_xy.phtml locale file
} else {
$resultField = _p(substr($i, 1));
}
// Otherwise take normal one
} else {
$resultField = $i;
}
$metaList[] = $resultField;
}
} else {
$hasTemplate = 0;
if ($mapLay->template) $hasTemplate = 1;
$numclasses = $mapLay->numclasses;
for ($cl=0; $cl < $numclasses; $cl++) {
$class = $mapLay->getClass($cl);
$classTemplate = $class->template;
if ($class->template) $hasTemplate = 1;
}
if ($mapLayType != 3 && $hasTemplate) {
$mapLay->open();
$metaList = $mapLay->getItems();
$mapLay->close();
//pm_logDebug(3, $metaList, "P.MAPPER-DEBUG: initgroups.phtml/createGroup()->metaList");
} else {
$metaList = array();
}
}
return $metaList;
}
/**
* init headers used for query result
*/
function _initResultHeaders($map, $mapLay, $mapLayType) {
if ($metaString = $this->getLayerMetaTag($mapLay, "RESULT_HEADERS")) {
$metaList = array();
$metaListStd = array();
$metaList0 = explode(",", $metaString);
foreach ($metaList0 as $m) {
$metaList[] = _p(trim($this->mapStringEncode($m)));
$metaListStd[] = trim($this->mapStringEncode($m));
}
} else {
if ($mapLayType != 3) {
$mapLay->open();
$metaList = $mapLay->getItems();
$mapLay->close();
$metaListStd = $metaList;
} else {
$metaList = array();
$metaListStd = array();
}
}
return array($metaList, $metaListStd);
}
/**
* init layer description
*/
function _initDescription($mapLay) {
if ($metaString = $this->getLayerMetaTag($mapLay, "DESCRIPTION")) {
$descriptionTag = _p($this->mapStringEncode($metaString));
} else {
if ($mapLay->group) {
$descriptionTag = _p($this->mapStringEncode($mapLay->group));
} else {
$descriptionTag = _p($this->mapStringEncode($mapLay->name));
}
}
return preg_replace(array("/\\\/", "/\|/"), array("", ""), trim($descriptionTag)); // ESCAPE APOSTROPHES (SINGLE QUOTES) IN NAME WITH BACKSLASH
}
/**
* init categories
*/
function _initCategories($mapLayName, $category) {
if (preg_match("/:/", $category)) {
$cL = explode(":", $category);
$category = $cL[0];
$categoryDescr = $cL[1];
} else {
$categoryDescr = $category;
}
$catLayerList = $_SESSION['categories'][$category];
if (!is_array($catLayerList))
$_SESSION['categories'][$category] = array("description"=>$categoryDescr, "groups"=>array());
if (!in_array($mapLayName, $_SESSION['categories'][$category]))
$_SESSION['categories'][$category]['groups'][] = $mapLayName;
}
/**
* Check for HYPERLINK FIELDS
* Check if hyperlink fields have been declared in map file
*/
function _getHyperFieldList($glayer)
{
// First split string into field arrays, then the chunks into field name and alias for link
if ($hyperMeta = $this->getLayerMetaTag($glayer, "RESULT_HYPERLINK")) {
$hyperStr = preg_split('/,/', $hyperMeta);
foreach ($hyperStr as $hs) {
if (preg_match ('/\|\|/', $hs)) {
$hfa = preg_split('/\|\|/', $hs);
$hyperFieldsAlias[trim($hfa[0])] = _p($this->mapStringEncode(trim($hfa[1])));
$hyperFieldsValues[] = trim($hfa[0]);
} else {
$hyperFieldsValues[] = trim($hs);
$hyperFieldsAlias = array();
}
}
return array($hyperFieldsValues, $hyperFieldsAlias);
} else {
return NULL;
}
}
/**
* Check for XY Layers
*/
function _getXYLayerPropList($XLLayerMetaStr)
{
$XYLayerList = preg_split("/\|\|/", $XLLayerMetaStr);
$XYLayerProperties["dsn"] = $XYLayerList[0];
$XYLayerProperties["xyTable"] = $XYLayerList[1];
$XYLayerFldList = preg_split("/,/", $XYLayerList[2]);
$XYLayerProperties["x_fld"] = $XYLayerFldList[0];
$XYLayerProperties["y_fld"] = $XYLayerFldList[1];
$XYLayerProperties["classidx_fld"] = $XYLayerFldList[2];
$XYLayerProperties["oid_fld"] = $XYLayerFldList[3];
$XYLayerProperties["noQuery"] = $XYLayerList[3];
return $XYLayerProperties;
}
/**
* Check for DB JOINS
* Check if DB joins have been declared in map file
*/
function _getJoinProperties($qLayer)
{
if ($joinStrMeta = $this->getLayerMetaTag($qLayer, "RESULT_JOIN")) {
$joinList = preg_split("/\|\|/", $joinStrMeta);
$joinPropList["dsn"] = $joinList[0];
// Join table properties
$tableProp = preg_split("/\@/", $joinList[1]);
$joinPropList["fromTable"] = $tableProp[0];
$joinPropList["fromField"] = $tableProp[1];
$joinPropList["fromFieldType"] = $tableProp[2];
$joinFieldStr = $tableProp[3];
$joinPropList["joinFields"] = $joinFieldStr;
// Field in Shapefile to join to
$joinPropList["toField"] = $joinList[2];
// Join type: one-to-one (0) or one-to-many (1)
$joinPropList["one2many"] = $joinList[3];
return $joinPropList;
} else {
return false;
}
}
/**
* check for map file encoding and encode strings accordingly
*/
function mapStringEncode($inString)
{
if ($this->map2unicode) {
$mapfile_encoding = trim($this->map->getMetaData("MAPFILE_ENCODING"));
if ($mapfile_encoding) {
if ($mapfile_encoding != "UTF-8") {
$outString = iconv($mapfile_encoding, "UTF-8", $inString);
} else {
$outString = $inString;
}
} else {
$outString = utf8_encode($inString);
}
} else {
$outString = $inString;
}
return $outString;
}
/**
* Try to get values from layer.ini. setting
* or from map file METADATA tags
*/
private function getLayerMetaTag($layer, $tag)
{
$iniTagStr = "layer." . $layer->name . ".$tag";
/*if ($this->ini == false) {
return $_SESSION["layer_" . $layer->name . "_$tag"];
} elseif (isset($this->ini[$iniTagStr])) {*/
if (isset($this->ini[$iniTagStr])) {
$_SESSION["layer_" . $layer->name . "_$tag"] = $this->ini[$iniTagStr];
return $this->ini[$iniTagStr];
} elseif ($metaData = $layer->getMetaData($tag)) {
return $metaData;
} else {
return false;
}
}
/**
* Parse DATA tag from PostGIS layer
*/
private function pgLayerParseData($layer)
{
$pg_data = $layer->data; //"the_geom from images";
$dl = preg_split('/ from /i', $pg_data);
$data_list['geocol'] = trim($dl[0]);
$flds = trim($dl[1]);
if (substr($flds, 0, 1) == '(') {
// is of type "the_geom from (select the_geom, oid, from mytable) AS foo USING UNIQUE gid USING SRID=4258"
$tabl = preg_split('/as ([a-z]|_|[A-Z]|[0-9])+ using unique /i', $dl[2]);
$unique_list = preg_split('/[\s,]+/', $tabl[1]);
$data_list['dbtable'] = $flds . " from " . trim($tabl[0]) . " as foo ";
$data_list['unique_field'] = trim($unique_list[0]);
} else {
$tabl = preg_split('/using unique/i', $dl[1]);
if (count($tabl) > 1) {
// is of type "the_geom from mytable USING UNIQUE gid "
$data_list['dbtable'] = trim($tabl[0]);
//$data_list['unique_field'] = trim($tabl[1]);
$unique_list = preg_split('/[\s]+/', trim($tabl[1]));
$data_list['unique_field'] = trim($unique_list[0]);
} else {
// is of type "the_geom from mytable"
$dbtable = trim($dl[1]);
$data_list['dbtable'] = $dbtable;
$data_list['unique_field'] = "oid";
pm_logDebug(2,"P.MAPPER Warning: no UNIQUE field specified for PostGIS table '$dbtable'. Trying using OID field...");
}
}
return $data_list;
}
/**
* Return properties of OracleSpatial layer
*/
private function oraGetDbProperties($layer)
{
}
} // class
?>