osam-core-framework/web/src/main/java/org/onap/osam/helper/DTOMapper.java

/*-
 * ============LICENSE_START=======================================================
 * OSAM Core
 * ================================================================================
 * Copyright (C) 2018 Netsia
 * ================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ============LICENSE_END=========================================================
 */



package org.onap.osam.helper;

import com.google.common.collect.Lists;
import org.onap.osam.common.dto.AccessPodDTO;
import org.onap.osam.common.dto.ChassisDTO;
import org.onap.osam.common.dto.OLTChassisDTO;
import org.onap.osam.common.dto.OLTPortDTO;
import org.onap.osam.common.dto.ONTDTO;
import org.onap.osam.model.dao.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


public final class DTOMapper {

    private DTOMapper () {

    }

    public static Chassis convertToChassis (ChassisDTO chassisDTO) {
        Chassis chassis = new Chassis();
        chassis.setClli(chassisDTO.getClli());
        chassis.setShelf(chassisDTO.getShelf());
        chassis.setRack(chassisDTO.getRack());
        chassis.setState(ActivityState.ACTIVE);
        AccessPod accessPod = new AccessPod();
        accessPod.setPnfId(chassisDTO.getPnfId());
        chassis.setAccessPod(accessPod);
        return chassis;
    }




    public static OLTSlot convertToOLT (OLTChassisDTO oltChassisDTO) {
        OLTSlot oltSlot = new OLTSlot();
        oltSlot.setIpAddress(oltChassisDTO.getIpAddress());
        oltSlot.setPort(oltChassisDTO.getPortNumber());
        oltSlot.setName(oltChassisDTO.getName());
        oltSlot.setOltDriver(OltDriver.valueOf(oltChassisDTO.getOltDriver()));
        oltSlot.setOltType(OltType.valueOf(oltChassisDTO.getOltType()));
        return oltSlot;
    }

    public static ChassisDTO convertChassisToDTO(Chassis chassis) {
        ChassisDTO chassisDTO = new ChassisDTO();
        chassisDTO.setId(chassis.getId());
        chassisDTO.setClli(chassis.getClli());
        chassisDTO.setRack(chassis.getRack());
        chassisDTO.setShelf(chassis.getShelf());
        chassisDTO.setPnfId(chassis.getAccessPod().getPnfId());
        return chassisDTO;
    }

    public static List<ChassisDTO> convertChassisToDTO(List<Chassis> chassises) {
        return chassises.stream().map(x -> convertChassisToDTO(x)).collect(Collectors.toList());
    }

    public static Map<String, List<OLTChassisDTO>> convertFromOLT(List<OLTSlot> oltSlots){
        return oltSlots.stream().map(x -> convertFromOLT(x)).collect(Collectors.toList()).stream().collect(Collectors.groupingBy(OLTChassisDTO::getClli));
    }

    public static OLTChassisDTO convertFromOLT (OLTSlot oltSlot) {
        OLTChassisDTO oltChassisDTO = new OLTChassisDTO();
        oltChassisDTO.setClli(oltSlot.getChassis().getClli());
        oltChassisDTO.setIpAddress(oltSlot.getIpAddress());
        oltChassisDTO.setName(oltSlot.getName());
        oltChassisDTO.setOltDriver(oltSlot.getOltDriver().name());
        oltChassisDTO.setOltType(oltSlot.getOltType().name());
        oltChassisDTO.setPortNumber(oltSlot.getPort());
        oltChassisDTO.setId(oltSlot.getId());
        return oltChassisDTO;
    }

    public static ONTDTO convertFromONTDevice (ONTDevice ontDevice) {
        ONTDTO ontdto = new ONTDTO();
        ontdto.setSerialNumber(ontDevice.getSerialNumber());
        ontdto.setPortNumber(ontDevice.getOLTPort().getPortNumber());
        ontdto.setId(ontDevice.getId());
        ontdto.setSlotNumber(ontDevice.getOLTPort().getOltSlot().getNumber());
        ontdto.setClli(ontDevice.getOLTPort().getOltSlot().getChassis().getClli());
        ontdto.setCtag(ontDevice.getCTag());
        ontdto.setStag(ontDevice.getSTag());
        ontdto.setCircuitId(ontDevice.getCircuitId());
        ontdto.setNasPortId(ontDevice.getNasPortId());
        if (ontDevice.getTechProfile() != null) {
            ontdto.setTechnologyProfile(ontDevice.getTechProfile().getName());
        }
        if (ontDevice.getSpeedProfile() != null) {
            ontdto.setSpeedProfile(ontDevice.getSpeedProfile().getName());
        }
        return ontdto;
    }

    public static ONTDevice convertToONTDevice (ONTDTO ontdto) {
        ONTDevice ontDevice = new ONTDevice();
        ontDevice.setNumber(ontdto.getOntNumber());
        ontDevice.setSerialNumber(ontdto.getSerialNumber());
        ontDevice.setCTag(ontdto.getCtag());
        ontDevice.setSTag(ontdto.getStag());
        ontDevice.setCircuitId(ontdto.getCircuitId());
        ontDevice.setNasPortId(ontdto.getNasPortId());
        TechnologyProfile technologyProfile = new TechnologyProfile();
        technologyProfile.setName(ontdto.getTechnologyProfile());
        ontDevice.setTechProfile(technologyProfile);
        SpeedProfile speedProfile = new SpeedProfile();
        speedProfile.setName(ontdto.getSpeedProfile());
        ontDevice.setSpeedProfile(speedProfile);
        Chassis chassis = new Chassis();
        chassis.setClli(ontdto.getClli());
        OLTSlot oltSlot = new OLTSlot();
        oltSlot.setChassis(chassis);
        OLTPort oltPort = new OLTPort();
        oltPort.setPortNumber(ontdto.getPortNumber());
        oltPort.setOltSlot(oltSlot);
        ontDevice.setOLTPort(oltPort);
        return ontDevice;
    }

    public static Map<String, List<ONTDTO>> convertFromONTDevice(List<ONTDevice> ontDevices){
        return ontDevices.stream().map(x -> convertFromONTDevice(x)).collect(Collectors.toList()).stream().collect(Collectors.groupingBy(ONTDTO::getClli));
    }

    public static AccessPod convertDtoToAccessPod(AccessPodDTO dto) {
        //TODO validate..
        AccessPod accessPod = new AccessPod();
        accessPod.setPnfId(dto.getPnfId());
        accessPod.setId(dto.getId());
        accessPod.setCoreIp(dto.getCoreIp());
        accessPod.setCorePort(dto.getCorePort());
        accessPod.setUsername(dto.getUsername());
        accessPod.setPassword(dto.getPassword());
        accessPod.setIp(dto.getIp());
        accessPod.setPort(dto.getPort());
        return accessPod;
    }

    public static AccessPodDTO convertAccessPodToDto(AccessPod accessPod) {
        //TODO validate..
        AccessPodDTO dto = new AccessPodDTO();
        dto.setPnfId(accessPod.getPnfId());
        dto.setCoreIp(accessPod.getCoreIp());
        dto.setCorePort(accessPod.getCorePort());
        dto.setUsername(accessPod.getUsername());
        dto.setPassword(accessPod.getPassword());
        dto.setIp(accessPod.getIp());
        dto.setId(accessPod.getId());
        dto.setPort(accessPod.getPort());
        return dto;
    }

    private static OLTPortDTO convertOLTPortToDTO(OLTPort oltPort) {
        OLTPortDTO oltPortDTO = new OLTPortDTO();
        oltPortDTO.setId(oltPort.getId());
        oltPortDTO.setAdminState(oltPort.getAdminState().name());
        oltPortDTO.setPortAuthState(oltPort.getPortAuthState().name());
        oltPortDTO.setPortNumber(oltPort.getPortNumber());
        return oltPortDTO;
    }

    public static List<AccessPodDTO> covertAccessPodsToDtos(List<AccessPod> accessPodList) {
        //TODO validate..
        List<AccessPodDTO> dtos = new ArrayList<>();
        for (AccessPod accessPod : accessPodList) {
            dtos.add(convertAccessPodToDto(accessPod));
        }
        return dtos;
    }

    public static AccessPodDTO representTheAccessPod(List<Chassis> chassisList, AccessPod accessPod) {
        if (accessPod == null) {
            return null;
        }
        AccessPodDTO accessPodDTO = convertAccessPodToDto(accessPod);
        if (chassisList == null || chassisList.isEmpty()) {
            return accessPodDTO;
        }
        List<ChassisDTO> chassisDTOS = new ArrayList<>();
        accessPodDTO.setChassises(chassisDTOS);
        for (Chassis chassis : chassisList) {
            chassisDTOS.add(representTheChassis(chassis));
        }
        return accessPodDTO;
    }

    public static ChassisDTO representTheChassis(Chassis chassis) {
        ChassisDTO chassisDTO = convertChassisToDTO(chassis);
        if (chassis.getOltSlots() == null || chassis.getOltSlots().isEmpty()) {
            return chassisDTO;
        }
        List<OLTChassisDTO> oltChassisDTOS = Lists.newArrayList();
        chassisDTO.setOlts(oltChassisDTOS);
        for (OLTSlot oltSlot : chassis.getOltSlots()) {
            oltChassisDTOS.add(representTheOLTSlot(oltSlot));
        }
        return chassisDTO;
    }

    public static OLTChassisDTO representTheOLTSlot(OLTSlot oltSlot) {
        OLTChassisDTO oltChassisDTO = convertFromOLT(oltSlot);
        if (oltSlot.getOltPorts() == null || oltSlot.getOltPorts().isEmpty()) {
            return oltChassisDTO;
        }
        List<OLTPortDTO> oltPortDTOS = Lists.newArrayList();
        oltChassisDTO.setOltPorts(oltPortDTOS);
        for (OLTPort oltPort : oltSlot.getOltPorts()) {
            oltPortDTOS.add(representTheOLTPort(oltPort));
        }
        return oltChassisDTO;
    }

    public static OLTPortDTO representTheOLTPort(OLTPort oltPort) {
        OLTPortDTO portDTO = convertOLTPortToDTO(oltPort);
        if (oltPort.getOntDevices() == null || oltPort.getOntDevices().isEmpty()) {
            return portDTO;
        }
        List<ONTDTO> ontdtos = Lists.newArrayList();
        portDTO.setOntDevices(ontdtos);
        for (ONTDevice ontDevice : oltPort.getOntDevices()) {
            ontdtos.add(convertFromONTDevice(ontDevice));
        }
        return portDTO;
    }
}