main.py

""" Main Merging Function

This Python script controls the four processes. Follow instructions in terminal to:

1. Create a duplicate detection job
2. Group and download the duplicates
3. Prepare the duplicates for merging
4. Execute the merge requests

You should update the logic in prepare_duplicates.py to meet your 
needs before running this end to end and create a .env file.

"""

from core.find_duplicates import create_duplicate_detection_job
from core.group_duplicates import download_and_group_duplicates
from core.prepare_duplicate import prepare_duplicates
from core.update_duplicates import update_duplicates
from core.utils.session_manager import SessionManager
from core.utils.dynamics_config import get_config


def main():
    """Provides a menu of options and walks through the process"""

    # Create session once at startup
    print("=== Dynamics 365 Duplicate Resolver ===\n")
    dotenv_name = input("Specify .env file to authenticate: ").strip()

    if dotenv_name is None:
        config = get_config()
    else:
        config = get_config(dotenv_name)

    manager = SessionManager(config)
    manager.get_authenticated_session()

    if not manager.validate_session():
        print("Authentication failed!")
        return

    print("\n✓ Authentication successful!\n")

    entity = None
    data_folder = None
    asyncoperationid = None
    target_is = None
    duplicate_groups = None
    perform_parenting_check = None
    duplicates = None
    max_number_of_dupes = None

    while True:
        print("\n=== Dynamics 365 Duplicate Resolver ===")
        print("1. Create duplicate detection job")
        print("2. Group duplicates")
        print("3. Prepare duplicates")
        print("4. Merge duplicates")
        print("5. Clear all and start again")
        print("0. Exit")

        choice = input("\nChoose an option: ").strip()

        if choice == "1":
            entity = input("Entity name: ").strip()
            view = input("View name: ").strip()

            print("\nCreating Dynamics Duplicate Detection Job\n")
            asyncoperationid = create_duplicate_detection_job(entity, view, manager)
            print(f"\n✓ Success! Job ID: {asyncoperationid}\n")

            print("Once complete, run 2: Group duplicates")

        elif choice == "2":
            entity = entity if entity else input("Entity name: ").strip()
            data_folder = data_folder if data_folder else input("Folder name to store data in: ").strip()
            max_number_of_dupes = max_number_of_dupes if max_number_of_dupes else input("Optional number of duplicates to import: ").strip()
            asyncoperationid = asyncoperationid if asyncoperationid else input("Duplicate Detection Job ID: ").strip()

            try:
                max_number_of_dupes = int(max_number_of_dupes) if max_number_of_dupes else None
            except ValueError:
                max_number_of_dupes = None

            max_number_str = "all duplicate" if max_number_of_dupes is None else max_number_of_dupes

            print(f"\nDownloading and grouping {max_number_str} {entity}s to store in the {data_folder}/group folder.\n")

            duplicate_groups = download_and_group_duplicates(
                entity = entity,
                asyncoperationid = asyncoperationid,
                data_folder = data_folder,
                manager = manager,
                max_number_of_dupes = max_number_of_dupes
            )

            number_of_groups = len(duplicate_groups.keys())
            number_of_duplicates = sum(len(v) for v in duplicate_groups.values())

            print(f"\n✓ Success! {number_of_duplicates} Duplicates downloaded into {number_of_groups} groups\n")

        elif choice == "3":
            entity = entity if entity else input("Entity name: ").strip()
            data_folder = data_folder if data_folder else input("Folder name to store data in: ").strip()
            target_is = target_is if target_is else input("Should the target be the oldest record or newest record? (oldest_record or newest_record):").strip()

            max_number_str = "all duplicate" if max_number_of_dupes is None else max_number_of_dupes

            print(f"\nPreparing and grouping {max_number_str} {entity}s by the {target_is} to store in the {data_folder}/prepare folder.\n")

            duplicates = prepare_duplicates(
                entity = entity,
                target_is = target_is,
                manager = manager,
                data_folder = data_folder,
                duplicate_groups = duplicate_groups)

        elif choice == "4":
            entity = entity if entity else input("Entity name: ").strip()
            data_folder = data_folder if data_folder else input("Folder name to store data in: ").strip()
            if perform_parenting_check is None:
                perform_parenting_check = input("Should a parent check be performed? (True or False):").strip().lower() == "true"
            max_number_of_dupes = input("Optionally maximum number of duplicates to merge (Number or Enter): ").strip()

            try:
                max_number_of_dupes = int(max_number_of_dupes) if max_number_of_dupes else None
            except ValueError:
                max_number_of_dupes = None

            max_number_str = "all duplicate" if max_number_of_dupes == -1 else max_number_of_dupes
            parent_check_str = "with a parenting check " if perform_parenting_check else ""

            print(f"\nExecuting merge requests on {max_number_str} {entity}s {parent_check_str}and storing result in the {data_folder}/update folder.\n")

            update_duplicates(
                entity = entity,
                data_folder = data_folder,
                manager = manager,
                dataframe = duplicates,
                perform_parenting_check = perform_parenting_check,
                max_number_to_execute = max_number_of_dupes)

        elif choice == "5":
            entity = None
            data_folder = None
            asyncoperationid = None
            target_is = None
            duplicate_groups = None
            perform_parenting_check = None
            duplicates = None
            max_number_of_dupes = None

            print("\nAll Varaiables cleared. Ready to start again.\n")

        elif choice == "0":
            manager.close_session()
            print("Goodbye!")
            break

        else:
            print("Invalid choice!")

if __name__ == "__main__":
    main()