Geografic-Information-System/gui/wxpython/dbmgr/vinfo.py

"""
@package dbmgr.vinfo

@brief Support classes for Database Manager

List of classes:
 - vinfo::VectorDBInfo

(C) 2007-2013 by the GRASS Development Team

This program is free software under the GNU General Public License
(>=v2). Read the file COPYING that comes with GRASS for details.

@author Martin Landa <landa.martin gmail.com>
"""

import os
import sys
import six

import wx

from gui_core.gselect import VectorDBInfo as VectorDBInfoBase
from gui_core.wrap import StaticText
from core.gcmd import RunCommand, GError
from core.settings import UserSettings
import grass.script as grass

if sys.version_info.major >= 3:
    unicode = str

    def GetUnicodeValue(value):
        """Get unicode value

        :param value: value to be recoded

        :return: unicode value
        """
        if isinstance(value, unicode):
            return value
        if isinstance(value, bytes):
            enc = GetDbEncoding()
            return str(value, enc, errors="replace")
        else:
            return str(value)

else:

    def GetUnicodeValue(value):
        """Get unicode value

        :param value: value to be recoded

        :return: unicode value
        """
        if isinstance(value, unicode):
            return value
        enc = GetDbEncoding()
        return unicode(str(value), enc, errors="replace")


def GetDbEncoding():
    """Checks if user set DB encoding (first user settings,
    then env variable), if not assumes unicode."""
    enc = UserSettings.Get(group="atm", key="encoding", subkey="value")
    if not enc and "GRASS_DB_ENCODING" in os.environ:
        enc = os.environ["GRASS_DB_ENCODING"]
    else:
        enc = "utf-8"  # assuming UTF-8
    return enc


def CreateDbInfoDesc(panel, mapDBInfo, layer):
    """Create database connection information content"""
    infoFlexSizer = wx.FlexGridSizer(cols=2, hgap=1, vgap=1)
    infoFlexSizer.AddGrowableCol(1)

    infoFlexSizer.Add(StaticText(parent=panel, id=wx.ID_ANY, label="Driver:"))
    infoFlexSizer.Add(
        StaticText(parent=panel, id=wx.ID_ANY, label=mapDBInfo.layers[layer]["driver"])
    )
    infoFlexSizer.Add(StaticText(parent=panel, id=wx.ID_ANY, label="Database:"))
    infoFlexSizer.Add(
        StaticText(
            parent=panel, id=wx.ID_ANY, label=mapDBInfo.layers[layer]["database"]
        )
    )
    infoFlexSizer.Add(StaticText(parent=panel, id=wx.ID_ANY, label="Table:"))
    infoFlexSizer.Add(
        StaticText(parent=panel, id=wx.ID_ANY, label=mapDBInfo.layers[layer]["table"])
    )
    infoFlexSizer.Add(StaticText(parent=panel, id=wx.ID_ANY, label="Key:"))
    infoFlexSizer.Add(
        StaticText(parent=panel, id=wx.ID_ANY, label=mapDBInfo.layers[layer]["key"])
    )

    return infoFlexSizer


class VectorDBInfo(VectorDBInfoBase):
    """Class providing information about attribute tables
    linked to the vector map"""

    def __init__(self, map):
        VectorDBInfoBase.__init__(self, map)

    def GetColumns(self, table):
        """Return list of columns names (based on their index)"""
        try:
            names = [""] * len(self.tables[table].keys())
        except KeyError:
            return []

        for name, desc in six.iteritems(self.tables[table]):
            names[desc["index"]] = name

        return names

    def SelectByPoint(self, queryCoords, qdist):
        """Get attributes by coordinates (all available layers)

        Return line id or None if no line is found"""
        line = None
        nselected = 0

        try:
            data = grass.vector_what(
                map=self.map,
                coord=(float(queryCoords[0]), float(queryCoords[1])),
                distance=float(qdist),
            )
        except grass.ScriptError:
            GError(
                parent=None,
                message=_(
                    "Failed to query vector map <{map}>. "
                    "Check database settings and topology."
                ).format(map=self.map),
            )

        if len(data) < 1 or all(("Table" not in record) for record in data):
            return None

        # process attributes
        ret = dict()
        for key in ["Category", "Layer", "Table", "Id"]:
            ret[key] = list()

        for record in data:
            if "Table" not in record:
                continue

            table = record["Table"]
            for key, value in six.iteritems(record["Attributes"]):
                if len(value) < 1:
                    value = None
                else:
                    if self.tables[table][key]["ctype"] != str:
                        value = self.tables[table][key]["ctype"](value)
                    else:
                        value = GetUnicodeValue(value)
                self.tables[table][key]["values"].append(value)

            for key, value in six.iteritems(record):
                if key == "Attributes":
                    continue
                if key in ret:
                    ret[key].append(value)
            if "Id" not in record.keys():
                ret["Id"].append(None)

        return ret

    def SelectFromTable(self, layer, cols="*", where=None):
        """Select records from the table

        Return number of selected records, -1 on error
        """
        if layer <= 0:
            return -1

        nselected = 0

        table = self.layers[layer]["table"]  # get table desc
        # select values (only one record)
        if where is None or where == "":
            sql = "SELECT %s FROM %s" % (cols, table)
        else:
            sql = "SELECT %s FROM %s WHERE %s" % (cols, table, where)

        ret = RunCommand(
            "db.select",
            read=True,
            quiet=True,
            flags="v",
            sql=sql,
            database=self.layers[layer]["database"],
            driver=self.layers[layer]["driver"],
        )

        # self.tables[table][key][1] = str(cat)
        if ret:
            for line in ret.splitlines():
                name, value = line.split("|")
                # casting ...
                if value:
                    if not isinstance("", self.tables[table][name]["ctype"]):
                        value = self.tables[table][name]["ctype"](value)
                    else:
                        value = GetUnicodeValue(value)
                else:
                    value = None
                self.tables[table][name]["values"].append(value)
                nselected = 1

        return nselected