1 files changed, 177 insertions, 0 deletions

diff --git a/kronos/storage.py b/kronos/storage.py
new file mode 100644
index 0000000..4add988
--- /dev/null
+++ b/kronos/storage.py
@@ -0,0 +1,177 @@
+# vim: set filencoding=utf8
+"""
+Storage Back-ends For Kronos
+
+@author: Mike Crute (mcrute@ag.com)
+@organization: American Greetings Interactive
+@date: February 04, 2010
+"""
+
+
+class StorageError(Exception):
+    """
+    Base class for all other storage exceptions.
+    """
+
+
+class NotConnected(StorageError):
+    """
+    Raised when a connection to the back-end is not avaiable.
+    """
+
+
+def _get_filtered_object_dict(dict_):
+    output = {}
+    for key, value in dict_.__dict__.items():
+        if not key.startswith('_') and not callable(value):
+            output[key] = value
+
+    return output
+
+
+class BaseStorageBackEnd(object):
+
+    def __init__(self):
+        self.load_engine()
+
+    def get(self, model_obj, **kwargs):
+        """
+        Get a model object instance from the storage back-end
+        where the criteria in the kwargs matches that in the
+        back-end.
+        """
+        name = model_obj.__name__
+        result = self.select(name, **kwargs)
+
+        instance = model_obj()
+        for key, value in result.items():
+            if key != 'id':
+                setattr(instance, key, value)
+            else:
+                instance.__db_id__ = value
+
+        return instance
+
+    def save(self, model_obj):
+        """
+        Persist a model object with the storage back-end.
+        """
+        name = model_obj.__class__.__name__
+        id_ = getattr(model_obj, '__db_id__', None)
+
+        values = _get_filtered_object_dict(model_obj)
+
+        if id_:
+            self.update(name, id_, **values)
+        else:
+            self.insert(name, **values)
+
+    def load_engine(self):
+        """
+        Load a storage engine module that contains a function
+        called connect suitable for setting up the actual
+        connection.
+        """
+
+    def select(self, table, **kwargs):
+        """
+        Select raw data from the storage engine and return
+        as a dictionary.
+        """
+
+    def insert(self, table, **values):
+        """
+        Insert values into the back-end named table or
+        equivalent data structure.
+        """
+
+    def update(self, table, criteria, **values):
+        """
+        Update values in the back-end table or equivalent
+        data structure based on the criteria.
+        """
+
+    def connect(self, database, *args, **kwargs):
+        """
+        Create a connection to the back-end.
+        """
+
+    def create_table(self, obj, **columns):
+        """
+        Create a table or equivalent data structure in the
+        storage back-end.
+        """
+
+
+class SQLiteBackEnd(BaseStorageBackEnd):
+
+    def __init__(self):
+        super(SQLiteBackEnd, self).__init__()
+        self.connection = None
+
+    def load_engine(self):
+        import sqlite3
+        self.engine = sqlite3
+
+    def _check_connection(self):
+        if not self.connection:
+            raise NotConnected("Not connected to storage back-end!")
+
+    def connect(self, database, *args, **kwargs):
+        self.connection = self.engine.connect(database)
+
+    def select(self, table, **kwargs):
+        sql = "SELECT * FROM {0} WHERE ".format(table)
+        for key in kwargs.keys():
+            sql += "{0}=? ".format(key)
+
+        return self._get_normalized_results(sql, **kwargs)[0]
+
+    def _get_normalized_results(self, sql, **kwargs):
+        self._check_connection()
+        cursor = self.connection.cursor()
+
+        results = cursor.execute(sql, kwargs.values())
+        return self._normalize_results(results)
+
+    def _normalize_results(self, results):
+        col_names = [col[0] for col in results.description]
+        output = []
+        for row in results.fetchall():
+            output.append(dict(zip(col_names, row)))
+
+        return output
+
+    def insert(self, table, **values):
+        placeholder = ("?," * len(values)).rstrip(',')
+        col_spec = ','.join(values.keys())
+        sql = "INSERT INTO {0}({1}) VALUES({2})".format(table, col_spec,
+                                                        placeholder)
+
+        self._execute_modification(sql, values.values())
+
+    def update(self, table, criteria, **values):
+        sql = "UPDATE {0} SET ".format(table)
+        for key in values.keys():
+            sql += "{0}=?, ".format(key)
+        sql = sql[:-2] + "WHERE id=?"
+
+        binds = values.values() + [criteria]
+        self._execute_modification(sql, binds)
+
+    def create_table(self, obj, **columns):
+        table = obj.__name__
+
+        sql = "CREATE TABLE {0} (".format(table)
+        sql += "id INTEGER PRIMARY KEY"
+        for key, value in columns.items():
+            sql += ", {0} {1}".format(key, value)
+        sql += ")"
+
+        self._execute_modification(sql)
+
+    def _execute_modification(self, sql, binds=()):
+        self._check_connection()
+        cursor = self.connection.cursor()
+        cursor.execute(sql, binds)
+        self.connection.commit()