Imported sources from code.google.com (w/o history)

Author: dotz

MANIFEST.in

@@ -0,0 +1,2 @@
+recursive-include datable *
+recursive-exclude test_project *

README.txt

@@ -0,0 +1,31 @@
+
+WARNING: this file is wildly outdated
+
+=dojango-datable=
+
+==What is it?==
+
+Dojango Data Tables allows you to define table layout and column types in
+Python instead of JS or HTML. It also includes a few template tags to create
+HTML required for the dojo.DataGrid in a configurable manner.
+
+It can also be used to generate a XLS file or CSV file out of displayed information,
+so you can either use it as a web UI widget or a XLS generator with Django and Dojango,
+or both. First, show a nice, scrollable table to the user, then let him/her download
+the data in preferred format.
+
+dojango-datable requires [http://code.google.com/p/dojango/ dojango] and [http://www.python-excel.org/ xlwt].
+
+==Installation==
+
+{{{
+$ pip install svn+http://dojango-datable.googlecode.com/svn/trunk/
+}}}
+
+
+== TODO ==
+
+6) save state of all filters
+7) save sort order of the table
+8) optional on-off columns
+9) minimal example for contrib.auth for the docs

datable/__init__.py

@@ -0,0 +1 @@
+version = "0.9.3"

datable/core/__init__.py

@@ -0,0 +1,7 @@
+"""Core, abstract classess
+"""
+
+from datable.core.filters import *
+from datable.core.serializers import *
+from datable.core.converters import *
+from datable.core import formats

datable/core/converters.py

@@ -0,0 +1,121 @@
+from iso8601 import parse_date
+from datetime import date
+
+class JSValueConverter:
+    """I convert values from and to JavaScript, both sides."""
+
+    def __init__(self, jsName):
+        self.jsName = jsName
+
+    def existsIn(self, requestDict):
+        if self.jsName in requestDict:
+            return True
+        return False
+
+    def valueFromJS(self, requestDict):
+        value = requestDict.get(self.jsName, None)
+        if value is None:
+            return None
+
+        return self.convertFromJS(safe_value=value)
+
+    def valueToJS(self, value):
+        if value is not None:
+            return self.convertToJS(value)
+        return None
+
+    def convertFromJS(self, safe_value):
+        raise NotImplementedError
+
+    def convertToJS(self, safe_value):
+        raise NotImplementedError
+
+
+class StringValueConverter(JSValueConverter):
+    def convertFromJS(self, safe_value):
+        return safe_value
+
+    def convertToJS(self, safe_value):
+        return unicode(safe_value)
+
+
+class DojoComboValueConverter(StringValueConverter):
+    def convertFromJS(self, safe_value):
+        if not safe_value:
+            return None
+
+        if safe_value[-1] == '*':
+            return safe_value[:-1]
+        return safe_value
+
+
+class DateTimeValueConverter(JSValueConverter):
+    timezone = None
+    
+    def convertToJS(self, safe_value):
+        return safe_value.isoformat()
+
+    def convertFromJS(self, safe_value):
+        return parse_date(safe_value, self.timezone)
+
+
+class DateValueConverter(JSValueConverter):
+    def convertToJS(self, safe_value):
+        return safe_value.strftime("%Y-%m-%d")
+
+    def convertFromJS(self, safe_value):
+        try:
+            y, m, d = safe_value.split('-', 2)
+        except ValueError:
+            return None
+
+        try:
+            y = int(y)
+            m = int(m)
+            d = int(d)
+        except (TypeError, ValueError):
+            return None
+
+        return date(y, m, d)
+
+
+class BooleanConverter(JSValueConverter):
+    def convertFromJS(self, safe_value):
+        if safe_value == 'true':
+            return True
+        return False
+
+    def convertToJS(self, safe_value):
+        if safe_value:
+            return 'true'
+
+        if safe_value is None:
+            return 'null'
+
+        return 'false'
+
+
+class IntegerConverter(JSValueConverter):
+    def __init__(self, jsName, max=None, min=None):
+        JSValueConverter.__init__(self, jsName)
+        self.min = min
+        self.max = max
+
+    def convertFromJS(self, safe_value):
+        try:
+            i = int(safe_value)
+        except (TypeError, ValueError):
+            return None
+
+        if self.min is not None:
+            if i < self.min:
+                return None
+
+        if self.max is not None:
+            if i > self.max:
+                return None
+
+        return i
+
+    def convertToJS(self, safe_value):
+        return str(safe_value)

datable/core/filters.py

@@ -0,0 +1,93 @@
+from datetime import date
+from datetime import datetime
+
+
+class NoFilter:
+    def __init__(self, field, operation=None):
+        pass
+
+    def filterQuerySet(self, querySet, value):
+        return querySet
+
+class SimpleFilter:
+    """This is an object, which is able to filter a QuerySet
+    using an operation. It also performs a 'cleaning' operation
+    on the input value (the filter parameter).
+    """
+
+    operation = "eq"
+
+    def __init__(self, field, operation=None):
+        self.field = field
+
+        if operation is not None:
+            self.operation = operation
+
+    def clean(self, value):
+        """By default, we just return this value"""
+        return value
+
+    def filterQuerySet(self, querySet, value):
+        """This modifies a QuerySet by filtering it, or just returns
+        it in case there are no modifications. The value has not
+        been cleaned yet!"""
+
+        if value is None:
+            return querySet
+
+        safe_value = self.clean(value)
+
+        if safe_value is None:
+            return querySet
+
+        return self.enabled(querySet, safe_value)
+
+    def enabled(self, querySet, safe_value):
+        """The filter is enabled -- we don't check anything at this point,
+        we just want to do the filtering right now. Value has been checked
+        to be safe & properly fomatted so we can just blindly filter
+        the query set here.
+        """
+
+        fn = self.field
+        if self.operation != "eq":
+            fn = self.field + "__" + self.operation
+
+        kw = {fn: safe_value}
+        return querySet.filter(**kw)
+
+
+class TypedFilter(SimpleFilter):
+    allowedTypes = None
+
+    def __init__(self, field, allowedTypes=None, *args, **kw):
+        SimpleFilter.__init__(self, field, *args, **kw)
+
+        if allowedTypes is not None:
+            self.allowedTypes = allowedTypes
+
+    def clean(self, value):
+        if type(value) not in self.allowedTypes:
+            err = "Type %r not supported by this filter" % type(value)
+            raise TypeError(err)
+
+        return value
+
+
+class IntegerFilter(TypedFilter):
+    allowedTypes = [int]
+
+class StringFilter(TypedFilter):
+    allowedTypes = [unicode, str]
+
+
+class DateTimeFilter(TypedFilter):
+    allowedTypes = [datetime, date]
+
+
+class DateFilter(TypedFilter):
+    allowedTypes = [date]
+
+
+class BooleanFilter(TypedFilter):
+    allowedTypes = [bool]

datable/core/formats.py

@@ -0,0 +1,28 @@
+JSON = 0
+XLS = 1
+CSV = 2
+HTML = 3
+
+_extensions = {
+    XLS: 'xls',
+    CSV: 'csv',
+    HTML: 'html'
+}
+
+
+_mimetypes = {
+    XLS: 'application/vnd.ms-excel',
+    CSV: 'text/csv',
+    HTML: 'text/html'
+}
+
+class UnknownFormat(Exception):
+    pass
+
+
+def getExtension(output):
+    return _extensions.get(output)
+
+
+def getMimetype(output):
+    return _mimetypes.get(output)