Freelancer Kotlin no Brasil: Como Comecar e Prosperar | Kotlin Brasil

// Tipo de projeto comum: MVP de app para startup
// Demonstra competencia tecnica e organizacao

@HiltViewModel
class HomeViewModel @Inject constructor(
    private val getPopularProducts: GetPopularProductsUseCase,
    private val searchProducts: SearchProductsUseCase,
    private val analytics: AnalyticsTracker
) : ViewModel() {

    private val _uiState = MutableStateFlow(HomeUiState())
    val uiState: StateFlow<HomeUiState> = _uiState.asStateFlow()

    private val searchQuery = MutableStateFlow("")

    init {
        carregarProdutosPopulares()
        observarBusca()
    }

    private fun carregarProdutosPopulares() {
        viewModelScope.launch {
            getPopularProducts()
                .onSuccess { produtos ->
                    _uiState.update { it.copy(
                        populares = produtos,
                        loading = false
                    )}
                }
                .onFailure { erro ->
                    _uiState.update { it.copy(
                        error = erro.message,
                        loading = false
                    )}
                }
        }
    }

    private fun observarBusca() {
        viewModelScope.launch {
            searchQuery
                .debounce(300)
                .filter { it.length >= 3 }
                .distinctUntilChanged()
                .flatMapLatest { query ->
                    flow {
                        emit(searchProducts(query))
                    }
                }
                .collect { result ->
                    result.onSuccess { produtos ->
                        _uiState.update { it.copy(resultadosBusca = produtos) }
                        analytics.track("search_completed")
                    }
                }
        }
    }

    fun onSearchQueryChanged(query: String) {
        searchQuery.value = query
    }
}

// API para e-commerce - Projeto freelance tipico
@Configuration
class SecurityConfig {
    @Bean
    fun securityFilterChain(http: HttpSecurity): SecurityFilterChain {
        return http
            .csrf { it.disable() }
            .authorizeHttpRequests { auth ->
                auth
                    .requestMatchers("/api/public/**").permitAll()
                    .requestMatchers("/api/admin/**").hasRole("ADMIN")
                    .anyRequest().authenticated()
            }
            .oauth2ResourceServer { it.jwt {} }
            .build()
    }
}

@Service
class OrderService(
    private val orderRepository: OrderRepository,
    private val paymentGateway: PaymentGateway,
    private val notificationService: NotificationService,
    private val inventoryService: InventoryService
) {
    @Transactional
    suspend fun processOrder(request: CreateOrderRequest): Order {
        // Validar estoque
        val items = request.items.map { item ->
            val available = inventoryService.checkAvailability(
                item.productId, item.quantity
            )
            if (!available) {
                throw InsufficientStockException(item.productId)
            }
            item.toOrderItem()
        }

        // Criar pedido
        val order = Order(
            id = OrderId.generate(),
            customerId = request.customerId,
            items = items,
            total = items.sumOf { it.subtotal },
            status = OrderStatus.PENDING
        )

        val saved = orderRepository.save(order)

        // Processar pagamento
        val payment = paymentGateway.charge(
            amount = order.total,
            customerId = order.customerId,
            orderId = order.id
        )

        // Atualizar status e notificar
        val updated = saved.copy(
            status = if (payment.approved) OrderStatus.PAID else OrderStatus.PAYMENT_FAILED,
            paymentId = payment.id
        )
        orderRepository.save(updated)

        if (payment.approved) {
            inventoryService.reserve(items)
            notificationService.sendOrderConfirmation(updated)
        }

        return updated
    }
}

// Servico de consultoria: migrar codigo Java legado para Kotlin idiomatico

// ANTES (Java convertido literalmente)
class UserService(private val repository: UserRepository) {
    fun getUser(id: String): User? {
        val user = repository.findById(id)
        if (user != null) {
            if (user.isActive()) {
                return user
            } else {
                return null
            }
        }
        return null
    }
}

// DEPOIS (Kotlin idiomatico)
class UserService(private val repository: UserRepository) {
    fun getUser(id: String): User? {
        return repository.findById(id)?.takeIf { it.isActive }
    }
}