io.rtr.alchemy.service.mapping.CoreMappings Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of alchemy-service Show documentation
REST service for hosting Alchemy as a service
The newest version!
package io.rtr.alchemy.service.mapping;

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;

import io.rtr.alchemy.dto.models.AllocationDto;
import io.rtr.alchemy.dto.models.ExperimentDto;
import io.rtr.alchemy.dto.models.TreatmentDto;
import io.rtr.alchemy.dto.models.TreatmentOverrideDto;
import io.rtr.alchemy.mapping.Mapper;
import io.rtr.alchemy.mapping.Mappers;
import io.rtr.alchemy.models.Allocation;
import io.rtr.alchemy.models.Experiment;
import io.rtr.alchemy.models.Treatment;
import io.rtr.alchemy.models.TreatmentOverride;

import java.util.List;

/** A helper class for configuring the base required mappers for core domain objects */
public class CoreMappings {

    private static  List safeArrayList(Iterable iterable) {
        return iterable != null ? Lists.newArrayList(iterable) : null;
    }

    public static void configure(final Mappers mappers) {
        // fixed domain types
        mappers.register(
                Treatment.class,
                TreatmentDto.class,
                new Mapper() {
                    @Override
                    public TreatmentDto toDto(Treatment treatment) {
                        return new TreatmentDto(treatment.getName(), treatment.getDescription());
                    }

                    @Override
                    public Treatment fromDto(TreatmentDto dto) {
                        throw new UnsupportedOperationException("mapping from dto not supported");
                    }
                });

        mappers.register(
                Allocation.class,
                AllocationDto.class,
                new Mapper() {
                    @Override
                    public AllocationDto toDto(Allocation allocation) {
                        return new AllocationDto(
                                allocation.getTreatment().getName(),
                                allocation.getOffset(),
                                allocation.getSize());
                    }

                    @Override
                    public Allocation fromDto(AllocationDto source) {
                        throw new UnsupportedOperationException("mapping from dto not supported");
                    }
                });

        mappers.register(
                TreatmentOverride.class,
                TreatmentOverrideDto.class,
                new Mapper() {
                    @Override
                    public TreatmentOverrideDto toDto(TreatmentOverride override) {
                        return new TreatmentOverrideDto(
                                override.getName(),
                                override.getFilter().toString(),
                                override.getTreatment().getName());
                    }

                    @Override
                    public TreatmentOverride fromDto(TreatmentOverrideDto source) {
                        throw new UnsupportedOperationException("mapping from dto not supported");
                    }
                });

        mappers.register(
                Experiment.class,
                ExperimentDto.class,
                new Mapper() {
                    @Override
                    public ExperimentDto toDto(Experiment experiment) {
                        if (experiment == null) {
                            return null;
                        }

                        return new ExperimentDto(
                                experiment.getName(),
                                experiment.getSeed(),
                                experiment.getDescription(),
                                experiment.getFilter() != null
                                        ? experiment.getFilter().toString()
                                        : null,
                                experiment.getHashAttributes() != null
                                        ? Sets.newLinkedHashSet(experiment.getHashAttributes())
                                        : null,
                                experiment.isActive(),
                                experiment.getCreated(),
                                experiment.getModified(),
                                experiment.getActivated(),
                                experiment.getDeactivated(),
                                safeArrayList(
                                        mappers.toDto(
                                                experiment.getTreatments(), TreatmentDto.class)),
                                safeArrayList(
                                        mappers.toDto(
                                                experiment.getAllocations(), AllocationDto.class)),
                                safeArrayList(
                                        mappers.toDto(
                                                experiment.getOverrides(),
                                                TreatmentOverrideDto.class)));
                    }

                    @Override
                    public Experiment fromDto(ExperimentDto source) {
                        throw new UnsupportedOperationException("mapping from dto not supported");
                    }
                });
    }
}