Beispiel #1
0
def alter_plraum_fields():
    d = (('akte', 'planungsr'),('fachstat', 'bz'), ('strassenkat', 'Plraum'))
    for t, f in d:
        SQL('ALTER TABLE %s MODIFY %s CHAR(8)' % (t, f)).execute()
        tab = Tabelle(tabelle=t)
        f = Feld(tab_id=tab['id'], feld=f)
        f.update({'typ': 'CHAR(8)'})
        logging.info("Feldlänge auf CHAR(8) gesetzt in Tabelle %s Feld %s" % (t, f['feld']))
Beispiel #2
0
def alter_plraum_fields():
    d = (("akte", "planungsr"), ("fachstat", "bz"), ("strassenkat", "Plraum"))
    for t, f in d:
        SQL("ALTER TABLE %s MODIFY %s CHAR(8)" % (t, f)).execute()
        tab = Tabelle(tabelle=t)
        f = Feld(tab_id=tab["id"], feld=f)
        f.update({"typ": "CHAR(8)"})
        logging.info("Feldlänge auf CHAR(8) gesetzt in Tabelle %s Feld %s" % (t, f["feld"]))
Beispiel #3
0
def create_new_table():
    tables = get_schema_info(schemainfo)
    jghstat07 = [t for t in tables if t.tablename == 'jghstat07'][0]
    db = getDBHandle()
    #print jghstat07.sql_create()
    db.query(jghstat07.sql_create())
    #table_id = 32
    #field_id = 333
    table_id = Tabelle().getNewId()
    #print jghstat07.sql_insert(table_id)
    db.query(jghstat07.sql_insert(table_id))
    for f in jghstat07.fields:
        field_id = Feld().getNewId()
        #print f.sql_insert(field_id)
        db.query(f.sql_insert(field_id))
    j07 = Tabelle(tabelle='jghstat07')
    logging.info("Neue Tabelle für %s: %s" % (j07['name'], 'jghstat07'))

    if config.BERLINER_VERSION:
        merkmale = 'merkmale_berlin.py'
    else:
        merkmale = 'merkmale_standard.py'
    create_new_kategorien(jghstat07,
                          join(config.EBKUS_HOME, 'sql',
                               merkmale))
    for f in jghstat07.fields:
        fupd = Feld()
        v = Code(code=f.verwtyp, kat_code='verwtyp')
        fupd['verwtyp'] = v['id']
        if f.verwtyp in 'kb':
            kat = Kategorie(code=f.kat_code)
            fupd['kat_id'] = kat['id']
            fupd['kat_code'] = kat['code']
        if f.verwtyp in 'fk':    # kodierte Felder sind Fremdschlüssel nach code
            fupd['ftab_id'] = Tabelle(tabelle=f.ftable)['id']
            if f.verwtyp in 'f':    # Name für inverse Beziehung
                fupd['inverse'] = f.inverse
        feld = Feld(feld=f.fieldname, tab_id=j07['id'])
        feld.update(fupd)

##     site = Code(kat_code='dbsite', code=config.SITE)
##     t = TabellenID()
##     t['table_id'] = j07['id']
##     t['table_name'] = j07['tabelle']
##     t['dbsite'] = site['id']
##     t['minid'] = site['mini']
##     t['maxid'] = site['maxi']
##     t['maxist'] = 1
##     t.insert()
    return True
Beispiel #4
0
def create_new_table():
    tables = get_schema_info(schemainfo)
    jghstat07 = [t for t in tables if t.tablename == "jghstat07"][0]
    db = getDBHandle()
    # print jghstat07.sql_create()
    db.query(jghstat07.sql_create())
    # table_id = 32
    # field_id = 333
    table_id = Tabelle().getNewId()
    # print jghstat07.sql_insert(table_id)
    db.query(jghstat07.sql_insert(table_id))
    for f in jghstat07.fields:
        field_id = Feld().getNewId()
        # print f.sql_insert(field_id)
        db.query(f.sql_insert(field_id))
    j07 = Tabelle(tabelle="jghstat07")
    logging.info("Neue Tabelle für %s: %s" % (j07["name"], "jghstat07"))

    if config.BERLINER_VERSION:
        merkmale = "merkmale_berlin.py"
    else:
        merkmale = "merkmale_standard.py"
    create_new_kategorien(jghstat07, join(config.EBKUS_HOME, "sql", merkmale))
    for f in jghstat07.fields:
        fupd = Feld()
        v = Code(code=f.verwtyp, kat_code="verwtyp")
        fupd["verwtyp"] = v["id"]
        if f.verwtyp in "kb":
            kat = Kategorie(code=f.kat_code)
            fupd["kat_id"] = kat["id"]
            fupd["kat_code"] = kat["code"]
        if f.verwtyp in "fk":  # kodierte Felder sind Fremdschlüssel nach code
            fupd["ftab_id"] = Tabelle(tabelle=f.ftable)["id"]
            if f.verwtyp in "f":  # Name für inverse Beziehung
                fupd["inverse"] = f.inverse
        feld = Feld(feld=f.fieldname, tab_id=j07["id"])
        feld.update(fupd)

    site = Code(kat_code="dbsite", code=config.SITE)
    t = TabellenID()
    t["table_id"] = j07["id"]
    t["table_name"] = j07["tabelle"]
    t["dbsite"] = site["id"]
    t["minid"] = site["mini"]
    t["maxid"] = site["maxi"]
    t["maxist"] = 1
    t.insert()
    return True
Beispiel #5
0
 def update_4_0_nach_4_1(self):
     if not self.has_field('jghstat07', 'jahr'):
         SQL('ALTER TABLE jghstat07 ADD COLUMN jahr INT').execute()
         logging.info("Feld 'jahr' zur Bundesstatistik hinzugefügt")
     tab_id = Tabelle(tabelle='jghstat07')['id']
     if not FeldList(where="tab_id=%s and feld='jahr'" % tab_id):
         feld = Feld()
         feld.init(tab_id=tab_id,
                   feld='jahr',
                   name='Jahr',
                   typ='INT',
                   verwtyp=cc('verwtyp', 'p'),
                   flag=0,
             )
         feld.new()
         feld.insert()
         logging.info("Metadaten für Feld 'jahr' hinzugefügt")
     self.jahr_in_bundesstatistik()
     Kategorie(code='kr').update({
         'dok': "amtlicher Gemeindeschlüssel (AGS, Ziffer 3-5)"})
     Kategorie(code='rbz').update({
         'dok': "amtlicher Gemeindeschlüssel (AGS) obsolet, in Kreis mit drin"})
     self.kreis_dreistellig_umstellen()
     self.einrichtungsnummer_sechsstellig_umstellen()
     self.keep_alive_anpassen()
     self.strassenkatalog_reparieren()
Beispiel #6
0
 def mehrfach_joker_felder_reparieren(self):
     # werte sichern
     # auf string umstellen
     # werte schreiben
     # feld anpassen
     felder = self._get_jokf_int_felder()
     for f in felder:
         werte = SQL("SELECT id, %s FROM fachstat" % f).execute()
         SQL("ALTER TABLE fachstat MODIFY %s VARCHAR(255)" % f).execute()
         for id, val in werte:
             if val == None:
                 SQL("""UPDATE fachstat SET %s=NULL WHERE id=%s""" % (f,id)).execute()
             else:
                 val = str(val)
                 SQL("""UPDATE fachstat SET %s='%s' WHERE id=%s""" % (f,val,id)).execute()
         feld = Feld(tab_id=Tabelle(tabelle='fachstat')['id'], feld=f)
         if feld['verwtyp__code'] == 'k':
             # war single vorher, soll so bleiben, wird in flag als bit 2 kodiert
             feld.update({'flag': feld['flag']|2})
         # Trotzdem alle auf 'm' stellen, da nur so die strings im Feld
         # richtig interpretiert werden.
         feld.update({'verwtyp': cc('verwtyp', 'm')})
         logging.info("Fachstatistik Feld %s umgestellt" % f)
Beispiel #7
0
    def fua_bs_neue_tabelle_fuer_mitarbeiter_zuordnung(self):
        if 'mitarbeiterfua_bs' in self.tables:
            logging.info("Tabelle 'mitarbeiterfua_bs' existiert bereits")
            return
        try:
            SQL("""CREATE TABLE mitarbeiterfua_bs (
id int NOT NULL,
mit_id int,
fua_bs_id  int,
zeit int,
PRIMARY KEY (id)
)""").execute()

            t = Tabelle()
            t.init(
                tabelle="mitarbeiterfua_bs",
                name="Zuordnung Mitarbeiter-fallunabhängige Aktivitäten",
                klasse="Mitarbeiterfua_bs",
                flag=0,
                maxist=0
                )
            t.new()
            t.insert()
            felder = (
                ('id', 'id', None, cc('verwtyp', 's'), None,),
                ('mit_id', 'Mitarbeiterid', 'mitarbeiterfuaktivitaeten',
                 cc('verwtyp', 'f'), Tabelle(tabelle='mitarbeiter')['id']),
                ('fua_bs_id', 'Fua_bsid', 'mitarbeiterfuaktivitaeten',
                 cc('verwtyp', 'f'), Tabelle(tabelle='fua_bs')['id']),
                ('zeit', 'Änderungszeit', None, cc('verwtyp', 'p'), None),
                )
            for feld, name, inverse, verwtyp, ftab_id in felder:
                f = Feld()
                f.init(
                    tab_id=t['id'],
                    feld=feld,
                    name=name,
                    inverse=inverse,
                    typ='INT',
                    verwtyp=verwtyp,
                    ftab_id=ftab_id,
                    flag=0,
                    )
                f.new()
                f.insert()
            logging.info("Neue Tabelle 'mitarbeiterfua_bs' eingefuehrt")
        except:
            #raise
            logging.error("************ Fehler beim Anlegen der Tabelle 'mitarbeiterfua_bs'")
Beispiel #8
0
    def neue_tabelle_fuer_gemeindeschluessel(self):
        if 'ags' in self.tables:
            logging.info("Tabelle 'ags' existiert bereits")
            return
        try:
            SQL("""CREATE TABLE ags (
id int NOT NULL,
plz CHAR(5),
ags CHAR(12),
ort VARCHAR(60),
PRIMARY KEY (id),
KEY(ort(10))
)""").execute()

            t = Tabelle()
            t.init(
                tabelle="ags",
                name="Amtliche Gemeindeschlüssel",
                klasse="AGS",
                flag=0,
                maxist=0
                )
            t.new()
            t.insert()
            felder = (
                ('id', 'id', None, 'INT', cc('verwtyp', 's'), None,),
                ('plz', 'Postleitzahl', None, 'CHAR(5)', cc('verwtyp', 'p'), None,),
                ('ags', 'Gemeindeschlüssel', None, 'CHAR(12)', cc('verwtyp', 'p'), None,),
                ('ort', 'Ort', None, 'VARCHAR(60)', cc('verwtyp', 'p'), None,),
                )
            for feld, name, inverse, typ, verwtyp, ftab_id in felder:
                f = Feld()
                f.init(
                    tab_id=t['id'],
                    feld=feld,
                    name=name,
                    inverse=inverse,
                    typ=typ,
                    verwtyp=verwtyp,
                    ftab_id=ftab_id,
                    flag=0,
                    )
                f.new()
                f.insert()
            logging.info("Neue Tabelle 'ags' fuer Gemeindeschluessel eingefuehrt")
        except:
            #raise
            logging.error("************ Fehler beim Anlegen der Tabelle 'ags'")
Beispiel #9
0
 def add_mail_fields_to_akte_bezugsperson(self):
     tabellen = ('akte', 'bezugsperson', 'einrichtung')
     for tn in tabellen:
         SQL("ALTER TABLE %s ADD mail VARCHAR(80)" % tn).execute()
         t = Tabelle(tabelle=tn)
         f = Feld()
         f.init(
             tab_id=t['id'],
             feld='mail',
             name='E-Mail',
             inverse=None,
             typ='VARCHAR(80)',
             verwtyp=cc('verwtyp', 'p'),
             ftab_id=None,
             flag=0,
             )
         f.new()
         f.insert()
         logging.info("Feld 'mail' fuer Tabelle '%s' eingefuehrt" % t['tabelle'])
Beispiel #10
0
 def add_field_to_register(self):
     SQL("ALTER TABLE register ADD valuestr TEXT").execute()
     t = Tabelle(tabelle='register')
     f = Feld()
     f.init(
         tab_id=t['id'],
         feld='valuestr',
         name='Wert als String',
         inverse=None,
         typ='TEXT',
         verwtyp=cc('verwtyp', 'p'),
         ftab_id=None,
         flag=0,
         )
     f.new()
     f.insert()
     # Nicht unbedingt nötig, aber es ist klarer, wenn das Feld künftig leer ist.
     SQL("UPDATE register set value=NULL,valuestr='%s' where regkey='Version'" % self.ist_db).execute()
     logging.info("Feld 'valuestr' fuer Tabelle 'register' eingefuehrt")