#!/usr/env/bin python3 import json import datetime import re import pytz import psycopg2 as pg import psycopg2.extras as pge from django.core.management.base import BaseCommand from django.core.management import call_command from django.db import transaction from django.core.exceptions import ValidationError from django.utils.timezone import make_aware from django.db import IntegrityError from django.contrib.auth.models import User from activity.models import ActivityType, Activity, Guest, Entry, GuestTransaction from note.models import Note from note.models import Alias from note.models import ( TemplateCategory, TransactionTemplate, Transaction, RecurrentTransaction, MembershipTransaction, SpecialTransaction, ) from member.models import Club, Membership from treasury.models import RemittanceType, Remittance, SpecialTransactionProxy """ Script d'import de la nk15: TODO: import transactions TODO: import adhesion TODO: import activite TODO: import ... """ M_DURATION = 396 M_START = datetime.date(2019, 8, 31) M_END = datetime.date(2020, 9, 30) MAP_IDBDE = { -4: 2, # Carte Bancaire -3: 4, # Virement -2: 1, # Especes -1: 3, # Chèque 0: 5, # BDE } MAP_IDACTIVITY = {} MAP_NAMEACTIVITY = {} MAP_NAMEGUEST = {} MAP_IDSPECIALTRANSACTION = {} def update_line(n, total, content): n = str(n) total = str(total) n.rjust(len(total)) print(f"\r ({n}/{total}) {content:10.10}", end="") @transaction.atomic def import_comptes(cur): cur.execute("SELECT * FROM comptes WHERE idbde > 0 ORDER BY idbde;") pkclub = 3 n = cur.rowcount for idx, row in enumerate(cur): update_line(idx, n, row["pseudo"]) if row["type"] == "personne": # sanitize password if row["passwd"] != "*|*" and not row["deleted"]: passwd_nk15 = "$".join(["custom_nk15", "1", row["passwd"]]) else: passwd_nk15 = '' try: obj_dict = { "username": row["pseudo"], "password": passwd_nk15, "first_name": row["nom"], "last_name": row["prenom"], "email": row["mail"], "is_active": True, # temporary } user = User.objects.create(**obj_dict) profile = user.profile profile.phone_number = row['tel'] profile.address = row['adresse'] profile.paid = row['normalien'] profile.registration_valid = True profile.email_confirmed = True user.save() profile.save() # sanitize duplicate aliases (nk12) except ValidationError as e: if e.code == 'same_alias': user.username = row["pseudo"] + str(row["idbde"]) user.save() else: raise e # profile and note created via signal. note = user.note date = row.get("last_negatif", None) if date is not None: note.last_negative = make_aware(date) note.balance = row["solde"] note.save() else: # club obj_dict = { "pk": pkclub, "name": row["pseudo"], "email": row["mail"], "membership_duration": M_DURATION, "membership_start": M_START, "membership_end": M_END, "membership_fee_paid": 0, "membership_fee_unpaid": 0, } club, c = Club.objects.get_or_create(**obj_dict) pkclub += 1 note = club.note note.balance = row["solde"] club.save() note.save() MAP_IDBDE[row["idbde"]] = note.note_ptr_id @transaction.atomic def import_boutons(cur): cur.execute("SELECT * FROM boutons;") n = cur.rowcount for idx, row in enumerate(cur): update_line(idx, n, row["label"]) cat, created = TemplateCategory.objects.get_or_create(name=row["categorie"]) if created: cat.save() obj_dict = { "pk": row["id"], "name": row["label"], "amount": row["montant"], "destination_id": MAP_IDBDE[row["destinataire"]], "category": cat, "display": row["affiche"], "description": row["description"], } try: with transaction.atomic(): # required for error management button = TransactionTemplate.objects.create(**obj_dict) except IntegrityError as e: # button with the same name is not possible in NK20. if "unique" in e.args[0]: qs = Club.objects.filter(note__note_ptr=MAP_IDBDE[row["destinataire"]]).values('name') note_name = qs[0]["name"] # rename button name obj_dict["name"] = f"{obj_dict_name['name']} {note_name}" button = TransactionTemplate.objects.create(**obj_dict) else: raise e button.save() @transaction.atomic def import_transaction(cur): idmin = 58770 bde = Club.objects.get(name="BDE") kfet = Club.objects.get(name="Kfet") cur.execute( "SELECT t.date AS transac_date, t.type, t.emetteur,\ t.destinataire,t.quantite, t.montant, t.description,\ t.valide, t.cantinvalidate, t.categorie, \ a.idbde, a.annee, a.wei, a.date AS adh_date, a.section\ FROM transactions AS t \ LEFT JOIN adhesions AS a ON t.id = a.idtransaction \ WHERE t.id> {} \ ORDER BY t.id;".format(idmin) ) n = cur.rowcount for idx, row in enumerate(cur): update_line(idx, n, row["description"]) try: date = make_aware(row["transac_date"]) except (pytz.NonExistentTimeError, pytz.AmbiguousTimeError): date = make_aware(row["transac_date"] + datetime.timedelta(hours=1)) # standart transaction object obj_dict = { # "pk": row["id"], "destination_id": MAP_IDBDE[row["destinataire"]], "source_id": MAP_IDBDE[row["emetteur"]], "created_at": date, "amount": row["montant"], "quantity": row["quantite"], "reason": row["description"], "valid": row["valide"], } ttype = row["type"] if ttype == "don" or ttype == "transfert": Transaction.objects.create(**obj_dict) elif ttype == "bouton": cat_name = row["categorie"] if cat_name is None: cat_name = 'None' cat, created = TemplateCategory.objects.get_or_create(name=cat_name) if created: cat.save() obj_dict["category"] = cat RecurrentTransaction.objects.create(**obj_dict) elif ttype == "crédit" or ttype == "retrait": field_id = "source_id" if ttype == "crédit" else "destination_id" if "espèce" in row["description"]: obj_dict[field_id] = 1 elif "carte" in row["description"]: obj_dict[field_id] = 2 elif "cheques" in row["description"]: obj_dict[field_id] = 3 elif "virement" in row["description"]: obj_dict[field_id] = 4 pk = max(row["destinataire"], row["emetteur"]) actor = Note.objects.get(id=MAP_IDBDE[pk]) # custom fields of SpecialTransaction if actor.__class__.__name__ == "NoteUser": obj_dict["first_name"] = actor.user.first_name obj_dict["last_name"] = actor.user.last_name elif actor.__class__.__name__ == "NoteClub": obj_dict["first_name"] = actor.club.name obj_dict["last_name"] = actor.club.name else: raise Exception("Badly formatted Special Transaction You should'nt be there.") tr = SpecialTransaction.objects.create(**obj_dict) if "cheques" in row["description"]: MAP_IDSPECIALTRANSACTION[row["id"]] = tr elif ttype == "adhésion": montant = row["montant"] # Create Double membership to Kfet and Bde # sometimes montant = 0, fees are modified accordingly. bde_dict = { "user": MAP_IDBDE[row["idbde"]], "club": bde, "date_start": row["date"].date(), # Only date, not time "fee": min(500, montant) } kfet_dict = { "user": MAP_IDBDE[row["idbde"]], "club": kfet, "date_start": row["date"].date(), # Only date, not time "fee": max(montant - 500, 0), } if row["valide"]: with transaction.atomic(): # membership save triggers MembershipTransaction creation bde_membership = Membership.objects.get_or_create(**bde_dict) kfet_membership = Membership.objects.get_or_create(**kfet_dict) bde_membership.transaction.created_at = row["transac_date"] bde_membership.transaction.description = row["description"] bde_membership.transaction.save() kfet_membership.transaction.created_at = row["transac_date"] kfet_membership.transaction.description = row["description"] + "(Kfet)" kfet_membership.transaction.save() else: # don't create membership MembershipTransaction.objects.create(**obj_dict) elif ttype == "invitation": m = re.search(r"Invitation (.*?) \((.*?)\)", row["description"]) if m is None: raise IntegrityError(f"Invitation is not well formated: {row['description']} (must be 'Invitation ACTIVITY_NAME (NAME)')") activity_name = m.group(1) guest_name = m.group(2) if activity_name not in MAP_NAMEACTIVITY: raise IntegrityError(f"Activity {activity_name} is not found") activity = MAP_NAMEACTIVITY[activity_name] if guest_name not in MAP_NAMEGUEST: raise IntegrityError(f"Guest {guest_name} is not found") guest = None for g in MAP_NAMEGUEST[guest_name]: if g.activity.pk == activity.pk: guest = g break if guest is None: raise IntegrityError("Guest {guest_name} didn't go to the activity {activity_name}") obj_dict["guest"] = guest GuestTransaction.objects.get_or_create(**obj_dict) else: print("other type not supported yet:", ttype) @transaction.atomic def import_aliases(cur): cur.execute("SELECT * FROM aliases ORDER by id") n = cur.rowcount for idx, row in enumerate(cur): update_line(idx, n, row["alias"]) alias_name = row["alias"] alias_name_good = (alias_name[:252] + '...') if len(alias_name) > 255 else alias_name obj_dict = { "note_id": MAP_IDBDE[row["idbde"]], "name": alias_name_good, "normalized_name": Alias.normalize(alias_name_good), } try: with transaction.atomic(): alias, created = Alias.objects.get_or_create(**obj_dict) except IntegrityError as e: if "unique" in e.args[0]: continue else: raise e alias.save() @transaction.atomic def import_activities(cur): cur.execute("SELECT * FROM activites ORDER by id") n = cur.rowcount activity_type = ActivityType.objects.get(name="Pot") # Need to be fixed manually kfet = Club.objects.get(name="Kfet") for idx, row in enumerate(cur): update_line(idx, n, row["alias"]) organizer = Club.objects.filter(name=row["signature"]) if organizer.exists(): # Try to find the club that organizes the activity. If not found, assume it's Kfet (fix manually) organizer = organizer.get() else: organizer = kfet obj_dict = { "name": row["titre"], "description": row["description"], "activity_type": activity_type, # By default Pot "creater": MAP_IDBDE[row["responsable"]], "organizer": organizer, "attendees_club": kfet, # Maybe fix manually "date_start": row["debut"], "date_end": row["fin"], "valid": row["validepar"] is not None, "open": row["open"], # Should always be False } # WARNING: Fields lieu, liste, listeimprimee are missing try: with transaction.atomic(): activity = Activity.objects.get_or_create(**obj_dict)[0] MAP_IDACTIVITY[row["id"]] = activity MAP_NAMEACTIVITY[activity.name] = activity except IntegrityError as e: raise e @transaction.atomic def import_activity_entries(cur): map_idguests = {} cur.execute("SELECT * FROM invites ORDER by id") n = cur.rowcount for idx, row in enumerate(cur): update_line(idx, n, row["nom"] + " " + row["prenom"]) obj_dict = { "activity": MAP_IDACTIVITY[row["activity"]], "last_name": row["nom"], "first_name": row["prenom"], "inviter": MAP_IDBDE[row["responsable"]], } try: with transaction.atomic(): guest = Guest.objects.get_or_create(**obj_dict)[0] map_idguests.setdefault(row["responsable"], []) map_idguests[row["id"]].append(guest) guest_name = guest.first_name + " " + guest.last_name MAP_NAMEGUEST.setdefault(guest_name, []) MAP_NAMEGUEST[guest_name].append(guest) except IntegrityError as e: raise e cur.execute("SELECT * FROM entree_activites ORDER by id") n = cur.rowcount for idx, row in enumerate(cur): update_line(idx, n, row["nom"] + " " + row["prenom"]) activity = MAP_IDACTIVITY[row["activity"]] guest = None if row["est_invite"]: for g in map_idguests[row["id"]]: if g.activity.pk == activity.pk: guest = g break if not guest: raise IntegrityError("Guest was not found: " + str(row)) obj_dict = { "activity": activity, "time": row["heure_entree"], "note": guest.inviter if guest else MAP_IDBDE[row["idbde"]], "guest": guest, } try: with transaction.atomic(): Entry.objects.get_or_create(**obj_dict) except IntegrityError as e: raise e @transaction.atomic def import_remittances(cur): cur.execute("SELECT * FROM remises ORDER by id") map_idremittance = {} n = cur.rowcount check_type = RemittanceType.objects.get(note__name="Chèque") for idx, row in enumerate(cur): update_line(idx, n, row["date"]) obj_dict = { "date": row["date"][10:], "remittance_type": check_type, "comment": row["commentaire"], "closed": row["close"], } try: with transaction.atomic(): remittance = Remittance.objects.get_or_create(**obj_dict) map_idremittance[row["id"]] = remittance except IntegrityError as e: raise e print("remittances are imported") print("imported checks") cur.execute("SELECT * FROM cheques ORDER by id") n = cur.rowcount for idx, row in enumerate(cur): update_line(idx, n, row["date"]) obj_dict = { "date": row["date"][10:], "remittance_type": check_type, "comment": row["commentaire"], "closed": row["close"], } tr = MAP_IDSPECIALTRANSACTION[row["idtransaction"]] proxy = SpecialTransactionProxy.objects.get_or_create(transaction=tr) proxy.remittance = map_idremittance[row["idremise"]] try: with transaction.atomic(): proxy.save() except IntegrityError as e: raise e class Command(BaseCommand): """ Command for importing the database of NK15. Need to be run by a user with a registered role in postgres for the database nk15. """ def print_success(self, to_print): return self.stdout.write(self.style.SUCCESS(to_print)) def add_arguments(self, parser): parser.add_argument('-c', '--comptes', action='store_true', help="import accounts") parser.add_argument('-b', '--boutons', action='store_true', help="import boutons") parser.add_argument('-t', '--transactions', action='store_true', help="import transaction") parser.add_argument('-al', '--aliases', action='store_true', help="import aliases") parser.add_argument('-ac', '--activities', action='store_true', help="import activities") parser.add_argument('-r', '--remittances', action='store_true', help="import check remittances") parser.add_argument('-s', '--save', action='store', help="save mapping of idbde") parser.add_argument('-m', '--map', action='store', help="import mapping of idbde") parser.add_argument('-d', '--nk15db', action='store', default='nk15', help='NK15 database name') parser.add_argument('-u', '--nk15user', action='store', default='nk15_user', help='NK15 database owner') def handle(self, *args, **kwargs): global MAP_IDBDE nk15db, nk15user = kwargs['nk15db'], kwargs['nk15user'] # connecting to nk15 database conn = pg.connect(database=nk15db, user=nk15user) cur = conn.cursor(cursor_factory=pge.DictCursor) if kwargs["comptes"]: # reset database. call_command("migrate") call_command("loaddata", "initial") self.print_success("reset nk20 database\n") import_comptes(cur) self.print_success("comptes table imported") elif kwargs["map"]: filename = kwargs["map"] with open(filename, 'r') as fp: MAP_IDBDE = json.load(fp) MAP_IDBDE = {int(k): int(v) for k, v in MAP_IDBDE.items()} if kwargs["save"]: filename = kwargs["save"] with open(filename, 'w') as fp: json.dump(MAP_IDBDE, fp, sort_keys=True, indent=2) # /!\ need a prober MAP_IDBDE if kwargs["boutons"]: import_boutons(cur) self.print_success("boutons table imported\n") if kwargs["activities"]: import_activities(cur) self.print_success("activities imported\n") import_activity_entries(cur) self.print_success("activity entries imported\n") if kwargs["aliases"]: import_aliases(cur) self.print_success("aliases imported\n") if kwargs["transactions"]: import_transaction(cur) self.print_success("transaction imported\n") if kwargs["remittances"]: import_remittances(cur) self.print_success("remittances imported\n")