# SPDX-License-Identifier: WTFPL """ No commits here: Has to be done elsewhere to support transactions! Fields has to be a tuple to have fixed order which simplifies debugging TODO primary keys can be multiple fields, stored as tuple do not include pk auto fields in inserts and updates! """ from datetime import datetime class DbRecord: REQUIRED = ('table', 'pk_field', 'pk_is_auto', 'fields') def __init_subclass__(cls, **kwargs): for variable in DbRecord.REQUIRED: if variable not in cls.__dict__: raise TypeError(f"{cls.__name__} subclass must define '{variable}'") def __init__(self, db, record_id=None): self.db = db self.cur = db.cur self.dcur = db.dcur self.conn = db.conn self.last_update = None self._title = _("DbRecord({})") # for pretty print self.pk_value = None if record_id is not None: self.pk_value = int(record_id) self.load() else: self.clear() def clear(self): self.pk_value = None self.data = {} # for old/new checks for field in self.fields: setattr(self, field, None) self.data[field] = None def load(self, record_id=None): if record_id is not None: self.pk_value = int(record_id) if self.pk_value is None: self.clear() return sql = ("SELECT {} FROM {} WHERE {}=%s").format(', '.join(self.fields), self.table, self.pk_field) try: self.dcur.execute(sql, (self.pk_value,)) self.data = self.dcur.fetchone() except Exception as e: print(e) print(sql) self.db.error = e self.clear() return False if self.data: for field, value in self.data.items(): setattr(self, field, value) return True else: self.clear() return False def save(self, rev_id=None): self.last_update = datetime.now() if self.pk_value is not None: ret = self._update() else: ret = self._insert() if ret == True and rev_id is not None: # set list change marker sql = ( "INSERT INTO revision (revtype, revid, changed) " "VALUES ('table', %s, NOW()) " "ON DUPLICATE KEY UPDATE changed = NOW()" ) self.cur.execute(sql, (rev_id,)) return ret def _update(self): sqlfield = [] values = [] if self.pk_is_auto: if type(self.pk_field) == tuple: flist = set(self.fields) - set(self.pk_field) else: flist = set(self.fields) - {self.pk_field} else: flist = self.fields for field in flist: newdata = getattr(self, field) if self.data[field] != newdata: sqlfield.append("{}=%s".format(field)) values.append(newdata) if values: # only save if there are changes sql = ( f"UPDATE {self.table} SET " + ",".join(sqlfield) + f" WHERE {self.pk_field}=%s" ) values.append(self.pk_value) try: self.cur.execute(sql, values) except Exception as e: print(e) print(sql) print(values) self.db.error = e return False for field in self.fields: self.data[field] = getattr(self, field) return True def _insert(self): if self.pk_is_auto: if type(self.pk_field) == tuple: flist = set(self.fields) - set(self.pk_field) else: flist = set(self.fields) - {self.pk_field} else: flist = self.fields sql = ( "INSERT INTO {} ({}) " "VALUES ({})" ).format( self.table, ','.join(flist), ','.join(["%s"] * len(flist)) ) values = [] for field in flist: newdata = getattr(self, field) values.append(newdata) self.data[field] = newdata try: self.cur.execute(sql, values) except Exception as e: print(e) print(sql) print(values) self.db.error = e return False self.pk_value = self.cur.lastrowid setattr(self, self.pk_field, self.pk_value) return True def delete(self, record_id=None): if record_id is None: if self.pk_value is None: return False record_id = self.pk_value sql = "DELETE FROM {} WHERE {}=%s".format(self.table, self.pk_field) try: self.dcur.execute(sql, (record_id,)) except Exception as e: print(e) print(sql) self.db.error = e return False if self.dcur.rowcount != 1: return False if self.pk_value == record_id: self.pk_value = None self.clear() return True def __str__(self): out = [self._title.format(self.pk_value)] for field in self.fields: value = getattr(self, field, None) oldvalue = self.data[field] if value != oldvalue: out.append(" {:15}: {} ({})".format(field, value, oldvalue)) else: out.append(" {:15}: {}".format(field, value)) return "\n".join(out)