orion/static/admin/js/user-create.js

// static/admin/js/user-create.js

// Create custom logger for user create
const userCreateLog = window.LogConfig.createLogger('USER-CREATE');

function adminUserCreate() {
    return {
        // Inherit base layout functionality from init-alpine.js
        ...data(),

        // User create page specific state
        currentPage: 'user-create',
        loading: false,
        formData: {
            username: '',
            email: '',
            password: '',
            first_name: '',
            last_name: '',
            role: 'vendor',
            is_super_admin: false,
            platform_ids: []
        },
        platforms: [],
        errors: {},
        saving: false,

        // Initialize
        async init() {
            userCreateLog.info('=== USER CREATE PAGE INITIALIZING ===');

            // Prevent multiple initializations
            if (window._userCreateInitialized) {
                userCreateLog.warn('User create page already initialized, skipping...');
                return;
            }
            window._userCreateInitialized = true;

            // Load platforms for admin assignment
            await this.loadPlatforms();

            userCreateLog.info('=== USER CREATE PAGE INITIALIZATION COMPLETE ===');
        },

        // Load available platforms
        async loadPlatforms() {
            try {
                userCreateLog.debug('Loading platforms...');
                const response = await apiClient.get('/admin/platforms');
                this.platforms = response.platforms || response.items || [];
                userCreateLog.debug(`Loaded ${this.platforms.length} platforms`);
            } catch (error) {
                userCreateLog.error('Failed to load platforms:', error);
                this.platforms = [];
            }
        },

        // Handle role change
        onRoleChange() {
            userCreateLog.debug('Role changed to:', this.formData.role);
            if (this.formData.role !== 'admin') {
                // Reset admin-specific fields when switching away from admin
                this.formData.is_super_admin = false;
                this.formData.platform_ids = [];
            }
        },

        // Validate form
        validateForm() {
            this.errors = {};

            if (!this.formData.username.trim()) {
                this.errors.username = 'Username is required';
            }
            if (!this.formData.email.trim()) {
                this.errors.email = 'Email is required';
            }
            if (!this.formData.password || this.formData.password.length < 6) {
                this.errors.password = 'Password must be at least 6 characters';
            }

            // Admin-specific validation
            if (this.formData.role === 'admin' && !this.formData.is_super_admin) {
                if (!this.formData.platform_ids || this.formData.platform_ids.length === 0) {
                    this.errors.platform_ids = 'Platform admins must be assigned to at least one platform';
                }
            }

            return Object.keys(this.errors).length === 0;
        },

        // Submit form
        async handleSubmit() {
            userCreateLog.info('=== CREATING USER ===');
            userCreateLog.debug('Form data:', { ...this.formData, password: '[REDACTED]' });

            if (!this.validateForm()) {
                userCreateLog.warn('Validation failed:', this.errors);
                Utils.showToast('Please fix the errors before submitting', 'error');
                return;
            }

            this.saving = true;

            try {
                let url, payload, response;

                if (this.formData.role === 'admin') {
                    // Use admin-users endpoint for creating admin users
                    url = '/api/v1/admin/admin-users';
                    payload = {
                        email: this.formData.email,
                        username: this.formData.username,
                        password: this.formData.password,
                        first_name: this.formData.first_name || null,
                        last_name: this.formData.last_name || null,
                        is_super_admin: this.formData.is_super_admin,
                        platform_ids: this.formData.is_super_admin ? [] : this.formData.platform_ids.map(id => parseInt(id))
                    };
                } else {
                    // Use regular users endpoint for vendor users
                    url = '/admin/users';
                    payload = {
                        email: this.formData.email,
                        username: this.formData.username,
                        password: this.formData.password,
                        first_name: this.formData.first_name || null,
                        last_name: this.formData.last_name || null,
                        role: this.formData.role
                    };
                }

                window.LogConfig.logApiCall('POST', url, { ...payload, password: '[REDACTED]' }, 'request');

                const startTime = performance.now();
                response = await apiClient.post(url, payload);
                const duration = performance.now() - startTime;

                window.LogConfig.logApiCall('POST', url, response, 'response');
                window.LogConfig.logPerformance('Create User', duration);

                const userType = this.formData.role === 'admin'
                    ? (this.formData.is_super_admin ? 'Super admin' : 'Platform admin')
                    : 'User';
                Utils.showToast(`${userType} created successfully`, 'success');
                userCreateLog.info(`${userType} created successfully in ${duration}ms`, response);

                // Redirect to the new user's detail page
                setTimeout(() => {
                    window.location.href = `/admin/users/${response.id}`;
                }, 1500);

            } catch (error) {
                window.LogConfig.logError(error, 'Create User');

                // Handle validation errors
                if (error.details && error.details.validation_errors) {
                    error.details.validation_errors.forEach(err => {
                        const field = err.loc?.[1] || err.loc?.[0];
                        if (field) {
                            this.errors[field] = err.msg;
                        }
                    });
                    userCreateLog.debug('Validation errors:', this.errors);
                }

                // Handle specific errors
                if (error.message) {
                    if (error.message.includes('Email already')) {
                        this.errors.email = 'This email is already registered';
                    } else if (error.message.includes('Username already')) {
                        this.errors.username = 'This username is already taken';
                    }
                }

                Utils.showToast(error.message || 'Failed to create user', 'error');
            } finally {
                this.saving = false;
                userCreateLog.info('=== USER CREATION COMPLETE ===');
            }
        }
    };
}

userCreateLog.info('User create module loaded');