Current development.

.gitignore

+HELP.md
+.gradle
+/build/
+!gradle/wrapper/gradle-wrapper.jar
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+/out/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/

README.md

-# CUREX
+# MAIN NODE
 

build.gradle

+plugins {
+	id 'org.springframework.boot' version '2.1.5.RELEASE'
+	id 'java'
+}
+
+apply plugin: 'org.springframework.boot'
+apply plugin: 'io.spring.dependency-management'
+apply plugin: 'war'
+
+group = 'main-node'
+version = '0.0.1-SNAPSHOT'
+sourceCompatibility = '1.8'
+
+configurations {
+	compileOnly {
+		extendsFrom annotationProcessor
+	}
+}
+
+repositories {
+	mavenCentral()
+	maven { url 'http://oss.jfrog.org/artifactory/oss-snapshot-local/' }
+}
+
+dependencies {
+	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+	compile group: 'com.googlecode.json-simple', name: 'json-simple', version: '1.1'
+	implementation 'org.springframework.boot:spring-boot-starter-data-rest'
+	implementation 'io.springfox:springfox-swagger2:2.9.2'
+	implementation 'io.springfox:springfox-swagger-ui:2.9.2'
+	implementation 'io.swagger:swagger-annotations:1.5.21'
+	implementation 'io.swagger:swagger-models:1.5.21'
+	implementation 'org.apache.commons:commons-io:1.3.2'
+	compile 'commons-codec:commons-codec:1.13'
+	compileOnly 'org.projectlombok:lombok'
+	compile group: 'javax.json', name: 'javax.json-api', version: '1.0-b01'
+	compile 'org.json:json:20171018'
+	runtimeOnly 'mysql:mysql-connector-java'
+	annotationProcessor 'org.projectlombok:lombok'
+	testImplementation 'org.springframework.boot:spring-boot-starter-test'
+	implementation 'org.springframework.boot:spring-boot-starter-web'
+	implementation 'org.webjars:bootstrap:4.1.3'
+	compile 'org.apache.tomcat.embed:tomcat-embed-jasper'
+	runtimeOnly 'javax.servlet:jstl'
+	compileOnly 'javax.servlet:javax.servlet-api:3.0.1'
+	compile group: 'com.google.code.gson', name: 'gson', version: '2.8.6'
+	compile group: 'org.apache.commons', name: 'commons-lang3', version: '3.9'
+	compile group: 'javax.ws.rs', name: 'javax.ws.rs-api', version: '2.1.1'
+	compile group: 'org.apache.httpcomponents', name: 'httpclient', version: '4.5.10'
+	compile group: 'org.apache.httpcomponents', name: 'httpmime', version: '4.5.10'
+	compile group: 'com.sun.mail', name: 'javax.mail', version: '1.6.2'
+
+}

gradle/wrapper/gradle-wrapper.properties

+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+    }
+}
+rootProject.name = 'main-node'

src/main/java/adt/mainnode/MainNodeApplication.java

+package adt.mainnode;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
+
+@SpringBootApplication
+public class MainNodeApplication extends SpringBootServletInitializer {
+
+    public static void main(String[] args) {
+
+        try {
+            SpringApplication.run(MainNodeApplication.class, args);
+        }catch(Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
+        return application.sources(MainNodeApplication.class);
+    }
+}
+

src/main/java/adt/mainnode/config/SwaggerConfig.java

+package adt.mainnode.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import springfox.documentation.builders.RequestHandlerSelectors;
+import springfox.documentation.service.ApiInfo;
+import springfox.documentation.service.Contact;
+import springfox.documentation.service.Tag;
+import springfox.documentation.spi.DocumentationType;
+import springfox.documentation.spring.web.plugins.Docket;
+import springfox.documentation.swagger2.annotations.EnableSwagger2;
+
+import java.util.Collections;
+
+import static springfox.documentation.builders.PathSelectors.regex;
+
+@EnableSwagger2
+@Configuration
+public class SwaggerConfig {
+
+    @Bean
+    public Docket DocketApi() {
+        return new Docket(DocumentationType.SWAGGER_2)
+                .groupName("ADT Main Node")
+                .select()
+                .apis(RequestHandlerSelectors.any())
+                .paths(regex("/(vlans|configurations|nlp|virt_query|event|presence_check).*"))
+                .build()
+                .apiInfo(metaInfo())
+                .tags(
+                        new Tag("Vlans", "Endpoints to create new assets or to retrieve existing ones."),
+                        new Tag("Configurations", "Endpoint queried by distributed nodes the first time they start up. Grants them a scanning configuration.")  ,
+                        new Tag("NLP", "Natural Language Processing functionalities."),
+                        new Tag("Virt_Query", "Endpoint to query the Virtuoso Database."),
+                        new Tag("(Event) Transfer Service", "Endpoint to send vulnerabilities' events to a pre-set URL.")
+                );
+    }
+
+    private ApiInfo metaInfo() {
+        return new ApiInfo(
+                "ADT Main Node",
+                "This is the online documentation of ADT Main Node. Click authorize to perform queries with your own credentials.",
+                "ALPHA 2",
+                "Terms of service",
+                new Contact("Roberto Garrido",
+                        "https://medal.ctb.upm.es/roberto-garrido-garcia",
+                        "roberto.garrido@ctb.upm.es"),
+                "License",
+                "License URL",
+                Collections.emptyList()
+        );
+    }
+
+}

src/main/java/adt/mainnode/controller/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;
+    }
+
+}

src/main/java/adt/mainnode/controller/ChildNodeController.java

+package adt.mainnode.controller;
+
+import io.swagger.annotations.Api;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.io.IOUtils;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Objects;
+
+@RestController
+@RequestMapping("child-node")
+@Api(
+        value = "/child-node",
+        tags = {"Child Node"}
+)
+@Slf4j
+public class ChildNodeController {
+
+    @GetMapping
+    public void downloadChildNodeJar(HttpServletRequest request, HttpServletResponse response) {
+
+        try {
+
+            log.info("ADT jar download request received from {}", request.getRemoteAddr());
+
+            InputStream childNodeJar = getClass().getClassLoader().getResourceAsStream("curex_child_node.jar");
+
+            response.setContentType("application/java-archive");
+            response.setHeader("Content-Disposition", "attachment; filename=\"curex_child_node.jar\"");
+
+            IOUtils.copy(Objects.requireNonNull(childNodeJar), response.getOutputStream());
+
+            log.info("Starting download of child node jar...");
+
+            response.flushBuffer();
+
+        } catch (IOException ex) {
+
+            log.error("Error writing to child node output stream.");
+            throw new RuntimeException("Error writing to output stream.");
+        }
+
+    }
+
+}

src/main/java/adt/mainnode/controller/IPCheckController.java

+package adt.mainnode.controller;
+
+import adt.mainnode.entity.*;
+import adt.mainnode.repository.*;
+
+import java.util.ArrayList;
+import java.lang.Integer;
+import java.util.List;
+
+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;
+
+
+@RestController
+@RequestMapping("presence_check")
+@Api(
+        value = "/presence_check",//"/asset",
+        produces = MediaType.APPLICATION_JSON_VALUE,
+        tags = {"PRESENCE_CHECK"}
+)
+@Slf4j
+public class IPCheckController {
+
+    private final CredentialsRepository credentialsRepository;
+    private final HostRepository hostRepository;
+
+    @Autowired
+    public IPCheckController(CredentialsRepository credentialsRepository, HostRepository hostRepository) {
+        this.credentialsRepository = credentialsRepository;
+        this.hostRepository = hostRepository;
+    }
+
+
+    @CrossOrigin
+    @ApiOperation(value = "Allows a distributed node to double-check the information about a specific IP.",
+            response = Integer.class)
+    @ResponseStatus(HttpStatus.CREATED)
+    @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
+    int checkIP(HttpServletResponse response, @RequestParam(value = "token") String token,
+                @RequestParam(value = "ip") String ip,
+                @RequestParam(value = "mac") String mac){//@RequestParam(value = "params") String params) {
+
+        /*String[] paramsArr = params.split("&");
+        String token = paramsArr[0];
+        String ip = paramsArr[1];
+        String mac = paramsArr[2];
+        */
+        log.info("Received query from Distributed Node DHCP Service. Parameters to check:\nIP: {}\nMAC: {}", ip, mac);
+
+        Credentials credential = credentialsRepository.findByToken(token);
+
+        if(credential != null) {
+
+            List<Host> hosts = null;
+            if(mac != null) {
+                hosts = hostRepository.findAllByIpAndMac(ip, mac);
+            }else{
+                // TODO: review later on
+                hosts = hostRepository.findAllByIp(ip);
+            }
+
+            if (hosts != null && hosts.size() > 0){
+
+                return 1;
+            }else{
+
+                return 0;
+            }
+        }
+
+        try {
+            response.sendError(400, "Unrecognized token. Access denied.");
+        }catch(IOException ioe){
+            // handled
+        }
+
+        return -1;
+    }
+
+
+}

src/main/java/adt/mainnode/controller/InitializeController.java

+package adt.mainnode.controller;
+
+import adt.mainnode.entity.Credentials;
+import adt.mainnode.entity.ScanConfig;
+import adt.mainnode.entity.Node;
+import adt.mainnode.entity.TPMHash;
+import adt.mainnode.entity.Vlan;
+import adt.mainnode.repository.CredentialsRepository;
+import adt.mainnode.repository.ScanConfigRepository;
+import adt.mainnode.repository.TPMHashRepository;
+import adt.mainnode.repository.NodeRepository;
+import adt.mainnode.repository.VlanRepository;
+import adt.mainnode.service.InitializeService;
+import adt.mainnode.service.FileHashingService;
+import adt.mainnode.service.TPMValidationService;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectWriter;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.web.bind.annotation.*;
+import java.util.List;
+import java.util.concurrent.Executors;
+import javax.servlet.http.HttpServletRequest;
+import lombok.extern.slf4j.Slf4j;
+import java.io.IOException;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectWriter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import java.io.FileWriter;
+
+import org.apache.commons.codec.digest.DigestUtils;
+import java.io.IOException;
+import java.io.*;
+import java.util.Arrays;
+import java.util.ArrayList;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+
+@RestController
+@RequestMapping("configurations")//"initialize")
+@Api(
+        value = "/configurations",//"/initialize",
+        produces = MediaType.APPLICATION_JSON_VALUE,
+        tags = {"Configurations"}
+)
+@Slf4j
+public class InitializeController {
+
+    private final InitializeService initializeService;
+    private final FileHashingService fileHashingService;
+    private final NodeRepository nodeRepository;
+    private final CredentialsRepository credentialsRepository;
+    private final ScanConfigRepository scanConfigRepository;
+    private final VlanRepository vlanRepository;
+    private final TPMHashRepository tpmHashRepository;
+    private final TPMValidationService tpmValidationService;
+    @Value("${main.ip}")
+    private String mainIP;
+
+    @Autowired
+    public InitializeController(InitializeService initializeService, TPMValidationService tpmValidationService, FileHashingService fileHashingService, TPMHashRepository tpmHashRepository,
+                                NodeRepository nodeRepository, CredentialsRepository credentialsRepository, ScanConfigRepository scanConfigRepository, VlanRepository vlanRepository) {
+
+        this.nodeRepository = nodeRepository;
+        this.initializeService = initializeService;
+        this.credentialsRepository = credentialsRepository;
+        this.scanConfigRepository = scanConfigRepository;
+        this.vlanRepository = vlanRepository;
+        this.tpmHashRepository = tpmHashRepository;
+        this.fileHashingService = fileHashingService;
+        this.tpmValidationService = tpmValidationService;
+
+        try {
+
+            String target = new String("printenv");
+
+            Runtime rt = Runtime.getRuntime();
+            Process proc = rt.exec(target);
+            int exitCode = proc.waitFor();
+
+            BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()));
+
+            String line = "";
+            while (line != null) {
+
+                if (initializeService.getServerPort() != null && initializeService.getServerIP() != null && initializeService.getTpmPresence() != null) {
+                    break;
+                }
+
+                if (line.contains("MAIN_IP=")) {
+
+                    String[] sep = line.split("=");
+                    if (sep.length == 2) {
+
+                        initializeService.setServerIP(sep[1]);
+
+                    }
+
+                }
+
+
+                if (line.contains("MAIN_PORT=")) {
+
+                    String[] sep = line.split("=");
+                    if (sep.length == 2) {
+
+                        initializeService.setServerPort(sep[1]);
+
+                    }
+
+                }
+
+
+                if (line.contains("TPM_PRESENCE=")) {
+
+                    String[] sep = line.split("=");
+                    if (sep.length == 2) {
+
+                        initializeService.setTpmPresence(sep[1]);
+                    }
+
+                }
+
+                line = reader.readLine();
+            }
+
+        } catch (Throwable t) {
+
+            t.printStackTrace();
+        }
+
+
+        enableRequiredConfiguration();
+
+
+        if (initializeService.getTpmPresence().equals("true") || initializeService.getTpmPresence().equals("tpm0")) {
+            log.info("A TPM device has been detected.");
+
+            if (tpmValidationService.verify_executableHash()) {
+
+                tpmValidationService.verify_pcrHash();
+
+            } else {
+                log.info("No TPM device detected. Launching with regular functioning.");
+            }
+
+
+        }
+    }
+
+
+    @CrossOrigin
+    @ApiOperation(value = "Save a new node and saves its configuration", response = Node.class)
+    @ResponseStatus(HttpStatus.CREATED)
+    @GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
+    Node saveNode(HttpServletResponse response, HttpServletRequest httpServletRequest, @RequestParam(value = "token"/*, required = false*/) String token) {
+        //TODO: Si está detrás de un Proxy (PE: NGINX) habria que obtener la IP de la cabecera si es que se envia
+        // 'X-Forwarded-For'.
+        Credentials credential = credentialsRepository.findByToken(token);
+
+        if(credential != null) {
+
+            List<ScanConfig> scanConfigs = scanConfigRepository.findAllByNodeId(credential.getName());
+            if (scanConfigs != null) {
+
+                if (credential.getAvailableEndpoint().contains("(GET) configurations/")) {
+
+                    Node node = nodeRepository.findByNodeId(credential.getName());
+                    Node nodeR = node;
+                    boolean flag = (node != null);
+                    if (!flag) {
+
+                        log.info("No information from this node was found. Creating new instance.");
+                        node = new Node();
+                        node.setNodeId(credential.getName());
+                        node.setIp(httpServletRequest.getRemoteAddr());
+
+                        nodeR = initializeService.saveNode(node, scanConfigs, flag);
+
+                    } else {
+                        log.info("There was previous information about this node.");
+                        log.info("Node ID: {}", nodeR.getNodeId());
+                        if(!nodeR.getIp().equals(httpServletRequest.getRemoteAddr())){
+
+                            nodeR.setIp(httpServletRequest.getRemoteAddr());
+                        }
+
+                        List<Vlan> vlans = vlanRepository.findAllByDistributedNodeId(credential.getName());
+                        nodeR.setVlan(vlans);
+                        nodeRepository.save(nodeR);
+
+                        log.info("Delay associated with its vlans: {}", vlans.get(0).getDelay());
+                    }
+
+                    return nodeR;
+
+                }
+            }
+        }
+
+        try {
+            response.sendError(400, "Unrecognized token. Access denied.");
+        }catch(IOException ioe){
+            // handled
+        }
+
+        return null;
+    }
+
+
+    public void enableRequiredConfiguration() {
+
+        try {
+
+            String target = new String("ldconfig -v");
+
+            Runtime rt = Runtime.getRuntime();
+            Process proc = rt.exec(target);
+            int exitCode = proc.waitFor();
+
+            BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()));
+
+            String line = "";
+            while (line != null) {
+
+                line = reader.readLine();
+            }
+
+        } catch (Throwable t) {
+
+            t.printStackTrace();
+        }
+    }
+
+
+}

src/main/java/adt/mainnode/controller/VirtuosoQueryController.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.PortRepository;
+import adt.mainnode.repository.HostRepository;
+import adt.mainnode.repository.SnapshotRepository;
+import adt.mainnode.repository.VlanRepository;
+import java.util.ArrayList;
+import adt.mainnode.service.AssetService;
+import io.swagger.annotations.Api;
+import javax.servlet.http.HttpServletRequest;
+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 java.io.InputStreamReader;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.io.FileReader;
+import java.io.FileNotFoundException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+import adt.mainnode.service.InitializeService;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import org.springframework.beans.factory.annotation.Value;
+
+
+@RestController
+@RequestMapping("virt_query")
+@Api(
+        value = "/virt_query",
+        produces = MediaType.APPLICATION_JSON_VALUE,
+        tags = {"Virt_Query"}
+)
+@Slf4j
+public class VirtuosoQueryController {
+
+    private final CredentialsRepository credentialsRepository;
+    private final InitializeService initializeService;
+    private final ArrayList<String> outputTypes_valid;
+    @Value("${main.ip}")
+    private String mainIP;
+
+    @Autowired
+    public VirtuosoQueryController(InitializeService initializeService, CredentialsRepository credentialsRepository) {
+
+        this.initializeService = initializeService;
+        this.credentialsRepository = credentialsRepository;
+
+        outputTypes_valid = new ArrayList<String>();
+        outputTypes_valid.add("json");
+        outputTypes_valid.add("xml");
+        outputTypes_valid.add("turtle");
+        outputTypes_valid.add("n3");
+        outputTypes_valid.add("rdf");
+        outputTypes_valid.add("rdf+xml");
+        outputTypes_valid.add("csv");
+        outputTypes_valid.add("tsv");
+
+    }
+
+    @CrossOrigin
+    @ApiOperation(value = "Make a SPARQL query to Virtuoso. Valid output formats include: [json, xml, turtle, n3, rdf, rdf+xml, csv, tsv].", response = String.class)
+    @ResponseStatus(HttpStatus.CREATED)
+    @PostMapping(produces = MediaType.APPLICATION_JSON_VALUE)
+    String queryVirtuoso(HttpServletRequest httpServletRequest,
+                         HttpServletResponse response,
+                         @RequestBody String query,
+                         @RequestParam String outputFormat,
+                         @RequestParam String token) {
+
+        Credentials credential = credentialsRepository.findByToken(token);
+
+        if(credential != null && credential.getStatus().equals("OPERATIVE")) {
+
+            outputFormat = outputFormat.toLowerCase();
+
+            if(query.length() == 0 || query.equals("{}")){
+
+                try {
+                    response.sendError(400, "Query was unspecified. Cannot process this input.");
+                }catch(IOException ioe){
+                    //
+                }
+
+                return null;
+            }
+
+            if(!outputTypes_valid.contains(outputFormat)){
+
+                try {
+                    response.sendError(400, "An invalid output format was specified. Please, check that it matches one of the following: [json, xml, turtle, n3, rdf, rdf+xml, csv, tsv].");
+                }catch(IOException ioe){
+                    //
+                }
+
+                return null;
+            }
+
+            if(credential.getAvailableEndpoint().contains("(GET) virt_query/")) {
+
+                try{
+
+                    log.info("New query to Virtuoso received");
+
+                    PrintWriter writer = new PrintWriter("./virtuoso/query_info.txt", "UTF-8");
+                    writer.println(query);
+                    writer.println(outputFormat);
+                    writer.println(httpServletRequest.getRemoteAddr());
+                    writer.close();
+
+                    String target = new String("python3 virtuoso/query_script.py http://" + initializeService.getServerIP() + ":8890/sparql-auth");
+
+                    Runtime rt = Runtime.getRuntime();
+                    Process proc = rt.exec(target);
+                    int exitCode = proc.waitFor();
+
+                    StringBuffer output = new StringBuffer();
+                    BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()));
+
+                    Object obj = new FileReader("./queryresp_virtuoso.xml");
+                    log.info("Virtuoso output processed: \n{}", obj);
+
+                    byte[] encoded = Files.readAllBytes(Paths.get("./queryresp_virtuoso.xml"));
+
+                    return new String(encoded, "utf-8");
+
+                } catch (Throwable t) {
+
+                    t.printStackTrace();
+                }
+
+            }
+        }
+
+        try {
+            response.sendError(400, "Unrecognized token. Access denied.");
+        }catch(IOException ioe){
+            //
+        }
+
+        return null;
+    }
+
+}

src/main/java/adt/mainnode/dto/AddForm.java

+package adt.mainnode.dto;
+
+import adt.mainnode.entity.Credentials;
+import adt.mainnode.entity.ScanConfig;
+import java.util.List;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+public class AddForm {
+
+    private Credentials credentials;
+    private List<ScanConfig> configs;
+
+}
\ No newline at end of file

src/main/java/adt/mainnode/dto/Asset.java

+package adt.mainnode.dto;
+
+import lombok.Data;
+import java.util.List;
+
+@Data
+public class Asset {
+
+    List<ScanInfoDto> scanInfo;
+    String discoveryMethod;
+
+    public static Asset createAsset_nlp(List<ScanInfoDto> scanInfoDto, String discoveryMethod) {
+
+        Asset asset = new Asset();
+
+        asset.setScanInfo(scanInfoDto);
+        asset.setDiscoveryMethod(discoveryMethod);
+
+        return asset;
+    }
+}

src/main/java/adt/mainnode/dto/HostDto.java

+package adt.mainnode.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import adt.mainnode.entity.Host;
+import lombok.Data;
+import java.util.Date;
+import java.util.List;
+
+@Data
+public class HostDto {
+
+    @JsonProperty("ip_address")
+    private String ip;
+
+    @JsonProperty("vlan_id")
+    private String vlanName;
+
+    @JsonProperty("timestamp_device_scan_start")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    private Date timestamp_ini;
+
+    @JsonProperty("timestamp_device_scan_end")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    private Date timestamp_end;
+
+    @JsonProperty("hostname")
+    private String hostname;
+
+    @JsonProperty("mac_address")
+    private String mac;
+
+    @JsonProperty("mac_manufacturer")
+    private String macManufacturer;
+
+    @JsonProperty("ports")
+    private List<PortDto> ports;
+
+    @JsonProperty("operating_system")
+    private String operatingSystem;
+
+    public static HostDto createHostDto(Host host) {
+        HostDto hostDto = new HostDto();
+        hostDto.setIp(host.getIp());
+        hostDto.setVlanName(host.getVlanName());
+        hostDto.setHostname(host.getHostname());
+        hostDto.setMac(host.getMac());
+        hostDto.setMacManufacturer(host.getMacManufacturer());
+        hostDto.setPorts(host.getPorts());
+        hostDto.setTimestamp_ini(host.getTimestamp_ini());
+        hostDto.setTimestamp_end(host.getTimestamp_end());
+        hostDto.setOperatingSystem(host.getOperatingSystem());
+        return hostDto;
+    }
+}
+

src/main/java/adt/mainnode/dto/PortDto.java

+package adt.mainnode.dto;
+
+import lombok.Data;
+import adt.mainnode.entity.Port;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+@Data
+public class PortDto {
+
+    //private int id;
+    @JsonProperty("port")
+    private String portNumber;
+
+    @JsonIgnore
+    private HostDto hostDto;
+
+    @JsonProperty("service")
+    private String serviceRunning;
+
+    @JsonProperty("service_version")
+    private String serviceVersion;
+
+    @JsonProperty("protocol")
+    private String protocol;
+
+    @JsonProperty("discovery_method")
+    private String discoveryMethod;
+
+    @JsonProperty("state")
+    private String state;
+
+    public static PortDto createPortDto(Port port) {
+        PortDto portDto = new PortDto();
+        portDto.setPortNumber(port.getPortNumber());
+        portDto.setServiceRunning(port.getServiceRunning());
+        portDto.setServiceVersion(port.getServiceVersion());
+        portDto.setProtocol(port.getProtocol());
+        portDto.setDiscoveryMethod(port.getDiscoveryMethod());
+        portDto.setState(port.getState());
+        return portDto;
+    }
+
+    public static PortDto createPortDto_nlp(String portNumber, String serviceRunning, String serviceVersion, String protocol, String discoveryMethod, String state) {
+
+        PortDto portDto = new PortDto();
+        portDto.setPortNumber(portNumber);
+        portDto.setServiceRunning(serviceRunning);
+        portDto.setServiceVersion(serviceVersion);
+        portDto.setProtocol(protocol);
+        portDto.setDiscoveryMethod(discoveryMethod);
+        portDto.setState(state);
+        return portDto;
+    }
+
+}

src/main/java/adt/mainnode/dto/Query.java

+package adt.mainnode.dto;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+public class Query {
+
+    private String query;
+    private String type;
+    private String token;
+
+    public String getQuery() {
+        return query;
+    }
+
+    public void setQuery(String query) {
+        this.query = query;
+    }
+
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public static Query createQuery(String query, String type, String token) {
+        Query q = new Query();
+
+        q.setQuery(query);
+        q.setType(type);
+
+        q.setToken(token);
+
+        return q;
+    }
+}

src/main/java/adt/mainnode/dto/ScanInfoDto.java

+package adt.mainnode.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import java.util.Date;
+import lombok.Data;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.time.DateUtils;
+import java.text.ParseException;
+
+@Data
+@Slf4j
+public class ScanInfoDto {
+
+    @JsonProperty("vlan_id")
+    String vlanName;
+
+    @JsonProperty("timestamp_main_node")
+    Date mainNode_timestamp;
+
+    @JsonProperty("node_ip_address")
+    String nodeIp;
+
+    @JsonProperty("timestamp_dist_node_scan_start")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    private Date iniTimestampScan;
+
+    @JsonProperty("timestamp_dist_node_scan_end")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    private Date endTimestampScan;
+
+    @JsonProperty("devices")
+    private List<HostDto> host;
+
+    @JsonProperty("mac_address")
+    private String macAddress;
+
+    public static ScanInfoDto createScanInfoDto_nlp(String vlanName, Date mainNode_timestamp, String nodeIp,
+                                                    String iniTimestampScan, String endTimestampScan, List<HostDto> hostDtos,
+                                                    String macAddress) {
+
+        ScanInfoDto scanInfoDto = new ScanInfoDto();
+
+        scanInfoDto.setVlanName(vlanName);
+        scanInfoDto.setMainNode_timestamp(mainNode_timestamp);
+        scanInfoDto.setNodeIp(nodeIp);
+
+        iniTimestampScan = iniTimestampScan.replace("b", "");
+        iniTimestampScan = iniTimestampScan.replace("'", "");
+        endTimestampScan = endTimestampScan.replace("b", "");
+        endTimestampScan = endTimestampScan.replace("'", "");
+
+        try {
+
+            Date date1 = DateUtils.parseDate(iniTimestampScan, "yyyy-MM-dd HH:mm:ss");
+
+            Date date2 = DateUtils.parseDate(endTimestampScan, "yyyy-MM-dd HH:mm:ss");
+
+            scanInfoDto.setIniTimestampScan(date1);
+            scanInfoDto.setEndTimestampScan(date2);
+        }catch(ParseException p){
+            log.error("{}",p);
+        }
+
+
+        scanInfoDto.setHost(hostDtos);
+        scanInfoDto.setMacAddress(macAddress);
+
+        return scanInfoDto;
+    }
+}

src/main/java/adt/mainnode/dto/Transfer.java

+package adt.mainnode.dto;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+public class Transfer {
+
+    private String user;
+    private String password;
+    private String tokenUrl;
+
+    private String url;
+
+
+    public String getUser() {
+        return user;
+    }
+
+    public void setUser(String user) {
+        this.user = user;
+    }
+
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+
+    public String getTokenUrl() {
+        return tokenUrl;
+    }
+
+    public void setTokenUrl(String tokenUrl) {
+        this.tokenUrl = tokenUrl;
+    }
+
+
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+
+    public static Transfer createTransfer(String url) {
+        Transfer q = new Transfer();
+
+        q.setUrl(url);
+
+        return q;
+    }
+}

src/main/java/adt/mainnode/dto/VisualToken.java

+package adt.mainnode.dto;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor
+public class VisualToken {
+
+    private String visualToken;
+
+
+    public String getVisualToken() {
+        return visualToken;
+    }
+
+    public void setVisualToken(String visualToken) {
+        this.visualToken = visualToken;
+    }
+
+
+    public static VisualToken createVisualToken(String visualToken) {
+        VisualToken q = new VisualToken();
+
+        q.setVisualToken(visualToken);
+
+        return q;
+    }
+}

src/main/java/adt/mainnode/entity/Credentials.java

+package adt.mainnode.entity;
+
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Transient;
+import javax.validation.constraints.Email;
+import javax.validation.constraints.NotBlank;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Data
+@NoArgsConstructor
+public class Credentials {
+
+    @Column(name = "type")
+    private String type;
+
+    @Column(name = "email")
+    private String email;
+
+    @Column(name = "name")
+    private String name;
+
+    @Column(name = "description")
+    private String description;
+
+    @Column(name = "password")
+    private String password;
+
+    @Id
+    @Column(name = "token")
+    private String token;
+
+    @Column(name = "availableEndpoint")
+    private String availableEndpoint;
+
+    @Column(name = "pcr_token")
+    private String pcrToken;
+
+    @Column(name = "status")
+    private String status;
+
+    @Transient
+    private String[] endpoints;
+
+    public static Credentials createCredentials(/*String nodeId, String vlanName,*/ String type, String email, String name, String description, String token, String availableEndpoing) {
+
+        Credentials credentials = new Credentials();
+
+        //credentials.setNodeId(nodeId);
+        //credentials.setVlanName(vlanName);
+        credentials.setType(type);
+        credentials.setEmail(email);
+        credentials.setName(name);
+        credentials.setDescription(description);
+        credentials.setToken(token);
+        credentials.setAvailableEndpoint(availableEndpoing);
+
+        return credentials;
+    }
+}

src/main/java/adt/mainnode/entity/Host.java

+package adt.mainnode.entity;
+
+import adt.mainnode.dto.HostDto;
+import adt.mainnode.dto.PortDto;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import adt.mainnode.identity.HostIdentity;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+
+import javax.persistence.*;
+import java.util.Date;
+import java.util.List;
+
+@Data
+@Entity
+@IdClass(HostIdentity.class)
+public class Host {
+
+    @Id
+    @Column(name = "ip")
+    @JsonProperty("ip_address")
+    private String ip;
+
+    @Id
+    @Column(name = "vlan_name")
+    @JsonProperty("vlan_id")
+    private String vlanName;
+
+    @Id
+    @JsonIgnore
+    @JsonProperty("snapshot_id")
+    String snapshotId;
+
+    @Column(name = "hostname")
+    @JsonProperty("hostname")
+    private String hostname;
+
+    @Column(name = "mac")
+    @JsonProperty("mac_address")
+    private String mac;
+
+    @Column(name = "mac_manufacturer")
+    @JsonProperty("mac_manufacturer")
+    private String macManufacturer;
+
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @JsonProperty("timestamp_device_scan_start")
+    private Date timestamp_ini;
+
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    @JsonProperty("timestamp_device_scan_end")
+    private Date timestamp_end;
+
+    @Transient
+    @JsonProperty("ports")
+    List<PortDto> ports;
+
+    @Column(name = "operatingSystem")
+    @JsonProperty("operating_system")
+    private String operatingSystem;
+
+    public static Host createHost(HostIdentity hostIdentity, HostDto hostDto) {
+        Host host = new Host();
+        host.setIp(hostIdentity.getIp());
+        host.setVlanName(hostIdentity.getVlanName());
+        host.setHostname(hostDto.getHostname());
+        host.setMac(hostDto.getMac());
+        host.setMacManufacturer(hostDto.getMacManufacturer());
+        host.setTimestamp_ini(hostDto.getTimestamp_ini());
+        host.setTimestamp_end(hostDto.getTimestamp_end());
+        host.setPorts(hostDto.getPorts());
+        host.setSnapshotId(hostIdentity.getSnapshotId());
+        host.setOperatingSystem(hostDto.getOperatingSystem());
+
+        return host;
+    }
+
+    public static Host createHost_nlp(String vlan_name, String ip_addr, String host_name, String mac_addr, String mac_manufacturer, String operating_system, String snapshotId, List<PortDto> ports) {
+        Host host = new Host();
+        host.setIp(ip_addr);
+        host.setVlanName(vlan_name);
+        host.setHostname(host_name);
+        host.setMac(mac_addr);
+        host.setMacManufacturer(mac_manufacturer);
+        host.setPorts(ports);
+        host.setSnapshotId(snapshotId);
+        host.setOperatingSystem(operating_system);
+
+        return host;
+    }
+
+}
+

src/main/java/adt/mainnode/entity/Node.java

+package adt.mainnode.entity;
+
+import lombok.Data;
+import java.util.List;
+import javax.persistence.*;
+
+@Entity
+@Data
+//@IdClass(NodeIdentity.class)
+public class Node {
+
+    //@Column(name = "token")
+    //private String token;
+
+    @Id
+    //@GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Column(name = "nodeId")
+    private String nodeId;
+
+    //@Id
+    @Column(name = "vlan_name")
+    private String vlanName;
+
+    @Column(name = "ip")
+    private String ip;
+
+    /*TODO utilidad?*/
+    @Column(name = "os_type")
+    private String osType;
+
+    @Transient
+    private List<Vlan> vlan;
+
+    public static Node createNode(String nodeId, String vlanName, String ip, String os_type) {
+        Node node = new Node();
+        node.setNodeId(nodeId);
+        node.setVlanName(vlanName);
+        node.setIp(ip);
+        node.setOsType(os_type);
+        return node;
+    }
+}

src/main/java/adt/mainnode/entity/Port.java

+package adt.mainnode.entity;
+
+import adt.mainnode.dto.PortDto;
+import adt.mainnode.identity.PortIdentity;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.IdClass;
+
+@Data
+@Entity
+@IdClass(PortIdentity.class)
+public class Port {
+
+    @Id
+    @Column(name = "port_number")
+    @JsonProperty("port")
+    private String portNumber;
+
+    @Id
+    @Column(name = "ip")
+    @JsonIgnore
+    @JsonProperty("ip_address")
+    private String ip;
+
+    @Id
+    @Column(name = "vlan_name")
+    @JsonIgnore
+    @JsonProperty("vlan_id")
+    private String vlanName;
+
+    @Id
+    @JsonIgnore
+    @JsonProperty("snapshot_id")
+    String snapshotId;
+
+    @Column(name = "service_running")
+    @JsonProperty("service")
+    private String serviceRunning;
+
+    @Column(name = "service_version")
+    @JsonProperty("service_version")
+    private String serviceVersion;
+
+    @Column(name = "protocol")
+    @JsonProperty("protocol")
+    private String protocol;
+
+    @Column(name = "discovery_method")
+    @JsonProperty("discovery_method")
+    private String discoveryMethod;
+
+    @Column(name = "state")
+    @JsonProperty("state")
+    private String state;
+
+    public static Port createPort(PortIdentity portIdentity, PortDto portDto) {
+        Port port = new Port();
+        port.setPortNumber(portIdentity.getPortNumber());
+        port.setIp(portIdentity.getIp());
+        port.setVlanName(portIdentity.getVlanName());
+        port.setServiceRunning(portDto.getServiceRunning());
+        port.setServiceVersion(portDto.getServiceVersion());
+        port.setProtocol(portDto.getProtocol());
+        port.setDiscoveryMethod(portDto.getDiscoveryMethod());
+        port.setState(portDto.getState());
+        port.setSnapshotId(portIdentity.getSnapshotId());
+
+        return port;
+    }
+
+}

src/main/java/adt/mainnode/entity/ScanConfig.java

+package adt.mainnode.entity;
+
+import adt.mainnode.identity.ScanConfigIdentity;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.IdClass;
+import javax.validation.constraints.NotBlank;
+
+@Entity
+@Data
+@NoArgsConstructor
+@IdClass(ScanConfigIdentity.class)
+public class ScanConfig {
+
+    @Id
+    @Column(name = "nodeId")
+    private String nodeId;
+
+    @Id
+    @Column(name = "vlanName")
+    private String vlanName;
+
+    @Column(name = "ipToScan")
+    private String ipToScan;
+
+    @Column(name = "mask")
+    private String mask;
+
+    @Column(name = "delay")
+    private Long delay;
+
+    public static ScanConfig createScanConfig(String vlanName, String nodeId,/* String token,*/ String ipToScan, String mask, Long delay) {
+
+        ScanConfig scanConfig = new ScanConfig();
+
+        scanConfig.setNodeId(nodeId);
+        scanConfig.setVlanName(vlanName);
+        //scanConfig.setToken(token);
+        scanConfig.setIpToScan(ipToScan);
+        scanConfig.setMask(mask);
+        scanConfig.setDelay(delay);
+
+        return scanConfig;
+    }
+
+}

src/main/java/adt/mainnode/entity/ScanInfo.java

+package adt.mainnode.entity;
+
+import java.text.ParseException;
+import adt.mainnode.dto.ScanInfoDto;
+import adt.mainnode.dto.HostDto;
+import adt.mainnode.identity.ScanInfoIdentity;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.extern.slf4j.Slf4j;
+import lombok.Data;
+//import org.springframework.util.DigestUtils;
+import org.apache.commons.codec.digest.DigestUtils;
+import javax.persistence.Entity;
+import javax.persistence.Transient;
+import javax.persistence.Id;
+import javax.persistence.IdClass;
+import java.util.Date;
+import java.text.SimpleDateFormat;
+import java.util.List;
+import org.apache.commons.lang3.time.DateUtils;
+
+@Data
+@Entity
+@IdClass(ScanInfoIdentity.class)
+@Slf4j
+public class ScanInfo {
+
+    @Id
+    @JsonProperty("vlan_id")
+    String vlanName;
+
+    @Id
+    @JsonIgnore
+    @JsonProperty("snapshot_id")
+    String snapshotId;
+
+    @JsonProperty("node_ip_address")
+    String nodeIp;
+
+    @JsonProperty("timestamp_dist_node_scan_start")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    Date iniTimestampScan;
+
+    @JsonProperty("timestamp_dist_node_scan_end")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    Date endTimestampScan;
+
+    @JsonProperty("timestamp_main_node")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    Date mainNode_timestamp; // Main node's timestamp of receipt
+
+    @Transient
+    @JsonProperty("devices")
+    List<HostDto> host;
+
+    @JsonProperty("mac_address")
+    private String macAddress;
+
+    public static ScanInfo createScanInfo(ScanInfoIdentity scanInfoIdentity, ScanInfoDto scanInfoDto) {//String vlanName, String nodeIp, Date iniTimestampScan, Date endTimestampScan) {
+        ScanInfo scanInfo = new ScanInfo();
+        scanInfo.setVlanName(scanInfoIdentity.getVlanName());
+        scanInfo.setSnapshotId(scanInfoIdentity.getSnapshotId());
+        scanInfo.setNodeIp(scanInfoDto.getNodeIp());
+        scanInfo.setIniTimestampScan(scanInfoDto.getIniTimestampScan());
+        scanInfo.setEndTimestampScan(scanInfoDto.getEndTimestampScan());
+
+        scanInfo.setMainNode_timestamp(scanInfoDto.getMainNode_timestamp());//new Date());
+/*
+        String generatedHash = DigestUtils.md5Hex( DigestUtils.md5Hex(scanInfo.getMainNode_timestamp().toString()) + DigestUtils.md5Hex(scanInfo.getIniTimestampScan().toString()) + DigestUtils.md5Hex(scanInfo.getEndTimestampScan().toString()) );
+*/
+        scanInfo.setHost(scanInfoDto.getHost());
+
+        //log.info("Generated hash code for a snapshot ID: {}", generatedHash);
+
+        return scanInfo;
+    }
+
+    public static ScanInfo createScanInfo(ScanInfoIdentity scanInfoIdentity, String nodeIp, String iniTimestampScan, String endTimestampScan, Date mainNodeTimestamp) {//String vlanName, String nodeIp, Date iniTimestampScan, Date endTimestampScan) {
+
+        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+        ScanInfo scanInfo = new ScanInfo();
+        scanInfo.setVlanName(scanInfoIdentity.getVlanName());
+        scanInfo.setSnapshotId(scanInfoIdentity.getSnapshotId());
+        scanInfo.setNodeIp(nodeIp);
+
+        iniTimestampScan = iniTimestampScan.replace("b", "");
+        iniTimestampScan = iniTimestampScan.replace("'", "");
+        endTimestampScan = endTimestampScan.replace("b", "");
+        endTimestampScan = endTimestampScan.replace("'", "");
+
+        try {
+
+            Date date1 = DateUtils.parseDate(iniTimestampScan, "yyyy-MM-dd HH:mm:ss");
+
+            Date date2 = DateUtils.parseDate(endTimestampScan, "yyyy-MM-dd HH:mm:ss");
+
+            scanInfo.setIniTimestampScan(date1);
+            scanInfo.setEndTimestampScan(date2);
+        }catch(ParseException p){
+            log.error("{}",p);
+        }
+        scanInfo.setMainNode_timestamp(mainNodeTimestamp);//new Date());
+/*
+        String generatedHash = DigestUtils.md5Hex( DigestUtils.md5Hex(scanInfo.getMainNode_timestamp().toString()) + DigestUtils.md5Hex(scanInfo.getIniTimestampScan().toString()) + DigestUtils.md5Hex(scanInfo.getEndTimestampScan().toString()) );
+*/
+        //scanInfo.setHost(scanInfoDto.getHost());
+
+        //log.info("Generated hash code for a snapshot ID: {}", generatedHash);
+
+        return scanInfo;
+    }
+
+}
+

src/main/java/adt/mainnode/entity/Snapshot.java

+package adt.mainnode.entity;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.IdClass;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import adt.mainnode.identity.SnapshotIdentity;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.apache.commons.lang3.time.DateUtils;
+
+import java.util.Date;
+
+@Entity
+@Data
+@NoArgsConstructor
+@IdClass(SnapshotIdentity.class)
+public class Snapshot {
+
+    @Id
+    @JsonIgnore
+    @Column(name = "vlan")
+    String vlanName;
+
+    @Id
+    @JsonIgnore
+    @Column(name = "node_id")
+    String nodeId;
+
+    @Id
+    @Column(name = "snapshotId")
+    String snapshotId;
+
+    @Column(name = "discovery_method")
+    String discoveryMethod;
+
+    @Column(name = "timestamp_main_node")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    Date timestamp_mainNode;
+
+    @Column(name = "timestamp_dist_node_scan_start")
+    @JsonProperty("timestamp_dist_node_scan_start")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    Date timestamp_distNode_ini;
+
+    @Column(name = "timestamp_dist_node_scan_end")
+    @JsonProperty("timestamp_dist_node_scan_end")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    Date timestampDistNodeEnd;
+
+    public static Snapshot createSnapshot(ScanInfo scanInfo, SnapshotIdentity snapshotIdentity, String discoveryMethod) {
+        Snapshot snapshot = new Snapshot();
+
+        snapshot.setVlanName(snapshotIdentity.getVlanName());
+        snapshot.setSnapshotId(snapshotIdentity.getSnapshotId());
+        snapshot.setNodeId(snapshotIdentity.getNodeId());
+        snapshot.setTimestamp_distNode_ini(scanInfo.getIniTimestampScan());
+        snapshot.setTimestampDistNodeEnd(scanInfo.getEndTimestampScan());
+        snapshot.setTimestamp_mainNode(scanInfo.getMainNode_timestamp());
+
+        snapshot.setDiscoveryMethod(discoveryMethod);
+
+        return snapshot;
+    }
+
+    public static Snapshot createSnapshot_nlp(String vlanName, String nodeId, String snapshotId,
+                              Date mainNode_timestamp, String timestamp_distNode_ini, String timestampDistNodeEnd, String discoveryMethod) {
+
+        Snapshot snapshot = new Snapshot();
+
+        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
+
+        snapshot.setVlanName(vlanName);
+        snapshot.setNodeId(nodeId);
+        snapshot.setSnapshotId(snapshotId);
+        snapshot.setTimestamp_mainNode(mainNode_timestamp);
+
+        snapshot.setDiscoveryMethod(discoveryMethod);
+
+        timestamp_distNode_ini = timestamp_distNode_ini.replace("b", "");
+        timestamp_distNode_ini = timestamp_distNode_ini.replace("'", "");
+        timestampDistNodeEnd = timestampDistNodeEnd.replace("b", "");
+        timestampDistNodeEnd = timestampDistNodeEnd.replace("'", "");
+
+        try {
+
+            Date date1 = DateUtils.parseDate(timestamp_distNode_ini, "yyyy-MM-dd HH:mm:ss");
+
+            Date date2 = DateUtils.parseDate(timestampDistNodeEnd, "yyyy-MM-dd HH:mm:ss");
+
+            snapshot.setTimestamp_distNode_ini(date1);
+            snapshot.setTimestampDistNodeEnd(date2);
+        }catch(ParseException p){
+        }
+        return snapshot;
+    }
+
+}

src/main/java/adt/mainnode/entity/TPMHash.java

+package adt.mainnode.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Transient;
+import javax.validation.constraints.Email;
+import javax.validation.constraints.NotBlank;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Date;
+
+@Entity
+@Data
+@NoArgsConstructor
+public class TPMHash {
+
+    @Id
+    @Column(name = "hash")
+    private String hash;
+
+    @Column(name = "timestamp")
+    private Date timestamp;
+
+
+    public static TPMHash createTPMHash(String hash) {
+
+        TPMHash myHash = new TPMHash();
+
+        myHash.setHash(hash);
+        myHash.setTimestamp(new Date());
+
+        return myHash;
+    }
+}

src/main/java/adt/mainnode/entity/Vlan.java

+package adt.mainnode.entity;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import adt.mainnode.identity.VlanIdentity;
+
+import javax.persistence.*;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Transient;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Data
+@NoArgsConstructor
+@IdClass(VlanIdentity.class)
+public class Vlan {
+
+    @Id
+    @Column(name = "distributedNodeId")
+    String distributedNodeId;
+
+    @Id
+    @JsonProperty("vlan_name")
+    @Column(name = "vlan_name")
+    String vlanName;
+
+    @Column(name = "delay")
+    Long delay; // Value in seconds
+
+    @Column(name = "gateway")
+    String gateway;
+
+    @Column(name = "net_addr")
+    String netAddress;
+
+    @Column(name = "mask")
+    String mask;
+
+    @Transient
+    List<Snapshot> snapshots;
+
+    public static Vlan createVlan(VlanIdentity vlanIdentity, Long delay, String netAddress, String gateway, String mask) {
+        Vlan vlan = new Vlan();
+        vlan.setDistributedNodeId(vlanIdentity.getDistributedNodeId());
+        vlan.setVlanName(vlanIdentity.getVlanName());
+        vlan.setDelay(delay);
+        vlan.setGateway(gateway);
+        vlan.setNetAddress(netAddress);
+        vlan.setMask(mask);
+        vlan.setSnapshots(new ArrayList<>());
+        return vlan;
+    }
+
+}

src/main/java/adt/mainnode/entity/changed/DeviceChange.java

+package adt.mainnode.entity.changed;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.IdClass;
+
+import java.text.ParseException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import adt.mainnode.identity.SnapshotIdentity;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.apache.commons.lang3.time.DateUtils;
+
+import java.util.Date;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import javax.persistence.Transient;
+
+import adt.mainnode.entity.changed.*;
+
+@Entity
+@Data
+@NoArgsConstructor
+public class DeviceChange {
+
+    @Id
+    @Column(name = "timestamp_device")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    Date timestamp_device;
+
+    @JsonProperty("type_of_change")
+    String type_of_change;
+
+    @JsonProperty("ip_address")
+    String ip_address;
+
+    @JsonProperty("mac_address")
+    String mac_address;
+
+    @JsonProperty("operating_system")
+    String operating_system;
+
+    @Transient
+    @JsonProperty("ports")
+    List<PortChange> ports;
+
+    public static DeviceChange createDeviceChange(Date timestamp_device, String type_of_change, String ip_address,
+                                                  String mac_address, String operating_system, List<PortChange> ports) {
+
+        DeviceChange deviceChange = new DeviceChange();
+
+        deviceChange.setTimestamp_device(timestamp_device);
+        deviceChange.setType_of_change(type_of_change);
+        deviceChange.setIp_address(ip_address);
+        deviceChange.setMac_address(mac_address);
+        deviceChange.setOperating_system(operating_system);
+        deviceChange.setPorts(ports);
+
+        return deviceChange;
+    }
+
+
+}

src/main/java/adt/mainnode/entity/changed/PortChange.java

+package adt.mainnode.entity.changed;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.IdClass;
+
+import java.text.ParseException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import adt.mainnode.identity.SnapshotIdentity;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.apache.commons.lang3.time.DateUtils;
+
+import java.util.Date;
+
+import java.util.List;
+import java.util.ArrayList;
+
+@Entity
+@Data
+@NoArgsConstructor
+public class PortChange {
+
+    @Id
+    @Column(name = "port")
+    String port;
+
+    @JsonProperty("protocol")
+    String protocol;
+
+    @JsonProperty("service")
+    String service;
+
+    @JsonProperty("service_version")
+    String service_version;
+
+    @JsonProperty("status")
+    String status;
+
+    public static PortChange createPortChange(String port, String protocol, String service,
+                                              String service_version, String status) {
+
+        PortChange portChange = new PortChange();
+
+        portChange.setPort(port);
+        portChange.setProtocol(protocol);
+        portChange.setService(service);
+        portChange.setService_version(service_version);
+        portChange.setStatus(status);
+
+        return portChange;
+    }
+
+
+}

src/main/java/adt/mainnode/entity/changed/SnapshotChange.java

+package adt.mainnode.entity.changed;
+
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.IdClass;
+
+import java.text.ParseException;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import adt.mainnode.identity.SnapshotIdentity;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.apache.commons.lang3.time.DateUtils;
+
+import java.util.Date;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import javax.persistence.Transient;
+
+import adt.mainnode.entity.changed.*;
+
+
+@Entity
+@Data
+@NoArgsConstructor
+public class SnapshotChange {
+
+    @Id
+    @Column(name = "timestamp_snapshot")
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
+    Date timestamp_snapshot;
+
+    @Column(name = "discovery_method")
+    String discoveryMethod;
+
+    @Transient
+    @JsonProperty("vlans")
+    List<VlanChange> vlans;
+
+    public static SnapshotChange createSnapshotChange(Date timestamp_snapshot, List<VlanChange> vlans, String discoveryMethod) {
+
+        SnapshotChange snapshotChange = new SnapshotChange();
+
+        snapshotChange.setTimestamp_snapshot(timestamp_snapshot);
+        snapshotChange.setVlans(vlans);
+        snapshotChange.setDiscoveryMethod(discoveryMethod);
+
+        return snapshotChange;
+    }
+
+
+}

src/main/java/adt/mainnode/entity/changed/VlanChange.java

+package adt.mainnode.entity.changed;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import adt.mainnode.identity.VlanIdentity;
+
+import javax.persistence.*;
+import javax.persistence.Column;
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Transient;
+import java.util.ArrayList;
+import java.util.List;
+
+import adt.mainnode.entity.changed.*;
+
+@Entity
+@Data
+@NoArgsConstructor
+public class VlanChange {
+
+    @Id
+    @JsonProperty("vlan_id")
+    @Column(name = "vlan_id")
+    String vlan_id;
+
+    @Transient
+    @JsonProperty("devices")
+    List<DeviceChange> hosts;
+
+    public static VlanChange createVlanChange(String vlan_id, List<DeviceChange> hosts) {
+
+        VlanChange vlanChange = new VlanChange();
+
+        vlanChange.setVlan_id(vlan_id);
+        vlanChange.setHosts(hosts);
+
+        return vlanChange;
+    }
+
+
+}

src/main/java/adt/mainnode/identity/HostIdentity.java

+package adt.mainnode.identity;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+import javax.persistence.Id;
+import java.io.Serializable;
+
+@Embeddable
+@Data
+@NoArgsConstructor
+public class HostIdentity implements Serializable {
+
+    @Id
+    @Column(name = "ip")
+    private String ip;
+
+    @Id
+    @Column(name = "vlan_name")
+    private String vlanName;
+
+    @Id
+    @Column(name = "snapshotId")
+    private String snapshotId;
+
+    public static HostIdentity createHostIdentity(String ip, String vlanName, String snapshotId) {
+        HostIdentity hostIdentity = new HostIdentity();
+        hostIdentity.setIp(ip);
+        hostIdentity.setVlanName(vlanName);
+        hostIdentity.setSnapshotId(snapshotId);
+        return hostIdentity;
+    }
+
+}

src/main/java/adt/mainnode/identity/PortIdentity.java

+package adt.mainnode.identity;
+
+import lombok.*;
+
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+import javax.persistence.Id;
+import java.io.Serializable;
+
+@Embeddable
+@Getter
+@Setter(AccessLevel.PRIVATE)
+@NoArgsConstructor
+public class PortIdentity implements Serializable {
+
+    @Id
+    @Column(name = "port_number")
+    private String portNumber;
+
+    @Id
+    @Column(name = "ip")
+    private String ip;
+
+    @Id
+    @Column(name = "vlan_name")
+    private String vlanName;
+
+    @Id
+    @Column(name = "snapshotId")
+    private String snapshotId;
+
+    public static PortIdentity createPortIdentity(String portNumber, String ip, String vlanName, String snapshotId) {
+        PortIdentity portIdentity = new PortIdentity();
+        portIdentity.setPortNumber(portNumber);
+        portIdentity.setIp(ip);
+        portIdentity.setVlanName(vlanName);
+        portIdentity.setSnapshotId(snapshotId);
+        return portIdentity;
+    }
+
+}

src/main/java/adt/mainnode/identity/ScanConfigIdentity.java

+package adt.mainnode.identity;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+import javax.persistence.Id;
+
+import java.io.Serializable;
+
+@Embeddable
+@Data
+@NoArgsConstructor
+public class ScanConfigIdentity implements Serializable{
+
+    @Id
+    @Column(name = "nodeId")
+    private String nodeId;
+
+    @Id
+    @Column(name = "vlanName")
+    private String vlanName;
+
+    public static ScanConfigIdentity createScanConfigIdentity(String nodeId, String vlanName) {
+        ScanConfigIdentity scanConfigIdentity = new ScanConfigIdentity();
+        scanConfigIdentity.setNodeId(nodeId);
+        scanConfigIdentity.setVlanName(vlanName);
+
+        return scanConfigIdentity;
+    }
+}

src/main/java/adt/mainnode/identity/ScanInfoIdentity.java

+package adt.mainnode.identity;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import java.io.Serializable;
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+import javax.persistence.Id;
+
+@Embeddable
+@Data
+@NoArgsConstructor
+public class ScanInfoIdentity implements Serializable {
+
+    @Id
+    @Column(name = "vlanName")
+    private String vlanName;
+
+    @Id
+    @Column(name = "snapshotId")
+    private String snapshotId;
+
+    public static ScanInfoIdentity createScanInfoIdentity(String vlanName, String snapshotId) {
+        ScanInfoIdentity scanInfoIdentity  = new ScanInfoIdentity();
+        scanInfoIdentity.setVlanName(vlanName);
+        scanInfoIdentity.setSnapshotId(snapshotId);
+        return scanInfoIdentity;
+    }
+
+}

src/main/java/adt/mainnode/identity/SnapshotIdentity.java

+package adt.mainnode.identity;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+import javax.persistence.Id;
+import java.io.Serializable;
+
+@Embeddable
+@Data
+@NoArgsConstructor
+public class SnapshotIdentity implements Serializable {
+
+    @Id
+    @Column(name = "vlan_name")
+    private String vlanName;
+
+    @Id
+    @Column(name = "node_id")
+    private String nodeId;
+
+    @Id
+    @Column(name = "snapshotId")
+    private String snapshotId;
+
+    public static SnapshotIdentity createSnapshotIdentity(String vlanName, String nodeId, String snapshotId) {
+        SnapshotIdentity snapshotIdentity = new SnapshotIdentity();
+        snapshotIdentity.setVlanName(vlanName);
+        snapshotIdentity.setNodeId(nodeId);
+        snapshotIdentity.setSnapshotId(snapshotId);
+
+        return snapshotIdentity;
+    }
+}

src/main/java/adt/mainnode/identity/VlanIdentity.java

+package adt.mainnode.identity;
+
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+import javax.persistence.Id;
+import java.io.Serializable;
+
+@Embeddable
+@Data
+@NoArgsConstructor
+public class VlanIdentity implements Serializable {
+
+
+    @Id
+    @Column(name = "distributedNodeId")
+    private String distributedNodeId;
+
+    @Id
+    @Column(name = "vlan_name")
+    private String vlanName;
+
+
+    public static VlanIdentity createVlanIdentity(String distributedNodeId, String vlanName) {
+        VlanIdentity vlanIdentity = new VlanIdentity();
+        vlanIdentity.setDistributedNodeId(distributedNodeId);
+        vlanIdentity.setVlanName(vlanName);
+        return vlanIdentity;
+    }
+
+}

src/main/java/adt/mainnode/repository/CredentialsRepository.java

+package adt.mainnode.repository;
+
+import adt.mainnode.entity.Credentials;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+public interface CredentialsRepository extends JpaRepository<Credentials, String>{
+
+    Credentials findByToken(String token);
+    Credentials findByName(String name);
+    @Transactional
+    void deleteByName(String name);
+
+}

src/main/java/adt/mainnode/repository/HostRepository.java

+package adt.mainnode.repository;
+
+
+import adt.mainnode.entity.Host;
+import adt.mainnode.entity.ScanInfo;
+import adt.mainnode.identity.HostIdentity;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface HostRepository extends JpaRepository<Host, HostIdentity> {
+
+    List<Host> findAllBySnapshotId(String snapshotId);
+    List<Host> findAllByVlanName(String vlanName);
+    List<Host> findAllByVlanNameAndSnapshotId(String vlanName, String snapshotId);
+    List<Host> findAllByIp(String ip);
+    List<Host> findAllByIpAndMac(String ip, String mac);
+
+}

src/main/java/adt/mainnode/repository/NodeRepository.java

+package adt.mainnode.repository;
+
+
+import adt.mainnode.entity.Node;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+
+public interface NodeRepository extends JpaRepository<Node, String> {
+
+    Node findByNodeId(String nodeId);
+    Node findByIp(String nodeIp);
+
+}

src/main/java/adt/mainnode/repository/PortRepository.java

+package adt.mainnode.repository;
+
+
+import adt.mainnode.entity.Host;
+import adt.mainnode.entity.Port;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.Set;
+
+public interface PortRepository extends JpaRepository<Port, Integer> {
+
+    List<Port> findAllBySnapshotId(String snapshotId);
+
+    List<Port> findAllByIpAndVlanNameAndSnapshotId(String ip, String vlanName, String snapshotId);
+
+}

src/main/java/adt/mainnode/repository/ScanConfigRepository.java

+package adt.mainnode.repository;
+
+import adt.mainnode.entity.ScanConfig;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+public interface ScanConfigRepository extends JpaRepository<ScanConfig, String>{
+
+    ScanConfig findByVlanName(String vlanName);
+    ScanConfig findByIpToScan(String ipToScan);
+    List<ScanConfig> findAllByNodeId(String nodeId);
+    List<ScanConfig> findAllByIpToScan(String ipToScan);
+
+    @Transactional
+    void deleteByVlanName(String vlanName);
+    @Transactional
+    void deleteAllByNodeId(String nodeId);
+}
\ No newline at end of file

src/main/java/adt/mainnode/repository/ScanInfoRepository.java

+package adt.mainnode.repository;
+
+
+
+import adt.mainnode.entity.ScanInfo;
+import java.util.List;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface ScanInfoRepository extends JpaRepository<ScanInfo, String> {
+
+    ScanInfo findBySnapshotId(String snapshotId);
+    List<ScanInfo> findAllBySnapshotId(String snapshotId);
+}

src/main/java/adt/mainnode/repository/SnapshotRepository.java

+package adt.mainnode.repository;
+
+import adt.mainnode.entity.Snapshot;
+import org.springframework.data.jpa.repository.JpaRepository;
+import java.util.List;
+
+public interface SnapshotRepository extends JpaRepository<Snapshot, String> {
+
+    List<Snapshot> findAllByVlanName(String vlanName);
+    List<Snapshot> findAllByVlanNameAndNodeId(String vlanName, String nodeId);
+    Snapshot findBySnapshotId(String snapshotId);
+
+    Snapshot findTopByVlanNameOrderByTimestampDistNodeEndDesc(String vlanName);
+
+}

src/main/java/adt/mainnode/repository/TPMHashRepository.java

+package adt.mainnode.repository;
+
+import adt.mainnode.entity.TPMHash;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface TPMHashRepository extends JpaRepository<TPMHash, String>{
+
+    TPMHash findByHash(String hash);
+}

src/main/java/adt/mainnode/repository/VlanRepository.java

+package adt.mainnode.repository;
+
+
+import adt.mainnode.entity.Vlan;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import org.springframework.transaction.annotation.Transactional;
+
+
+public interface VlanRepository extends JpaRepository<Vlan, String> {
+
+    //List<VlanInterface> findAllBy();
+    Vlan findByVlanName(String vlanName);
+    Vlan findByNetAddress(String netAddress);
+    List<Vlan> findAllByDistributedNodeId(String distributedNodeId);
+    @Transactional
+    void deleteByVlanName(String vlanName);
+
+}

src/main/java/adt/mainnode/service/EmailService.java

+package adt.mainnode.service;
+
+import org.springframework.stereotype.Service;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.sun.mail.smtp.SMTPTransport;
+
+import javax.mail.Message;
+import javax.mail.MessagingException;
+import javax.mail.Session;
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeMessage;
+import java.util.Date;
+import java.util.Properties;
+
+
+// FOR ATTACHMENTS
+import javax.mail.internet.MimeBodyPart;
+import javax.mail.internet.MimeMessage;
+import javax.mail.internet.MimeMultipart;
+
+
+@Service
+public class EmailService {
+
+    private static final String SMTP_SERVER = "smtp.gmail.com";
+    private static final String USERNAME = "adt.event.notifier@gmail.com";
+    private static final String PASSWORD = "adtctb2020";
+
+    private static final String EMAIL_FROM = "adt.event.notifier@gmail.com";
+    private static final String EMAIL_TO = "alb.blazquez.h@gmail.com, alberto.bherranz@upm.es";
+    private static final String EMAIL_TO_CC = "";
+
+    private static final String EMAIL_SUBJECT = "Test Send Email via SMTP";
+    private static final String EMAIL_TEXT = "Hello Java Mail \n ABC123";
+
+    @Autowired
+    public EmailService() {
+
+    }
+
+
+    public static void sendEmail(String destination) {
+
+        Properties prop = System.getProperties();
+        prop.put("mail.smtp.host", SMTP_SERVER); //optional, defined in SMTPTransport
+        prop.put("mail.smtp.auth", "true");
+        prop.put("mail.smtp.starttls.enable", "true");
+        prop.put("mail.smtp.port", "25"); // default port 25
+
+        Session session = Session.getInstance(prop, null);
+        Message msg = new MimeMessage(session);
+
+        try {
+
+            // from
+            msg.setFrom(new InternetAddress(EMAIL_FROM));
+
+            // to
+            msg.setRecipients(Message.RecipientType.TO,
+                    InternetAddress.parse(EMAIL_TO, false));
+
+            // cc
+            msg.setRecipients(Message.RecipientType.CC,
+                    InternetAddress.parse(EMAIL_TO_CC, false));
+
+            // subject
+            msg.setSubject(EMAIL_SUBJECT);
+
+            /* //Attachment part1
+            MimeBodyPart p1 = new MimeBodyPart();
+            p1.setText(EMAIL_TEXT);
+            */
+
+            // content
+            msg.setText(EMAIL_TEXT);
+
+            msg.setSentDate(new Date());
+
+            /* //Attachment part 2
+            MimeBodyPart p2 = new MimeBodyPart();
+            FileDataSource fds = new FileDataSource("path/example.txt");
+            p2.setDataHandler(new DataHandler(fds));
+            p2.setFileName(fds.getName());
+
+            Multipart mp = new MimeMultipart();
+            mp.addBodyPart(p1);
+            mp.addBodyPart(p2);
+
+            msg.setContent(mp);
+            */
+
+            // Get SMTPTransport
+            SMTPTransport t = (SMTPTransport) session.getTransport("smtp");
+
+            // connect
+            t.connect(SMTP_SERVER, USERNAME, PASSWORD);
+
+            // send
+            t.sendMessage(msg, msg.getAllRecipients());
+
+            System.out.println("Response: " + t.getLastServerResponse());
+
+            t.close();
+
+        } catch (MessagingException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+}
\ No newline at end of file

src/main/java/adt/mainnode/service/FileHashingService.java

+package adt.mainnode.service;
+
+import java.io.*;
+import java.security.MessageDigest;
+import org.springframework.stereotype.Service;
+import org.springframework.beans.factory.annotation.Autowired;
+
+@Service
+public class FileHashingService {
+
+    @Autowired
+    public FileHashingService() {
+
+    }
+
+
+    public static byte[] createChecksum(String filename) throws Exception {
+        InputStream fis = new FileInputStream(filename);
+
+        byte[] buffer = new byte[1024];
+        MessageDigest complete = MessageDigest.getInstance("MD5");
+        int numRead;
+
+        do {
+            numRead = fis.read(buffer);
+            if (numRead > 0) {
+                complete.update(buffer, 0, numRead);
+            }
+        } while (numRead != -1);
+
+        fis.close();
+        return complete.digest();
+    }
+
+    // see this How-to for a faster way to convert
+    // a byte array to a HEX string
+    public static String getMD5Checksum(String filename) throws Exception {
+        byte[] b = createChecksum(filename);
+        String result = "";
+
+        for (int i = 0; i < b.length; i++) {
+            result += Integer.toString((b[i] & 0xff) + 0x100, 16).substring(1);
+        }
+        return result;
+    }
+
+}
\ No newline at end of file

src/main/java/adt/mainnode/service/InitializeService.java

+package adt.mainnode.service;
+
+import adt.mainnode.entity.Node;
+import adt.mainnode.entity.ScanConfig;
+import adt.mainnode.entity.TPMHash;
+import adt.mainnode.entity.Vlan;
+import adt.mainnode.identity.VlanIdentity;
+import adt.mainnode.repository.TPMHashRepository;
+import adt.mainnode.repository.NodeRepository;
+import adt.mainnode.repository.ScanConfigRepository;
+import adt.mainnode.repository.VlanRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import lombok.extern.slf4j.Slf4j;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Date;
+
+@Slf4j
+@Service
+public class InitializeService {
+
+    private final NodeRepository nodeRepository;
+    private final VlanRepository vlanRepository;
+    private final ScanConfigRepository scanConfigRepository;
+    private final TPMHashRepository tpmHashRepository;
+    private String serverIP;
+    private String serverPort;
+    private String tpmPresence;
+
+    private String transferUser;
+    private String transferPassword;
+    private String petitionUrl;
+
+    private String transferUrl;
+
+    private String transferToken;
+    private Date transferTokenReceipt;
+
+    private TPMHash tpmHash;
+    private String pcrHash;
+
+
+    @Autowired
+    public InitializeService(NodeRepository nodeRepository, TPMHashRepository tpmHashRepository, ScanConfigRepository scanConfigRepository, VlanRepository vlanRepository){
+        this.nodeRepository = nodeRepository;
+        this.scanConfigRepository = scanConfigRepository;
+        this.vlanRepository = vlanRepository;
+        this.tpmHashRepository = tpmHashRepository;
+        this.transferToken = null;
+        this.serverIP = null;
+        this.serverPort = null;
+        this.tpmPresence = null;
+        this.pcrHash = null;
+
+        if(tpmHashRepository.findAll().size() > 0) {
+            this.tpmHash = tpmHashRepository.findAll().get(0);
+        }else{
+            log.info("**************___sero");
+            this.tpmHash = null;
+        }
+        log.info("**************___{}",tpmHash);
+
+    }
+
+
+    public String getServerIP() {
+        return serverIP;
+    }
+
+    public void setServerIP(String serverIP) {
+        this.serverIP = serverIP;
+    }
+
+
+    public String getServerPort() {
+        return serverPort;
+    }
+
+    public void setServerPort(String serverPort) {
+        this.serverPort = serverPort;
+    }
+
+    public String getTpmPresence() {
+        return tpmPresence;
+    }
+
+    public void setTpmPresence(String tpmPresence) {
+        this.tpmPresence = tpmPresence;
+    }
+
+
+    public String getTransferUser() {
+        return transferUser;
+    }
+
+    public void setTransferUser(String transferUser) {
+        this.transferUser = transferUser;
+    }
+
+
+    public String getTransferPassword() {
+        return transferPassword;
+    }
+
+    public void setTransferPassword(String transferPassword) {
+        this.transferPassword = transferPassword;
+    }
+
+
+    public String getPetitionUrl() {
+        return petitionUrl;
+    }
+
+    public void setPetitionUrl(String petitionUrl) {
+        this.petitionUrl = petitionUrl;
+    }
+
+
+    public String getTransferUrl() {
+        return transferUrl;
+    }
+
+    public void setTransferUrl(String transferUrl) {
+        this.transferUrl = transferUrl;
+    }
+
+
+    public String getTransferToken() {
+        return transferToken;
+    }
+
+    public void setTransferToken(String transferToken) {
+        this.transferToken = transferToken;
+    }
+
+
+    public Date getTransferTokenReceipt() {
+        return transferTokenReceipt;
+    }
+
+    public void setTransferTokenReceipt(Date transferTokenReceipt) { this.transferTokenReceipt = transferTokenReceipt; }
+
+
+    public TPMHash getTPMHash() {
+        return tpmHash;
+    }
+
+    public void setTPMHash(TPMHash tpmHash) {
+        this.tpmHash = tpmHash;
+    }
+
+
+    public String getPCRHash() {
+        return pcrHash;
+    }
+
+    public void setPCRHash(String pcrHash) {
+        this.pcrHash = pcrHash;
+    }
+
+
+    // TODO: Obtener la gateway
+    public Node saveNode(Node node, List<ScanConfig> scanConfigs, boolean flag) {
+
+        List<Vlan> vlans = new ArrayList<>();
+
+        for(int i=0; i<scanConfigs.size(); i++) {
+
+            ScanConfig scanConfig = scanConfigs.get(i);
+
+            VlanIdentity vlanId = VlanIdentity.createVlanIdentity(node.getNodeId(), scanConfig.getVlanName());
+
+            Vlan vlan = Vlan.createVlan(vlanId, scanConfig.getDelay(), scanConfig.getIpToScan(), scanConfig.getIpToScan(), scanConfig.getMask());//"192.168.1.0",null, "24");
+            vlans.add(vlan);
+        }
+        //node.setVlan(vlan);
+        node.setVlan(vlans);
+
+        vlanRepository.saveAll(vlans);
+
+        //if(!flag){
+        nodeRepository.save(node);
+        //}
+
+        return node;//nodeRepository.save(node);
+    }
+
+
+}

src/main/resources/application.yml

+logging:
+  file: logs/mainNode.log
+
+debug: true
+
+spring:
+  datasource:
+    driver-class-name: com.mysql.cj.jdbc.Driver
+    url: jdbc:mysql://${HOST_DB:localhost}:${PORT_DB:3306}/${NAME_DB:curex_adt}?autoReconnect=true&useSSL=false
+    password: ${PASSWORD_DB:f4k64g6a65fWGTYmE488NJsfu}
+    username: ${USER_DB:curex_adt}
+
+  mvc:
+    view:
+      prefix: /WEB-INF/jsp/
+      suffix: .jsp
+    
+  jpa:
+    database-platform: org.hibernate.dialect.MySQL57InnoDBDialect
+    hibernate:
+      ddl-auto: update
+    properties:
+      hibernate:
+        show_sql: false
+        format_sql: true