import box.tapsi.libs.utilities.* import box.tapsi.libs.utilities.validator.* // Common extensions val castedValue: String = anyObject.castOrThrow<String>() val persianNumbers = "12345".toPersianNumber() // "۱۲۳۴۵" // Security services @Autowired lateinit var encryptionService: EncryptionService val encrypted = encryptionService.encrypt("sensitive data", "salt") val decrypted = encryptionService.decrypt(encrypted, "salt") // Random code generation @Autowired lateinit var codeGenerator: CodeGenerator val uniqueCode = codeGenerator.generate(8, "ORDER") // "ORDER-12345678" // Time operations @Autowired lateinit var timeOperator: TimeOperator val now = timeOperator.now() val formattedDate = timeOperator.format(now, "yyyy-MM-dd") // Validation framework @Autowired lateinit var validatorFactory: ValidatorFactory val validator = validatorFactory.getValidator<User>("userValidator", "emailValidator") validator.validate(user).subscribe()

// Safe type casting val result: String = someObject.castOrThrow<String>() // Collection utilities val items = listOf("a", "b", "a", "c") val distinctLast = items.distinctLastBy { it } // ["b", "a", "c"] // Number conversion val persian = "123".toPersianNumber() // "۱۲۳" val english = "۱۲۳".toEnglishNumber() // "123" // Method reflection val method = MyClass::class.java.getMethod("getData") val isReactive = method.isReturningPublisher() // true if returns Mono/Flux

@Service class UserService( private val encryptionService: EncryptionService, private val hashService: HashService ) { fun createUser(password: String): User { val salt = encryptionService.generateSalt() val hashedPassword = hashService.hash(password, salt) return User( passwordHash = hashedPassword, salt = salt ) } fun verifyPassword(password: String, user: User): Boolean { return hashService.verify(password, user.passwordHash, user.salt) } }

// Mono extensions Mono.just("data") .withContext("key", "value") .subscribe() // Context utilities Mono.deferContextual { ctx -> val userId = ctx.get<String>("userId") getUserById(userId) }

@Service class SchedulingService( private val timeOperator: TimeOperator ) { fun scheduleTask() { val now = timeOperator.now() val tomorrow = timeOperator.addDays(now, 1) val formatted = timeOperator.format(tomorrow, "yyyy-MM-dd HH:mm:ss") // Schedule logic here } }

// Define custom validators @Component("emailValidator") class EmailValidator : Validator<User> { override fun validate(input: User): Mono<Void> { return if (input.email.isValidEmail()) { Mono.empty() } else { Mono.error(ValidationException("Invalid email format")) } } } @Component("ageValidator") class AgeValidator : Validator<User> { override fun validate(input: User): Mono<Void> { return if (input.age >= 18) { Mono.empty() } else { Mono.error(ValidationException("User must be at least 18 years old")) } } } // Use ValidatorFactory to combine validators @Service class UserService( private val validatorFactory: ValidatorFactory ) { fun createUser(user: User): Mono<User> { val validator = validatorFactory.getValidator<User>("emailValidator", "ageValidator") return validator.validate(user) .then(Mono.just(user)) .doOnNext { saveUser(it) } } } // Manual composite validator usage @Service class OrderService { fun validateOrder(order: Order): Mono<Void> { val validators = listOf( OrderAmountValidator(), OrderItemValidator(), OrderStatusValidator() ) val compositeValidator = CompositeValidator(validators) return compositeValidator.validate(order) } }

// Validator beans are automatically discovered and registered @Component("userValidator") class UserValidator : Validator<User> { ... } @Component("orderValidator") class OrderValidator : Validator<Order> { ... } // ValidatorFactory is automatically available for injection @Service class MyService( private val validatorFactory: ValidatorFactory ) { fun validateUser(user: User) { val validator = validatorFactory.getValidator<User>("userValidator") // Use validator... } }

@SpringBootTest class MyServiceTest { @Test fun `should encrypt and decrypt data`() { val encryptionService = EncryptionServiceImpl() val original = "test data" val salt = encryptionService.generateSalt() val encrypted = encryptionService.encrypt(original, salt) val decrypted = encryptionService.decrypt(encrypted, salt) assertEquals(original, decrypted) } @Test fun `should validate user with composite validator`() { val emailValidator = EmailValidator() val ageValidator = AgeValidator() val validators = listOf(emailValidator, ageValidator) val compositeValidator = CompositeValidator(validators) val validUser = User(email = "test@example.com", age = 25) compositeValidator.validate(validUser) .test() .verifyComplete() } @Test fun `should fail validation for invalid user`() { val emailValidator = EmailValidator() val ageValidator = AgeValidator() val validators = listOf(emailValidator, ageValidator) val compositeValidator = CompositeValidator(validators) val invalidUser = User(email = "invalid-email", age = 16) compositeValidator.validate(invalidUser) .test() .verifyError() } }