이탈리아 정육점 주문관리 시스템 개발기

// android/app/build.gradle.kts
flavorDimensions += "app"
productFlavors {
    create("customer") {
        dimension = "app"
        applicationId = "dev.nariinfo.mazzucchi.customer"
        resValue("string", "app_name", "Macelleria Mazzucchi")
    }
    create("admin") {
        dimension = "app"
        applicationId = "dev.nariinfo.mazzucchi"
        resValue("string", "app_name", "Mazzucchi Admin")
    }
}

# scripts/build_ios_ipa.sh
case "$flavor" in
  customer)
    target="lib/main_customer.dart"
    bundle_id="dev.nariinfo.mazzucchi.customer"
    entitlements="Runner/Runner.entitlements"
    ;;
  admin)
    target="lib/main.dart"
    bundle_id="dev.nariinfo.mazzucchi.admin"
    entitlements="Runner/Admin.entitlements"
    ;;
esac
 
cat > "$app_flavor_file" <<EOF
APP_BUNDLE_ID=$bundle_id
APP_DISPLAY_NAME=$display_name
APP_ENTITLEMENTS=$entitlements
EOF

// models/Products.kt — Exposed table definition
object Products : UUIDTable("products") {
    val pricePerUnit = decimal("price_per_unit", 10, 2)
    val unitType     = varchar("unit_type", 20)          // "kg" | "pz"
    val isAvailable  = bool("is_available").default(true)
    val isDeleted    = bool("is_deleted").default(false) // soft delete (protects FKs)
    val categoryId   = reference("category_id", Categories)
    val createdAt    = datetime("created_at").defaultExpression(CurrentDateTime)
}

@Serializable
data class FinalizeOrderItemRequest(
    val orderItemId: String,    // OrderItem UUID
    val actualQuantity: Double  // measured weight
)
 
@Serializable
data class FinalizeOrderRequest(
    val items: List<FinalizeOrderItemRequest>,
    val totalPrice: Double      // final billed amount
)

// repositories/OrderRepository.kt
suspend fun finalizeOrder(id: String, request: FinalizeOrderRequest): Boolean = runCatching {
    dbQuery {
        // 1. Bulk-update measured weights (single SQL)
        val validated = request.items.map {
            UUID.fromString(it.orderItemId) to it.actualQuantity  // throws on bad UUID
        }
        val cases = validated.joinToString(" ") { (uuid, qty) -> "WHEN '$uuid' THEN $qty" }
        val ids   = validated.joinToString(",") { (uuid, _) -> "'$uuid'" }
 
        TransactionManager.current().exec("""
            UPDATE order_items
            SET actual_quantity = CASE id $cases END
            WHERE id IN ($ids)
        """.trimIndent())
 
        // 2. Fix the final price + transition to COMPLETED
        Orders.update({ Orders.id eq UUID.fromString(id) }) {
            it[totalPrice]  = request.totalPrice.toBigDecimal()
            it[status]      = "COMPLETED"
            it[completedAt] = LocalDateTime.now()
        } > 0
    }
}.getOrDefault(false)

// models/Orders.kt
object Orders : UUIDTable("orders") {
    // ...
    init {
        index(false, status, completedAt) // sales report: WHERE status='COMPLETED' AND ...
        index(false, scheduledAt)         // slot lookups · daily order list
        index(false, customerId)          // per-customer order history
    }
}

// plugins/Cache.kt
object ProductCache {
    private val cache = ConcurrentHashMap<String, ProductData>()
 
    suspend fun reload() = dbQuery {
        // includes soft-deleted products — needed for past-order lookups
        val rows = (Products leftJoin ProductTranslations).selectAll().toList()
 
        val newCache = rows
            .groupBy { it[Products.id].value.toString() }
            .mapValues { (_, productRows) -> /* build per-language translation map */ }
        // ...
    }
}

// plugins/ApnsService.kt — provider token signing (cached 50 min)
private fun providerToken(): String {
    cachedProviderToken?.let { if (it.expiresAt.isAfter(now.plusSeconds(60))) return it.token }
 
    val header  = """{"alg":"ES256","kid":"${keyId()}"}"""
    val payload = """{"iss":"${teamId()}","iat":${now.epochSecond}}"""
    val signingInput = "${base64Url(header)}.${base64Url(payload)}"
    val token = "$signingInput.${base64Url(signEs256(signingInput.toByteArray()))}"
 
    cachedProviderToken = CachedProviderToken(token, now.plusSeconds(50 * 60))
    return token
}

// DER (SEQUENCE of two INTEGERs) → JOSE (r ‖ s, 32 bytes each)
private fun derToJose(der: ByteArray, outputLength: Int): ByteArray {
    var offset = 2
    val rLength = der[offset + 1].toInt()
    val r = der.copyOfRange(offset + 2, offset + 2 + rLength)
    offset += 2 + rLength
    val sLength = der[offset + 1].toInt()
    val s = der.copyOfRange(offset + 2, offset + 2 + sLength)
 
    val jose = ByteArray(outputLength)
    copyUnsigned(BigInteger(1, r).toByteArray(), jose, 0, outputLength / 2)
    copyUnsigned(BigInteger(1, s).toByteArray(), jose, outputLength / 2, outputLength / 2)
    return jose
}

# deploy.sh — deployment, kept boring on purpose
rsync -avz --exclude 'backend/build' --exclude 'frontend' ./ "$SERVER:$REMOTE_DIR/"
ssh "$SERVER" "cd $REMOTE_DIR/infra && docker compose --profile production up -d --build"