go_service/controllers/ParseController.go

package controller

import (
	"db_service/models"
	helper "db_service/pkg"
	"db_service/repositories"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"strconv"
	"strings"
	"time"
)

func ParseLink(w http.ResponseWriter, route *http.Request) {

	link := route.URL.Query().Get("url")

	helper.Info("link: ", link)

	if strings.Contains(link, "lcwaikiki.com"){
		ParseLinkLCW(link,w)
	}else {
		ParseLinkTY(link,w)
	}


}

func ParseLinkLCW(link string,w http.ResponseWriter) {
	start := time.Now()
	fmt.Println(link)
	linkParser := repositories.NewLCWScraper(link)

	product, err := linkParser.InitProductDetailParsing()

	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		json.NewEncoder(w).Encode(map[string]string{
			"msg": err.Error(),
		})
		fmt.Println(err)
		return
	}

	/////////////////////////////
	importRepo, err := repositories.ParseImporterInstance()

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		fmt.Println(err)
		return
	}
	//wait until initialization data is loaded to memory
	importRepo.ImportWGroup.Wait()
	log.Println(product);

	if err = importRepo.UpdateOrCreateLCW(product).Error; err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		fmt.Println(err)
		return
	}
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(map[string]string{
		"msg":            "Link parsed successfully",
		"productGroupId": product.ProductNumber,
	})

	elapsed := time.Since(start)
	log.Printf("end parse took %s", elapsed)
	return
}

func ParseLinkTY(link string,w http.ResponseWriter) {
	start := time.Now()

	linkParser := repositories.NewLinkParser(link)

	product, err := linkParser.ParseLink()

	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		json.NewEncoder(w).Encode(map[string]string{
			"msg": err.Error(),
		})
		fmt.Println(err)
		return
	}
	elapsed := time.Since(start)
	log.Printf("link parsed at %s", elapsed)
	jsonProduct, err := linkParser.GetProductDetailWithOptions(product.ID, product.ProductGroupID)

	elapsed = time.Since(start)
	log.Printf("product gat at %s", elapsed)


	if err != nil {
		helper.Error(err)
		return
	}
	/////////////////////////////
	importRepo, err := repositories.ImporterInstance()

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	//wait until initialization data is loaded to memory
	importRepo.ImportWGroup.Wait()

	if err = importRepo.UpdateOrCreate(jsonProduct).Error; err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(map[string]string{
		"msg":            "Link parsed successfully",
		"productGroupId": strconv.Itoa(product.ID),
	})
	elapsed = time.Since(start)
	log.Printf("imported at  %s", elapsed)
	return
	/////////////////////////////////////////

}

func ImportLink(w http.ResponseWriter, route *http.Request) {

	var product models.Product

	err := json.NewDecoder(route.Body).Decode(&product)

	if err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	/////////////////////////////
	importRepo, err := repositories.ImporterInstance()

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	//wait until initialization data is loaded to memory
	importRepo.ImportWGroup.Wait()

	if err = importRepo.UpdateOrCreate(product).Error; err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.WriteHeader(http.StatusOK)

	json.NewEncoder(w).Encode(map[string]string{
		"msg":            "Link parsed successfully",
		"productGroupId": product.ProductGroupID,
	})
}