File size: 4,545 Bytes
41aafc4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
cfd9177
41aafc4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
"""
Database initialization script for SCM microservice.
Creates all collections, indexes, and validation rules.
"""
import asyncio
from motor.motor_asyncio import AsyncIOMotorClient
# from insightfy_utils.logging import get_logger  # TODO: Uncomment when package is available
import logging
from app.core.config import settings
from app.db_init.merchant_settings_init import initialize_merchant_settings_database

# logger = get_logger(__name__)  # TODO: Uncomment when insightfy_utils is available
logger = logging.getLogger(__name__)


async def initialize_database():
    """
    Initialize the complete SCM database structure.
    
    This script creates:
    - Collections with schema validation
    - Performance indexes
    - Default data (if needed)
    """
    client = None
    try:
        logger.info("Starting database initialization")
        
        # Connect to MongoDB
        logger.info(f"Connecting to MongoDB: {settings.MONGODB_URI}")
        client = AsyncIOMotorClient(settings.MONGODB_URI)
        db = client[settings.MONGODB_DB_NAME]
        
        # Test connection
        await client.admin.command('ping')
        logger.info(f"Connected to database: {settings.MONGODB_DB_NAME}")
        
        # Initialize merchant settings
        await initialize_merchant_settings_database(db)
        
        # Add other collection initializations here as needed
        # await initialize_merchants_database(db)
        # await initialize_staff_database(db)
        # await initialize_orders_database(db)
        
        logger.info("Database initialization completed successfully")
        
    except Exception as e:
        logger.error("Database initialization failed", exc_info=e)
        raise
    finally:
        if client:
            client.close()
            logger.info("Database connection closed")


async def verify_database_setup():
    """
    Verify that the database setup is correct.
    """
    client = None
    try:
        logger.info("Starting database verification")
        
        # Connect to MongoDB
        client = AsyncIOMotorClient(settings.MONGODB_URI)
        db = client[settings.MONGODB_DB_NAME]
        
        # Test connection
        await client.admin.command('ping')
        
        # List all collections
        collections = await db.list_collection_names()
        logger.info(f"Found collections: {collections}")
        
        # Check merchant_settings collection
        from app.constants.collections import SCM_MERCHANT_SETTINGS_COLLECTION
        
        if SCM_MERCHANT_SETTINGS_COLLECTION in collections:
            collection = db[SCM_MERCHANT_SETTINGS_COLLECTION]
            
            # Check indexes
            indexes = await collection.index_information()
            logger.info(f"Merchant settings indexes: {list(indexes.keys())}")
            
            # Check collection stats
            stats = await db.command("collStats", SCM_MERCHANT_SETTINGS_COLLECTION)
            logger.info(f"Merchant settings collection stats:", extra={
                "count": stats.get("count", 0),
                "size": stats.get("size", 0),
                "indexes": stats.get("nindexes", 0)
            })
            
            logger.info("βœ… Merchant settings collection is properly configured")
        else:
            logger.warning(f"❌ Collection {SCM_MERCHANT_SETTINGS_COLLECTION} not found")
        
        logger.info("Database verification completed")
        
    except Exception as e:
        logger.error("Database verification failed", exc_info=e)
        raise
    finally:
        if client:
            client.close()


if __name__ == "__main__":
    import sys
    
    # Check command line arguments
    if len(sys.argv) > 1:
        command = sys.argv[1]
        
        if command == "init":
            print("πŸš€ Initializing database...")
            asyncio.run(initialize_database())
            print("βœ… Database initialization completed")
            
        elif command == "verify":
            print("πŸ” Verifying database setup...")
            asyncio.run(verify_database_setup())
            print("βœ… Database verification completed")
            
        else:
            print(f"Unknown command: {command}")
            print("Usage: python db_init.py [init|verify]")
            sys.exit(1)
    else:
        print("Usage:")
        print("  python db_init.py init    - Initialize database structure")
        print("  python db_init.py verify  - Verify database setup")
        sys.exit(1)