old-backend/controllers/devices_controller.go

package controllers

import (
	"context"
	"encoding/json"
	"errors"
	"log"
	"math/big"
	"net/http"
	"strconv"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/jinzhu/gorm"
	"gitlab.com/pactual1/backend/config"
	"gitlab.com/pactual1/backend/database/contract"
	"gitlab.com/pactual1/backend/database/device"
	"gitlab.com/pactual1/backend/models"
	"gitlab.com/pactual1/backend/services/blockchain"
	"gitlab.com/pactual1/backend/shared"
)

func SaveDeviceInfo(c *gin.Context) {
	var deviceInfo models.DeviceInfo
	rawData, _ := c.GetRawData()

	// Unmarshal to the important info structure
	err := json.Unmarshal(rawData, &deviceInfo)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid JSON payload"})
		log.Printf("Invalid json pyload : %v", err)
		return
	}

	deviceInfo.RawJSON = string(rawData)
	deviceInfo.X = deviceInfo.AccInfo.X
	deviceInfo.Y = deviceInfo.AccInfo.Y
	deviceInfo.Z = deviceInfo.AccInfo.Z

	// Attempt to find the device by IMEI; if not found, create a new device
	var device models.Device
	if err := shared.GetDb().Unscoped().Where("device_id = ?", deviceInfo.ExternalDeviceID).First(&device).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// Create new device
			device = models.Device{
				IMEI:                deviceInfo.IMEI,
				IMSI:                deviceInfo.IMSI,
				DeviceID:            deviceInfo.ExternalDeviceID,
				DeviceConfiguration: string(rawData),
			}
			if err := shared.GetDb().Create(&device).Error; err != nil {
				log.Printf("CREATE -Device DB Error: %v", err)
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not create new device"})
				return
			}
			deviceInfo.DeviceID = device.ID
		} else {
			log.Printf("CREATE -Device DB Error: %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Database error"})
			return
		}
	} else {
		log.Printf("Current device deleted at: %v", device.DeletedAt)

		if device.DeletedAt.Valid {
			// Use raw SQL to update the record
			if err := shared.GetDb().Exec("UPDATE devices SET deleted_at = NULL, company_id = NULL WHERE id = ?", device.ID).Error; err != nil {
				log.Printf("UNDELETE -Device DB Error: %v", err)
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not revive deleted device"})
				return
			} else {
				log.Printf("Device undeleted successfuly : %v", device.DeletedAt)
			}
		}
		deviceInfo.DeviceID = device.ID
	}

	// Save deviceInfo to your database
	if err := shared.GetDb().Create(&deviceInfo).Error; err != nil {
		log.Printf("SaveDeviceInfo CREATE -DeviceInfo DB Error: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not save device info"})
		return
	}

	if device.CurrentContractID != nil {
		deviceContract, _, err := contract.GetContractByID(*device.CurrentContractID)
		if err != nil {
			log.Printf("SaveDeviceInfo - GetContractByID error : %v", err)
			c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not fetch device contract"})
			return
		}

		if deviceContract.Status == models.ContractStatusActive {
			deviceInfoBytes, _ := json.Marshal(deviceInfo)
			deviceInfoEncryptedStr, err := shared.NewEncryptionClient(config.AppConfig.Service.BlockchainSecret).Encrypt(string(deviceInfoBytes))
			if err != nil {
				log.Printf("SaveDeviceInfo - Enrypt error : %v", err)
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not encrypt device info"})
				return
			}

			err = blockchain.NewService(config.AppConfig.Blockchain).AddIOTData(context.Background(), shared.CovertUintToByte32(deviceContract.ID), shared.CovertUintToByte32(device.ID), big.NewInt(time.Now().Unix()), []byte(deviceInfoEncryptedStr))
			if err != nil {
				log.Printf("SaveDeviceInfo CREATE -DeviceInfo Blockchain Error: %v", err)
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Could not save device info in blockchain"})
				return
			}
		}
	}

	log.Printf("Successfully received and saved device info: %v", deviceInfo)
	c.JSON(http.StatusOK, gin.H{"message": "Successfully received and saved device info", "data": deviceInfo})
}

func GetDeviceData(c *gin.Context) {
	// Get the device ID and contract ID from query parameters
	deviceIDStr := c.DefaultQuery("device_id", "")
	contractIDStr := c.DefaultQuery("contract_id", "")

	if deviceIDStr == "" {
		log.Printf("GetDeviceData Error: Device ID is required")
		c.JSON(http.StatusBadRequest, gin.H{"error": "Device ID is required"})
		return
	}

	deviceID, err := strconv.ParseUint(deviceIDStr, 10, 32)
	if err != nil {
		log.Printf("GetDeviceData Error: Invalid Device ID: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid Device ID"})
		return
	}

	contractID, err := strconv.ParseUint(contractIDStr, 10, 32)
	if err != nil {
		log.Printf("GetDeviceData Error: Invalid Contract ID: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid Contract ID"})
		return
	}

	contract, st, err := contract.GetContractByID(uint(contractID))
	if err != nil {
		c.JSON(st, gin.H{"error": err.Error()})
		return
	}

	deviceConnectedToContract := false
	for _, contractDeviceID := range contract.DeviceIDs {
		if deviceID == uint64(contractDeviceID) {
			deviceConnectedToContract = true
		}
	}

	if !deviceConnectedToContract {
		log.Printf("Device %v is not connected to contract %v", deviceID, contractID)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Device is not present int his contract"})
		return
	}

	featureCollection, st, err := device.GetDeviceInfoForContract(deviceID, contract)

	if err != nil {
		c.JSON(st, gin.H{"error": err.Error()})
		return
	}

	// Respond with the GeoJSON feature collection
	c.JSON(http.StatusOK, gin.H{"data": featureCollection})
}

func GetDevicesByContract(c *gin.Context) {
	// Get the contract ID from query parameter
	contractIDStr := c.DefaultQuery("contract_id", "")
	if contractIDStr == "" {
		log.Printf("GetDevicesByContract Error: Contract ID is required")
		c.JSON(http.StatusBadRequest, gin.H{"error": "Contract ID is required"})
		return
	}

	// Convert string to uint
	contractID, err := strconv.ParseUint(contractIDStr, 10, 32)
	if err != nil {
		log.Printf("GetDevicesByContract Error: Invalid Contract ID: %v", err)
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid Contract ID"})
		return
	}

	log.Printf("This is the  ID: %v", contractID)
	devices, st, err := device.GetDevicesForContract(contractID)

	if err != nil {
		c.JSON(st, gin.H{"error": err.Error()})
		return
	}
	// Respond with the devices
	c.JSON(http.StatusOK, gin.H{"data": models.ConvertDeviceToResponse(devices)})
}