def __init__(self, source):
self.__implicit = []
self.__prioritized = []
self.__required = []
self.__optional = []
self.__expected = set()
for name, source_type in source.items():
if isinstance(source_type, Optional):
checker = TypeChecker.make(source_type.source)
if isinstance(checker, Implicit):
raise base.ImplementationError(
"implicit parameter cannot be optional: %s" % name)
self.__optional.append((name, checker))
else:
checker = TypeChecker.make(source_type)
if isinstance(checker, Implicit):
self.__implicit.append((name, checker))
elif isinstance(checker, Prioritized):
self.__prioritized.append((name, checker))
else:
self.__required.append((name, checker))
for suffix, _ in checker.getSuffixedCheckers():
if name.endswith("_" + suffix):
raise base.ImplementationError(
"invalid parameter name: %s (includes optional suffix)"
% name)
def fetchPreference(db, item, user=None, repository=None, filter_id=None):
cursor = db.cursor()
cursor.execute("SELECT type FROM preferences WHERE item=%s", (item, ))
row = cursor.fetchone()
if not row:
raise base.ImplementationError("invalid preference: %s" % item)
preference_type = row[0]
arguments = [item]
where = ["item=%s"]
if preference_type in ("boolean", "integer"):
columns = ["integer"]
else:
columns = ["string"]
if user is not None and not user.isAnonymous():
arguments.append(user.id)
where.append("uid=%s OR uid IS NULL")
columns.append("uid")
else:
where.append("uid IS NULL")
if repository is not None:
arguments.append(repository.id)
where.append("repository=%s OR repository IS NULL")
columns.append("repository")
else:
where.append("repository IS NULL")
if filter_id is not None:
arguments.append(filter_id)
where.append("filter=%s OR filter IS NULL")
columns.append("filter")
else:
where.append("filter IS NULL")
query = (
"""SELECT %(columns)s
FROM userpreferences
WHERE %(where)s""" % {
"columns": ", ".join(columns),
"where": " AND ".join("(%s)" % condition
for condition in where)
})
cursor.execute(query, arguments)
rows = cursor.fetchall()
if not rows:
raise base.ImplementationError(
"invalid preference read: %s (no value found)" % item)
value = sorted(rows, key=lambda row: row[1:])[-1][0]
if preference_type == "boolean":
return bool(value)
return value
def __init__(self, parameter_types, accept_anonymous_user=False):
"""
Initialize input data type checker.
The parameter_types argument must be a dict object. See TypeChecker and
sub-classes for details on how it works. A parameter types argument of
{ "name": str,
"points": [{"x": int, "y": int }],
"what": Optional(str) }
would for instance represents an input object with two required
properties named "name" and "points", and an optional property named
"what". The "name" and "what" property values should be a strings. The
"points" property value should be an array of objects, each with two
properties named "x" and "y", whose values should be integer.
The operation's process() method would be called with the keyword
arguments "name", "points" and "what".
"""
from operation.typechecker import TypeChecker
if not type(parameter_types) is dict:
raise base.ImplementationError("invalid source type")
self.__checker = TypeChecker.make(parameter_types)
self.__accept_anonymous_user = accept_anonymous_user
def make(source):
"""
Construct a structure of TypeChecker objects.
The source argument should be a dict object, single-element list object,
a set object containing strings, or str, int or bool (the actual type
objects, not a string, integer or boolean value).
If the source argument is a dict object, per-element type checkers are
constructed by calling this function on the value of each item in the
dictionary. See DictionaryChecker for details.
If the source argument is a list object, a per-element type checker is
constructed by calling this function on the value of the single element
in the list.
If the source argument is a set object, all elements in it should be
strings, and the constructed checker verifies that the value is a string
that is a member of the set.
Otherwise the constructed checker verifies that the value is of the type
of the source argument (or, in the case of source=str, that the value's
type is either str or unicode).
"""
if isinstance(source, TypeChecker):
return source
elif isinstance(source, dict):
if (len(source) == 1 and all(key is str for key in source.keys())
and all(
isinstance(value, type) for value in source.values())):
return GenericDictionaryChecker(source)
return DictionaryChecker(source)
elif isinstance(source, list):
return ArrayChecker(source)
elif isinstance(source, set):
if all(type(x) is str for x in source):
return EnumerationChecker(source)
return VariantChecker(source)
elif source is str:
return StringChecker()
elif source is int:
return IntegerChecker()
elif source is bool:
return BooleanChecker()
try:
is_type_checker = issubclass(source, TypeChecker)
except TypeError:
pass
else:
if is_type_checker:
return source()
raise base.ImplementationError("invalid source type: %r" % source)
def __init__(self, source):
self.__checker = TypeChecker.make(str)
for item in source:
if not type(item) is str:
raise base.ImplementationError("invalid source type")
self.__enumeration = source
def __init__(self, source):
if len(source) != 1:
raise base.ImplementationError("invalid source type")
self.__checker = TypeChecker.make(source[0])
def storePreference(db,
item,
value,
user=None,
repository=None,
filter_id=None):
# A preference value can be set for either a repository or a filter, but
# not for both at the same time. A filter implies a repository anyway,
# so there would be no point.
assert repository is None or filter_id is None
assert filter_id is None or user is not None
# If all are None, we'd be deleting the global default and not setting a
# new one, which would be bad.
if value is None and user is None \
and repository is None and filter is None:
raise base.ImplementationError(
"attempted to delete global default")
if User.fetchPreference(db, item, user, repository,
filter_id) != value:
cursor = db.cursor()
arguments = [item]
where = ["item=%s"]
user_id = repository_id = None
if user is not None:
user_id = user.id
arguments.append(user_id)
where.append("uid=%s")
else:
where.append("uid IS NULL")
if repository is not None:
repository_id = repository.id
arguments.append(repository_id)
where.append("repository=%s")
else:
where.append("repository IS NULL")
if filter_id is not None:
arguments.append(filter_id)
where.append("filter=%s")
else:
where.append("filter IS NULL")
query = ("DELETE FROM userpreferences WHERE %s" %
(" AND ".join("(%s)" % condition for condition in where)))
cursor.execute(query, arguments)
if value is not None:
cursor.execute("SELECT type FROM preferences WHERE item=%s",
(item, ))
(value_type, ) = cursor.fetchone()
integer = string = None
if value_type == "boolean":
value = bool(value)
integer = int(value)
elif value_type == "integer":
integer = int(value)
else:
string = str(value)
cursor.execute(
"""INSERT INTO userpreferences (item, uid, repository, filter, integer, string)
VALUES (%s, %s, %s, %s, %s, %s)""",
(item, user_id, repository_id, filter_id, integer, string))
if user is not None:
cache_key = _preferenceCacheKey(item, repository, filter_id)
if cache_key in user.preferences:
del user.preferences[cache_key]
return True
else:
return False