316 lines
13 KiB
Python
316 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
|
"default plugin for value: set it in a simple dictionary"
|
|
# Copyright (C) 2013-2021 Team tiramisu (see AUTHORS for all contributors)
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify it
|
|
# under the terms of the GNU Lesser General Public License as published by the
|
|
# Free Software Foundation, either version 3 of the License, or (at your
|
|
# option) any later version.
|
|
#
|
|
# This program 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 Lesser General Public License for more
|
|
# details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
# ____________________________________________________________
|
|
|
|
from .sqlite3db import Sqlite3DB
|
|
from .storage import delete_session
|
|
from ...setting import undefined, owners
|
|
from ...i18n import _
|
|
from ...log import log
|
|
|
|
|
|
class Values(Sqlite3DB):
|
|
__slots__ = ('__weakref__',)
|
|
|
|
def __init__(self, storage):
|
|
"""init plugin means create values storage
|
|
"""
|
|
super(Values, self).__init__(storage)
|
|
|
|
# sqlite
|
|
async def _sqlite_select(self,
|
|
connection,
|
|
path,
|
|
index):
|
|
request = "SELECT value FROM value WHERE path = ? AND session_id = ? "
|
|
params = (path, self._session_id)
|
|
if index is not None:
|
|
request += "and idx = ? "
|
|
params = (path, self._session_id, index)
|
|
request += "LIMIT 1"
|
|
return await connection.select(request, params)
|
|
|
|
# value
|
|
async def setvalue(self,
|
|
connection,
|
|
path,
|
|
value,
|
|
owner,
|
|
index,
|
|
new=False):
|
|
"""set value for an option
|
|
a specified value must be associated to an owner
|
|
"""
|
|
log.debug('setvalue %s %s %s %s', path, value, owner, index)
|
|
path = self._sqlite_encode_path(path)
|
|
if index is not None:
|
|
if not new:
|
|
await self.resetvalue_index(connection,
|
|
path,
|
|
index)
|
|
await connection.execute("INSERT INTO value(path, value, owner, idx, session_id) VALUES "
|
|
"(?, ?, ?, ?, ?)", (path, self._sqlite_encode(value),
|
|
str(owner),
|
|
index,
|
|
self._session_id))
|
|
else:
|
|
if not new:
|
|
await self.resetvalue(connection,
|
|
path)
|
|
await connection.execute("INSERT INTO value(path, value, owner, session_id) VALUES "
|
|
"(?, ?, ?, ?)", (path, self._sqlite_encode(value),
|
|
str(owner),
|
|
self._session_id))
|
|
|
|
async def hasvalue(self,
|
|
connection,
|
|
path,
|
|
index=None):
|
|
"""if opt has a value
|
|
return: boolean
|
|
"""
|
|
log.debug('hasvalue %s %s', path, index)
|
|
path = self._sqlite_encode_path(path)
|
|
return await self._sqlite_select(connection,
|
|
path,
|
|
index) is not None
|
|
|
|
|
|
async def reduce_index(self,
|
|
connection,
|
|
path,
|
|
index):
|
|
"""
|
|
_values == ((path1, path2), ((idx1_1, idx1_2), None),
|
|
((value1_1, value1_2), value2), ((owner1_1, owner1_2), owner2))
|
|
"""
|
|
log.debug('reduce_index %s %s %s', path, index, id(self))
|
|
await connection.execute("UPDATE value SET idx = ? WHERE path = ? and idx = ? "
|
|
"AND session_id = ?",
|
|
(index - 1, path, index, self._session_id))
|
|
|
|
async def resetvalue_index(self,
|
|
connection,
|
|
path,
|
|
index):
|
|
"""remove value means delete value in storage
|
|
"""
|
|
log.debug('resetvalue_index %s %s', path, index)
|
|
path = self._sqlite_encode_path(path)
|
|
await connection.execute("DELETE FROM value WHERE path = ? AND session_id = ? AND idx = ?",
|
|
(path, self._session_id, index))
|
|
|
|
async def resetvalue(self,
|
|
connection,
|
|
path):
|
|
"""remove value means delete value in storage
|
|
"""
|
|
log.debug('resetvalue %s', path)
|
|
path = self._sqlite_encode_path(path)
|
|
await connection.execute("DELETE FROM value WHERE path = ? AND session_id = ?",
|
|
(path, self._session_id))
|
|
|
|
# owner
|
|
async def setowner(self,
|
|
connection,
|
|
path,
|
|
owner,
|
|
index=None):
|
|
"""change owner for an option
|
|
"""
|
|
log.debug('setowner %s %s %s', path, owner, index)
|
|
path = self._sqlite_encode_path(path)
|
|
if index is None:
|
|
await connection.execute("UPDATE value SET owner = ? WHERE path = ? AND session_id = ?",
|
|
(str(owner), path, self._session_id))
|
|
else:
|
|
await connection.execute("UPDATE value SET owner = ? WHERE path = ? and idx = ? AND session_id = ?",
|
|
(str(owner), path, index, self._session_id))
|
|
|
|
async def getowner(self,
|
|
connection,
|
|
path,
|
|
default,
|
|
index=None,
|
|
with_value=False):
|
|
"""get owner for an option
|
|
return: owner object
|
|
"""
|
|
log.debug('getowner %s %s %s %s', path, default, index, with_value)
|
|
path = self._sqlite_encode_path(path)
|
|
request = "SELECT owner, value FROM value WHERE path = ? AND session_id = ?"
|
|
if index is not None:
|
|
request += " AND idx = ?"
|
|
params = (path, self._session_id, index)
|
|
else:
|
|
params = (path, self._session_id)
|
|
request += ' LIMIT 1'
|
|
owner = await connection.select(request, params)
|
|
if owner is None:
|
|
if not with_value:
|
|
return default
|
|
else:
|
|
return default, None
|
|
else:
|
|
# autocreate owners
|
|
try:
|
|
nowner = getattr(owners, owner[0])
|
|
except AttributeError: # pragma: no cover
|
|
owners.addowner(owner[0])
|
|
nowner = getattr(owners, owner[0])
|
|
if not with_value:
|
|
return nowner
|
|
else:
|
|
value = self._sqlite_decode(owner[1])
|
|
return nowner, value
|
|
|
|
async def set_information(self,
|
|
connection,
|
|
path,
|
|
key,
|
|
value):
|
|
"""updates the information's attribute
|
|
(which is a dictionary)
|
|
|
|
:param key: information's key (ex: "help", "doc"
|
|
:param value: information's value (ex: "the help string")
|
|
"""
|
|
log.debug('set_information %s %s', key, value)
|
|
path = self._sqlite_encode_path(path)
|
|
await connection.execute("DELETE FROM information WHERE key = ? AND session_id = ? AND path = ?",
|
|
(key, self._session_id, path))
|
|
await connection.execute("INSERT INTO information(key, value, session_id, path) VALUES "
|
|
"(?, ?, ?, ?)", (key, self._sqlite_encode(value), self._session_id, path))
|
|
|
|
async def get_information(self,
|
|
connection,
|
|
path,
|
|
key,
|
|
default):
|
|
"""retrieves one information's item
|
|
|
|
:param key: the item string (ex: "help")
|
|
"""
|
|
log.debug('get_information %s %s', key, default)
|
|
path = self._sqlite_encode_path(path)
|
|
value = await connection.select("SELECT value FROM information WHERE key = ? AND "
|
|
"session_id = ? AND path = ?",
|
|
(key, self._session_id, path))
|
|
if value is None:
|
|
if default is undefined:
|
|
raise ValueError(_("information's item"
|
|
" not found: {0}").format(key))
|
|
return default
|
|
else:
|
|
return self._sqlite_decode(value[0])
|
|
|
|
async def del_information(self,
|
|
connection,
|
|
path,
|
|
key,
|
|
raises):
|
|
log.debug('del_information %s %s', key, raises)
|
|
path = self._sqlite_encode_path(path)
|
|
information = await connection.select("SELECT value FROM information WHERE key = ? "
|
|
"AND session_id = ? AND path = ?",
|
|
(key, self._session_id, path))
|
|
if raises and information is None:
|
|
raise ValueError(_("information's item not found {0}").format(key))
|
|
await connection.execute("DELETE FROM information WHERE key = ? AND session_id = ? AND path = ?",
|
|
(key, self._session_id, path))
|
|
|
|
async def list_information(self,
|
|
connection,
|
|
path):
|
|
path = self._sqlite_encode_path(path)
|
|
rows = await connection.select("SELECT key FROM information WHERE session_id = ? AND path = ?",
|
|
(self._session_id, path),
|
|
only_one=False)
|
|
ret = []
|
|
for row in rows:
|
|
ret.append(self._sqlite_decode_path(row[0]))
|
|
return ret
|
|
|
|
async def del_informations(self,
|
|
connection):
|
|
await connection.execute("DELETE FROM information WHERE session_id = ?",
|
|
(self._session_id,))
|
|
|
|
async def exportation(self,
|
|
connection):
|
|
log.debug('exportation')
|
|
rows = await connection.select("SELECT path, value, owner, idx FROM value WHERE "
|
|
"session_id = ?;", (self._session_id,), only_one=False)
|
|
ret = [[], [], [], []]
|
|
for row in rows:
|
|
path = self._sqlite_decode_path(row[0])
|
|
value = self._sqlite_decode(row[1])
|
|
owner = row[2]
|
|
index = row[3]
|
|
if index is None:
|
|
ret[0].append(path)
|
|
ret[1].append(index)
|
|
ret[2].append(value)
|
|
ret[3].append(owner)
|
|
else:
|
|
if path in ret[0]:
|
|
path_idx = ret[0].index(path)
|
|
ret[1][path_idx].append(index)
|
|
ret[2][path_idx].append(value)
|
|
ret[3][path_idx].append(owner)
|
|
else:
|
|
ret[0].append(path)
|
|
ret[1].append([index])
|
|
ret[2].append([value])
|
|
ret[3].append([owner])
|
|
|
|
return ret
|
|
|
|
async def importation(self,
|
|
connection,
|
|
export):
|
|
log.debug('importation')
|
|
request = "DELETE FROM value WHERE session_id = ?"
|
|
await connection.execute(request, (self._session_id,))
|
|
for idx, path in enumerate(export[0]):
|
|
path = self._sqlite_encode_path(path)
|
|
index = export[1][idx]
|
|
value = export[2][idx]
|
|
owner = export[3][idx]
|
|
if index is None:
|
|
await connection.execute("INSERT INTO value(path, value, owner, idx, session_id) VALUES "
|
|
"(?, ?, ?, ?, ?)", (path, self._sqlite_encode(value),
|
|
str(owner), index,
|
|
self._session_id))
|
|
else:
|
|
for val in zip(index, value, owner):
|
|
await connection.execute("INSERT INTO value(path, value, owner, idx, session_id)"
|
|
"VALUES (?, ?, ?, ?, ?)", (path,
|
|
self._sqlite_encode(val[1]),
|
|
str(val[2]), val[0],
|
|
self._session_id))
|
|
|
|
async def get_max_length(self,
|
|
connection,
|
|
path):
|
|
log.debug('get_max_length %s', path)
|
|
val_max = await connection.select("SELECT max(idx) FROM value WHERE path = ? AND session_id = ?",
|
|
(path, self._session_id), False)
|
|
if val_max[0][0] is None:
|
|
return 0
|
|
return val_max[0][0] + 1
|