package some.packages
@Action
class MyAction {
fun someAssertion(b: Boolean) {
}
}
package some.packages
@Action
class MyAction {
fun someMethod(i: Int, b: Boolean) {
}
}
package some.packages
@Action
class MyAction {
fun someMethod(paymentMean: PaymentMean, b: Boolean) {
}
}
package some.packages
@Action
class MyAction {
fun someMethod(paymentMean: PaymentMean, b: Boolean?) {
}
}
package some.packages
@Action
class MyAction {
fun someMethod(paymentMean: PaymentMean, billingInfo: BillingInfo) {
}
}
package some.packages.infra
@Action
class MyAction {
fun someMethod() {
}
}
package some.packages.infra
@DomainService
class MyDomainService {
fun someMethod() {
}
}
package some.packages.action
@Repository
class MyRepository {
fun someMethod() {
}
}
package some.packages.action
@Gateway
class MyGateway {
fun someMethod() {
}
}
package some.packages.action
@Component
class MyComponent {
fun someMethod() {
}
}
package some.packages.infra.gateways.myservice
@Component
class MyComponent {
fun someMethod() {
}
}
package some.packages.actions
@Action
class MyAction {
fun someMethod() {
}
}
class MyClass {
fun someMethod() {
}
}
package some.packages
@Action
class MyAction {
fun someMethod() {
for (i in 0..10){
println("Hello World")
}
}
}
package some.packages
@Action
class MyAction {
private var hello = true
fun someMethod() {
if (hello){
var i = 0
while (i < 10){
println("Hello World")
i++
}
}
}
}
package some.packages
data class Traveler(val id: Int)
fun List<Traveler>.tookApart(toDo: (Traveler) -> Unit) = this.map { toDo(it) }
@Action
class MyAction {
private var hello = true
fun someMethod(theTravelers : List<Traveler>) {
theTravelers.tookApart { println ("Hello " + it) }
}
}
package some.packages
import org.springframework.web.client.RestTemplate
@Action
class MyAction {
fun someMethod() {
val template = RestTemplate()
val template2 = org.springframework.data.mongodb.core.MongoTemplate()
}
}
package some.packages
import org.springframework.web.client.RestTemplate
@DomainService
class MyDomainService {
fun someMethod() {
val template = RestTemplate()
val template2 = org.springframework.data.mongodb.core.MongoTemplate()
}
}
package some.packages
@DomainService
class MyAction {
private val userProfileReader: UserProfileReader
fun someMethod(val id: Int) {
val userProfile = userProfileReader.read(id)
}
}
package some.packages
import org.springframework.web.client.RestTemplate
@Gateway
class MyGateway {
fun someMethod() {
val template = RestTemplate()
val template2 = org.springframework.data.mongodb.core.MongoTemplate()
}
}
package some.packages
fun someMethod() {
var i
for (i in 0..10){
if (i == 2) continue
println (i + " (skipping 3)")
if (i == 4) break
}
}
package some.packages
@ForeignModel
data class A(val i: Int)
data class B(val j: Int)
@ForeignModel
data class C(val k: Int)
data class D(val l: Int)
package some.packages
@ForeignModel
data class A(val i: Int)
@ValueType
data class B(val j: Int)
@ForeignModel
data class C(val k: Int)
package some.packages
@Entity
@ForeignModel
data class Account(var id: ObjectId, var firstName: String, var lastName: String)
package some.packages
@Entity
data class Account(var id: ObjectId, var firstName: String, var lastName: String)
package some.packages
@Action
class MyAction1 {
}
@Action
class MyAction2 {
val action1: MyAction1
}
package some.packages
@Action
class MyAction1 {
val myAction2: MyAction2
}
@Action
class MyAction2 {
}
package some.packages
class MyClass {
private var myFieldOne: Int
private var myFieldTwo: String
private var myFieldThree: Boolean
}
package some.packages
class MyClass : Object {
private var myFieldOne: Int
private var myFieldTwo: String
private var myFieldThree: Boolean
}
package some.packages
@ValueType
data class MyClass (
val myFieldOne: Int,
val myFieldTwo: String,
val myFieldThree: Boolean
)
package some.packages
@ValueType
data class MyClass (
val myFieldOne: Int,
val myFieldTwo: String,
val myFieldThree: Map<String, Any>
)
package some.packages
fun someMethod() {
val i = 0
var below2 = false
if (i > 0)
below2 = if (i < 2) true else false
}
package some.packages
fun someMethod() {
val i = 0
if (i < 0)
println("i must be below 0")
else if (i >= 0)
println ("i must be equal to 0")
}
package some.packages
fun someMethod() {
val i = 0
if (i <= 0) {
if (i >= 0) {
println ("i must be equal to 0")
}
}
}
package org.toilelibre.libe.domaindrivendesignktrules
import kotlin.String
import org.toilelibre.libe.domaindrivendesignktrules.A
@Action
class B {
fun testingTheViolation(a: A) {
}
}
@ForeignModel
data class A
package org.toilelibre.libe.domaindrivendesignktrules
import kotlin.String
import org.toilelibre.libe.domaindrivendesignktrules.A
@ForeignModel
data class A
@Action
class B {
fun testingTheViolation(a: A) {
}
}
package org.toilelibre.libe.domaindrivendesignktrules
import kotlin.String
import org.toilelibre.libe.domaindrivendesignktrules.A
@ForeignModel
data class A
@Gateway
class B {
fun testingTheViolation(a: A) {
}
}
package org.toilelibre.libe.domaindrivendesignktrules
import kotlin.String
import org.toilelibre.libe.domaindrivendesignktrules.A
@ForeignModel
data class A
@Gateway
class B {
private fun testingTheViolation(a: A) {
}
}
package org.toilelibre.libe.domaindrivendesignktrules
import org.toilelibre.libe.domaindrivendesignktrules.A
@ForeignModel
data class A(val e: Int)
@ValueType
data class C(val f: Int)
@Action
class B {
fun testingTheViolation(): A {
return A()
}
}
package org.toilelibre.libe.domaindrivendesignktrules
import kotlin.String
import org.toilelibre.libe.domaindrivendesignktrules.A
@ForeignModel
data class A
@DomainService
class B {
fun testingTheViolation(a: A) {
}
}
package some.packages.actions
import some.packages.domain.transverse.DomainDrivenDesignAnnotations.Action
import some.packages.infra.database.Storage
import org.bson.types.ObjectId
@Entity
data class Instance(val id: Int)
@Action
class GetInstanceByRowId(private val storage: Storage) {
infix fun retrievePaymentBy(`an id`: ObjectId): Instance? = storage rowMatching `an id`
}
package some.packages.infra.endpoint
import some.packages.actions.HandleVerifyRequest
@Action
class HandleVerifyRequest {
fun with(verifyOperationRequest: VerifyOperationRequest){
}
}
@Controller
class TheController(val handleVerifyRequest: HandleVerifyRequest) {
fun performVerify(
@RequestBody verifyOperationRequest: VerifyOperationRequest
) = runBlocking {
handleVerifyRequest.with(verifyOperationRequest)
}
}
package some.packages
@Action
class TheAction {
fun doIt(){
}
}
@Controller
class TheController {
fun someMethod() {
println("Hello world")
}
}
package some.packages
class TheController {
@RabbitListener
fun someMethod() {
println("Hello world")
}
}
package some.packages
class TheController {
@EventListener
fun someMethod() {
println("Hello world")
}
}
package some.packages
fun someMethod() {
try {
println("Hello World")
} catch (e: Exception){
}
}
package some.packages
@Repository
class MyRepository(var dataSource: DataSource, private var jdbcUrl: String, val password: String){
fun find(id: ObjectId){ // this should be allowed
var ref = id.toString() // this should be allowed
return dataSource.findOne(ref)
}
}
package some.packages
@Entity
@ForeignModel
data class Account(val id: ObjectId, val firstName: String, val lastName: String)
package some.packages
class Tester(id: ObjectId) {
fun isValid(){
return true
}
}
package some.packages
class Tester(override var id: ObjectId) {
fun isValid(){
return true
}
}
package some.packages
@Action
class MyAction {
fun doIt(){
this.doItBetter()
}
private fun doItBetter(){
}
fun doItAgain(){
this.doItAgainBetter()
}
private fun doItAgainBetter(){
}
}
package some.packages
@Action
class MyAction {
fun doIt(){
}
}
package com.egencia.service.infra.test1
import com.egencia.service.infra.test1.Test1
import com.egencia.service.infra.test2.Test2
@DomainService
class HelloIT
package com.egencia.service.infra.test1
import com.egencia.service.infra.test1.Test1
import com.egencia.service.infra.test2.Test2
@DomainService
class MyTest
package com.egencia.service.domain.ktlintrules
import com.egencia.service.infra.test1.Test1
import com.egencia.service.infra.test2.Test2
@DomainService
class Hello
package com.egencia.service.infra.test1
import com.egencia.service.infra.test1.Test1
import com.egencia.service.infra.test1.Test11
@Gateway
class Hello
package com.egencia.service.infra.test1
import com.egencia.service.infra.test1.Test1
import com.egencia.service.infra.test2.Test2
@Configuration
class TestConfiguration
package com.egencia.service.infra.test1
import com.egencia.service.infra.test1.Test1
import com.egencia.service.infra.test2.Test2
@Gateway
class Hello
package some.packages
@ValueType
data class Currency {
fun rate(olderCurrency: Currency): Float {
return CURRENCY_TABLE[olderCurrency]
}
}
@ValueType
data class Price (
val currency: Currency,
val amount: Float,
) {
fun toCurrency(newCurrency: Currency): Float {
return newCurrency.rate(currency) * amount
}
}
package some.packages
@ValueType
data class Currency(val name: String, val currencyTable: Map<String, Float>)
class PriceConverter(val currencyHelper: CurrencyHelper) {
fun getRate(newCurrency: Currency): Float {
return currencyHelper.extractRateFromCurrencyTable(currency.name, newCurrency.name)
}
}
package com.company.service.test.infra.gateways.configservice
import com.company.library.configuration.configservice.resolver.ConfigurationResolver
import com.company.library.configuration.configservice.resolver.ResolverParams
import com.company.service.test.infra.gateways.configservice.ProductAndTravelerReferences
import com.company.service.test.domain.transverse.DomainDrivenDesignAnnotations.Gateway
@ValueType
data class ProductAndTravelerReferences(pointOfSale: PointOfSale, company: Company, productsAndTravelersMapping: List<Mapping>)
@Gateway
class ArrangerCardsToggler(private val config: ConfigurationResolver) {
infix fun displayOrHideArrangerCardsAccordingTo(theInput: ProductAndTravelerReferences): Boolean =
theInput.productsAndTravelersMapping.any {
val params = ResolverParams()
.withProductId(theInput.pointOfSale.code)
.withCompanyId(theInput.company.id.value)
.withStripe("lineOfBusiness", it.designation.lineOfBusiness.name)
config.resolve("arrangerCreditCardAllowed", params) as String? == "true" &&
config.resolve("arrangercc", params) as String? == "1"
}
}
package com.company.service.test.domain.booking
import com.company.service.test.domain.payment.Instance
import com.company.service.test.domain.payment.search.RetrievePayment
import com.company.service.test.domain.transverse.DomainDrivenDesignAnnotations.DomainService
import org.slf4j.LoggerFactory
@ValueType
data class Booking(val id: String?, val bookingContext: BookingContext?, val traveler: Traveler) {
val rightOriginalBookingPaymentInstanceId get() = id
val hasProvidedAnOriginalBookingPaymentInstance get() = id != 0
}
@DomainService
class RetrieveOriginalBookingPaymentInstance(private val retrieveOriginalPayment: RetrievePayment) {
fun fromThe(booking: Booking) =
if (booking.hasProvidedAnOriginalBookingPaymentInstance)
retrieveOriginalPayment byIdFromThe booking
?: retrieveOriginalPayment byLookingToHistoryFromThe booking
else null
companion object {
private val LOGGER = LoggerFactory.getLogger(RetrieveOriginalBookingPaymentInstance::class.java)
private infix fun RetrievePayment.byIdFromThe(booking: Booking) =
by(listOf(booking.rightOriginalBookingPaymentInstanceId!!))
.firstOrNull()
.takeIf { it?.bookingContext?.userId == booking.traveler.userId }
}
}
package some.packages
@ValueType
data class Currency(val name: String, val currencyTable: Map<String, Float>)
class PriceConverter(val currencyHelper: CurrencyHelper) {
fun getRate(newCurrency: Currency): Float {
return this.delegateToCurrencyHelper(newCurrency)
}
private fun delegateToCurrencyHelper(newCurrency: Currency) {
return currencyHelper.extractRateFromCurrencyTable(currency.name, newCurrency.name)
}
}
package some.packages
@ValueType
data class ProductNotAvailableException(val name: String): RuntimeException
@ControllerAdvice
class ExceptionHandler() {
@ExceptionHandler(ProductNotAvailableException::class)
@ResponseStatus(value = HttpStatus.BAD_REQUEST)
@ResponseBody
fun handleAProductNotAvailableException(productNotAvailableException: ProductNotAvailableException): ErrorNode {
LOGGER.error(ex.message, ex)
return ErrorNode(name = productNotAvailableException.name, errorDescription = productNotAvailableException.message)
}
}
package some.packages
@ValueType
data class Currency(val name: String, val currencyTable: Map<String, Float>)
class PriceConverter {
fun getRate(newCurrency: Currency): Float {
return newCurrency.currencyTable[currency.name]
}
}
package some.packages
import org.springframework.web.client.RestTemplate
@Gateway
class MyGateway {
private val restTemplate1: RestTemplate
private val restTemplate2: RestTemplate
}
package some.packages
import org.springframework.web.client.RestTemplate
import org.springframework.data.mongodb.core.MongoTemplate
@Gateway
class MyGateway {
private val restTemplate: RestTemplate
private val mongoTemplate: MongoTemplate
}
package some.packages
import org.springframework.web.client.RestTemplate
import org.springframework.data.mongodb.core.MongoTemplate
@Repository
class MyRepository {
private val restTemplate: RestTemplate
private val mongoTemplate: MongoTemplate
}
package some.packages
import org.springframework.web.client.RestTemplate
import org.springframework.data.mongodb.core.MongoTemplate
@Repository
class MyRepository {
private val mongoTemplate: MongoTemplate
}
package some.packages
import org.springframework.web.client.RestTemplate
import org.springframework.data.mongodb.core.MongoTemplate
@Repository
class MyRepository {
private val mongoTemplate: MongoTemplate
}
package some.packages
@ValueType
data class Price (
val currency: Currency,
val amount: Float,
) {
fun toCurrency(newCurrency: Currency): Float {
return Currency.rate(currency, newCurrency) * amount
}
}
package some.packages
@ValueType
data class Price (
@Inject
val currencyConverter: CurrencyConverter,
val amount: Float,
) {
fun toCurrency(newCurrency: Currency): Float {
return currencyConverter.rate(currency, newCurrency) * amount
}
}
package some.packages
@ValueType
data class USDPrice (
val amount: Float,
) {
fun getInEuros(@Autowired currencyConverter: CurrencyConverter): Float {
return currencyConverter.rate("USD", "EUR") * amount
}
}