io.hackle.sdk.internal.workspace.DefaultWorkspace.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of hackle-server-sdk Show documentation
Hackle SDK for Java and Kotlin
The newest version!
package io.hackle.sdk.internal.workspace

import io.hackle.sdk.core.model.*
import io.hackle.sdk.core.model.Experiment.Type.AB_TEST
import io.hackle.sdk.core.model.Experiment.Type.FEATURE_FLAG
import io.hackle.sdk.core.workspace.Workspace

/**
 * @author Yong
 */
internal class DefaultWorkspace(
    override val id: Long,
    override val environmentId: Long,
    override val experiments: List,
    override val featureFlags: List,
    private val eventTypes: Map,
    private val buckets: Map,
    private val segments: Map,
    private val containers: Map,
    private val parameterConfigurations: Map,
    private val remoteConfigParameters: Map
) : Workspace {

    override val inAppMessages: List get() = emptyList()

    private val _experiments = experiments.associateBy { it.key }
    private val _featureFlags = featureFlags.associateBy { it.key }

    override fun getEventTypeOrNull(eventTypeKey: String): EventType? {
        return eventTypes[eventTypeKey]
    }

    override fun getFeatureFlagOrNull(featureKey: Long): Experiment? {
        return _featureFlags[featureKey]
    }

    override fun getExperimentOrNull(experimentKey: Long): Experiment? {
        return _experiments[experimentKey]
    }

    override fun getBucketOrNull(bucketId: Long): Bucket? {
        return buckets[bucketId]
    }

    override fun getSegmentOrNull(segmentKey: String): Segment? {
        return segments[segmentKey]
    }

    override fun getContainerOrNull(containerId: Long): Container? {
        return containers[containerId]
    }

    override fun getParameterConfigurationOrNull(parameterConfigurationId: Long): ParameterConfiguration? {
        return parameterConfigurations[parameterConfigurationId]
    }

    override fun getRemoteConfigParameterOrNull(parameterKey: String): RemoteConfigParameter? {
        return remoteConfigParameters[parameterKey]
    }

    override fun getInAppMessageOrNull(inAppMessageKey: Long): InAppMessage? {
        return null
    }

    companion object {
        fun from(dto: WorkspaceConfigDto): Workspace {

            val experiments: List = dto.experiments.mapNotNull { it.toExperimentOrNull(AB_TEST) }

            val featureFlags: List = dto.featureFlags.mapNotNull { it.toExperimentOrNull(FEATURE_FLAG) }

            val eventTypes: Map = dto.events.associate { it.key to it.toEventType() }

            val buckets: Map =
                dto.buckets.associate { it.id to it.toBucket() }

            val segments =
                dto.segments.asSequence()
                    .mapNotNull { it.toSegmentOrNull() }
                    .associateBy { it.key }

            val containers = dto.containers.asSequence()
                .map { it.toContainer() }
                .associateBy { it.id }

            val parameterConfigurations =
                dto.parameterConfigurations.asSequence()
                    .map { it.toParameterConfiguration() }
                    .associateBy { it.id }

            val remoteConfigParameters = dto.remoteConfigParameters.asSequence()
                .mapNotNull { it.toRemoteConfigParameterOrNull() }
                .associateBy { it.key }

            return DefaultWorkspace(
                id = dto.workspace.id,
                environmentId = dto.workspace.environment.id,
                experiments = experiments,
                featureFlags = featureFlags,
                eventTypes = eventTypes,
                buckets = buckets,
                segments = segments,
                containers = containers,
                parameterConfigurations = parameterConfigurations,
                remoteConfigParameters = remoteConfigParameters,
            )
        }
    }
}