NextZen-UserService/service/1panel.go

package service

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"log"
	"net/http"

	model2 "github.com/KaySar12/NextZen-UserService/service/model"
)

type OnePanelService interface {
	Login(m model2.OnePanelCredentials, baseURL string, entranceCode string) (model2.LoginResponse, []*http.Cookie, error)
	Logout(m model2.OnePanelCredentials, baseURL string) (model2.LogoutResponse, error)
	HealthCheck(baseURL string) (string, error)
	SearchInstalledApp(p model2.InstalledAppRequest, baseURL string) (model2.InstalledAppResponse, error)
	SearchWebsite(m model2.SearchWebsiteRequest, baseUrl string, headers map[string]string) (model2.SearchWebsiteResponse, error)
	CreateWebsite(m model2.CreateWebsiteRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error)
	DeleteWebsite(m model2.DeleteWebsiteRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error)
	GetProxyWebsite(m model2.ProxyWebsiteRequest, baseUrl string, headers map[string]string) (model2.ProxyWebsiteResponse, error)
	UpdateProxyWebsite(m model2.ProxyDetail, baseUrl string, headers map[string]string) (model2.GenericResponse, error)
	AcmeAccountSearch(m model2.AcmeSearchRequest, baseUrl string, headers map[string]string) (model2.AcmeSearchResponse, error)
	SelfSignedCertSearch(m model2.SelfSignedCertSearchRequest, baseUrl string, headers map[string]string) (model2.SelfSignedCertSearchResponse, error)
	IssueSelfSignedCert(m model2.SelfSignedIssueRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error)
	CreateSelfSignedCert(m model2.CreateSelfSignedCertRequest, baseUrl string, headers map[string]string) (model2.CreateSelfSignedCertResponse, error)
	ApplyWebsiteSSl(m model2.CreateSSLRequest, baseUrl string, headers map[string]string) (model2.CreateSSLResponse, error)
	SearchWebsiteSSl(m model2.SearchSSLRequest, baseUrl string, headers map[string]string) (model2.SearchSSLResponse, error)
	UpdateWebsiteProtocol(m model2.WebsiteHttpsConfigRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error)
	DeleteWebsiteSSL(m model2.DeleteSSLRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error)
	GetSSLDetail(sslId int, baseUrl string, headers map[string]string) (model2.SSLDetail, error)
}

var (
	prefixV1 = "/api/v1"
)

type onePanelService struct {
}

func (o *onePanelService) GetSSLDetail(sslId int, baseUrl string, headers map[string]string) (model2.SSLDetail, error) {
	path := baseUrl + fmt.Sprintf("/api/v1/websites/ssl/%d", sslId)

	req, err := http.NewRequest("GET", path, nil)
	if err != nil {
		return model2.SSLDetail{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.SSLDetail{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.SSLDetail{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.SSLDetail
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.SSLDetail{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) DeleteWebsiteSSL(m model2.DeleteSSLRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error) {
	path := baseUrl + "/api/v1/websites/ssl/del"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.GenericResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.GenericResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) UpdateWebsiteProtocol(m model2.WebsiteHttpsConfigRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error) {
	path := baseUrl + fmt.Sprintf("/api/v1/websites/%d/https", m.WebsiteID)
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.GenericResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.GenericResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) SelfSignedCertSearch(m model2.SelfSignedCertSearchRequest, baseUrl string, headers map[string]string) (model2.SelfSignedCertSearchResponse, error) {
	path := baseUrl + "/api/v1/websites/ca/search"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.SelfSignedCertSearchResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.SelfSignedCertSearchResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.SelfSignedCertSearchResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.SelfSignedCertSearchResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.SelfSignedCertSearchResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.SelfSignedCertSearchResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) CreateSelfSignedCert(m model2.CreateSelfSignedCertRequest, baseUrl string, headers map[string]string) (model2.CreateSelfSignedCertResponse, error) {
	path := baseUrl + "/api/v1/websites/ca"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.CreateSelfSignedCertResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.CreateSelfSignedCertResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.CreateSelfSignedCertResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.CreateSelfSignedCertResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.CreateSelfSignedCertResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.CreateSelfSignedCertResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) IssueSelfSignedCert(m model2.SelfSignedIssueRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error) {
	path := baseUrl + "/api/v1/websites/ca/obtain"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.GenericResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.GenericResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) SearchWebsiteSSl(m model2.SearchSSLRequest, baseUrl string, headers map[string]string) (model2.SearchSSLResponse, error) {
	path := baseUrl + "/api/v1/websites/ssl/search"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.SearchSSLResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.SearchSSLResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.SearchSSLResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.SearchSSLResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.SearchSSLResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.SearchSSLResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) ApplyWebsiteSSl(m model2.CreateSSLRequest, baseUrl string, headers map[string]string) (model2.CreateSSLResponse, error) {
	path := baseUrl + "/api/v1/websites/ssl"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.CreateSSLResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.CreateSSLResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.CreateSSLResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.CreateSSLResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.CreateSSLResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.CreateSSLResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) AcmeAccountSearch(m model2.AcmeSearchRequest, baseUrl string, headers map[string]string) (model2.AcmeSearchResponse, error) {
	path := baseUrl + "/api/v1/websites/acme/search"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.AcmeSearchResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.AcmeSearchResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.AcmeSearchResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.AcmeSearchResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.AcmeSearchResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.AcmeSearchResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) UpdateProxyWebsite(m model2.ProxyDetail, baseUrl string, headers map[string]string) (model2.GenericResponse, error) {
	path := baseUrl + "/api/v1/websites/proxies/update"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error making request: %v", err)
	}

	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.GenericResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.GenericResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}

func (o *onePanelService) GetProxyWebsite(m model2.ProxyWebsiteRequest, baseUrl string, headers map[string]string) (model2.ProxyWebsiteResponse, error) {
	path := baseUrl + "/api/v1/websites/proxies"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.ProxyWebsiteResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.ProxyWebsiteResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.ProxyWebsiteResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.ProxyWebsiteResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.ProxyWebsiteResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.ProxyWebsiteResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) SearchWebsite(m model2.SearchWebsiteRequest, baseUrl string, headers map[string]string) (model2.SearchWebsiteResponse, error) {
	path := baseUrl + "/api/v1/websites/search"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.SearchWebsiteResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.SearchWebsiteResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.SearchWebsiteResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.SearchWebsiteResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.SearchWebsiteResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.SearchWebsiteResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) CreateWebsite(m model2.CreateWebsiteRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error) {
	path := baseUrl + "/api/v1/websites"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.GenericResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.GenericResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) DeleteWebsite(m model2.DeleteWebsiteRequest, baseUrl string, headers map[string]string) (model2.GenericResponse, error) {
	path := baseUrl + "/api/v1/websites/del"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	// Add headers to the request
	for key, value := range headers {
		req.Header.Set(key, value)
	}

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.GenericResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.GenericResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.GenericResponse{}, fmt.Errorf("error decoding response: %v", err)
	}
	return result, nil
}
func (o *onePanelService) SearchInstalledApp(m model2.InstalledAppRequest, baseUrl string) (model2.InstalledAppResponse, error) {
	path := baseUrl + "/api/v1/websites/search"
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.InstalledAppResponse{}, fmt.Errorf("error marshaling request body: %v", err)
	}
	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	// req.AddCookie()
	if err != nil {
		return model2.InstalledAppResponse{}, fmt.Errorf("error creating request: %v", err)
	}
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return model2.InstalledAppResponse{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.InstalledAppResponse{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}
	var result model2.InstalledAppResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.InstalledAppResponse{}, fmt.Errorf("error decoding response: %v", err)
	}

	return result, nil
}
func (o *onePanelService) Login(m model2.OnePanelCredentials, baseURL string, entranceCode string) (model2.LoginResponse, []*http.Cookie, error) {
	path := baseURL + prefixV1 + "/auth/login"

	// Create the request body by marshaling the credentials into JSON
	reqBody, err := json.Marshal(m)
	if err != nil {
		return model2.LoginResponse{}, []*http.Cookie{}, fmt.Errorf("error marshaling request body: %v", err)
	}

	req, err := http.NewRequest("POST", path, bytes.NewReader(reqBody))
	if err != nil {
		return model2.LoginResponse{}, []*http.Cookie{}, fmt.Errorf("error creating request: %v", err)
	}
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")
	req.Header.Set("Entrancecode", base64.StdEncoding.EncodeToString([]byte(entranceCode)))
	// Reuse the HTTP client (consider making it a field in onePanelService)
	client := &http.Client{}
	resp, err := client.Do(req)
	cookies := resp.Cookies()
	if err != nil {
		return model2.LoginResponse{}, []*http.Cookie{}, fmt.Errorf("error making request: %v", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return model2.LoginResponse{}, []*http.Cookie{}, fmt.Errorf("HTTP error: %s", resp.Status)
	}

	var result model2.LoginResponse
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		return model2.LoginResponse{}, []*http.Cookie{}, fmt.Errorf("error decoding response: %v", err)
	}

	return result, cookies, nil
}

func (o *onePanelService) Logout(m model2.OnePanelCredentials, baseURL string) (model2.LogoutResponse, error) {
	return model2.LogoutResponse{}, nil
}

func (o *onePanelService) HealthCheck(baseURL string) (string, error) {
	path := baseURL + "/health"
	req, err := http.NewRequest("GET", path, nil)
	if err != nil {
		log.Println("Error creating health/live request:", err)
		return "Offline", err
	}
	client := &http.Client{
		CheckRedirect: func(req *http.Request, via []*http.Request) error {
			return nil // Always follow redirects
		},
	}
	respLive, err := client.Do(req)
	if err != nil {
		log.Println("Error on health/live request:", err)
		return "Offline", err // Exit if the request fails
	}
	defer respLive.Body.Close()
	if respLive.StatusCode == http.StatusOK {
		return "Live", nil
	}
	return "Offline", err
}

func NewOnePanelService() OnePanelService {
	return &onePanelService{}
}