vali-tools/app.go

package main

import (
	"Vali-Tools/handlers" // 根据实际项目路径调整
	"Vali-Tools/utils"
	"context"
	"encoding/json"
	"fmt"
	"github.com/wailsapp/wails/v2/pkg/options"
	"github.com/wailsapp/wails/v2/pkg/runtime"
	"os"
	"os/exec"
	"strings"
)

// App struct
type App struct {
	ctx                  context.Context
	Token                string
	Env                  string
	directoryHandler     *handlers.DirectoryHandler
	dialogHandler        *handlers.DialogHandler
	UrlHost              string // 根据实际项目路径调整
	HomePage             string //首次要打开得页面路径
	handlerRequest       *handlers.HandlerRequests
	cameraMachineHandler *handlers.CameraMachineHandler
}

var wailsContext *context.Context

// NewApp creates a new App application struct
func NewApp() *App {
	return &App{}
}

// startup is called when the app starts
func (a *App) startup(ctx context.Context) {
	a.ctx = ctx
	wailsContext = &ctx
	a.directoryHandler = handlers.NewDirectoryHandler(ctx)
	a.dialogHandler = handlers.NewDialogHandler(ctx)
	fmt.Printf("All startup args: %v\n", os.Args)
	args := os.Args
	if len(args) > 1 {
		Args := args[1]
		paramsMap := a.parsArguments(Args)
		a.Token = paramsMap["token"]
		env := paramsMap["env"]
		page := paramsMap["page"]
		urlHost := "https://dev2.pubdata.cn"
		if env != "dev" && env != "" {
			urlHost = "https://dev2.valimart.net"
		}
		a.UrlHost = urlHost
		a.HomePage = page
		println("Token:", a.Token)
		println("UrlHost", a.UrlHost)
		a.handlerRequest = handlers.NewHandlerRequests(ctx, a.Token, a.UrlHost)
		a.cameraMachineHandler = handlers.NewCameraMachineHandler(ctx, a.Token)
		fmt.Printf("获取到了Token信息: %s\n", a.Token)
	}
}
func (a *App) onSecondInstanceLaunch(secondInstanceData options.SecondInstanceData) {
	secondInstanceArgs := secondInstanceData.Args
	println("user opened second instance", strings.Join(secondInstanceData.Args, ","))
	println("user opened second from", secondInstanceData.WorkingDirectory)
	runtime.WindowUnminimise(*wailsContext)
	runtime.Show(*wailsContext)
	go runtime.EventsEmit(*wailsContext, "launchArgs", secondInstanceArgs)
}

// 解析参数
func (a *App) parsArguments(params string) map[string]string {
	result := make(map[string]string)
	pairs := strings.Split(params, "&")

	for _, pair := range pairs {
		kv := strings.Split(pair, "=")
		if len(kv) == 2 {
			result[kv[0]] = kv[1]
		}
	}

	return result
}

type UserInfo struct {
	AccountName string `json:"account_name"`
	CompanyName string `json:"brand_company_name"`
	RealName    string `json:"real_name"`
}

// GetAppArgument 获取APP传递得参数
func (a *App) GetAppArgument() interface{} {
	if a.handlerRequest == nil {
		fmt.Printf("handlerRequest未初始化\n")
		return nil
	}
	info, err := a.handlerRequest.GetUserInfo()
	if err != nil {
		fmt.Printf("获取用户信息失败: %v\n", err)
		return nil
	}
	// 将 map 转换为 JSON 再解析为结构体
	// 安全地提取用户信息数据
	var userInfo interface{}
	if infoMap, ok := info.(map[string]interface{}); ok {
		if data, exists := infoMap["data"]; exists {
			userInfo = data
		} else {
			userInfo = infoMap
		}
	} else {
		userInfo = info
	}
	return map[string]interface {
	}{
		"token":     a.Token,
		"user_info": userInfo,
		"home_page": a.HomePage,
	}
}

// SelectDirectory 目录选择方法
func (a *App) SelectDirectory() (string, error) {
	return a.dialogHandler.SelectDirectory()
}

// HandlerDirectory 处理目录复制的主要方法
func (a *App) HandlerDirectory(sourceDir, targetDir string) error {
	return a.directoryHandler.HandlerDirectory(sourceDir, targetDir)
}

// HandlerOutPutDirectory 处理输出目录
func (a *App) HandlerOutPutDirectory() []handlers.ImageResult {
	applicationDirectory, err := a.directoryHandler.GetApplicationDirectory()
	if err != nil {
		return nil
	}
	directory, err := a.directoryHandler.HandlerOutPutDirectory(applicationDirectory + "/output")
	if err != nil {
		return []handlers.ImageResult{}
	}
	return directory
}

type PostJsonData struct {
	ImageUrl    string `json:"image_url"`
	GoodsArtNo  string `json:"goods_art_no"`
	Category    string `json:"category"`
	Description string `json:"description"`
	Price       string `json:"price"`
}

func (a *App) MakeProducts(imageProduct []handlers.ImageResult) map[string]interface{} {
	//	生成产品册
	var postData []PostJsonData
	for _, product := range imageProduct {
		result, err := a.handlerRequest.MakeFileRequest(utils.UploadImages, product.ImagePath, "file")
		if err != nil {
			fmt.Printf("上传图片失败: %v\n", err)
			continue
		}
		if resultMap, ok := result.(map[string]interface{}); ok {
			// 安全获取 data 字段
			dataValue, exists := resultMap["data"]
			if !exists {
				fmt.Println("响应中未找到 data 字段")
				continue
			}
			// 类型断言为 map[string]interface{}
			reqData, ok := dataValue.(map[string]interface{})
			if !ok {
				fmt.Printf("data字段类型不正确，期望map[string]interface{}，实际类型: %T\n", dataValue)
				continue
			}
			var imageUrl string
			if urlValue, exists := reqData["url"]; exists {
				// 安全转换为字符串
				switch v := urlValue.(type) {
				case string:
					imageUrl = v
				case fmt.Stringer:
					imageUrl = v.String()
				default:
					imageUrl = fmt.Sprintf("%v", v)
				}
			}
			// 安全获取各个字段并进行类型转换
			goodsArtNo := product.GoodsArtNo
			category := product.Category
			description := product.Description
			priceValue := product.Price
			// 添加到 postData
			postData = append(postData, PostJsonData{
				ImageUrl:    imageUrl,
				GoodsArtNo:  goodsArtNo,
				Category:    category,
				Description: description,
				Price:       priceValue,
			})
		}
	}
	HLMData := map[string]interface{}{
		"data": postData,
	}
	result, err := a.handlerRequest.MakePostRequest(utils.CreateProduct, HLMData)
	if err != nil {
		fmt.Printf("request err:%v\n", err)
		return nil
	}
	if resultMap, ok := result.(map[string]interface{}); ok {
		dataValue, exists := resultMap["data"]
		if !exists {
			return nil
		}
		reqData, _ := dataValue.(map[string]interface{})
		//a.UrlHost
		productIndex, _ := reqData["product_index"].(string)
		urlShuffix := "/product_catalog/index.html?product_index="
		// 检查 URL 是否包含特定域名
		HtmlUrl := "https://b2b2.valimart.net"
		if strings.Contains(a.UrlHost, "pubdata.cn") {
			// 处理 pubdata.cn 域名的逻辑
			HtmlUrl = "https://b2b2.pubdata.cn"
		}
		returnUrl := HtmlUrl + urlShuffix + productIndex
		fmt.Println("返回的URL:", returnUrl)
		return map[string]interface{}{
			"url": returnUrl,
		}
	}
	return nil
}

// GetPhotoList 获取拍照记录列表
func (a *App) GetPhotoList() (*handlers.PhotoRecordResponse, error) {
	request, err := a.handlerRequest.MakeGetRequest(handlers.GetPhotoRecordUrl)
	if err != nil {
		return nil, err
	}

	// 将返回结果转换为 map
	//resultMap, ok := request.(map[string]interface{})
	//if !ok {
	//	return nil, fmt.Errorf("无法将响应转换为 map")
	//}

	// 解析 JSON 数据
	jsonData, err := json.Marshal(request)
	if err != nil {
		return nil, fmt.Errorf("序列化响应数据失败: %v", err)
	}

	var response handlers.PhotoRecordResponse
	if err := json.Unmarshal(jsonData, &response); err != nil {
		return nil, fmt.Errorf("解析JSON数据失败: %v", err)
	}

	fmt.Printf("数据列表获取成功，共 %d 条记录\n", len(response.List))
	return &response, nil
}
func (a *App) GetPhotoListApp(page string) (*handlers.PhotoRecordResponse, error) {

	return a.cameraMachineHandler.GetPhotoList(page)
}

func (a *App) RemoveBackgroundApp(goodsArtNos []string) (string, error) {

	return a.cameraMachineHandler.RemoveBackground(goodsArtNos)
}
func (a *App) OpenFolder(path string) error {
	var cmd *exec.Cmd
	windowsPath := strings.ReplaceAll(path, "/", "\\")
	cmd = exec.Command("explorer", "/select,", windowsPath+"\\")
	return cmd.Start()
}