rattail-project/rattail Changeset

Changeset - d46ae258fc4e

Parent rev.

Child rev.

[Not reviewed]

0 3 0

Lance Edgar (lance) - 12 years ago 2012-04-10 22:25:32
lance@edbob.org

save point

3 files changed with 120 insertions and 63 deletions:

rattail/batches.py

rattail/db.py

rattail/model.py

0 comments (0 inline, 0 general)

rattail/batches.py

➞

Show inline comments

@@ @@ -144,15 +144,20 @@ class RattailBatchTerminal(BatchTerminal): @@
             'F01',
             'F02',
             ],
+        }
     target_columns = {
         'DEPT_DCT': [
             'F03',
             'F238',
             ],
         'ITEM_DCT': [
             'F01',
             'F02',
             'F155',
             ],
+        }
     # def import_main_item(self, session, elements=None, progress_factory=None):
     #     """
     #     Create a main item (ITEM_DCT) batch from current Rattail data.
@@ @@ -175,28 +180,59 @@ class RattailBatchTerminal(BatchTerminal): @@
     #             prog.update(i)
     #     if prog:
     #         prog.destroy()
     #     return batch
     def execute_batch(self, batch):
         """
         Executes ``batch``, which should be a :class:`rattail.Batch` instance.
         """
     def add_departments(self, session, batch):
         for row in batch.provide_rows():
             dept = rattail.Department()
             dept.number = row.F03
             dept.name = row.F238
             session.add(dept)
             session.flush()
         assert batch.action_type == rattail.BATCH_ADD
         assert batch.dictionary.name == 'ITEM_DCT'
     def add_products(self, session, batch):
         q = session.query(rattail.Brand)
         brands = {}
         for brand in q:
             brands[brand.name] = brand
         session = object_session(batch)
         for row in batch.provide_rows():
             if row.F155 in brands:
                 brand = brands[row.F155]
             else:
                 brand = rattail.Brand(name=row.F155)
                 session.add(brand)
                 session.flush()
                 brands[brand.name] = brand
             prod = rattail.Product()
             prod.upc = row.F01
             prod.description = row.F02
             prod.brand = brand
             session.add(prod)
             session.flush()
     def execute_batch(self, batch):
         """
         Executes ``batch``, which should be a :class:`rattail.Batch` instance.
         """
         session = object_session(batch)
         if batch.action_type == rattail.BATCH_ADD:
             if batch.dictionary.name == 'DEPT_DCT':
                 self.add_departments(session, batch)
                 return
             if batch.dictionary.name == 'ITEM_DCT':
                 self.add_products(session, batch)
                 return
         assert False, "FIXME"
 # def make_batch(source, elements, session, batch_id=None, **kwargs):
 #     """
 #     Create and return a new SIL-based :class:`rattail.Batch` instance.
 #     """

rattail/db.py

➞

Show inline comments

@@ @@ -38,30 +38,37 @@ def init_database(session): @@
     activate_extension('rattail', session.bind)
     columns = [
         ('F01',         'UPC',                  'GPC(14)'),
         ('F02',         'Description',          'CHAR(20)'),
         ('F03',         'Department Number',    'NUMBER(4,0)'),
         ('F155',        'Brand',                'CHAR(30)'),
         ('F238',        'Department Name',      'CHAR(30)'),
+        ]
     for name, disp, dtype in columns:
         session.add(rattail.SilColumn(
                 sil_name=name, display=disp, data_type=dtype))
         session.flush()
     dictionaries = [
         # ('CLASS_GROUP', 'Scale Class / Group', []),
         # ('DEPT_DCT', 'Department', []),
         # ('FCOST_DCT', 'Future Cost', []),
         # ('FSPRICE_DCT', 'Future Sale Price', []),
         ('DEPT_DCT', 'Department', [
                 ('F03', True),
                 'F238',
                 ]),
         ('ITEM_DCT', 'Product', [
                 ('F01', True),
                 'F02',
                 'F155',
                 ]),
         # ('NUTRITION', 'Scale Nutrition', []),
         # ('PRICE_DCT', 'Price', []),
         # ('FCOST_DCT', 'Future Cost', []),
         # ('FSPRICE_DCT', 'Future Sale Price', []),
         # ('CLASS_GROUP', 'Scale Class / Group', []),
         # ('NUTRITION', 'Scale Nutrition', []),
         # ('SCALE_TEXT', 'Scale Text', []),
         # ('VENDOR_DCT', 'Vendor', []),
+        ]
     for name, desc, cols in dictionaries:
         bd = rattail.BatchDictionary(name=name, description=desc)
@@ @@ -70,9 +77,9 @@ def init_database(session): @@
             if not isinstance(col, basestring):
                 col, key = col
             q = session.query(rattail.SilColumn)
             q = q.filter(rattail.SilColumn.sil_name == col)
             col = q.one()
             bd.columns.append(
-                rattail.BatchDictionaryColumn(column=col, key=key))
+                rattail.BatchDictionaryColumn(sil_column=col, key=key))
         session.add(bd)
         session.flush()

rattail/model.py

➞

Show inline comments

@@ @@ -26,24 +26,24 @@ @@
 ``rattail.db.extension.model`` -- Schema Definition
 """
 import re
 from sqlalchemy import (Column, String, Integer, Date, DateTime,
                         Boolean, Text, ForeignKey, BigInteger)
+                        Boolean, Text, ForeignKey, BigInteger, Numeric)
 from sqlalchemy.orm import relationship, object_session
 import edbob
 from edbob.db.model import Base, uuid_column
 __all__ = ['SilColumn', 'BatchDictionaryColumn', 'BatchDictionary',
            'BatchTerminalSourceColumn', 'BatchTerminalTargetColumn',
            'BatchTerminal', 'BatchColumn', 'Batch', 'Brand', 'Product']
            'BatchTerminalColumn', 'BatchTerminal', 'BatchColumn',
            'Batch', 'Brand', 'Department', 'Product']
 sil_type_pattern = re.compile(r'^(CHAR)\((\d+)\)$')
+sil_type_pattern = re.compile(r'^(CHAR|NUMBER)\((\d+(?:\,\d+)?)\)$')
 class SilColumn(Base):
     """
     Represents a SIL-compatible column available to the batch system.
     """
@@ @@ -68,22 +68,22 @@ class BatchDictionaryColumn(Base): @@
     """
     __tablename__ = 'batch_dictionary_columns'
     uuid = uuid_column()
     dictionary_uuid = Column(String(32), ForeignKey('batch_dictionaries.uuid'))
-    column_uuid = Column(String(32), ForeignKey('sil_columns.uuid'))
+    sil_column_uuid = Column(String(32), ForeignKey('sil_columns.uuid'))
     key = Column(Boolean)
-    column = relationship(SilColumn)
+    sil_column = relationship(SilColumn)
     def __repr__(self):
-        return "<BatchDictionaryColumn: %s>" % self.column
+        return "<BatchDictionaryColumn: %s>" % self.sil_column
     def __str__(self):
-        return str(self.column or '')
+        return str(self.sil_column or '')
 class BatchDictionary(Base):
     """
     Represents a SIL-based dictionary supported by one or more
     :class:`BatchTerminal` classes.
@@ @@ -103,58 +103,36 @@ class BatchDictionary(Base): @@
         return "<BatchDictionary: %s>" % self.name
     def __str__(self):
         return str(self.description or '')
-class BatchTerminalSourceColumn(Base):
+class BatchTerminalColumn(Base):
     """
-    Represents a "source column" supported by a :class:`BatchTerminal`.
     Represents a column supported by a :class:`BatchTerminal`.
     """
-    __tablename__ = 'batch_terminal_source_columns'
+    __tablename__ = 'batch_terminal_columns'
     uuid = uuid_column()
     terminal_uuid = Column(String(32), ForeignKey('batch_terminals.uuid'))
     dictionary_uuid = Column(String(32), ForeignKey('batch_dictionaries.uuid'))
     column_uuid = Column(String(32), ForeignKey('sil_columns.uuid'))
     ordinal = Column(Integer)
     dictionary = relationship(BatchDictionary)
     column = relationship(SilColumn)
     def __repr__(self):
         return "<BatchTerminalSourceColumn: %s, %s, %s>" % (
             self.terminal, self.dictionary, self.name)
     def __str__(self):
         return str(self.name or '')
 class BatchTerminalTargetColumn(Base):
     """
     Represents a "target column" supported by a :class:`BatchTerminal`.
     """
     __tablename__ = 'batch_terminal_target_columns'
     uuid = uuid_column()
     terminal_uuid = Column(String(32), ForeignKey('batch_terminals.uuid'))
     dictionary_uuid = Column(String(32), ForeignKey('batch_dictionaries.uuid'))
     column_uuid = Column(String(32), ForeignKey('sil_columns.uuid'))
     sil_column_uuid = Column(String(32), ForeignKey('sil_columns.uuid'))
     ordinal = Column(Integer)
     source = Column(Boolean)
     target = Column(Boolean)
     dictionary = relationship(BatchDictionary)
-    column = relationship(SilColumn)
+    sil_column = relationship(SilColumn)
     def __repr__(self):
         return "<BatchTerminalTargetColumn: %s, %s, %s>" % (
             self.terminal, self.dictionary, self.name)
         return "<BatchTerminalColumn: %s, %s, %s>" % (
             self.terminal, self.dictionary, self.sil_column)
     def __str__(self):
-        return str(self.name or '')
+        return str(self.sil_column or '')
 class BatchTerminal(Base):
     """
     Represents a terminal, or "junction" for batch data.
     """
@@ @@ -168,27 +146,29 @@ class BatchTerminal(Base): @@
     functional = Column(Boolean, default=False)
     source = Column(Boolean)
     target = Column(Boolean)
     source_kwargs = Column(Text)
     target_kwargs = Column(Text)
     source_columns = relationship(
         BatchTerminalSourceColumn,
         backref='terminal')
     target_columns = relationship(
         BatchTerminalTargetColumn,
     columns = relationship(
         BatchTerminalColumn,
         backref='terminal')
     _terminal = 'not_got_yet'
     def __repr__(self):
         return "<BatchTerminal: %s>" % self.sil_id
     def __str__(self):
         return str(self.description or '')
     def source_columns(self, dictionary):
         for col in self.columns:
             if col.dictionary is dictionary:
                 yield col
     def get_terminal(self):
         """
         Returns the :class:`rattail.batches.BatchTerminal` instance which is
         associated with the database record via its ``python_spec`` field.
         """
@@ @@ -208,26 +188,26 @@ class BatchColumn(Base): @@
     __tablename__ = 'batch_columns'
     uuid = uuid_column()
     batch_uuid = Column(String(32), ForeignKey('batches.uuid'))
     ordinal = Column(Integer)
-    column_uuid = Column(String(32), ForeignKey('sil_columns.uuid'))
+    sil_column_uuid = Column(String(32), ForeignKey('sil_columns.uuid'))
     source_uuid = Column(String(32), ForeignKey('batch_terminals.uuid'))
     targeted = Column(Boolean)
-    column = relationship(SilColumn)
+    sil_column = relationship(SilColumn)
     source = relationship(
         BatchTerminal,
         primaryjoin=BatchTerminal.uuid == source_uuid,
         order_by=[BatchTerminal.description],
+        )
     def __repr__(self):
-        return "<BatchColumn: %s, %s>" % (self.batch, self.column)
+        return "<BatchColumn: %s, %s>" % (self.batch, self.sil_column)
 # def get_sil_column(name):
 #     """
 #     Returns a ``sqlalchemy.Column`` instance according to Rattail's notion of
 #     what each SIL field ought to look like.
@@ @@ -262,14 +242,24 @@ def get_sil_type(data_type): @@
     if data_type == 'GPC(14)':
         return BigInteger
     m = sil_type_pattern.match(data_type)
     if m:
         data_type, precision = m.groups()
         if precision.isdigit():
             precision = int(precision)
             scale = 0
         else:
             precision, scale = precision.split(',')
             precision = int(precision)
             scale = int(scale)
         if data_type == 'CHAR':
             return String(int(precision))
             assert not scale, "FIXME"
             return String(precision)
         if data_type == 'NUMBER':
             return Numeric(precision, scale)
     assert False, "FIXME"
 class Batch(Base):
     """
@@ @@ -415,13 +405,13 @@ class Batch(Base): @@
         if self.uuid not in self._row_classes:
             kwargs = {
                 '__tablename__':        'batch.%s' % self.name,
                 'uuid':                 uuid_column(),
+                }
             for col in self.columns:
-                kwargs[col.column.sil_name] = Column(get_sil_type(col.column.data_type))
+                kwargs[col.sil_column.sil_name] = Column(get_sil_type(col.sil_column.data_type))
             self._row_classes[self.uuid] = type('BatchRow', (Base,), kwargs)
         return self._row_classes[self.uuid]
     def create_table(self):
         """
         Creates the batch's data table within the database.
@@ @@ -509,12 +499,36 @@ class Brand(Base): @@
     __tablename__ = 'brands'
     uuid = uuid_column()
     name = Column(String(100))
     def __repr__(self):
         return "<Brand: %s>" % self.name
     def __str__(self):
         return str(self.name or '')
 class Department(Base):
     """
     Represents an organizational department.
     """
     __tablename__ = 'departments'
     uuid = uuid_column()
     number = Column(Integer)
     name = Column(String(30))
     def __repr__(self):
         return "<Department: %s>" % self.name
     def __str__(self):
         return str(self.name)
 class Product(Base):
     """
     Represents a product for sale and/or purchase.
     """

0 comments (0 inline, 0 general)