namespace for IPRefresher instead of class

added return codes for IPrefresher refresh method.
error messages in gui.
2020-05-15 13:57:09 +02:00 · 2020-05-14 23:08:19 +02:00 · 2020-05-10 18:10:44 +02:00 · 2020-05-10 15:00:51 +02:00 · 2020-05-09 23:08:23 +02:00 · 2020-05-08 17:28:19 +02:00
35 changed files with 1188 additions and 295 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -0,0 +1,49 @@
+image: luki42/dynuiprefresher_build:latest
+
+stages:
+  - cmake
+  - build
+  - build_package
+  - test
+
+cache:
+  paths:
+    - build/
+    - src/
+    - inc/
+    - tests/
+    - postinst
+
+cmake:
+  stage: cmake
+  script:
+    - cmake -S . -B build
+
+build:
+  stage: build
+  script:
+    - cd build
+    - make
+  artifacts:
+    paths:
+      - "build/bin/*"
+
+
+build_package:
+  stage: build_package
+  script:
+    - cd build
+    - make package
+  artifacts:
+    paths:
+      - "build/packages/*"
+
+test:
+  stage: test
+  script:
+    - cd build
+    - make test
+    - make build-xml
+  artifacts:
+    reports:
+      junit: build/report.xml
--- a/.idea/.gitignore
+++ b/.idea/.gitignore
@ -1,2 +0,0 @@
-# Default ignored files
-/workspace.xml
--- a/.idea/iprefresher.iml
+++ b/.idea/iprefresher.iml
@ -1,2 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module classpath="CMake" type="CPP_MODULE" version="4" />
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
-  <component name="JavaScriptSettings">
-    <option name="languageLevel" value="ES6" />
-  </component>
-</project>
--- a/.idea/modules.xml
+++ b/.idea/modules.xml
@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/iprefresher.iml" filepath="$PROJECT_DIR$/.idea/iprefresher.iml" />
-    </modules>
-  </component>
-</project>
--- a/.idea/vcs.xml
+++ b/.idea/vcs.xml
@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,25 +1,43 @@
+# @author Lukas Heiligenbrunner
+# main CMake file
+#
+# Build lib dependencies:
+## libcurl (with sources)
+## libconfig (with sources)
+#
+# for documenation build doxygen needs to be installed.
+# for test build gtest needs to be installed.
+
 cmake_minimum_required(VERSION 3.13)
 project(iprefresher DESCRIPTION "Dynu ip refresher")
+SET(PROJECT_VERSION 1.3.3)

-set(CMAKE_CXX_STANDARD 17)
+# CONFIGURATION
+SET(CMAKE_BUILD_TYPE Release) # manually SET build type (Release / Debug)
+SET(LIB_METHOD STATIC) #SHARED / STATIC

-set(CMAKE_BUILD_TYPE Release) # manually set build type (Release / Debug)
-set(LIB_METHOD STATIC) #SHARED / STATIC
+option(BUILD_DOC "Build documentation" ON) # additional dependency for Doxygen
+option(PACKAGING "Allow Packaging to <exe>, <deb> or <rpm>" ON) # additional dependencies for RPMbuild,dpkg  or NSIS
+option(TESTS "Build Tests" ON) # additional dependencies for GTEST - to build tests
+option(GUI "Build GUI elements" ON) # additional dependencies to QT libraries needed
 set(WinBuild false)
-set(PROJECT_VERSION 1.2.2)
-option(BUILD_DOC "Build documentation" ON)

-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
-#set up toolchain
+# helper variables
+SET(CMAKE_CXX_STANDARD 17)
+string(TIMESTAMP TIMESTAMP_NOW "%d.%m.%Y")

+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+# setup winbuild compilers
 if (${WinBuild})
    set(LIBSUFFIX .dll)
    set(SUFFIX .exe)

-    set(CMAKE_SYSTEM_NAME Windows)
-    set(TOOLCHAIN_PREFIX x86_64-w64-mingw32)
+    set(CMAKE_SYSTEM_NAME WindowsStore)
+    set(CMAKE_SYSTEM_VERSION 10.0)
+    set(TOOLCHAIN_PREFIX x86_64-w64-mingw32) # x64 build toolchain
    #set(TOOLCHAIN_PREFIX i686-w64-mingw32)

    # cross compilers to use for C and C++
@ -28,137 +46,288 @@ if (${WinBuild})
    set(CMAKE_RC_COMPILER ${TOOLCHAIN_PREFIX}-windres)

    # target environment on the build host system
-    set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX} /usr/lib/gcc/${TOOLCHAIN_PREFIX}/9.2.1)
+    set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX})


    # modify default behavior of FIND_XXX() commands to
    # search for headers/libs in the target environment and
    # search for programs in the build host environment
-    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+    set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
    set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
    set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+    set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

-    #    set(CMAKE_CXX_STANDARD_LIBRARIES -lcurl -lpthread -static-libgcc -static-libstdc++ -lcrypto -lssl -lws2_32 -std=c++11 -static -DCURL_STATICLIB)
-#    set(CMAKE_CXX_STANDARD_LIBRARIES "-static-libgcc -static-libstdc++  -DCURL_STATICLIB -lstdc++ -lwsock32 -lws2_32 ${CMAKE_CSS_STANDARD_LIBRARIES}")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -DCURL_STATICLIB -static -lpthread")
-    #    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
-    #    set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
-    #add_definitions(-DCURL_STATICLIB)
+    set(CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CSS_STANDARD_LIBRARIES}")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
+    # currently libs are dynamically linked eg. dlls have to be copied to same folder
+    # todo link dynamically.
+    # maybe so: set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++ -static")
+    # or set(CMAKE_CXX_STANDARD_LIBRARIES -lcurl -lpthread -static-libgcc -static-libstdc++ -lcrypto -lssl -lws2_32 -static -DCURL_STATICLIB)
+    # or add_definitions(-DCURL_STATICLIB)
+
+    # windows config path is same as executable
+    set(CONFIG_PATH "./iprefresher.cfg")
 else ()
    set(LIBSUFFIX .so)
    set(SUFFIX "")
+
+    # set /etc/ config path
+    set(CONFIG_PATH "/etc/iprefresher.cfg")
 endif ()

-#config libs
+
+# config libs
 message(STATUS "Config of Libraries")
-find_package(CURL REQUIRED)
-if (CURL_FOUND)
-    message(STATUS "Found CURL version: ${CURL_VERSION_STRING}")
+# libcurl
+if (${WinBuild})
+    SET(CMAKE_FIND_LIBRARY_SUFFIXES ".lib" ".dll")
+    # configure libcurl
+    FIND_PATH(CURL_INCLUDE_DIRS curl/curl.h /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/include/) # search for libconfig include headers
+    FIND_LIBRARY(CURL_LIBRARIES NAMES libcurl.dll.a HINTS /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/lib) # search for actual lib
+
    message(STATUS "Using CURL include dir(s): ${CURL_INCLUDE_DIRS}")
    message(STATUS "Using CURL lib(s): ${CURL_LIBRARIES}")
-else ()
-    message(FATAL_ERROR "Could not find CURL")
-endif ()
-message("")
-include_directories(${CURL_INCLUDE_DIR} inc)
+    message(STATUS "")

+    include_directories(${CURL_INCLUDE_DIRS} inc)
+
+    # configure libconfig
+    FIND_PATH(LIBCONFIG++_INCLUDE_DIRS libconfig.h++ /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/include/) # search for libconfig include headers
+    FIND_LIBRARY(LIBCONFIG++_LIBRARIES NAMES libconfig++.dll.a HINTS /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/lib) # search for actual lib
+
+    message(STATUS "Using LIBCONFIG++ include dir(s): ${LIBCONFIG++_INCLUDE_DIRS}")
+    message(STATUS "Using LIBCONFIG++ lib(s): ${LIBCONFIG++_LIBRARIES}")
+
+    include_directories(${LIBCONFIG++_INCLUDE_DIRS} inc)
+
+    if (${GUI})
+        set(CMAKE_PREFIX_PATH "/usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/lib/cmake")
+    endif ()
+else ()
+    find_package(CURL REQUIRED)
+    if (CURL_INCLUDE_DIRS AND CURL_LIBRARIES)
+        message(STATUS "Found CURL version: ${CURL_VERSION_STRING}")
+        message(STATUS "Using CURL include dir(s): ${CURL_INCLUDE_DIRS}")
+        message(STATUS "Using CURL lib(s): ${CURL_LIBRARIES}")
+    else ()
+        message(FATAL_ERROR "Could not find CURL")
+    endif ()
+    include_directories(${CURL_INCLUDE_DIR} inc)
+
+    message("")
+    # libconfig
+    FIND_PATH(LIBCONFIG++_INCLUDE_DIRS
+            NAMES libconfig.h++
+            PATHS /usr/include /usr/local/include) # search for libconfig include headers
+    FIND_LIBRARY(LIBCONFIG++_LIBRARIES
+            NAMES config++
+            PATHS /usr/lib /usr/local/lib) # search for actual lib
+
+    if (LIBCONFIG++_INCLUDE_DIRS AND LIBCONFIG++_LIBRARIES)
+        message(STATUS "Fount libconfig!")
+        message(STATUS "Using libconfig include dir(s): ${LIBCONFIG++_INCLUDE_DIRS}")
+        message(STATUS "Using libconfig lib(s): ${LIBCONFIG++_LIBRARIES}")
+    else ()
+        message(FATAL_ERROR "Could not find LIBCONFIG")
+    endif ()
+
+    include_directories(${LIBCONFIG_INCLUDE_DIRS})
+endif ()
+
+if (${GUI})
+    set(CMAKE_AUTOMOC ON)
+    set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+    find_package(Qt5Widgets REQUIRED)
+    find_package(Qt5PrintSupport REQUIRED)
+    find_package(Qt5Sql REQUIRED)
+endif ()
+
+message("")
+
+#read sample config
+FILE(READ ${CMAKE_SOURCE_DIR}/config/iprefresher.cfg SAMPLECONFIG)
 #add version header
 FILE(WRITE ${CMAKE_SOURCE_DIR}/inc/Version.h
-        "\#pragma once\nclass Version {\npublic:\n  static const std::string VERSION;\n};\n\n std::string const Version::VERSION = \"${PROJECT_VERSION}\";"
+        "/**
+ * Version header to store Version, Config dir and a Sample config
+ * Do not edit this file manually, it is generated by the cmake script!
+ *
+ * @author Lukas Heiligenbrunner
+ * @date ${TIMESTAMP_NOW}
+ */
+
+#pragma once
+
+#include <string>
+
+namespace Version {
+  const std::string VERSION = \"${PROJECT_VERSION}\";
+  const std::string ConfigDir = \"${CONFIG_PATH}\";
+  const std::string SAMPLECONFIG = R\"(${SAMPLECONFIG})\";
+}"
        )

 add_library(api ${LIB_METHOD}
        src/api/API.cpp
-
        src/api/TelegramAPI.cpp
-
        src/api/DynuAPI.cpp
+        src/api/IPAPI.cpp)

-        src/api/IPAPI.cpp
-        )
-
-add_library(logger ${LIB_METHOD}
+add_library(dynuiprefresher ${LIB_METHOD}
+        src/IPRefresher.cpp
+        src/Config.cpp
+        src/IpHelper.cpp
        src/FileLogger.cpp
        src/Logger.cpp
        )

-
-set(SOURCE
-        src/main.cpp
-        src/IPRefresher.cpp
-        )
-
-add_executable(iprefresher ${SOURCE})
+add_executable(iprefresher src/main.cpp)

 # LINK generated LIBS #
-target_link_libraries(iprefresher api logger ${CURL_LIBRARIES})
+target_link_libraries(iprefresher dynuiprefresher api ${CURL_LIBRARIES} ${LIBCONFIG++_LIBRARIES})

-# INSTALL to SYSTEM #
-install(TARGETS iprefresher DESTINATION bin)
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/iprefresher.service DESTINATION /lib/systemd/system)
+if (${GUI})
+    set(QT5_LIBRARIES Qt5::Widgets Qt5::PrintSupport Qt5::Sql)

+    set(UI_SOURCES
+            src/gui/mainwindow.ui
+            )

-IF (UNIX)
+    #
+    # Generate necessary headers from .ui files. (qmake lets `uic` do this job.)
+    # hint from [Cross-platform Qt5 project using cmake](http://stackoverflow.com/questions/21174586/cross-platform-qt5-project-using-cmake)
+    #
+    qt5_wrap_ui(UI_GENERATED_HEADERS ${UI_SOURCES})
+
+    add_executable(iprefresher-gui
+            src/maingui.cpp
+            src/gui/MainWindow.cpp
+            src/gui/MainWindow.h ${UI_GENERATED_HEADERS})
+
+    # LINK generated LIBS #
+    target_link_libraries(iprefresher-gui -lpthread dynuiprefresher api ${CURL_LIBRARIES} ${LIBCONFIG++_LIBRARIES} ${QT5_LIBRARIES})
+endif ()
+
+# setting install targets
+IF (NOT ${WinBuild})
+    # INSTALL to Linux SYSTEM #
+
+    # install binaries
+    install(TARGETS iprefresher DESTINATION usr/bin)
+    # install systemd service and enable it
+    install(FILES service/iprefresher.service DESTINATION lib/systemd/system)
+ELSE ()
+    # INSTALL to Windows SYSTEM #
+
+    # install binary to current folder
+    set_target_properties(iprefresher PROPERTIES SUFFIX ".exe")
+    install(TARGETS iprefresher DESTINATION .)
+
+    # install .dll dependencies
+    # todo check if files exist...
+    install(FILES /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libcurl-4.dll
+            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libssh2-1.dll
+            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libstdc++-6.dll
+            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libgcc_s_seh-1.dll
+            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libcrypto-1_1-x64.dll
+            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libssl-1_1-x64.dll
+            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libwinpthread-1.dll
+            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/zlib1.dll
+            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libidn2-0.dll
+            /usr/${TOOLCHAIN_PREFIX}/sys-root/mingw/bin/libconfig++-11.dll
+            DESTINATION .)
+ENDIF ()
+
+if (${PACKAGING})
+    # General Packaging options:
    message(STATUS "config of Package build")
-    SET(CPACK_DEB_COMPONENT_INSTALL 1)
-    SET(CPACK_OUTPUT_FILE_PREFIX packages)
-
-    FIND_PROGRAM(RPMBUILD_EXECUTABLE rpmbuild)
-    FIND_PROGRAM(DEB_EXECUTABLE dpkg)
-
-    SET(CPACK_GENERATOR "TGZ;TBZ2")
-
-    #check if rpm build is possible
-    if (NOT ${RPMBUILD_EXECUTABLE} STREQUAL "RPMBUILD_EXECUTABLE-NOTFOUND")
-        message(STATUS "found rpm build executeable --> able to build rpm")
-        set(CPACK_GENERATOR "${CPACK_GENERATOR};RPM")
-        set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "/lib/systemd/system" "/lib/systemd" "/lib") # --> needed to not override existing folders
-    else (NOT ${RPMBUILD_EXECUTABLE} STREQUAL "RPMBUILD_EXECUTABLE-NOTFOUND")
-        message(STATUS "not found rpm build tools --> not building rpm")
-    endif (NOT ${RPMBUILD_EXECUTABLE} STREQUAL "RPMBUILD_EXECUTABLE-NOTFOUND")
-
-    #check if deb build is possible
-    if (NOT ${DEB_EXECUTABLE} STREQUAL "DEB_EXECUTABLE-NOTFOUND")
-        message(STATUS "found deb build tools --> able to build deb")
-        set(CPACK_GENERATOR "${CPACK_GENERATOR};DEB")
-    else (NOT ${DEB_EXECUTABLE} STREQUAL "DEB_EXECUTABLE-NOTFOUND")
-        message(STATUS "not found  deb build tools --> not building deb")
-    endif (NOT ${DEB_EXECUTABLE} STREQUAL "DEB_EXECUTABLE-NOTFOUND")
-
-
-    SET(CPACK_CMAKE_GENERATOR "Unix Makefiles")
-    SET(CPACK_SOURCE_GENERATOR "TGZ;TBZ2")

+    set(CPACK_PACKAGE_NAME "DynuIpRefresher")
    SET(CPACK_PACKAGE_DESCRIPTION "IPrefresher to refresh Dynu ip address and notify user via Telegram")
    SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "IPrefresher to refresh Dynu ip address and notify user via Telegram")
    SET(CPACK_PACKAGE_VENDOR "Lukas Heilgienbrunner")
-    SET(CPACK_PACKAGE_VERSION_MAJOR "1")
-    SET(CPACK_PACKAGE_VERSION_MINOR "2")
-    set(CPACK_PACKAGE_VERSION_PATCH "1")
    SET(CPACK_PACKAGE_VERSION "${PROJECT_VERSION}")
    SET(CPACK_SOURCE_PACKAGE_FILE_NAME "${CMAKE_PROJECT_NAME}-${PROJECT_VERSION}")
-    SET(CPACK_PACKAGE_CONTACT "Lukas Heiligenbrunner <ultimategameingcookie@gmail.com>")
-    SET(CPACK_PACKAGE_SECTION "games")
-    set(CPACK_PACKAGE_DEPENDS "libcurl (>= 7.0.0-1)")
+    SET(CPACK_PACKAGE_CONTACT "Lukas Heiligenbrunner <lukas.heiligenbrunner@gmail.com>")
+
+    SET(CMAKE_INSTALL_PREFIX "/")
+
+    IF (NOT ${WinBuild})
+        # generate post script for checking if configuration already exists
+        FILE(WRITE ${CMAKE_SOURCE_DIR}/postinst
+                "#!/bin/bash
+# Post installation script for linux packages
+# do not edit this file manually, it is generated by the cmake script
+if [ ! -f ${CONFIG_PATH} ]; then
+    cat > ${CONFIG_PATH} <<- EOM
+${SAMPLECONFIG}EOM
+fi\n"
+                )
+
+
+        SET(CPACK_DEB_COMPONENT_INSTALL 1)
+        SET(CPACK_OUTPUT_FILE_PREFIX packages)
+        SET(CPACK_PACKAGING_INSTALL_PREFIX "/") # no prefix for package structure
+
+        FIND_PROGRAM(RPMBUILD_EXECUTABLE rpmbuild)
+        FIND_PROGRAM(DEB_EXECUTABLE dpkg)
+
+        SET(CPACK_GENERATOR "TGZ;TBZ2")
+
+        #check if rpm build is possible
+        if (NOT ${RPMBUILD_EXECUTABLE} STREQUAL "RPMBUILD_EXECUTABLE-NOTFOUND")
+            message(STATUS "found rpm build executeable --> able to build rpm")
+            SET(CPACK_GENERATOR "${CPACK_GENERATOR};RPM")
+            SET(CPACK_RPM_POST_INSTALL_SCRIPT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/postinst")
+            SET(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION "/lib/systemd/system" "/lib/systemd" "/lib" "/usr/local/bin" "/usr/local") # --> needed to not override existing folders
+            set(CPACK_RPM_PACKAGE_REQUIRES "libcurl,libconfig")
+        else (NOT ${RPMBUILD_EXECUTABLE} STREQUAL "RPMBUILD_EXECUTABLE-NOTFOUND")
+            message(STATUS "not found rpm build tools --> not building rpm")
+        endif (NOT ${RPMBUILD_EXECUTABLE} STREQUAL "RPMBUILD_EXECUTABLE-NOTFOUND")
+
+        #check if deb build is possible
+        if (NOT ${DEB_EXECUTABLE} STREQUAL "DEB_EXECUTABLE-NOTFOUND")
+            message(STATUS "found deb build tools --> able to build deb")
+            SET(CPACK_GENERATOR "${CPACK_GENERATOR};DEB") # add deb generator
+            set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_CURRENT_SOURCE_DIR}/postinst") # set post inst file
+            set(CPACK_DEBIAN_PACKAGE_DEPENDS "libcurl4,libconfig++9v5") # add debian dependencies
+        else (NOT ${DEB_EXECUTABLE} STREQUAL "DEB_EXECUTABLE-NOTFOUND")
+            message(STATUS "not found  deb build tools --> not building deb")
+        endif (NOT ${DEB_EXECUTABLE} STREQUAL "DEB_EXECUTABLE-NOTFOUND")
+
+
+        SET(CPACK_CMAKE_GENERATOR "Unix Makefiles")
+        SET(CPACK_SOURCE_GENERATOR "TGZ;TBZ2")
+
+        SET(CPACK_PACKAGE_SECTION "games")
+    ELSE ()
+        # Pack a NSIS intaller
+        set(CPACK_GENERATOR NSIS)
+        message(STATUS "Using NSIS Package build.")
+
+        set(CPACK_NSIS_testcomp_INSTALL_DIRECTORY /)
+        set(CPACK_PACKAGE_INSTALL_DIRECTORY "DynuIpRefresher")
+        SET(CPACK_NSIS_MODIFY_PATH ON)
+    ENDIF ()

    INCLUDE(CPack)

-    add_custom_target(build-linux-packages
+    add_custom_target(build-packages
            "${CMAKE_COMMAND}" --build "${CMAKE_BINARY_DIR}" --target package
            DEPENDS ${PROJECT_NAME}
-            COMMENT "Installing ${PROJECT_NAME}")
-message("")
-ENDIF (UNIX)
+            COMMENT "Packing ${PROJECT_NAME}")
+    message("")
+ENDIF ()

 # check if Doxygen is installed
-
 if (BUILD_DOC)
    message(STATUS "config of DOxygen build")
    find_package(Doxygen)
    if (DOXYGEN_FOUND)
-        # set input and output files
-        set(DOXYGEN_IN ${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile.in)
-        set(DOXYGEN_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)
+        # SET input and output files
+        SET(DOXYGEN_IN ${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile.in)
+        SET(DOXYGEN_OUT ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile)

        # request to configure the file
        configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT} @ONLY)
@ -170,9 +339,47 @@ if (BUILD_DOC)
                COMMENT "Generating API documentation with Doxygen"
                VERBATIM)
        message(STATUS "Successfully configured doxygen")
-
    else (DOXYGEN_FOUND)
        message(STATUS "Doxygen need to be installed to generate the doxygen documentation")
    endif (DOXYGEN_FOUND)
    message("")
 endif (BUILD_DOC)
+
+# Test Cases
+if (TESTS)
+    include(GoogleTest)
+
+    mark_as_advanced(
+            BUILD_GMOCK BUILD_GTEST BUILD_SHARED_LIBS
+            gmock_build_tests gtest_build_samples gtest_build_tests
+            gtest_disable_pthreads gtest_force_shared_crt gtest_hide_internal_symbols
+    )
+
+    enable_testing()
+
+    macro(package_add_test TESTNAME)
+        # create an exectuable in which the tests will be stored
+        add_executable(${TESTNAME} ${ARGN})
+        # link the Google test infrastructure, mocking library, and a default main fuction to
+        target_link_libraries(${TESTNAME} gtest gtest_main -lpthread -lm dynuiprefresher api ${CURL_LIBRARIES} ${LIBCONFIG++_LIBRARIES})
+        # see https://cmake.org/cmake/help/v3.10/module/GoogleTest.html for more options to pass to it
+        gtest_discover_tests(${TESTNAME}
+                WORKING_DIRECTORY ${PROJECT_DIR}
+                EXTRA_ARGS --gtest_output=xml:report.xml -VV
+                PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY "${PROJECT_DIR}"
+                )
+        set_target_properties(${TESTNAME} PROPERTIES FOLDER tests)
+    endmacro()
+
+    package_add_test(test1 tests/UnitTest.cpp ${SOURCE})
+
+    add_custom_target(build-test
+            "${CMAKE_COMMAND}" --build "${CMAKE_BINARY_DIR}" --target test
+            DEPENDS ${PROJECT_NAME}
+            COMMENT "Packing ${PROJECT_NAME}")
+
+    add_custom_target(build-xml
+            "bin/test1" --gtest_output="xml:report.xml"
+            DEPENDS ${PROJECT_NAME}
+            COMMENT "Packing ${PROJECT_NAME}")
+ENDIF ()
--- a/README.md
+++ b/README.md
@ -1,4 +1,20 @@
+[![pipeline status](http://gitlab.heili.eu/lukas/dynuiprefresher/badges/master/pipeline.svg)](http://gitlab.heili.eu/lukas/dynuiprefresher/-/commits/master)
 # DynuIPRefresher
+A lightweight C++ application to setup a service for refreshing a dynamic IP to the Dynu servers. 
+Dynu.com is a free DDns service and provides an API.
+
+## Installation
+Download the latest Release at [Release_Page](https://github.com/Lukas-Heiligenbrunner/DynuIPRefresher/releases).
+I'm providing executables for Debian/Ubuntu (.deb) and RHEL/Debian (.rpm). 
+But you can still compile the code my your own (see build section).
+
+## Configuration
+There is a configuration file `/etc/iprefresher.cfg` where you have to specify the DYNU API key (get it from their homepage), the domainid and your domain.
+Furthermore, you can optionally specify a Telegram API key and a Chat ID if you want to be notfied when your local ip changes.
+
+To enable and start the service: 
+`systemctl enable iprefresher.service` and `systemctl start iprefresher.service`
+

 ## Build
 ## Basic Build
@ -9,13 +25,27 @@
 ### install build dependencies

 `libcurl`
-`libcurl-devel`
+`libconfig`

-Debian:
+#### Debian:
 `apt install libcurl4-openssl-dev`

-Fedora:
-`dnf install libcurl-devel`
+#### Fedora:
+`dnf install libcurl-devel libconfig-devel`
+
+#### Alpine Linux:
+Compiler dependencies:
+
+`apk add make cmake g++`
+
+Lib dependencies:
+
+`apk add libcurl curl-dev libconfig libconfig-dev`
+
+Packaging dependencies:
+
+`apk add dpkg rpm`
+

 #### dependencies for package build
 `dpkg` --> debian/ubuntu package
@ -35,11 +65,23 @@ cd into downloaded files and Generate makefiles:

 `make install`

-[root] or create Linux packages
+(optional) create Linux packages

 `make package`



 ### Windows cross build
-TODO!
+Set Winbuild flag in CMakeList.txt.
+
+Dependencies:
+* MinGW Compiler
+* MinGW-libcurl
+* MinGW-libconfig++
+
+Optional dependencies
+* NSIS Pack tool (for creating installer)
+* doxygen (for generating html doc)
+
+Some addition configuration of lib paths may be needed in CMakeList.txt. 
+`make package` will pack it into a NSIS installer for Windows. 
--- a/config/iprefresher.cfg
+++ b/config/iprefresher.cfg
@ -0,0 +1,12 @@
+# Dynu IP refresher config
+# 2020
+# Lukas Heiligenbrunner
+
+## DYNU API Config
+dynuapikey = ""
+domainid = ""
+domainname = ""
+
+## Telegram API Config (optional)
+#telegramApiKey = ""
+#chatId = ""
--- a/inc/Config.h
+++ b/inc/Config.h
@ -0,0 +1,86 @@
+/**
+ * A static class to manage the configuration file, read/write parameters to it.
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 11.02.2020
+ */
+
+#pragma once
+
+#include <string>
+
+class Config {
+public:
+    /**
+    * read configuration out of config file
+    *
+    * @return success of config read
+    */
+    static bool readConfig();
+
+    /**
+     * validate config file
+     *
+     * @return validity of config file
+     */
+    static bool validateConfig();
+
+    /**
+     * check if telegram credentials in config are set
+     * @return is supported?
+     */
+    static bool isTelegramSupported();
+
+    /** Getters **/
+
+    /**
+     * encapsulated getter for DynuApiKey
+     * @return api key
+     */
+    static const std::string &getDynuapikey();
+
+    /**
+     * encapsulated getter for DomainId
+     * @return DomainId
+     */
+    static const std::string &getDomainid();
+
+    /**
+     * encapsulated getter for Domainname
+     * @return Domainname
+     */
+    static const std::string &getDomainname();
+
+    /**
+     * encapsulated getter for TelegramApiKey
+     * @return TelegramApiKey
+     */
+    static const std::string &getTelegramApiKey();
+
+    /**
+     * encapsulated getter for ChatId
+     * @return ChatId
+     */
+    static const std::string &getChatId();
+
+
+private:
+    /**
+     * private constructor --> don't allow instance of this class
+     */
+    Config();
+
+    /**
+     * helper variable for managing telegram Support
+     */
+    static bool telegramSupport;
+
+    /**
+     * helper variables for storing keys and ids
+     */
+    static std::string dynuapikey;
+    static std::string domainid; //id of the dynu domain
+    static std::string domainname;
+    static std::string telegramApiKey;
+    static std::string chatId;
+};
--- a/inc/FileLogger.h
+++ b/inc/FileLogger.h
@ -1,17 +1,16 @@
-//
-// Created by lukas on 05.05.19.
-//
+/**
+ * Read and write current ip to a temp file to remember last ip until restart
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 05.05.2019
+ */
+
 #pragma once

 #include <string>
+
 class FileLogger {
 public:
-    /**
-     * log messages to logfile
-     * @param text message
-     */
-    void logToLogfile(std::string text);
-
    /**
     * safe ip to temp file
     * @param ip ip address to save
--- a/inc/IPRefresher.h
+++ b/inc/IPRefresher.h
@ -1,16 +1,33 @@
-//
-// Created by lukas on 02.08.19.
-//
+/**
+ * IPrefresher library
+ * - start checking ip once
+ * - or in loop mode
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 06.04.2019
+ */

 #pragma once

-class IPRefresher {
-public:
+namespace IPRefresher {
+    /**
+     * Status return-codes for startUpService
+     */
+    namespace Status_Code {
+        const int SUCCESS = 1;
+        const int ERROR = -1;
+        const int ERROR_NO_INTERNET = -2;
+        const int NOREFRESH = 0;
+    }
+
    /**
     * refresh ip address on Dynu server
     */
-    void checkIPAdress(bool force);
+    bool checkIPAdress(bool force);

-    IPRefresher();
-    explicit IPRefresher(bool loop);
-};
+    /**
+     * start the service in loop mode
+     * every 5 minutes the ip is checked an refreshed (needed for .service)
+     */
+    void startUpService(int interval = 300);
+}
--- a/inc/IpHelper.h
+++ b/inc/IpHelper.h
@ -0,0 +1,22 @@
+/**
+ * A helper class for general IP String actions
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 07.05.2020
+ */
+
+#pragma once
+
+#include <string>
+
+class IpHelper {
+public:
+    /**
+     * check if ip is valid
+     * @param ip ip address to test
+     * @return validity
+     */
+    static bool isIpValid(std::string ip);
+
+private:
+};
--- a/inc/Logger.h
+++ b/inc/Logger.h
@ -1,6 +1,10 @@
-//
-// Created by lukas on 26.10.19.
-//
+/**
+ * Fancy console log output format
+ * todo log level support
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 26.10.2019
+ */

 #pragma once

@ -8,15 +12,40 @@

 class Logger {
 public:
+    /**
+     * a debug message
+     * @param message message
+     */
    static void debug(std::string message);
+
+    /**
+     * a default message
+     * @param message message
+     */
    static void message(std::string message);
+
+    /**
+     * a warning message
+     * @param message message
+     */
    static void warning(std::string message);
+
+    /**
+     * a error message
+     * @param message message
+     */
    static void error(std::string message);

-    static void log(std::string &message, int level);
+    /**
+     * a log message with manual level set
+     * @param message message
+     * @param level loglevel (1-4) or predefined labels
+     */
+    static void log(const std::string &message, int level);

-    static const int Debug;
-    static const int Message;
-    static const int Warning;
-    static const int Error;
+
+    static const int Debug = 4;
+    static const int Message = 3;
+    static const int Warning = 2;
+    static const int Error = 1;
 };
--- a/inc/api/API.h
+++ b/inc/api/API.h
@ -1,12 +1,17 @@
-//
-// Created by lukas on 06.04.19.
-//
+/**
+ * API class
+ * - manages all curl download stuff
+ * - easy POST/GET requests
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 06.04.2019
+ */

 #pragma once

+#include "Hashmap.h"

 #include <string>
-#include "Hashmap.h"

 class API {
 public:
@ -25,7 +30,10 @@ public:
     * @param headers header fields
     * @return return string of server
     */
-    std::string request(std::string myurl, bool post, Hashmap<std::string, std::string> &map, std::vector<std::string> &headers);
+    std::string request(std::string myurl,
+                        bool post,
+                        Hashmap<std::string, std::string> &map,
+                        std::vector<std::string> &headers);

 private:
    static size_t write_data(void *buffer, size_t size, size_t buffersize, FILE *stream);
--- a/inc/api/DynuAPI.h
+++ b/inc/api/DynuAPI.h
@ -1,23 +1,44 @@
-//
-// Created by lukas on 18.06.19.
-//
+/**
+ * Dynu API - Refresh the IP
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 18.06.2019
+ */

 #pragma once

-
 #include "API.h"

-class DynuAPI : API{
+class DynuAPI : API {
 public:
    /**
     * refresh the ip of domain on Dynu server
     * @param ip new ip
     * @return request status
     */
-    int refreshIp(std::string ip);
-private:
-    const std::string dynuapikey = "88vNpMfDhMM2YYDNfWR1DNYfRX9W6fYg";
+    bool refreshIp(std::string ip);

-    const std::string domainid = "8506047"; //id of the dynu domain
-    const std::string domainname = "luki.dynu.net";
+    /**
+     * init Telegram api with apikey and chatid
+     * @param dynuApiKey Dynu Api key
+     * @param domainId ID of domain received by Dynu
+     * @param domainName domainname to refresh
+     */
+    void init(const std::string &dynuApiKey, const std::string &domainId, const std::string &domainName);
+
+private:
+    /**
+     * Dynu API Key
+     */
+    std::string dynuapikey;
+
+    /**
+     * Dynu Domain ID
+     */
+    std::string domainid;
+
+    /**
+     * Domain name eg. "mydomain.dynu.net"
+     */
+    std::string domainname;
 };
--- a/inc/api/Hashmap.h
+++ b/inc/api/Hashmap.h
@ -1,10 +1,12 @@
-//
-// Created by lukas on 07.04.19.
-//
+/**
+ * A Hashmap class for easier Key-Value maps
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 07.04.2019
+ */

 #pragma once

-
 #include <iostream>
 #include <vector>

--- a/inc/api/IPAPI.h
+++ b/inc/api/IPAPI.h
@ -1,13 +1,17 @@
-//
-// Created by lukas on 18.06.19.
-//
+/**
+ * IPAPI for getting global ip of current network
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 18.06.2019
+ */

 #pragma once

-#include <string>
 #include "API.h"

-class IPAPI : API{
+#include <string>
+
+class IPAPI : API {
 public:
    /**
     * get global ip of current internet connection
--- a/inc/api/TelegramAPI.h
+++ b/inc/api/TelegramAPI.h
@ -1,12 +1,15 @@
-//
-// Created by lukas on 08.05.19.
-//
+/**
+ * Telegram API for sending message to specific chat
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 08.05.2019
+ */

 #pragma once

+#include "API.h"

 #include <string>
-#include "API.h"

 class TelegramAPI : API {
 public:
@ -14,7 +17,7 @@ public:
     * send telegram Message to predefined destination
     * @param text message
     */
-    void sendMessage(std::string text);
+    int sendMessage(const std::string &text);

    /**
     * init Telegram api with apikey and chatid
--- a/service/iprefresher.service
+++ b/service/iprefresher.service
--- a/src/Config.cpp
+++ b/src/Config.cpp
@ -0,0 +1,140 @@
+#include "Config.h"
+#include "Logger.h"
+#include "Version.h"
+
+#include <iostream>
+#include <cstring>
+#include <fstream>
+#include <libconfig.h++>
+
+std::string Config::dynuapikey;
+std::string Config::domainid; //id of the dynu domain
+std::string Config::domainname;
+
+std::string Config::telegramApiKey;
+std::string Config::chatId;
+
+bool Config::telegramSupport;
+
+bool Config::readConfig() {
+    libconfig::Config cfg;
+    try {
+        cfg.readFile(Version::ConfigDir.c_str());
+    }
+    catch (const libconfig::FileIOException &fioex) {
+        std::cout << "I/O error while reading config file." << std::endl << "creating new config file!" << std::endl;
+
+        std::ofstream myfile;
+        myfile.open(Version::ConfigDir);
+        if (myfile.is_open()) {
+            myfile << Version::SAMPLECONFIG;
+            myfile.close();
+        } else {
+            Logger::error("error creating file");
+        }
+
+        return false;
+    }
+    catch (const libconfig::ParseException &pex) {
+        std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
+                  << " - " << pex.getError() << std::endl;
+        return false;
+    }
+
+    try {
+        // needed parameters
+        dynuapikey = (std::string) cfg.lookup("dynuapikey");
+        domainid = (std::string) cfg.lookup("domainid");
+        domainname = (std::string) cfg.lookup("domainname");
+        // optional parameters
+        telegramApiKey = (std::string) cfg.lookup("telegramApiKey");
+        chatId = (std::string) cfg.lookup("chatId");
+        telegramSupport = true;
+    }
+    catch (const libconfig::SettingNotFoundException &nfex) {
+        // triggered if setting is missing in config
+        if (!(std::strcmp("telegramApiKey", nfex.getPath()) == 0 || std::strcmp("chatId", nfex.getPath()) == 0)) {
+            std::cerr << "No '" << nfex.getPath() << "' setting in configuration file." << std::endl;
+        } else {
+            Logger::message("no Telegram support - fields in config not set");
+            telegramSupport = false;
+        }
+    }
+    // check if needed values aren't empty
+    return !(Config::dynuapikey.empty() || Config::domainid.empty() || Config::domainname.empty());
+}
+
+bool Config::validateConfig() {
+    libconfig::Config cfg;
+    try {
+        Logger::message("reading config file");
+        cfg.readFile(Version::ConfigDir.c_str());
+    }
+    catch (const libconfig::FileIOException &fioex) {
+        Logger::warning("config file doesn't exist or permission denied!");
+        return false;
+    }
+    catch (const libconfig::ParseException &pex) {
+        std::cerr << "Parse error at " << pex.getFile() << ":" << pex.getLine()
+                  << " - " << pex.getError() << std::endl;
+        return false;
+    }
+    Logger::message("Syntax and Permission is OK");
+
+    try {
+        // needed parameters
+        if (((std::string) cfg.lookup("dynuapikey")).empty()) {
+            Logger::warning("required parameter \"dynuapikey\" seems to be empty.");
+            return false;
+        }
+        if (((std::string) cfg.lookup("domainid")).empty()) {
+            Logger::warning("required parameter \"domainid\" seems to be empty.");
+            return false;
+        }
+        if (((std::string) cfg.lookup("domainname")).empty()) {
+            Logger::warning("required parameter \"domainname\" seems to be empty.");
+            return false;
+        }
+        // optional parameters
+        cfg.lookup("telegramApiKey");
+        cfg.lookup("chatId");
+        telegramSupport = true;
+    }
+    catch (const libconfig::SettingNotFoundException &nfex) {
+        // triggered if setting is missing in config
+        if (!(std::strcmp("telegramApiKey", nfex.getPath()) == 0 || std::strcmp("chatId", nfex.getPath()) == 0)) {
+            std::cerr << "No '" << nfex.getPath() << "' setting in configuration file." << std::endl;
+            return false;
+        } else {
+            Logger::message("no Telegram support - fields in config not set");
+            telegramSupport = false;
+        }
+    }
+    return true;
+}
+
+bool Config::isTelegramSupported() {
+    return telegramSupport;
+}
+
+const std::string &Config::getDynuapikey() {
+    return dynuapikey;
+}
+
+const std::string &Config::getDomainid() {
+    return domainid;
+}
+
+const std::string &Config::getDomainname() {
+    return domainname;
+}
+
+const std::string &Config::getTelegramApiKey() {
+    return telegramApiKey;
+}
+
+const std::string &Config::getChatId() {
+    return chatId;
+}
+
+Config::Config() = default;
--- a/src/FileLogger.cpp
+++ b/src/FileLogger.cpp
@ -1,13 +1,8 @@
-//
-// Created by lukas on 05.05.19.
-//
+#include "FileLogger.h"
+#include "IpHelper.h"

 #include <fstream>
-#include <ctime>
 #include <iostream>
-#include <sstream>
-
-#include "FileLogger.h"

 void FileLogger::safeip(std::string ip) {
    std::ofstream out;
@ -26,24 +21,9 @@ std::string FileLogger::readip() {

    in >> ip;

-    return ip;
-}
-
-void FileLogger::logToLogfile(std::string text) {
-    std::ofstream out;
-    out.open("dynurefresher.log", std::ios::out | std::ios::app);
-
-
-    std::time_t t = std::time(0);   // get time now
-    std::tm *now = std::localtime(&t);
-
-    std::stringstream logline;
-
-    logline << "[ " << (now->tm_year + 1900) << '-' << (now->tm_mon + 1) << '-' << now->tm_mday
-            << "_" << now->tm_hour << ":" << now->tm_min << ":" << now->tm_sec << " ] " << '\t' << text << std::endl;
-
-
-    out << logline.str();
-
-    out.close();
+    // when received ip has no . return 0.0.0.0
+    if (!IpHelper::isIpValid(ip))
+        return "0.0.0.0";
+    else
+        return ip;
 }
--- a/src/IPRefresher.cpp
+++ b/src/IPRefresher.cpp
@ -1,66 +1,73 @@
-//
-// Created by lukas on 02.08.19.
-//
-
-#include <string>
-
-#include <FileLogger.h>
-#include <api/IPAPI.h>
-#include <api/DynuAPI.h>
-#include <api/TelegramAPI.h>
+#include "IPRefresher.h"
+#include "FileLogger.h"
+#include "api/IPAPI.h"
+#include "api/DynuAPI.h"
+#include "api/TelegramAPI.h"
+#include "Config.h"
+#include "Version.h"
+#include "IpHelper.h"

 #include <chrono>
 #include <thread>
 #include <Logger.h>

-#include <IPRefresher.h>
+using namespace IPRefresher;

-void IPRefresher::checkIPAdress(bool force) {
+bool IPRefresher::checkIPAdress(bool force) {
    FileLogger logger;

    IPAPI ipapi;
    std::string ip = ipapi.getGlobalIp();

    if (ip.empty()) {
-        //no internet connection
-        logger.logToLogfile("[WARNING] no internet connection");
+        //no internet connection (or other error)
        Logger::warning("no internet connection");
+        return Status_Code::ERROR_NO_INTERNET;
+    } else if (!IpHelper::isIpValid(ip)) {
+        // error when ip doesn't contain a :
+        Logger::warning("an error occured when getting the global ip");
+        return Status_Code::ERROR;
    } else {
        std::string oldip = logger.readip();

        if (oldip == ip && !force) {
            Logger::message("no change -- ip: " + ip);
-            logger.logToLogfile(" [INFO] no change -- ip: " + ip);
+            return Status_Code::NOREFRESH;
        } else {
-            logger.logToLogfile(" [INFO] ip changed! -- from :" + oldip + "to: " + ip);
            Logger::message("ip changed! -- from :" + oldip + "to: " + ip);

            DynuAPI dynu;
+            dynu.init(Config::getDynuapikey(), Config::getDomainid(), Config::getDomainname());
+            // actual refresh of IP in api - here
+            bool result = dynu.refreshIp(ip);

-            if (dynu.refreshIp(ip)) {
+            if (result && Config::isTelegramSupported()) {
                TelegramAPI tele;
-                tele.init("717213769:AAHan1nSXhUsxLJAN1Dv8Oc0z8wqwDdYPn4", "618154204");
+                tele.init(Config::getTelegramApiKey(), Config::getChatId());
                tele.sendMessage(oldip + " moved to " + ip);
-            } else {
+            } else if (!result) {
                //error
-                logger.logToLogfile(" [ERROR] failed to write ip to dynu api!");
                Logger::error("failed to write ip to dynu api!");
+                return Status_Code::ERROR;
            }

            logger.safeip(ip);
+            return result ? Status_Code::SUCCESS : Status_Code::ERROR;
        }
    }
 }

-IPRefresher::IPRefresher() {
-
-}
-
-IPRefresher::IPRefresher(bool loop) {
+void IPRefresher::startUpService(int interval) {
    Logger::message("startup of service");
-    while (loop) {
-        Logger::message("starting check");
-        checkIPAdress(false);
-        std::this_thread::sleep_for(std::chrono::milliseconds(300000));
+    Logger::message("Version: " + Version::VERSION);
+    if (Config::readConfig()) {
+        while (true) {
+            Logger::message("starting check");
+            checkIPAdress(false);
+            std::this_thread::sleep_for(std::chrono::milliseconds(interval * 1000));
+        }
+    } else {
+        std::cout << "incorrect credentials!" << std::endl;
    }
+
 }
--- a/src/IpHelper.cpp
+++ b/src/IpHelper.cpp
@ -0,0 +1,7 @@
+#include "IpHelper.h"
+
+#include <climits>
+
+bool IpHelper::isIpValid(std::string ip) {
+    return (ip.find('.') != ULONG_MAX);
+}
--- a/src/Logger.cpp
+++ b/src/Logger.cpp
@ -1,35 +1,25 @@
-//
-// Created by lukas on 26.10.19.
-//
+#include "Logger.h"

 #include <sstream>
 #include <iostream>

-#include "Logger.h"
-
-
-const int Logger::Warning = 1;
-const int Logger::Debug = 2;
-const int Logger::Message = 3;
-const int Logger::Error = 4;
-
-void Logger::debug(std::string message) {
+void Logger::debug(const std::string message) {
    log(message, Logger::Debug);
 }

-void Logger::message(std::string message) {
+void Logger::message(const std::string message) {
    log(message, Logger::Message);
 }

-void Logger::warning(std::string message) {
+void Logger::warning(const std::string message) {
    log(message, Logger::Warning);
 }

-void Logger::error(std::string message) {
+void Logger::error(const std::string message) {
    log(message, Logger::Error);
 }

-void Logger::log(std::string &message, int level) {
+void Logger::log(const std::string &message, int level) {
    std::stringstream out;
    out << "[";
    switch (level) {
@ -45,6 +35,9 @@ void Logger::log(std::string &message, int level) {
        case Error:
            out << "ERROR";
            break;
+        default:
+            out << "UNDEFINED";
+            break;
    }
    out << "] ";
    out << message;
--- a/src/api/API.cpp
+++ b/src/api/API.cpp
@ -1,16 +1,8 @@
-//
-// Created by lukas on 06.04.19.
-//
-
 #include "api/API.h"
-#include "api/Hashmap.h"

-#include <string>
-#include <iostream>
 #include <sstream>
 #include <curl/curl.h>

-
 std::string API::request(std::string myurl) {
    Hashmap<std::string, std::string> map;
    std::vector<std::string> str;
--- a/src/api/DynuAPI.cpp
+++ b/src/api/DynuAPI.cpp
@ -1,27 +1,22 @@
-//
-// Created by lukas on 18.06.19.
-//
-
 #include "api/DynuAPI.h"

-int DynuAPI::refreshIp(std:: string ip) {
-
+bool DynuAPI::refreshIp(std::string ip) {
    Hashmap<std::string, std::string> args;
    args.add("name", domainname);
    args.add("ipv4Address", ip);

    std::vector<std::string> headers;
-    headers.push_back("accept: application/json");
-    headers.push_back("User-Agent: Mozilla/5.0 (compatible; Rigor/1.0.0; http://rigor.com)");
-    headers.push_back("API-Key: " + dynuapikey);
+    headers.emplace_back("accept: application/json");
+    headers.emplace_back("User-Agent: Mozilla/5.0 (compatible; Rigor/1.0.0; http://rigor.com)");
+    headers.emplace_back("API-Key: " + dynuapikey);

-    std::string dynurepl = request("https://api.dynu.com/v2/dns/" + domainid, true, args, headers);
+    const std::string dynurepl = request("https://api.dynu.com/v2/dns/" + domainid, true, args, headers);

-//    std::cout << "[DEBUG] api reply:: " << dynurepl << std::endl;
-
-    if (dynurepl != "{\"statusCode\":200}") {
-        return -1;
-    } else {
-        return 1;
-    }
+    return (dynurepl == "{\"statusCode\":200}");
+}
+
+void DynuAPI::init(const std::string &dynuApiKey, const std::string &domainId, const std::string &domainName) {
+    this->dynuapikey = dynuApiKey;
+    this->domainid = domainId;
+    this->domainname = domainName;
 }
--- a/src/api/IPAPI.cpp
+++ b/src/api/IPAPI.cpp
@ -1,7 +1,3 @@
-//
-// Created by lukas on 18.06.19.
-//
-
 #include "api/IPAPI.h"

 std::string IPAPI::getGlobalIp() {
--- a/src/api/TelegramAPI.cpp
+++ b/src/api/TelegramAPI.cpp
@ -1,10 +1,9 @@
-//
-// Created by lukas on 08.05.19.
-//
-
 #include "api/TelegramAPI.h"
+#include "Logger.h"

-void TelegramAPI::sendMessage(std::string text) {
+#include <climits>
+
+int TelegramAPI::sendMessage(const std::string &text) {
    Hashmap<std::string, std::string> args;
    args.add("chat_id", chatid);
    args.add("text", text);
@ -12,10 +11,15 @@ void TelegramAPI::sendMessage(std::string text) {
    std::vector<std::string> headers;

    std::string reply = request("https://api.telegram.org/bot" + apikey + "/sendmessage", false, args, headers);
-//    std::cout << "[DEBUG] " << reply << std::endl;
+
+    if (reply.find("\"error_code\"") != ULONG_MAX) {
+        Logger::error("failed to refresh the ip (Dynu API)");
+        return -1;
+    }
+    return 1;
 }

-void TelegramAPI::init(std::string apikey, std::string chatid) {
+void TelegramAPI::init(const std::string apikey, const std::string chatid) {
    this->apikey = apikey;
    this->chatid = chatid;
 }
--- a/src/gui/MainWindow.cpp
+++ b/src/gui/MainWindow.cpp
@ -0,0 +1,84 @@
+#include "MainWindow.h"
+#include "ui_mainwindow.h"
+
+#include "api/IPAPI.h"
+#include "IPRefresher.h"
+#include "Config.h"
+#include "Logger.h"
+
+#include <thread>
+
+MainWindow::MainWindow() : QMainWindow(), ui(new Ui::MainWindow) {
+    ui->setupUi(this);
+
+    // needs to be defined with new -- would be termintated after this constructor.
+    new std::thread([this]() {
+        IPAPI ipapi;
+        std::string ip = ipapi.getGlobalIp();
+        Logger::message("Current global IP: " + ip);
+        std::string msg = "Your current global IP: " + ip;
+        this->ui->labelCurrentIP->setText(msg.c_str());
+    });
+
+    // set config info label and initial check if config is valid
+    ui->labelConfig->setText(Config::validateConfig() ? "Config is: OK" : "Config is: NOT OK");
+
+    connect(ui->buttonCheckConfig, SIGNAL(clicked()), this, SLOT(checkConfigBtn()));
+    connect(ui->buttonRefreshIP, SIGNAL(clicked()), this, SLOT(refreshIPBtn()));
+
+    connect(this, SIGNAL(appendLogField(QString)), ui->textLog, SLOT(appendPlainText(QString)));
+}
+
+MainWindow::~MainWindow() {
+    // todo check if disconnects are really necessary
+    disconnect(ui->buttonCheckConfig);
+    disconnect(ui->buttonRefreshIP);
+    delete ui;
+}
+
+void MainWindow::checkConfigBtn() {
+    Logger::message("checking config!");
+    appendLogField("checking config!");
+
+    if (Config::validateConfig()) {
+        Logger::message("Config file is OK");
+        appendLogField("Config file is OK");
+        ui->labelConfig->setText("Config is: OK");
+    } else {
+        Logger::error("There are errors in config file!");
+        appendLogField("There are errors in config file!");
+    }
+    appendLogField("");
+}
+
+void MainWindow::refreshIPBtn() {
+    Logger::message("start refreshing Dynu IP.");
+    appendLogField("");
+    appendLogField("start refreshing Dynu IP.");
+    new std::thread([this]() {
+        if (Config::readConfig()) {
+            int code = IPRefresher::checkIPAdress(false);
+            switch (code) {
+                case IPRefresher::Status_Code::SUCCESS:
+                    appendLogField("successfully refreshed IP!");
+                    break;
+                case IPRefresher::Status_Code::NOREFRESH:
+                    appendLogField("IP is already correct.");
+                    break;
+                case IPRefresher::Status_Code::ERROR_NO_INTERNET:
+                    appendLogField("Error: No Internet connection");
+                    break;
+                case IPRefresher::Status_Code::ERROR:
+                    appendLogField("An error occured while refreshing.");
+                    break;
+                default:
+                    appendLogField("An unknown error code occured");
+            }
+        } else {
+            std::cout << "incorrect credentials!" << std::endl;
+        }
+
+        Logger::message("Finished refreshing Dynu IP.");
+        this->appendLogField("Finished refreshing Dynu IP.");
+    });
+}
--- a/src/gui/MainWindow.h
+++ b/src/gui/MainWindow.h
@ -0,0 +1,50 @@
+/**
+ * Main GUI controller - User IO handlings
+ *
+ * @author Lukas Heiligenbrunner
+ * @date 09.05.2020
+ */
+
+#pragma once
+
+#include <QtWidgets/QMainWindow>
+
+namespace Ui {
+    class MainWindow;
+}
+
+class MainWindow : public QMainWindow {
+Q_OBJECT
+
+public:
+    /**
+     * constructor with basic initializations
+     */
+    explicit MainWindow();
+
+    /**
+     * destruct all gui elements
+     */
+    ~MainWindow();
+
+private:
+    Ui::MainWindow *ui;
+private slots:
+    /**
+     * executed click handler for config button
+     */
+    void checkConfigBtn();
+
+    /**
+     * executed click handler for refresh btn
+     */
+    void refreshIPBtn();
+
+signals:
+    /**
+     * append a String line to the Log field
+     *
+     * @param QString string to be appended
+     */
+    void appendLogField(QString);
+};
--- a/src/gui/mainwindow.ui
+++ b/src/gui/mainwindow.ui
@ -0,0 +1,103 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>823</width>
+    <height>618</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QPushButton" name="buttonRefreshIP">
+    <property name="geometry">
+     <rect>
+      <x>290</x>
+      <y>300</y>
+      <width>91</width>
+      <height>33</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Refresh IP</string>
+    </property>
+   </widget>
+   <widget class="QLabel" name="labelCurrentIP">
+    <property name="geometry">
+     <rect>
+      <x>40</x>
+      <y>60</y>
+      <width>301</width>
+      <height>17</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Your current global IP:</string>
+    </property>
+   </widget>
+   <widget class="QPlainTextEdit" name="textLog">
+    <property name="enabled">
+     <bool>false</bool>
+    </property>
+    <property name="geometry">
+     <rect>
+      <x>40</x>
+      <y>410</y>
+      <width>691</width>
+      <height>191</height>
+     </rect>
+    </property>
+    <property name="cursor" stdset="0">
+     <cursorShape>IBeamCursor</cursorShape>
+    </property>
+   </widget>
+   <widget class="QLabel" name="label_2">
+    <property name="geometry">
+     <rect>
+      <x>40</x>
+      <y>380</y>
+      <width>64</width>
+      <height>17</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Log:</string>
+    </property>
+   </widget>
+   <widget class="QPushButton" name="buttonCheckConfig">
+    <property name="geometry">
+     <rect>
+      <x>270</x>
+      <y>140</y>
+      <width>91</width>
+      <height>33</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Check Config</string>
+    </property>
+   </widget>
+   <widget class="QLabel" name="labelConfig">
+    <property name="geometry">
+     <rect>
+      <x>270</x>
+      <y>180</y>
+      <width>141</width>
+      <height>17</height>
+     </rect>
+    </property>
+    <property name="text">
+     <string>Config is: undefined</string>
+    </property>
+   </widget>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
--- a/src/main.cpp
+++ b/src/main.cpp
@ -1,8 +1,12 @@
-#include <iostream>
-#include <IPRefresher.h>
-#include <Version.h>
-#include <Logger.h>
+#include "Version.h"
+#include "IPRefresher.h"
+#include "Logger.h"
+#include "Config.h"
+#include "api/IPAPI.h"

+/**
+ * application entry point
+ */
 int main(int argc, char *argv[]) {
    if (argc > 1) {
        std::string firstarg(argv[1]);
@ -11,22 +15,40 @@ int main(int argc, char *argv[]) {
                      << "[-v] [--version] print the software version" << std::endl
                      << "[-f] [--force] force refresh of ip" << std::endl
                      << "[-l] [--loop] infinite loop to refresh ip every five minutes" << std::endl
+                      << "[-c] [--checkconfig] validate configuration" << std::endl
+                      << "[-ip] [--currentip] get current global ip" << std::endl
                      << "[no argument] normal ip check and refresh" << std::endl;
        } else if (firstarg == "-v" || firstarg == "--version") {
            std::cout << "Version " << Version::VERSION << std::endl;
        } else if (firstarg == "-f" || firstarg == "--force") {
-            IPRefresher ipr;
-            ipr.checkIPAdress(true);
+            if (Config::readConfig()) {
+                IPRefresher::checkIPAdress(true);
+            } else {
+                std::cout << "incorrect credentials!" << std::endl;
+            }
+
        } else if (firstarg == "-l" || firstarg == "--loop") {
-            IPRefresher ipr(true);
+            IPRefresher::startUpService(true);
+        } else if (firstarg == "-c" || firstarg == "--checkconfig") {
+            if (Config::validateConfig()) {
+                Logger::message("Config file is OK");
+            } else {
+                Logger::error("There are errors in config file!");
+                return -1;
+            }
+        } else if (firstarg == "-ip" || firstarg == "--currentip") {
+            IPAPI ipapi;
+            std::cout << "Current global IP: " << ipapi.getGlobalIp() << std::endl;
        } else {
            Logger::message("wrong arguments!  -h for help");
        }
    } else {
-        IPRefresher ipr;
        Logger::message("starting check");
-        ipr.checkIPAdress(false);
-
+        if (Config::readConfig()) {
+            IPRefresher::checkIPAdress(false);
+        } else {
+            std::cout << "incorrect credentials!" << std::endl;
+        }
    }

    return 0;
--- a/src/maingui.cpp
+++ b/src/maingui.cpp
@ -0,0 +1,14 @@
+#include <QApplication>
+#include "gui/MainWindow.h"
+
+/**
+ * application entry point
+ */
+int main(int argc, char *argv[]) {
+    QApplication a(argc, argv);
+    MainWindow w;
+    w.setWindowTitle("startUpService");
+    w.show();
+
+    return QApplication::exec();
+}
--- a/tests/UnitTest.cpp
+++ b/tests/UnitTest.cpp
@ -0,0 +1,30 @@
+//
+// Created by lukas on 06.05.20.
+//
+
+#include <FileLogger.h>
+#include <api/IPAPI.h>
+#include <climits>
+#include "gtest/gtest.h"
+
+/**
+ * Test if default ip is 0.0.0.0 when last ip file doesn't exist.
+ */
+TEST(ReadIp, testzeroIpIfNotExists) {
+    FileLogger logger;
+    std::string oldip = logger.readip();
+    ASSERT_EQ(oldip, "0.0.0.0");
+}
+/**
+ * Test if default ip is 0.0.0.0 when last ip file doesn't exist.
+ */
+TEST(IPAPI, testIpAPIcheckIPSyntax) {
+    IPAPI ipapi;
+    std::string ip = ipapi.getGlobalIp();
+    if (ip.find('.') == ULONG_MAX) {
+        // error when ip doesn't contain a .
+        ASSERT_TRUE(false);
+    } else {
+        ASSERT_TRUE(true);
+    }
+}
Author	SHA1	Message	Date
lukas	b5b352f83d	namespace for IPRefresher instead of class	2020-05-15 13:57:09 +02:00
lukas	3b32f60190	added return codes for IPrefresher refresh method. error messages in gui.	2020-05-14 23:08:19 +02:00
Lukas Heiligenbrunner	0eea7095e0	added better thread management cross compilation features.	2020-05-10 18:10:44 +02:00
lukas	ab772aac55	further gui developments	2020-05-10 15:00:51 +02:00
lukas	c25996a925	first qt gui steps	2020-05-09 23:08:23 +02:00
lukas	826386e849	define cached files globally/ including last test job	2020-05-08 17:28:19 +02:00
lukas	25f32dc4f4	cache whole project between jobs	2020-05-08 17:23:19 +02:00
lukas	2b863c6050	keep data between stages	2020-05-08 17:20:11 +02:00
lukas	a43b730b53	multistaging ci	2020-05-08 17:17:20 +02:00
lukas	309aefee2e	added a build badge	2020-05-08 17:02:46 +02:00
lukas	713e7a1f95	everywhere same code header reformatings cdoc	2020-05-08 16:45:27 +02:00
Lukas Heiligenbrunner	12de026842	Update .gitlab-ci.yml	2020-05-07 18:08:31 +00:00
Lukas-Heiligenbrunner	463853dbd7	Unit test framework (#10 ) * add first Unit Test with gtest and cmake dependencies * optionally build tests or not added some realistic tests * added ci compatible run configuration * added test dependencies -lpthread -lm to work in debian correctly * added some docs and option infos	2020-05-07 19:58:16 +02:00
lukas	335bcf1259	wrong variable name	2020-05-07 16:19:59 +02:00
lukas	db4c71d7fe	don't use find_package for libconfig, no default package in debian/libconfig installation	2020-05-07 16:17:47 +02:00
lukas	ba4af36df0	* new class for IP utils * method to check telegram support out of config * getters in Config.cpp * lots of reformatings and cdoc	2020-05-07 14:54:40 +02:00
lukas	b133ab6961	options to allow/deny package build option cleanup	2020-05-06 11:33:29 +02:00
Lukas-Heiligenbrunner	2e3a39f38c	Merge pull request #6 from Lukas-Heiligenbrunner/cross-compilation Cross compilation	2020-05-06 11:04:49 +02:00
Lukas-Heiligenbrunner	4bab9b21eb	Merge branch 'master' into cross-compilation	2020-05-06 11:04:42 +02:00
lukas	9f99997c8b	added Readme for cross compile tasks	2020-05-06 11:03:39 +02:00
lukas	aef369b38b	correct order of #includes to include own libs first and then system ones	2020-05-05 19:25:23 +02:00
Lukas-Heiligenbrunner	8659237ece	Merge pull request #8 from Lukas-Heiligenbrunner/DoctypeBug Doctype bug	2020-05-05 19:15:57 +02:00
lukas	1756b0cf5e	check also read ip from file if valid	2020-05-05 19:15:08 +02:00
lukas	a3c8fe44dd	use climits for MAX_ULONG check if received ip from api has at least a :	2020-05-05 19:11:47 +02:00
lukas	d353a2485c	more dynamic .dll folder for exe packing other config dir for windows build	2020-05-05 17:02:39 +02:00
Lukas-Heiligenbrunner	8a9c39051d	Merge pull request #7 from Lukas-Heiligenbrunner/currentipparameter added option to get current global ip	2020-05-05 15:57:16 +02:00
lukas	d5812f8266	added option to get current global ip	2020-05-05 15:32:07 +02:00
lukas	c3bc2293c7	remove double include of cpack	2020-05-05 14:34:25 +02:00
lukas	2b66e229e3	improved windows cross build nsis packaging	2020-05-05 14:20:02 +02:00
lukas	714c087973	first winbuild tests	2020-05-04 21:17:10 +02:00
lukas	2353e4b420	release version 1.3.2	2020-05-02 14:59:56 +02:00
lukas	81d85a51f8	right package dependencies for deb and rpm packages.	2020-05-02 14:59:08 +02:00
Lukas-Heiligenbrunner	3936d9b949	Update README.md	2020-05-01 16:37:15 +02:00
Lukas Heiligenbrunner	a127fc4893	naming postinst instead of conffiles -- deb name convention	2020-05-01 17:11:59 +02:00
Lukas Heiligenbrunner	b72f9749a4	debian package postscript must have specific name	2020-05-01 17:05:19 +02:00
Lukas Heiligenbrunner	98f181fd6d	store sampleconfig also in header for regenerating it if missing during runtime	2020-05-01 16:56:37 +02:00
Lukas Heiligenbrunner	ae9aa1d423	check if config file exists with a post script (during package installation process)	2020-05-01 16:47:22 +02:00
Lukas Heiligenbrunner	2505e2cbf4	new option to verify syntax and parameters of config file cdoc for logging class	2020-05-01 15:33:20 +02:00
Lukas Heiligenbrunner	cf49bf7bc5	don't overwrite config on update Config.cpp namespace instead of static class print version on service startup	2020-05-01 12:33:51 +02:00
lukas	78d07ac95b	cdoc and some minor renames	2020-04-30 19:37:11 +02:00
lukas	53e59e9931	edited install path to /usr/bin -- more common	2020-04-30 17:12:30 +02:00
lukas	4bc836c971	added gitlab build job improved readme	2020-04-30 15:15:01 +02:00
lukas	7f83203dfd	release version 1.3.0	2020-04-30 12:25:27 +02:00
lukas	a5e64667c5	removed useless ide files	2020-04-30 12:21:41 +02:00
lukas	9d33964b93	remove logging to file added some doc	2020-04-30 12:16:29 +02:00
Lukas Heiligenbrunner	7cf8e965b0	improved check of incorrect config	2020-04-30 11:30:41 +02:00
Lukas Heiligenbrunner	04e64ad79c	improved libconfig lib error handling in cmake	2020-04-30 10:47:32 +02:00
lukas	f53d46dd49	update readme	2020-04-29 22:02:51 +02:00
lukas	722d25b325	use libconfig for a /etc/iprefresher.cfg config file there can all the api credentials be specified	2020-04-29 20:06:27 +02:00
lukas	5499fadac8	lots cmake improvements correct non root packaging	2020-04-29 18:33:30 +02:00
Lukas-Heiligenbrunner	54a0ea9f98	basic refactor	2020-02-11 17:22:14 +01:00
Lukas-Heiligenbrunner	4bb1fd148a	moved credential definition in seperate file	2020-02-11 17:14:17 +01:00
Lukas-Heiligenbrunner	0ac9c497ae	create Credentials class to specify all credentials there.	2020-02-11 16:42:05 +01:00