AssetController.java

package adt.mainnode.controller;

import adt.mainnode.dto.Asset;
import adt.mainnode.dto.HostDto;
import adt.mainnode.dto.PortDto;
import adt.mainnode.entity.*;
import adt.mainnode.repository.CredentialsRepository;
import adt.mainnode.repository.ScanInfoRepository;
import adt.mainnode.repository.ScanConfigRepository;
import adt.mainnode.repository.NodeRepository;

import adt.mainnode.repository.PortRepository;
import adt.mainnode.repository.HostRepository;
import adt.mainnode.repository.SnapshotRepository;
import adt.mainnode.repository.VlanRepository;
import java.util.ArrayList;
//import adt.mainnode.repository.VlanSnapRepository;
import adt.mainnode.service.AssetService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


import java.util.List;

@RestController
@RequestMapping("vlans")
@Api(
        value = "/vlans",//"/asset",
        produces = MediaType.APPLICATION_JSON_VALUE,
        tags = {"Vlans"}
)
@Slf4j
public class AssetController {

    private final AssetService assetService;
    //private final VlanSnapRepository vlanSnapRepository;
    private final VlanRepository vlanRepository;
    private final SnapshotRepository snapshotRepository;
    private final CredentialsRepository credentialsRepository;
    private final ScanInfoRepository scanInfoRepository;
    private final NodeRepository nodeRepository;
    private final HostRepository hostRepository;
    private final PortRepository portRepository;
    private final ScanConfigRepository scanConfigRepository;

    @Autowired
    public AssetController(NodeRepository nodeRepository, ScanConfigRepository scanConfigRepository, AssetService assetService, VlanRepository vlanRepository, SnapshotRepository snapshotRepository, CredentialsRepository credentialsRepository, ScanInfoRepository scanInfoRepository, HostRepository hostRepository, PortRepository portRepository) {
        this.assetService = assetService;
        this.nodeRepository = nodeRepository;
        this.vlanRepository = vlanRepository;
        this.snapshotRepository = snapshotRepository;
        this.credentialsRepository = credentialsRepository;
        this.scanInfoRepository = scanInfoRepository;
        this.hostRepository = hostRepository;
        this.scanConfigRepository = scanConfigRepository;
        this.portRepository = portRepository;
    }

    @CrossOrigin
    @ApiOperation(value = "Save a new set of assets", response = Long.class)
    @ResponseStatus(HttpStatus.CREATED)
    @PostMapping(produces = MediaType.APPLICATION_JSON_VALUE)
    Long saveAssets(HttpServletResponse response, @RequestBody Asset asset, @RequestParam String token) {

        Credentials credential = credentialsRepository.findByToken(token);

        if(credential != null && credential.getStatus().equals("OPERATIVE")) {

            if(credential.getAvailableEndpoint().contains("(POST) vlans/")) {

                log.info("New assets received");

                assetService.saveAssets(asset, credential);

                return scanConfigRepository.findAllByNodeId(credential.getName()).get(0).getDelay();

            }
        }

        try {
            response.sendError(400, "Unrecognized token. Access denied.");
        }catch(IOException ioe){
            //
        }

        return null;
    }


    @CrossOrigin
    @ApiOperation(value = "Get all snapshots' info from all VLANs.", response = Vlan.class)
    @ResponseStatus(HttpStatus.CREATED)
    @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
    List<Vlan> loadSnapshots(HttpServletResponse response, @RequestParam(value = "token"/*, required = false*/) String token) { //@PathVariable("token") String token) {

        Credentials credential = credentialsRepository.findByToken(token);

        if(credential != null && credential.getStatus().equals("OPERATIVE")) {

            if(credential.getAvailableEndpoint().contains("(GET) vlans/")  || credential.getAvailableEndpoint().contains("Visualization Service")) {

                //List<VlanSnap> vlanSnaps = vlanSnapRepository.findAll();
                List<Vlan> vlans = vlanRepository.findAll();

                log.info("Petition received \n {}", vlans);

                for (int i = 0; i < vlans.size(); i++) {

                    List<Snapshot> snaps = snapshotRepository.findAllByVlanNameAndNodeId(vlans.get(i).getVlanName(), vlans.get(i).getDistributedNodeId());
                    vlans.get(i).setSnapshots(snaps);
                }

                return vlans;
            }
        }

        try {
            response.sendError(400, "Unrecognized token. Access denied.");
        }catch(IOException ioe){
            //
        }

        return null;
    }


    @CrossOrigin
    @ApiOperation(value = "Get a specific snapshot by providing its ID.", response = ScanInfo.class)
    @ResponseStatus(HttpStatus.CREATED)
    @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
    @RequestMapping(value = "/{snapshotId}", method = RequestMethod.GET)
    List<ScanInfo> getSnapshot(HttpServletResponse response, @RequestParam String snapshotId, @RequestParam String token) {

        Credentials credential = credentialsRepository.findByToken(token);

        if (credential != null && credential.getStatus().equals("OPERATIVE")) {

            if(credential.getAvailableEndpoint().contains("(GET) vlans/{snapshot_id}")  || credential.getAvailableEndpoint().contains("Visualization Service")) {

                List<ScanInfo> allScans = scanInfoRepository.findAllBySnapshotId(snapshotId);

                if(allScans == null){

                    try {
                        response.sendError(400, "The provided Snapshot ID does not correspond to any of the stored Snapshot IDs. Please, check this field.");
                    }catch(IOException ioe){
                        //
                    }

                    return null;
                }

                allScans.forEach(scanInfo -> {

                    List<Host> hosts = hostRepository.findAllByVlanNameAndSnapshotId(scanInfo.getVlanName(), snapshotId);

                    List<HostDto> hostDtos = new ArrayList<>();

                    for (int i = 0; i < hosts.size(); i++) {

                        HostDto hostDto = HostDto.createHostDto(hosts.get(i));
                        hostDtos.add(hostDto);

                        List<Port> ports = portRepository.findAllByIpAndVlanNameAndSnapshotId(hostDto.getIp(), hostDto.getVlanName(), snapshotId);

                        List<PortDto> portDtos = new ArrayList<>();

                        for (int j = 0; j < ports.size(); j++) {

                            PortDto portDto = PortDto.createPortDto(ports.get(j));
                            portDtos.add(portDto);
                        }

                        hostDto.setPorts(portDtos);
                    }

                    scanInfo.setHost(hostDtos);

                });

                return allScans;

            }
        }

        try {
            response.sendError(400, "Unrecognized token. Access denied.");
        }catch(IOException ioe){
            //
        }

        return null;
    }

}