Some regservice tests

PartnerApiITEx.kt

package megaproject.backend.features.itex

import megaproject.backend.APPLICATION_JSON_UTF8
import megaproject.backend.config.WithMockSuperuser
import megaproject.backend.convertAnyToJsonBytes
import megaproject.backend.core.cqrs.findOneOrThrow
import megaproject.backend.doLogJson
import megaproject.backend.features.catalog.command.AddOrganizationToCatalog
import megaproject.backend.features.catalog.command.CreateEstateObject
import megaproject.backend.features.catalog.command.CreateOrganizationPersonInCatalog
import megaproject.backend.features.catalog.command.dto.EstateObjectData
import megaproject.backend.features.catalog.command.dto.OrganizationData
import megaproject.backend.features.catalog.command.dto.RosreestrDivisionData
import megaproject.backend.features.catalog.domain.CatalogItemState
import megaproject.backend.features.catalog.domain.EstateObjectDetails
import megaproject.backend.features.catalog.domain.RegNumberType
import megaproject.backend.features.catalog.domain.type.OrganizationType
import megaproject.backend.features.catalog.repository.OrganizationPersonRepository
import megaproject.backend.features.catalog.repository.OrganizationRepository
import megaproject.backend.features.common.domain.spi.AnyOrganization
import megaproject.backend.features.integration.partner.model.CustomerPersonApiData
import megaproject.backend.features.integration.partner.model.OrderApiData
import megaproject.backend.features.integration.partner.model.OrderEstateObjectApiData
import megaproject.backend.features.integration.partner.model.OrderOrganizationSignerApiData
import megaproject.backend.features.integration.partner.query.GetOrganizationsApiData
import megaproject.backend.features.integration.partner.web.EstateObjectPublicApiResource
import megaproject.backend.features.integration.partner.web.OrderDataPublicApiResource
import megaproject.backend.features.integration.partner.web.OrganizationPersonPublicApiResource
import megaproject.backend.features.integration.partner.web.OrganizationPublicApiResource
import megaproject.backend.features.operator.command.data.CreateUserByEmailData
import megaproject.backend.features.order.domain.type.AgreementType
import megaproject.backend.features.order.service.UserModeToolset
import megaproject.backend.features.poa.domain.PoaInfo
import megaproject.backend.features.user.comman.userIds
import megaproject.backend.features.user.domain.AuthorityConstants
import megaproject.backend.features.user.domain.UserIds
import megaproject.backend.generator.DadataAddressGenerator
import megaproject.backend.generator.OrganizationGenerator
import megaproject.backend.generator.PersonGenerator
import megaproject.backend.generator.RosreestrDivisionGenerator
import megaproject.backend.generator.randomNumericString
import megaproject.backend.getIdValue
import java.time.LocalDate
import mu.KLogging
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.mockito.MockitoAnnotations
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.data.domain.Pageable
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
import org.springframework.test.web.servlet.result.MockMvcResultHandlers
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
import org.springframework.test.web.servlet.setup.MockMvcBuilders

@WithMockSuperuser
class PartnerApiITEx : UserModeToolset() {

    @Autowired
    lateinit var organizationRepository: OrganizationRepository

    @Autowired
    lateinit var organizationPersonRepository: OrganizationPersonRepository

    @BeforeEach
    fun setUp() {
        MockitoAnnotations.initMocks(this)

        val estateObjectResource = EstateObjectPublicApiResource(
            handlerServiceProvider,
            managerPersonService,
            appProperties
        )

        val organizationsResource = OrganizationPublicApiResource(
            handlerServiceProvider,
            managerPersonService,
            appProperties
        )

        val organizationPersonPublicApiResource = OrganizationPersonPublicApiResource(
            handlerServiceProvider,
            managerPersonService,
            appProperties
        )

        val orderResource = OrderDataPublicApiResource(
            handlerServiceProvider,
            managerPersonService,
            appProperties
        )

        publicApiPrefixValue = appProperties.publicApi.prefix.orEmpty()

        mockMvc = MockMvcBuilders.standaloneSetup(
            estateObjectResource,
            organizationsResource,
            organizationPersonPublicApiResource,
            orderResource
        )
            .addPlaceholderValue(publicApiPrefix, publicApiPrefixValue)
            .setCustomArgumentResolvers(pageableArgumentResolver)
            .setControllerAdvice(errorHandling)
            .setMessageConverters(jacksonMessageConverter)
            .build()
    }

    @Test
    fun `test create partner`() {
        val brokerOrgId =
            organizationInitializer.createOrganization(OrganizationType.BROKER)

        val brokerOrg = brokerMode(brokerOrgId)

        assertThat(brokerOrg.whoAmI())
            .isEqualTo(OrganizationType.BROKER)
        assertThat(brokerOrg.organizationId()).isNotEqualTo(
            DEFAULT_ORGANIZATION_ID
        )

        actions {

            var userIds: UserIds? = null
            operator(brokerOrgId) {
                val addUserCmd = addUser(generateNewId()) {
                    CreateUserByEmailData(
                        email = "broker${randomNumericString(5)}@anyemail${randomNumericString(
                            2
                        )}.com",
                        sendConfirmEmail = false
                    )
                }.applyOnService()
                userIds = addUserCmd.userIds()
                user(userIds?.userId!!) {
                    addAuthority(AuthorityConstants.PUBLIC_API)
                        .applyOnService()

                    longTermSwt().query().apply {
                        logger.info { "token: $token" }

                        extractUserRoles(token).query()?.let {
                            logger.info { "JWT Roles:" + it.roles }
                        }
                    }
                }
            }

            withTestManager(userIds!!) {
                val organizationCmd =
                    OrganizationGenerator.organizationCatalogData.let {
                        val id = generateNewId()

                        AddOrganizationToCatalog(
                            organizationId = id,
                            apiKey = id.toString(),
                            organizationType = OrganizationType.AGENT,
                            data = it.getNew(false),
                            state = CatalogItemState.APPROVED
                        ).applyOnService()
                    }

                val catalogOrg =
                    organizationRepository.findOneOrThrow(organizationCmd.organizationId)

                // Check DB record
                assertThat(catalogOrg.recordOwnerId).isEqualTo(userIds?.organizationId!!)
                assertThat(catalogOrg.catalogItemState).isEqualTo(
                    CatalogItemState.APPROVED
                )
                assertThat(catalogOrg.organizationType).isEqualTo(
                    OrganizationType.AGENT
                )
                assertThat(catalogOrg.catalogItem).isTrue()
                assertThat(catalogOrg.deleted).isFalse()

                GetOrganizationsApiData(
                    recordOwnerId = userIds?.organizationId!!,
                    pageable = Pageable.unpaged(),
                    state = CatalogItemState.APPROVED
                ).query()
                    .apply {
                        assertThat(content.size).isGreaterThan(0)
                    }

                mockMvc.perform(get("$publicApiPrefixValue/catalog/organizations"))
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(status().isOk)

                mockMvc.perform(get("$publicApiPrefixValue/catalog/organizations/${catalogOrg.id}"))
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(status().isOk)

                val newOrgPerson =
                    PersonGenerator.organizationPerson.generateNewData().let {
                        CreateOrganizationPersonInCatalog(
                            organizationId = catalogOrg.id,
                            personId = uuidSequence.newId(),
                            data = it,
                            poaRequired = it.poaRequired,
                            poaInfo = PoaInfo(
                                poaIssuedDate = it.poaIssuedDate,
                                poaExpirationDate = it.poaExpirationDate,
                                poaExpirationNever = it.poaExpirationNever
                            ),
                            position = it.modPosition()
                        )
                            .applyOnService()
                    }

                organizationPersonRepository.findByOrganizationId(catalogOrg.id)
                    .apply {
                        assertThat(this).isNotEmpty
                        forEach {
                            assertThat(it.recordOwnerId).isEqualTo(userIds?.organizationId)
                            assertThat(it.recordOwnerId).isEqualTo(userIds?.organizationId)
                        }
                    }

                mockMvc.perform(
                    get("$publicApiPrefixValue/catalog/persons").param(
                        "organizationKey", catalogOrg.id.toString()
                    )
                )
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(status().isOk)

                mockMvc.perform(
                    get("$publicApiPrefixValue/catalog/persons/${newOrgPerson.personId}").param(
                        "organizationKey", catalogOrg.id.toString()
                    )
                )
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(status().isOk)

                val signerApiData = OrderOrganizationSignerApiData(
                    organizationKey = catalogOrg.id.toString(),
                    personKey = newOrgPerson.personId.toString()
                )

                val newEstateObject = catalogOrg.let { OrganizationData(it) }
                    .createEstateObjectData().let {
                        CreateEstateObject(
                            id = generateNewId(),
                            state = CatalogItemState.APPROVED,
                            data = it.copy(
                                organizationId = it.organizationId
                                    ?: catalogOrg.id
                            )
                        ).apply {
                            assertThat(data.organizationId).isNotNull()
                        }
                    }
                    .applyOnService()
                    .apply {
                        assertThat(id).isNotEqualTo(organizationId)
                        assertThat(organizationId).isNotNull()
                    }

                mockMvc.perform(get("$publicApiPrefixValue/catalog/estate-objects"))
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(status().isOk)

                mockMvc.perform(get("$publicApiPrefixValue/catalog/estate-objects/${newEstateObject.id}"))
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(status().isOk)

                val draft = draftDsl(
                    developer = signerApiData,
                    estateObject = OrderEstateObjectApiData(
                        estateObjectKey = newEstateObject.id.toString(),
                        aptNr = 23,
                        floor = 3,
                        area = 234.2
                    )
                )

                draft.doLogJson("Draft", logger)

                val createResult = mockMvc.perform(
                    post("$publicApiPrefixValue/orders/draft")
                    .contentType(APPLICATION_JSON_UTF8)
                    .content(convertAnyToJsonBytes(draft)
                    )
                )
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(status().isOk)

                val orderApiKey = createResult.andReturn().getIdValue("apiKey")

                mockMvc.perform(
                    get("$publicApiPrefixValue/orders/$orderApiKey/status")
                )
                    .andDo(MockMvcResultHandlers.print())
                    .andExpect(status().isOk)
            }
        }
    }

    private fun AnyOrganization.createEstateObjectData(): EstateObjectData {
        return EstateObjectData(
            objectName = "New Mega Apartment " + randomNumericString(2),
            organizationId = this.organizationId,
            registrationAddress = DadataAddressGenerator.getNew(),
            objectArea = 9999.0,
            regNumber = RosreestrDivisionGenerator.registry.randomRegNumber(),
            regNumberType = RegNumberType.KN,
            details = EstateObjectDetails(
                organizationData = OrganizationData.fromAnyOrganization(this),
                rosreestrDivision = RosreestrDivisionData(
                    okato = RosreestrDivisionGenerator.okato(),
                    oktmo = RosreestrDivisionGenerator.oktmo()
                )
            )
        )
    }

    fun draftDsl(
        developer: OrderOrganizationSignerApiData,
        estateObject: OrderEstateObjectApiData
    ): OrderApiData {
        val tmpl = createDraftTemplate {
            withDeveloper {
                developer
            }

            customer {
                PersonGenerator.customer.getNew().let { CustomerPersonApiData(it) }
            }

            withEstateObject {
                estateObject
            }

            withAgreementType {
                AgreementType.DDU
            }

            withAgreementDate {
                LocalDate.now()
            }

            withAgreementNr {
                "368389"
            }
        }
            .order()

        tmpl.doLogJson("Draft Order", logger)
        return tmpl
    }

    private fun createDraftTemplate(action: DraftTemplate.() -> Unit): DraftTemplate {
        val draftTemplate = DraftTemplate()
        return action.invoke(draftTemplate).let { draftTemplate }
    }

    inner class DraftTemplate {

        private var order: OrderApiData = OrderApiData()

        fun order() = order.copy()

        fun developer(data: OrderOrganizationSignerApiData.() -> Unit) {
            order = order.copy(
                developer = OrderOrganizationSignerApiData().apply {
                    data.invoke(
                        this
                    )
                }
            )
        }

        fun withDeveloper(data: () -> OrderOrganizationSignerApiData) {
            order = order.copy(
                developer = data.invoke()
            )
        }

        fun estateObject(data: OrderEstateObjectApiData.() -> Unit) {
            order = order.copy(
                estateObject = OrderEstateObjectApiData().apply { data.invoke(this) }
            )
        }

        fun withEstateObject(data: () -> OrderEstateObjectApiData) {
            order = order.copy(
                estateObject = data.invoke()
            )
        }

        fun withAgreementType(data: () -> AgreementType) {
            order = order.copy(
                agreementType = data.invoke()
            )
        }

        fun withAgreementDate(data: () -> LocalDate) {
            order = order.copy(
                agreementDate = data.invoke()
            )
        }

        fun withAgreementNr(data: () -> String) {
            order = order.copy(
                agreementNr = data.invoke()
            )
        }

        fun withCustomer(data: CustomerPersonApiData.() -> Unit) {
            order = order.copy(
                customers = listOf(CustomerPersonApiData().apply { data.invoke(this) })
            )
        }

        fun customer(data: () -> CustomerPersonApiData) {
            order = order.copy(
                customers = listOf(data.invoke())
            )
        }
    }

    companion object : KLogging()
}