plateforme-tfjm2/apps/member/management/commands/import_olddb.py

import os

from django.core.management import BaseCommand, CommandError
from django.db import transaction
from member.models import TFJMUser, Document, Solution, Synthesis, Authorization, MotivationLetter
from tournament.models import Team, Tournament


class Command(BaseCommand):
    """
    Import the old database.
    Tables must be found into the import_olddb folder, as CSV files.
    """

    def add_arguments(self, parser):
        parser.add_argument('--tournaments', '-t', action="store", help="Import tournaments")
        parser.add_argument('--teams', '-T', action="store", help="Import teams")
        parser.add_argument('--users', '-u', action="store", help="Import users")
        parser.add_argument('--documents', '-d', action="store", help="Import all documents")

    def handle(self, *args, **options):
        if "tournaments" in options:
            self.import_tournaments()

        if "teams" in options:
            self.import_teams()

        if "users" in options:
            self.import_users()

        if "documents" in options:
            self.import_documents()

    @transaction.atomic
    def import_tournaments(self):
        """
        Import tournaments into the new database.
        """
        print("Importing tournaments...")
        with open("import_olddb/tournaments.csv") as f:
            first_line = True
            for line in f:
                if first_line:
                    first_line = False
                    continue

                line = line[:-1].replace("\"", "")
                args = line.split(";")
                args = [arg if arg and arg != "NULL" else None for arg in args]

                if Tournament.objects.filter(pk=args[0]).exists():
                    continue

                obj_dict = {
                    "id": args[0],
                    "name": args[1],
                    "size": args[2],
                    "place": args[3],
                    "price": args[4],
                    "description": args[5],
                    "date_start": args[6],
                    "date_end": args[7],
                    "date_inscription": args[8],
                    "date_solutions": args[9],
                    "date_syntheses": args[10],
                    "date_solutions_2": args[11],
                    "date_syntheses_2": args[12],
                    "final": args[13],
                    "year": args[14],
                }
                with transaction.atomic():
                    Tournament.objects.create(**obj_dict)
        print(self.style.SUCCESS("Tournaments imported"))

    @staticmethod
    def validation_status(status):
        if status == "NOT_READY":
            return "0invalid"
        elif status == "WAITING":
            return "1waiting"
        elif status == "VALIDATED":
            return "2valid"
        else:
            raise CommandError("Unknown status: {}".format(status))

    @transaction.atomic
    def import_teams(self):
        """
        Import teams into new database.
        """
        self.stdout.write("Importing teams...")
        with open("import_olddb/teams.csv") as f:
            first_line = True
            for line in f:
                if first_line:
                    first_line = False
                    continue

                line = line[:-1].replace("\"", "")
                args = line.split(";")
                args = [arg if arg and arg != "NULL" else None for arg in args]

                if Team.objects.filter(pk=args[0]).exists():
                    continue

                obj_dict = {
                    "id": args[0],
                    "name": args[1],
                    "trigram": args[2],
                    "tournament": Tournament.objects.get(pk=args[3]),
                    "inscription_date": args[13],
                    "validation_status": Command.validation_status(args[14]),
                    "selected_for_final": args[15],
                    "access_code": args[16],
                    "year": args[17],
                }
                with transaction.atomic():
                    Team.objects.create(**obj_dict)
        print(self.style.SUCCESS("Teams imported"))

    @staticmethod
    def role(role):
        if role == "ADMIN":
            return "0admin"
        elif role == "ORGANIZER":
            return "1volunteer"
        elif role == "ENCADRANT":
            return "2coach"
        elif role == "PARTICIPANT":
            return "3participant"
        else:
            raise CommandError("Unknown role: {}".format(role))

    @transaction.atomic
    def import_users(self):
        """
        Import users into the new database.
        :return:
        """
        self.stdout.write("Importing users...")
        with open("import_olddb/users.csv") as f:
            first_line = True
            for line in f:
                if first_line:
                    first_line = False
                    continue

                line = line[:-1].replace("\"", "")
                args = line.split(";")
                args = [arg if arg and arg != "NULL" else None for arg in args]

                if TFJMUser.objects.filter(pk=args[0]).exists():
                    continue

                obj_dict = {
                    "id": args[0],
                    "email": args[1],
                    "username": args[1],
                    "password": "bcrypt$" + args[2],
                    "last_name": args[3],
                    "first_name": args[4],
                    "birth_date": args[5],
                    "gender": "male" if args[6] == "M" else "female",
                    "address": args[7],
                    "postal_code": args[8],
                    "city": args[9],
                    "country": args[10],
                    "phone_number": args[11],
                    "school": args[12],
                    "student_class": args[13].lower().replace('premiere', 'première') if args[13] else None,
                    "responsible_name": args[14],
                    "responsible_phone": args[15],
                    "responsible_email": args[16],
                    "description": args[17].replace("\\n", "\n") if args[17] else None,
                    "role": Command.role(args[18]),
                    "team": Team.objects.get(pk=args[19]) if args[19] else None,
                    "year": args[20],
                    "date_joined": args[23],
                    "is_active": args[18] == "ADMIN" or os.getenv("TFJM_STAGE", "dev") == "prod",
                    "is_staff": args[18] == "ADMIN",
                    "is_superuser": args[18] == "ADMIN",
                }
                with transaction.atomic():
                    TFJMUser.objects.create(**obj_dict)
        self.stdout.write(self.style.SUCCESS("Users imported"))

        self.stdout.write("Importing organizers...")
        # We also import the information about the organizers of a tournament.
        with open("import_olddb/organizers.csv") as f:
            first_line = True
            for line in f:
                if first_line:
                    first_line = False
                    continue

                line = line[:-1].replace("\"", "")
                args = line.split(";")
                args = [arg if arg and arg != "NULL" else None for arg in args]

                with transaction.atomic():
                    tournament = Tournament.objects.get(pk=args[2])
                    organizer = TFJMUser.objects.get(pk=args[1])
                    tournament.organizers.add(organizer)
                    tournament.save()
        self.stdout.write(self.style.SUCCESS("Organizers imported"))

    @transaction.atomic
    def import_documents(self):
        """
        Import the documents (authorizations, motivation letters, solutions, syntheses) from the old database.
        """
        self.stdout.write("Importing documents...")
        with open("import_olddb/documents.csv") as f:
            first_line = True
            for line in f:
                if first_line:
                    first_line = False
                    continue

                line = line[:-1].replace("\"", "")
                args = line.split(";")
                args = [arg if arg and arg != "NULL" else None for arg in args]

                if Document.objects.filter(file=args[0]).exists():
                    doc = Document.objects.get(file=args[0])
                    doc.uploaded_at = args[5].replace(" ", "T")
                    doc.save()
                    continue

                obj_dict = {
                    "file": args[0],
                    "uploaded_at": args[5],
                }
                if args[4] != "MOTIVATION_LETTER":
                    obj_dict["user"] = TFJMUser.objects.get(args[1]),
                    obj_dict["type"] = args[4].lower()
                else:
                    try:
                        obj_dict["team"] = Team.objects.get(pk=args[2])
                    except Team.DoesNotExist:
                        print("Team with pk {} does not exist, ignoring".format(args[2]))
                        continue
                with transaction.atomic():
                    if args[4] != "MOTIVATION_LETTER":
                        Authorization.objects.create(**obj_dict)
                    else:
                        MotivationLetter.objects.create(**obj_dict)
        self.stdout.write(self.style.SUCCESS("Authorizations imported"))

        with open("import_olddb/solutions.csv") as f:
            first_line = True
            for line in f:
                if first_line:
                    first_line = False
                    continue

                line = line[:-1].replace("\"", "")
                args = line.split(";")
                args = [arg if arg and arg != "NULL" else None for arg in args]

                if Document.objects.filter(file=args[0]).exists():
                    doc = Document.objects.get(file=args[0])
                    doc.uploaded_at = args[4].replace(" ", "T")
                    doc.save()
                    continue

                obj_dict = {
                    "file": args[0],
                    "team": Team.objects.get(pk=args[1]),
                    "problem": args[3],
                    "uploaded_at": args[4],
                }
                with transaction.atomic():
                    try:
                        Solution.objects.create(**obj_dict)
                    except:
                        print("Solution exists")
        self.stdout.write(self.style.SUCCESS("Solutions imported"))

        with open("import_olddb/syntheses.csv") as f:
            first_line = True
            for line in f:
                if first_line:
                    first_line = False
                    continue

                line = line[:-1].replace("\"", "")
                args = line.split(";")
                args = [arg if arg and arg != "NULL" else None for arg in args]

                if Document.objects.filter(file=args[0]).exists():
                    doc = Document.objects.get(file=args[0])
                    doc.uploaded_at = args[5].replace(" ", "T")
                    doc.save()
                    continue

                obj_dict = {
                    "file": args[0],
                    "team": Team.objects.get(pk=args[1]),
                    "source": "opponent" if args[3] == "1" else "rapporteur",
                    "round": args[4],
                    "uploaded_at": args[5],
                }
                with transaction.atomic():
                    try:
                        Synthesis.objects.create(**obj_dict)
                    except:
                        print("Synthesis exists")
        self.stdout.write(self.style.SUCCESS("Syntheses imported"))