@shaykec/app-agent 1.0.5 → 1.0.6

package/templates/shared/android/WixMemberBackend/WixBookingsManager.kt

@@ -0,0 +1,239 @@
+package com.appship.shared.wix.member
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Manages Wix Bookings (services, time slots, bookings).
+ */
+class WixBookingsManager(
+    private val apiClient: WixApiClient,
+    private val authManager: WixAuthManager
+) {
+    private val _services = MutableStateFlow<List<WixService>>(emptyList())
+    val services: StateFlow<List<WixService>> = _services.asStateFlow()
+    
+    private val _isLoading = MutableStateFlow(false)
+    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()
+    
+    private val _error = MutableStateFlow<WixApiError?>(null)
+    val error: StateFlow<WixApiError?> = _error.asStateFlow()
+    
+    /**
+     * List all available services
+     */
+    suspend fun listServices(): Result<List<WixService>> {
+        _isLoading.value = true
+        _error.value = null
+        
+        return try {
+            val result = apiClient.get<WixListResponse<WixService>>(
+                path = "/bookings/v1/services"
+            )
+            
+            _isLoading.value = false
+            
+            result.fold(
+                onSuccess = { response ->
+                    val items = response.items ?: emptyList()
+                    _services.value = items
+                    Result.success(items)
+                },
+                onFailure = { error ->
+                    _error.value = error as? WixApiError ?: WixApiError.UnknownError(error.message ?: "Unknown error")
+                    Result.failure(error)
+                }
+            )
+        } catch (e: Exception) {
+            _isLoading.value = false
+            val apiError = WixApiError.UnknownError(e.message ?: "Failed to list services")
+            _error.value = apiError
+            Result.failure(apiError)
+        }
+    }
+    
+    /**
+     * Get a single service by ID
+     */
+    suspend fun getService(id: String): Result<WixService> {
+        _isLoading.value = true
+        _error.value = null
+        
+        return try {
+            val result = apiClient.get<WixService>(
+                path = "/bookings/v1/services/$id"
+            )
+            
+            _isLoading.value = false
+            
+            result.fold(
+                onSuccess = { service ->
+                    Result.success(service)
+                },
+                onFailure = { error ->
+                    _error.value = error as? WixApiError ?: WixApiError.UnknownError(error.message ?: "Unknown error")
+                    Result.failure(error)
+                }
+            )
+        } catch (e: Exception) {
+            _isLoading.value = false
+            val apiError = WixApiError.UnknownError(e.message ?: "Failed to get service")
+            _error.value = apiError
+            Result.failure(apiError)
+        }
+    }
+    
+    /**
+     * Get available time slots for a service
+     */
+    suspend fun getAvailableSlots(
+        serviceId: String,
+        start: String, // ISO 8601 date string
+        end: String    // ISO 8601 date string
+    ): Result<List<WixTimeSlot>> {
+        _isLoading.value = true
+        _error.value = null
+        
+        return try {
+            val result = apiClient.get<WixListResponse<WixTimeSlot>>(
+                path = "/bookings/v1/services/$serviceId/slots",
+                queryParams = mapOf(
+                    "start" to start,
+                    "end" to end
+                )
+            )
+            
+            _isLoading.value = false
+            
+            result.fold(
+                onSuccess = { response ->
+                    val items = response.items ?: emptyList()
+                    Result.success(items)
+                },
+                onFailure = { error ->
+                    _error.value = error as? WixApiError ?: WixApiError.UnknownError(error.message ?: "Unknown error")
+                    Result.failure(error)
+                }
+            )
+        } catch (e: Exception) {
+            _isLoading.value = false
+            val apiError = WixApiError.UnknownError(e.message ?: "Failed to get available slots")
+            _error.value = apiError
+            Result.failure(apiError)
+        }
+    }
+    
+    /**
+     * Book a service (requires login)
+     */
+    suspend fun bookService(
+        serviceId: String,
+        slotId: String,
+        contact: WixContactInfo
+    ): Result<WixBooking> {
+        _isLoading.value = true
+        _error.value = null
+        
+        return try {
+            val requestBody = mapOf(
+                "serviceId" to serviceId,
+                "slotId" to slotId,
+                "contact" to mapOf(
+                    "name" to contact.name,
+                    "email" to contact.email,
+                    "phone" to (contact.phone ?: ""),
+                    "notes" to (contact.notes ?: "")
+                )
+            )
+            
+            val result = apiClient.post<Map<String, Any>, WixBooking>(
+                path = "/bookings/v1/bookings",
+                body = requestBody
+            )
+            
+            _isLoading.value = false
+            
+            result.fold(
+                onSuccess = { booking ->
+                    Result.success(booking)
+                },
+                onFailure = { error ->
+                    _error.value = error as? WixApiError ?: WixApiError.UnknownError(error.message ?: "Unknown error")
+                    Result.failure(error)
+                }
+            )
+        } catch (e: Exception) {
+            _isLoading.value = false
+            val apiError = WixApiError.UnknownError(e.message ?: "Failed to book service")
+            _error.value = apiError
+            Result.failure(apiError)
+        }
+    }
+    
+    /**
+     * Get booking by ID (requires login)
+     */
+    suspend fun getBooking(bookingId: String): Result<WixBooking> {
+        _isLoading.value = true
+        _error.value = null
+        
+        return try {
+            val result = apiClient.get<WixBooking>(
+                path = "/bookings/v1/bookings/$bookingId"
+            )
+            
+            _isLoading.value = false
+            
+            result.fold(
+                onSuccess = { booking ->
+                    Result.success(booking)
+                },
+                onFailure = { error ->
+                    _error.value = error as? WixApiError ?: WixApiError.UnknownError(error.message ?: "Unknown error")
+                    Result.failure(error)
+                }
+            )
+        } catch (e: Exception) {
+            _isLoading.value = false
+            val apiError = WixApiError.UnknownError(e.message ?: "Failed to get booking")
+            _error.value = apiError
+            Result.failure(apiError)
+        }
+    }
+    
+    /**
+     * List user's bookings (requires login)
+     */
+    suspend fun listBookings(limit: Int = 50): Result<List<WixBooking>> {
+        _isLoading.value = true
+        _error.value = null
+        
+        return try {
+            val result = apiClient.get<WixListResponse<WixBooking>>(
+                path = "/bookings/v1/bookings",
+                queryParams = mapOf(
+                    "limit" to limit.toString()
+                )
+            )
+            
+            _isLoading.value = false
+            
+            result.fold(
+                onSuccess = { response ->
+                    val items = response.items ?: emptyList()
+                    Result.success(items)
+                },
+                onFailure = { error ->
+                    _error.value = error as? WixApiError ?: WixApiError.UnknownError(error.message ?: "Unknown error")
+                    Result.failure(error)
+                }
+            )
+        } catch (e: Exception) {
+            _isLoading.value = false
+            val apiError = WixApiError.UnknownError(e.message ?: "Failed to list bookings")
+            _error.value = apiError
+            Result.failure(apiError)
+        }
+    }
+}

package/templates/shared/android/WixMemberBackend/WixBookingsScreen.kt

@@ -0,0 +1,440 @@
+package com.appship.shared.wix.member
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.CalendarToday
+import androidx.compose.material3.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.ComponentActivity
+import com.appship.shared.wix.member.R
+import kotlinx.coroutines.launch
+import java.text.SimpleDateFormat
+import java.util.*
+
+/**
+ * Wix Bookings screen - browse services, book appointments.
+ */
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun WixBookingsScreen(
+    bookingsManager: WixBookingsManager,
+    authManager: WixAuthManager,
+    modifier: Modifier = Modifier
+) {
+    val context = LocalContext.current
+    val activity = context as? ComponentActivity
+    
+    val services by bookingsManager.services.collectAsState()
+    val isLoading by bookingsManager.isLoading.collectAsState()
+    val error by bookingsManager.error.collectAsState()
+    
+    var selectedService by remember { mutableStateOf<WixService?>(null) }
+    var showBookingDialog by remember { mutableStateOf(false) }
+    var showSuccessDialog by remember { mutableStateOf(false) }
+    
+    val scope = rememberCoroutineScope()
+    
+    LaunchedEffect(Unit) {
+        bookingsManager.listServices()
+    }
+    
+    Scaffold(
+        topBar = {
+            TopAppBar(
+                title = { Text(stringResource(R.string.wix_bookings_title)) }
+            )
+        }
+    ) { padding ->
+        Column(
+            modifier = modifier
+                .fillMaxSize()
+                .padding(padding)
+        ) {
+            when {
+                isLoading && services.isEmpty() -> {
+                    Box(
+                        modifier = Modifier.fillMaxSize(),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        CircularProgressIndicator(
+                            modifier = Modifier.testTag("wix_bookings_loading")
+                        )
+                    }
+                }
+                
+                services.isEmpty() -> {
+                    Box(
+                        modifier = Modifier.fillMaxSize(),
+                        contentAlignment = Alignment.Center
+                    ) {
+                        Column(
+                            horizontalAlignment = Alignment.CenterHorizontally,
+                            modifier = Modifier.testTag("wix_bookings_empty")
+                        ) {
+                            Text(
+                                text = stringResource(R.string.wix_empty_services),
+                                style = MaterialTheme.typography.bodyLarge,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant
+                            )
+                        }
+                    }
+                }
+                
+                else -> {
+                    LazyColumn(
+                        contentPadding = PaddingValues(16.dp),
+                        verticalArrangement = Arrangement.spacedBy(12.dp),
+                        modifier = Modifier.testTag("wix_bookings_list")
+                    ) {
+                        items(services) { service ->
+                            ServiceCard(
+                                service = service,
+                                onClick = {
+                                    selectedService = service
+                                    showBookingDialog = true
+                                },
+                                modifier = Modifier.testTag("wix_bookings_service_${service.id}")
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    // Booking dialog
+    if (showBookingDialog && selectedService != null) {
+        BookingDialog(
+            service = selectedService!!,
+            bookingsManager = bookingsManager,
+            authManager = authManager,
+            onDismiss = { showBookingDialog = false },
+            onSuccess = {
+                showBookingDialog = false
+                showSuccessDialog = true
+            },
+            modifier = Modifier.testTag("wix_bookings_booking_dialog")
+        )
+    }
+    
+    // Success dialog
+    if (showSuccessDialog) {
+        AlertDialog(
+            onDismissRequest = { showSuccessDialog = false },
+            title = {
+                Text(stringResource(R.string.wix_bookings_confirmation_title))
+            },
+            text = {
+                Text(stringResource(R.string.wix_bookings_confirmation_message))
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = { showSuccessDialog = false },
+                    modifier = Modifier.testTag("wix_bookings_success_ok")
+                ) {
+                    Text("OK")
+                }
+            },
+            modifier = Modifier.testTag("wix_bookings_success_dialog")
+        )
+    }
+}
+
+@Composable
+private fun ServiceCard(
+    service: WixService,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    Card(
+        onClick = onClick,
+        modifier = modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(12.dp)
+    ) {
+        Column(
+            modifier = Modifier.padding(16.dp)
+        ) {
+            Text(
+                text = service.name,
+                style = MaterialTheme.typography.titleLarge,
+                modifier = Modifier.testTag("wix_bookings_service_name_${service.id}")
+            )
+            
+            service.description?.let { desc ->
+                Spacer(modifier = Modifier.height(8.dp))
+                Text(
+                    text = desc,
+                    style = MaterialTheme.typography.bodyMedium,
+                    maxLines = 3,
+                    overflow = TextOverflow.Ellipsis,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    modifier = Modifier.testTag("wix_bookings_service_description_${service.id}")
+                )
+            }
+            
+            Spacer(modifier = Modifier.height(12.dp))
+            
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                service.duration?.let { duration ->
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(4.dp)
+                    ) {
+                        Icon(
+                            imageVector = Icons.Filled.CalendarToday,
+                            contentDescription = null,
+                            modifier = Modifier.size(16.dp)
+                        )
+                        Text(
+                            text = stringResource(R.string.wix_bookings_duration, duration),
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                }
+                
+                Text(
+                    text = service.price?.formatted ?: stringResource(R.string.wix_store_price_free),
+                    style = MaterialTheme.typography.titleMedium,
+                    color = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.testTag("wix_bookings_service_price_${service.id}")
+                )
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun BookingDialog(
+    service: WixService,
+    bookingsManager: WixBookingsManager,
+    authManager: WixAuthManager,
+    onDismiss: () -> Unit,
+    onSuccess: () -> Unit,
+    modifier: Modifier = Modifier
+) {
+    val context = LocalContext.current
+    val activity = context as? ComponentActivity
+    
+    var selectedDate by remember { mutableStateOf<Long?>(null) }
+    var selectedSlot by remember { mutableStateOf<WixTimeSlot?>(null) }
+    var availableSlots by remember { mutableStateOf<List<WixTimeSlot>>(emptyList()) }
+    var isLoadingSlots by remember { mutableStateOf(false) }
+    
+    var contactName by remember { mutableStateOf("") }
+    var contactEmail by remember { mutableStateOf("") }
+    var contactPhone by remember { mutableStateOf("") }
+    var contactNotes by remember { mutableStateOf("") }
+    
+    val isLoading by bookingsManager.isLoading.collectAsState()
+    val scope = rememberCoroutineScope()
+    
+    // Load slots when date is selected
+    LaunchedEffect(selectedDate) {
+        selectedDate?.let { date ->
+            isLoadingSlots = true
+            val startDate = Date(date)
+            val endDate = Date(date + 86400000) // +1 day
+            
+            val dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.US)
+            dateFormat.timeZone = TimeZone.getTimeZone("UTC")
+            
+            val result = bookingsManager.getAvailableSlots(
+                serviceId = service.id,
+                start = dateFormat.format(startDate),
+                end = dateFormat.format(endDate)
+            )
+            
+            isLoadingSlots = false
+            result.onSuccess { slots ->
+                availableSlots = slots.filter { it.available }
+            }
+        }
+    }
+    
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = {
+            Text(stringResource(R.string.wix_bookings_booking_form_title))
+        },
+        text = {
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .verticalScroll(rememberScrollState()),
+                verticalArrangement = Arrangement.spacedBy(16.dp)
+            ) {
+                // Date picker
+                OutlinedButton(
+                    onClick = {
+                        // DatePicker would be shown here - simplified for this implementation
+                    },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .testTag("wix_bookings_date_picker")
+                ) {
+                    Icon(
+                        imageVector = Icons.Filled.CalendarToday,
+                        contentDescription = null,
+                        modifier = Modifier.size(18.dp)
+                    )
+                    Spacer(modifier = Modifier.width(8.dp))
+                    Text(
+                        text = selectedDate?.let {
+                            SimpleDateFormat("MMM dd, yyyy", Locale.getDefault()).format(Date(it))
+                        } ?: "Select Date"
+                    )
+                }
+                
+                // Time slots
+                if (selectedDate != null) {
+                    if (isLoadingSlots) {
+                        CircularProgressIndicator(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .testTag("wix_bookings_slots_loading")
+                        )
+                    } else if (availableSlots.isEmpty()) {
+                        Text(
+                            text = stringResource(R.string.wix_bookings_no_slots),
+                            style = MaterialTheme.typography.bodyMedium,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                            modifier = Modifier.testTag("wix_bookings_no_slots")
+                        )
+                    } else {
+                        Text(
+                            text = stringResource(R.string.wix_bookings_select_slot),
+                            style = MaterialTheme.typography.labelLarge
+                        )
+                        
+                        Spacer(modifier = Modifier.height(8.dp))
+                        
+                        Column(
+                            modifier = Modifier.testTag("wix_bookings_slots_grid"),
+                            verticalArrangement = Arrangement.spacedBy(8.dp)
+                        ) {
+                            availableSlots.forEach { slot ->
+                                FilterChip(
+                                    selected = selectedSlot?.slotId == slot.slotId,
+                                    onClick = { selectedSlot = slot },
+                                    label = {
+                                        Text(slot.startTime)
+                                    },
+                                    modifier = Modifier
+                                        .fillMaxWidth()
+                                        .testTag("wix_bookings_slot_${slot.slotId}")
+                                )
+                            }
+                        }
+                    }
+                }
+                
+                // Contact form
+                OutlinedTextField(
+                    value = contactName,
+                    onValueChange = { contactName = it },
+                    label = { Text(stringResource(R.string.wix_bookings_contact_name)) },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .testTag("wix_bookings_contact_name_field"),
+                    singleLine = true
+                )
+                
+                OutlinedTextField(
+                    value = contactEmail,
+                    onValueChange = { contactEmail = it },
+                    label = { Text(stringResource(R.string.wix_bookings_contact_email)) },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .testTag("wix_bookings_contact_email_field"),
+                    singleLine = true
+                )
+                
+                OutlinedTextField(
+                    value = contactPhone,
+                    onValueChange = { contactPhone = it },
+                    label = { Text(stringResource(R.string.wix_bookings_contact_phone)) },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .testTag("wix_bookings_contact_phone_field"),
+                    singleLine = true
+                )
+                
+                OutlinedTextField(
+                    value = contactNotes,
+                    onValueChange = { contactNotes = it },
+                    label = { Text(stringResource(R.string.wix_bookings_contact_notes)) },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .testTag("wix_bookings_contact_notes_field"),
+                    maxLines = 3
+                )
+            }
+        },
+        confirmButton = {
+            Button(
+                onClick = {
+                    if (activity != null && selectedSlot != null) {
+                        scope.launch {
+                            authManager.requireLogin(activity) {
+                                val contact = WixContactInfo(
+                                    name = contactName,
+                                    email = contactEmail,
+                                    phone = contactPhone.takeIf { it.isNotBlank() },
+                                    notes = contactNotes.takeIf { it.isNotBlank() }
+                                )
+                                
+                                val result = bookingsManager.bookService(
+                                    serviceId = service.id,
+                                    slotId = selectedSlot!!.slotId,
+                                    contact = contact
+                                )
+                                
+                                result.onSuccess {
+                                    onSuccess()
+                                }
+                            }
+                        }
+                    }
+                },
+                enabled = !isLoading && selectedSlot != null && contactName.isNotBlank() && contactEmail.isNotBlank(),
+                modifier = Modifier.testTag("wix_bookings_confirm_button")
+            ) {
+                if (isLoading) {
+                    CircularProgressIndicator(
+                        modifier = Modifier.size(18.dp),
+                        color = MaterialTheme.colorScheme.onPrimary
+                    )
+                } else {
+                    Text(stringResource(R.string.wix_bookings_confirm_button))
+                }
+            }
+        },
+        dismissButton = {
+            TextButton(
+                onClick = onDismiss,
+                modifier = Modifier.testTag("wix_bookings_cancel_button")
+            ) {
+                Text("Cancel")
+            }
+        },
+        modifier = modifier
+    )
+}