fear(server): Soham Desktop Application

.vscode/launch.json

@@ -4,6 +4,14 @@
   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
   "version": "0.2.0",
   "configurations": [
+    {
+      "name": "Tunnel Client",
+      "type": "go",
+      "request": "launch",
+      "mode": "debug",
+      "args": ["--dev"],
+      "program": "${workspaceFolder}/servers/tunnel-client/main.go"
+    },
     {
       "name": "Soham Client Release Server",
       "type": "go",
@@ -20,6 +28,14 @@
       "args": ["--dev"],
       "program": "${workspaceFolder}/apps/sohan/whatsapp/main.go"
     },
+    {
+      "name": "Run File Server",
+      "type": "go",
+      "request": "launch",
+      "mode": "auto",
+      "args": ["--dev"],
+      "program": "${workspaceFolder}/servers/file-server-middleware/main.go"
+    },
     {
       "name": "Run Telegram Server",
       "type": "go",

apps/sohan/whatsapp/.gitignore

@@ -0,0 +1,4 @@
+whatsapp-client*
+*.lock
+*.json
+*.db

apps/sohan/whatsapp/FyneApp12333.toml

@@ -0,0 +1,6 @@
+Website = "https://rpso.in"
+Details = "A description of your application"
+Name = "WABOT"
+ID = "in.rpso.wabot"
+Icon = "icon.ico"
+Version = "1.0.0"

apps/sohan/whatsapp/auto-download/index.go

@@ -9,12 +9,14 @@ import (
 	"log"
 	"net/http"
 	"os"
+	"path/filepath"
 	"runtime"
 	"time"
 
 	"fyne.io/fyne/v2"
 	"fyne.io/fyne/v2/widget"
-	soham_whatsapp_gui_config "github.com/rpsoftech/golang-servers/apps/sohan/whatsapp/config"
+	sohan_whatsapp_keys "github.com/rpsoftech/golang-servers/apps/sohan/whatsapp/keys"
+	utility_functions_gzip "github.com/rpsoftech/golang-servers/utility/functions/gzip"
 )
 
 const VersionFileName = "client-version.json"
@@ -112,6 +114,7 @@ func CheckAndDownload(progress *widget.ProgressBar, win fyne.Window) string {
 	if runtime.GOOS == "windows" {
 		serverBinary = "whatsapp-client.exe"
 	}
+	serverBinary = filepath.Join(sohan_whatsapp_keys.ConfigDir, serverBinary)
 	if checkAndRunCalled {
 		return serverBinary
 	}
@@ -135,7 +138,7 @@ func CheckAndDownload(progress *widget.ProgressBar, win fyne.Window) string {
 		json.Unmarshal(data, &local)
 	}
 
-	tmpFile := serverBinary + ".tmp"
+	gzipFile := serverBinary + ".gz"
 
 	needDownload := false
 
@@ -148,11 +151,11 @@ func CheckAndDownload(progress *widget.ProgressBar, win fyne.Window) string {
 	}
 
 	if needDownload {
-		os.Remove(tmpFile)
+		os.Remove(gzipFile)
 		fyne.DoAndWait(func() {
 			win.Show()
 		})
-		err := downloadFileWithProgress(cloud.URL, tmpFile, progress)
+		err := downloadFileWithProgress(cloud.URL, gzipFile, progress)
 		if err != nil {
 			if _, err := os.Stat(serverBinary); os.IsNotExist(err) {
 				panic(fmt.Errorf("File Downloading Failed"))
@@ -161,16 +164,16 @@ func CheckAndDownload(progress *widget.ProgressBar, win fyne.Window) string {
 			return serverBinary
 		}
 
-		hash, err := sha256File(tmpFile)
+		hash, err := sha256File(gzipFile)
 		if err != nil {
 			return serverBinary
 		}
 
 		if hash != cloud.SHA256 {
-			os.Remove(tmpFile)
+			os.Remove(gzipFile)
 			return serverBinary
 		}
-		err = replaceBinarySafe(tmpFile, serverBinary)
+		err = replaceBinarySafe(gzipFile, serverBinary)
 		if err != nil {
 			log.Println("Binary replace failed:", err)
 			return serverBinary
@@ -219,9 +222,9 @@ func downloadFileWithProgress(url string, filepath string, progress *widget.Prog
 func replaceBinarySafe(tmpFile string, serverBinary string) error {
 
 	// stop server first
-	if soham_whatsapp_gui_config.ServerCmd != nil && soham_whatsapp_gui_config.ServerCmd.Process != nil {
-		soham_whatsapp_gui_config.ServerCmd.Process.Kill()
-		time.Sleep(1 * time.Second)
+	if sohan_whatsapp_keys.ServerCmd != nil && sohan_whatsapp_keys.ServerCmd.Process != nil {
+		sohan_whatsapp_keys.ServerCmd.Process.Kill()
+		time.Sleep(3 * time.Second)
 	}
 
 	// backup existing binary
@@ -234,7 +237,7 @@ func replaceBinarySafe(tmpFile string, serverBinary string) error {
 	}
 
 	// move new binary
-	err := os.Rename(tmpFile, serverBinary)
+	err := utility_functions_gzip.GzipDecompressFile(tmpFile, serverBinary)
 	if err != nil {
 		return err
 	}

apps/sohan/whatsapp/config/index.go

@@ -1,39 +1,61 @@
 package soham_whatsapp_gui_config
 
 import (
+	"bytes"
+	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
+	"image"
+	"io"
 	"log"
+	"net/http"
 	"os"
-	"os/exec"
 	"path/filepath"
+	"strings"
 
-	"github.com/rpsoftech/golang-servers/env"
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"github.com/google/uuid"
+	sohan_whatsapp_keys "github.com/rpsoftech/golang-servers/apps/sohan/whatsapp/keys"
 	whatsapp_config "github.com/rpsoftech/golang-servers/functions/whatsapp/config"
 	whatsapp_interfaces "github.com/rpsoftech/golang-servers/interfaces/whatsapp"
 	utility_functions "github.com/rpsoftech/golang-servers/utility/functions"
 	"github.com/rpsoftech/golang-servers/validator"
 )
 
-var ServerConfigFilePath = ""
-var ServerCmd *exec.Cmd
+type LoginStatusApiReponse struct {
+	Status int `json:"status"`
+}
+
+type QrCodeApiCallResponse struct {
+	QrCode     string `json:"qrCode"`
+	QrCodeData string `json:"qrCodeData"`
+}
 
 func init() {
-	CurrentDirectory := env.FindAndReturnCurrentDir()
-	ServerConfigFilePath = filepath.Join(CurrentDirectory, whatsapp_config.ServerConfigFileName)
+	// CurrentDirectory := env.FindAndReturnCurrentDir()
+	dirname, err := os.UserHomeDir()
+	if err != nil {
+		log.Fatal(err)
+	}
+	// fmt.Println(dirname)
+	sohan_whatsapp_keys.HomeDir = dirname
+	sohan_whatsapp_keys.ConfigDir = filepath.Join(dirname, ".wabot_service")
+	sohan_whatsapp_keys.ServerConfigFilePath = filepath.Join(sohan_whatsapp_keys.ConfigDir, whatsapp_config.ServerConfigFileName)
 }
 
-func ValidateConfig() bool {
-	if _, err := utility_functions.Exist(ServerConfigFilePath); errors.Is(err, os.ErrNotExist) {
-		panic(fmt.Errorf("CONFIG_NOT_EXIST_ON_PATH %s", ServerConfigFilePath))
+func ValidateConfig() (bool, *whatsapp_interfaces.IServerConfig) {
+	if _, err := utility_functions.Exist(sohan_whatsapp_keys.ServerConfigFilePath); errors.Is(err, os.ErrNotExist) {
+		// panic(fmt.Errorf("CONFIG_NOT_EXIST_ON_PATH %s", sohan_whatsapp_keys.ServerConfigFilePath))
+		return false, nil
 	}
-	_, err := readConfigFileAndReturniserverConfig(ServerConfigFilePath)
+	config, err := readConfigFileAndReturniserverConfig(sohan_whatsapp_keys.ServerConfigFilePath)
 	if err != nil {
-		return false
+		return false, nil
 		// panic(err)
 	}
-	return true
+	return true, config
 }
 
 func readConfigFileAndReturniserverConfig(configFilePath string) (*whatsapp_interfaces.IServerConfig, error) {
@@ -50,7 +72,15 @@ func readConfigFileAndReturniserverConfig(configFilePath string) (*whatsapp_inte
 		return nil, err
 	}
 	if errs := validator.Validator.Validate(config); len(errs) > 0 {
-		panic(fmt.Errorf("CONFIG_ERROR %#v", errs))
+		return nil, fmt.Errorf("CONFIG_ERROR %#v", errs)
+	}
+	if len(config.Tokens) == 0 {
+		return nil, errors.New("NO_TOKENS")
+	}
+	for token := range config.Tokens {
+		if _, err := ValidUUID(token); err != "" {
+			return nil, errors.New(err)
+		}
 	}
 	if config.JID == nil {
 		config.JID = make(map[string]string)
@@ -69,3 +99,106 @@ func SaveConfig(config *whatsapp_interfaces.IServerConfig) {
 		log.Fatal(err)
 	}
 }
+
+func CreateQRFromBase64(base64Str string) (*canvas.Image, error) {
+
+	data, err := base64.StdEncoding.DecodeString(base64Str)
+	if err != nil {
+		return nil, err
+	}
+
+	img, _, err := image.Decode(bytes.NewReader(data))
+	if err != nil {
+		return nil, err
+	}
+
+	qr := canvas.NewImageFromImage(img)
+
+	qr.FillMode = canvas.ImageFillContain
+
+	qr.SetMinSize(
+		fyne.NewSize(200, 200),
+	)
+
+	return qr, nil
+}
+
+//////////////////////////////////////////////////////
+// UUID VALIDATION
+//////////////////////////////////////////////////////
+
+func ValidUUID(uuidstring string) (bool, string) {
+	u, err := uuid.Parse(uuidstring)
+	if err != nil {
+		return false, fmt.Sprintf("String %q is invalid: %v\n", uuidstring, err)
+	}
+	// Check if it is specifically version 5
+	if u.Version() == 5 {
+		return true, ""
+	} else {
+		return false, fmt.Sprintf("It is UUID Version %d.\n", u.Version())
+	}
+}
+
+func QrCodeApiCall(token string) (bool, string) {
+	req, err := http.NewRequest("GET", sohan_whatsapp_keys.QRCODEURL, nil)
+
+	if err != nil {
+		fmt.Println(err)
+		return false, ""
+	}
+	req.Header.Add("X-Api-Token", token)
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		fmt.Println(err)
+		return false, ""
+	}
+	defer res.Body.Close()
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		fmt.Println(err)
+		return false, ""
+	}
+	if strings.Contains(string(body), "success") {
+		return false, ""
+	}
+	qrcodeRespo := new(QrCodeApiCallResponse)
+	err = json.Unmarshal(body, qrcodeRespo)
+	if err != nil {
+		fmt.Println(err)
+		return false, ""
+	}
+	return true, qrcodeRespo.QrCode
+}
+func LoginApiCall(token string) (bool, error) {
+	req, err := http.NewRequest("GET", sohan_whatsapp_keys.LoginStatusURL, nil)
+
+	if err != nil {
+		fmt.Println(err)
+		return false, err
+	}
+	req.Header.Add("X-Api-Token", token)
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		fmt.Println(err)
+		return false, err
+	}
+	defer res.Body.Close()
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		fmt.Println(err)
+		return false, err
+	}
+	statusRespo := new(LoginStatusApiReponse)
+	err = json.Unmarshal(body, statusRespo)
+	if err != nil {
+		fmt.Println(err)
+		return false, err
+	}
+	if statusRespo.Status == 1 {
+		return true, nil
+	} else {
+		return false, nil
+
+	}
+}

apps/sohan/whatsapp/keys/index.go

@@ -0,0 +1,11 @@
+package sohan_whatsapp_keys
+
+import "os/exec"
+
+var ServerConfigFilePath = ""
+var ServerCmd *exec.Cmd
+var HomeDir string
+var ConfigDir string
+
+const QRCODEURL = "http://localhost:4000/v1/qr_code"
+const LoginStatusURL = "http://localhost:4000/v1/status"