osam-core/core/src/main/java/org/onap/osam/core/DeviceServiceImpl.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.core;

import com.google.common.collect.Lists;
import org.onap.osam.api.service.AccessPodService;
import org.onap.osam.common.exception.AbstractOLTException;
import org.onap.osam.common.exception.InvalidOperationException;
import org.onap.osam.common.exception.NotFoundException;
import org.onap.osam.api.service.DeviceService;
import org.onap.osam.common.exception.ServerException;
import org.onap.osam.external.grpc.AbstractOLTClient;
import org.onap.osam.model.dao.*;
import org.onap.osam.model.repository.ChassisRepository;
import org.onap.osam.model.repository.OLTPortRepository;
import org.onap.osam.model.repository.OLTSlotRepository;
import org.onap.osam.model.repository.ONTDeviceRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;

/**
 * Created by Zafer Kaban on 18.09.2018.
 */
@Service
public class DeviceServiceImpl extends AbstractBaseServiceImpl implements DeviceService {

    private ChassisRepository chassisRepository;
    private OLTPortRepository oltPortRepository;
    private OLTSlotRepository oltSlotRepository;
    private ONTDeviceRepository ontDeviceRepository;
    private AbstractOLTClient abstractOLTClient;
    private AccessPodService accessPodService;

    public static int NUMBER_OF_OLT_PORTS   = 16;
    public static int NUMBER_OF_ONT_DEVICES = 64;

    @Autowired
    public DeviceServiceImpl(ChassisRepository chassisRepository,
                             OLTPortRepository oltPortRepository,
                             OLTSlotRepository oltSlotRepository,
                             ONTDeviceRepository ontDeviceRepository,
                             AbstractOLTClient abstractOLTClient,
                             AccessPodService accessPodService) {
        this.chassisRepository = chassisRepository;
        this.oltPortRepository = oltPortRepository;
        this.oltSlotRepository = oltSlotRepository;
        this.ontDeviceRepository = ontDeviceRepository;
        this.abstractOLTClient = abstractOLTClient;
        this.accessPodService = accessPodService;
    }

    @Override
    public Chassis addChassis(Chassis chassis) {
        AccessPod accessPod = accessPodService.findByPnfId(chassis.getAccessPod().getPnfId());
        chassis.setAccessPod(accessPod);
        abstractOLTClient.createChassis(chassis);
        return add(chassis, chassisRepository);
    }

    @Override
    public void deleteChassis(Long id) {
        log.info("Deleting chassis, id: {}", id);
        remove(id, chassisRepository,Chassis.class);
    }

    public void deleteChassisByClli(String clli) {
        Optional<Chassis> chassis = chassisRepository.findByClli(clli);
        if (chassis.isPresent()){
            Long id = chassis.get().getId();
            log.trace("Deleting chassis, clli: {}", clli);
            remove(id, chassisRepository,Chassis.class);
        } else {
            log.error("Chassis not found for clli {}, nothing to delete", clli);
            throw new NotFoundException("Chassis not found for clli {}",clli);
        }
    }

    @Override
    public Chassis getChassisById(Long id) {
        Optional<Chassis> chassis = chassisRepository.findById(id);
        if (!chassis.isPresent()) {
            log.error("Chassis not found for id {}", id);
            throw new NotFoundException("Chassis not found for id {}",id);
        }
        return chassis.get();
    }

    @Override
    public Chassis getChassisByClli(String clli) {
        Optional<Chassis> chassis = chassisRepository.findByClli(clli);
        if (!chassis.isPresent()) {
            log.error("Chassis not found for clli {}", clli);
            throw new NotFoundException("Chassis not found for clli {}",clli);
        }
        return chassis.get();
    }

    @Override
    public Long getChassisCount() {
        return chassisRepository.count();
    }

    @Override
    public List<Chassis> getByPnfId(String pnfId) {
        Optional<List<Chassis>> chassisList = chassisRepository.findByAccessPodPnfId(pnfId);
        if (!chassisList.isPresent()) {
            log.error("Chassis is not found with pnfId {}", pnfId);
            throw new NotFoundException("Chassis is not found with pnfId : {}",pnfId);
        }
        return chassisList.get();
    }

    @Override
    public List<Chassis> getAllChassis() {
        return Lists.newArrayList(chassisRepository.findAll());
    }

    @Override
    public OLTSlot addOLTSlot(OLTSlot oltSlot, Chassis chassis) {
        Set<OLTSlot> oltSlots = Optional.ofNullable(chassis.getOltSlots()).orElse(new HashSet<>());
        int size = oltSlots.size();
        if (size == NUMBER_OF_OLT_PORTS) {
            log.error("Maximum number of OLTs exceeded, max size per chassis: {}", NUMBER_OF_OLT_PORTS);
            throw new InvalidOperationException("Maximum number of OLTs exceeded");
        }
        oltSlot.setNumber(size+1);
        oltSlot.setAdminState(AdminState.ENABLED);
        oltSlot.setOperationalState(ActivityState.ACTIVE);
        oltSlot.setPortAuthState(ActivityState.ACTIVE);
        abstractOLTClient.createOLTChassis(oltSlot);

        oltSlot.setChassis(chassis);
        log.trace("Adding OLT Slot, OLT slot: {}", oltSlot);
        add(oltSlot, oltSlotRepository);
        for (int j = 0; j < 16 ; j++) {
            OLTPort oltPort = new OLTPort();
            oltPort.setOltSlot(oltSlot);
            oltPort.setPortNumber(j+1);
            oltPort.setAdminState(AdminState.ENABLED);
            oltPort.setPortAuthState(ActivityState.ACTIVE);
            log.trace("Adding OLT Port on this slot, OLT port: {}", oltPort);
            add(oltPort, oltPortRepository);
        }
        oltSlots.add(oltSlot);
        chassis.setOltSlots(oltSlots);
        log.trace("Adding this OLT slot to chassis {}", chassis);
        chassisRepository.save(chassis);
        return oltSlot;
    }

    @Override
    public void deleteOLTSlot(Long id) {
        log.info("Deleting OLT slot, id: {}", id);
        oltSlotRepository.deleteById(id);
    }

    @Override
    public OLTSlot getOLTSlotById(Long id) {
        Optional<OLTSlot> oltSlot = oltSlotRepository.findById(id);
        if (!oltSlot.isPresent()) {
            log.error("OLT Slot not found with id {}", id);
            throw new NotFoundException("OLT Slot not found with id "+id);
        }
        return oltSlot.get();
    }

    @Override
    public OLTSlot getOLTSlotBySerialNumber(String serialNumber) {
        Optional<OLTSlot> oltSlot = oltSlotRepository.findBySerialNumber(serialNumber);
        if (!oltSlot.isPresent()) {
            log.error("OLT Slot not found with serial number {}", serialNumber);
            throw new NotFoundException("OLT Slot not found with serialNumber {}",serialNumber);
        }
        return oltSlot.get();
    }

    @Override
    public List<OLTSlot> getAllOLTSlots() {
        return Lists.newArrayList(oltSlotRepository.findAll());
    }

    @Override
    public void deleteOLTPort(Long id) {
        log.info("Deleting OLT port, id: {}", id);
        oltPortRepository.deleteById(id);
    }

    @Override
    public OLTPort getOLTPortById(Long id) {
        Optional<OLTPort> oltPort = oltPortRepository.findById(id);
        if (!oltPort.isPresent()) {
            log.error("OLT Port not found, id: {}", id);
            throw new NotFoundException("OLT Port not found, id {}",id);
        }
        return oltPort.get();
    }

    @Override
    public ONTDevice provisionONTDevice(ONTDevice ont, OntProvisioningType provisioningType){
        log.trace("ONT Device provisioning, ONT Device: {}, provisioning type: ");
        OLTPort oltPort = ont.getOLTPort();
        int portNumber = oltPort.getPortNumber();
        OLTSlot oltSlot = oltPort.getOltSlot();
        int slotNumber = oltSlot.getNumber();
        Chassis chassis = oltSlot.getChassis();
        String clli = chassis.getClli();
        int ontNumber = ont.getNumber();
        String serialNumber = ont.getSerialNumber();
        Optional<OLTPort> thePort = oltPortRepository.findByPortNumberAndOltSlot_NumberAndOltSlot_ChassisClli(portNumber,slotNumber,clli);
        if (thePort.isPresent()) {
            OLTPort port = thePort.get();
            log.trace("Port found : {}", thePort);
            Set<ONTDevice> ontDevices = Optional.ofNullable(port.getOntDevices()).orElse(new HashSet<>());

            ONTDevice ontDevice = new ONTDevice();
            ontDevice.setSerialNumber(serialNumber);
            ontDevice.setNumber(ontNumber);
            ontDevice.setOLTPort(port);
            ontDevice.setAdminState(AdminState.ENABLED);
            ontDevice.setOperationalState(ActivityState.ACTIVE);
            ontDevice.setPortAuthState(ActivityState.ACTIVE);
            ontDevice.setCTag(ont.getCTag());
            ontDevice.setSTag(ont.getSTag());
            ontDevice.setCircuitId(ont.getCircuitId());
            ontDevice.setNasPortId(ont.getNasPortId());

            //TODO Handle technology and speed profiles later
            ontDevice.setSpeedProfile(null);
            ontDevice.setTechProfile(null);

            boolean success =  false;
            if (provisioningType == OntProvisioningType.FULL) {
                success = abstractOLTClient.provisionOntFull(ont);
            } else if (provisioningType == OntProvisioningType.PREPROVISION) {
                success = abstractOLTClient.preProvisionOnt(ont);
            } else {
                success = abstractOLTClient.provisionONT(ont);
            }

            if (success){
                ontDevice = add(ontDevice, ontDeviceRepository);
                ontDevices.add(ontDevice);
                port.setOntDevices(ontDevices);
                oltPortRepository.save(port);
            } else {
                log.error("Failed to process ONTDevice at Abstract OLT, ONTDevice: {}", ont);
                throw new ServerException("Failed to provision ONTDevice with serial number " + ont.getSerialNumber());
            }

        } else {
            log.error("Port not found, port number: {}", portNumber);
            throw new NotFoundException("Port not found, port number {}",portNumber);
        }
        return ont;
    }

    @Override
    public void deleteONTDevice(Long id) {
        log.info("Deleting ONT device port, id: {}", id);
        ontDeviceRepository.deleteById(id);
    }

    @Override
    public ONTDevice getONTDeviceById(Long id) {
        Optional<ONTDevice> ontDevice = ontDeviceRepository.findById(id);
        if (!ontDevice.isPresent()) {
            log.error("Couldn't find ONT Device with ID {}", id);
            throw new NotFoundException("Couldn't find ONT Device with ID {}",id);
        }
        return ontDevice.get();
    }

    @Override
    public ONTDevice getONTDeviceBySerialNumber(String serialNumber) {
        Optional<ONTDevice> ontDevice = ontDeviceRepository.findBySerialNumber(serialNumber);
        if (!ontDevice.isPresent()) {
            log.error("Couldn't find ONT Device with serialNumber {}", serialNumber);
            throw new NotFoundException("Couldn't find ONT Device with serialNumber {}",serialNumber);
        }
        return ontDevice.get();
    }

    @Override
    public List<ONTDevice> getAllONTDevices() {
        return Lists.newArrayList(ontDeviceRepository.findAll());
    }
}