canopusgo.go

package canopusgo

import (
	"bytes"
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"crypto/x509"
	"encoding/base64"
	"encoding/json"
	"encoding/pem"
	"errors"
	"fmt"
	"io/ioutil"
	"net/http"
)

type Canopus struct {
	Type        string // snap | api
	MerchantKey []byte
	MerchantPem []byte
	MerchantID  string
	Secret      string
	Client      *http.Client
	Token       string
}

// TODO: create validation in parameter for each function
func CreateService(init InitService) (*Canopus, error) {
	if len(init.MerchantPem) == 0 {
		return &Canopus{}, errors.New("field MerchantPem cannot empty")
	}
	if len(init.MerchantKey) == 0 {
		return &Canopus{}, errors.New("field MerchantKey cannot empty")
	}
	if init.MerchantID == "" {
		return &Canopus{}, errors.New("field MerchantID cannot empty")
	}
	if init.Secret == "" {
		return &Canopus{}, errors.New("field Secret cannot empty")
	}

	canType := DefaultType
	timeout := DefaultDuration

	if init.Type != "" {
		canType = init.Type
	}
	if init.TimeOut != 0 {
		timeout = init.TimeOut
	}

	client := &http.Client{Timeout: timeout}
	return &Canopus{
		Type:        canType,
		MerchantKey: init.MerchantKey,
		MerchantPem: init.MerchantPem,
		MerchantID:  init.MerchantID,
		Secret:      init.Secret,
		Client:      client,
	}, nil
}

// GenerateSignature ...
func (cano *Canopus) GenerateSignature(payload []byte) (string, error) {
	var signature string
	var err error

	block, _ := pem.Decode(cano.MerchantKey)
	if block == nil {
		err = errors.New("failed to decode key file")
		return signature, err
	}

	privKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return signature, err
	}

	hashed := sha256.Sum256(payload)

	s, err := rsa.SignPKCS1v15(rand.Reader, privKey, crypto.SHA256, hashed[:])
	if err != nil {
		return signature, err
	}

	signature = base64.StdEncoding.EncodeToString(s)

	return signature, err
}

// GetToken ...
func (cano *Canopus) GetToken() (string, error) {
	url := fmt.Sprintf("%v/api/v1/merchants/%v/token", BaseURL, cano.MerchantID)
	body := make(map[string]string)
	body["secret"] = cano.Secret
	bodyJson, _ := json.Marshal(body)
	signature, err := cano.GenerateSignature(bodyJson)
	if err != nil {
		return "", err
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyJson))

	if err != nil {
		return "", err
	}

	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("X-Signature", signature)

	resp, err := cano.Client.Do(req)
	if err != nil {
		return "", err
	}
	response, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		errMsg := fmt.Sprintf("error http code: %v", resp.StatusCode)
		return "", errors.New(errMsg)
	}

	respResult, err := ValidateResponse(response)
	if err != nil {
		return "", err
	}

	token := respResult.Response.Data["token"].(string)
	if token == "invalid" || len(token) <= 0 {
		return "", errors.New("invalid token")
	}

	// set new token to struct
	cano.Token = token
	return token, nil
}

// GetAvailableMethod Get all available method by merhantID
func (cano *Canopus) GetAvailableMethod(amount float64) ([]PaymentMethod, error) {
	url := fmt.Sprintf("%v/api/v1/merchants/%v/method", BaseURL, cano.MerchantID)
	body := make(map[string]interface{})
	body["MerchantID"] = cano.MerchantID
	body["amount"] = amount
	bodyJson, _ := json.Marshal(body)
	signature, err := cano.GenerateSignature(bodyJson)
	if err != nil {
		return []PaymentMethod{}, err
	}

	req, err := http.NewRequest("GET", url, bytes.NewBuffer(bodyJson))

	if err != nil {
		return []PaymentMethod{}, err
	}

	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("X-Signature", signature)

	resp, err := cano.Client.Do(req)
	if err != nil {
		return []PaymentMethod{}, err
	}
	response, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return []PaymentMethod{}, err
	}

	defer resp.Body.Close()

	respResult, err := ValidateResponse(response)
	if err != nil {
		return []PaymentMethod{}, err
	}

	_, err = VerifySignature(cano.MerchantPem, response, respResult.Signature)
	if err != nil {
		return []PaymentMethod{}, err
	}

	var result []PaymentMethod
	for _, payment := range respResult.Response.Data["method"].([]interface{}) {
		var tmp PaymentMethod
		paymentJson, err := json.Marshal(payment)
		if err != nil {
			return []PaymentMethod{}, err
		}
		err = json.Unmarshal(paymentJson, &tmp)
		if err != nil {
			return []PaymentMethod{}, err
		}
		result = append(result, tmp)
	}

	return result, nil
}

func (cano *Canopus) GenerateCart(payload CartPayload, paymentMethod PaymentMethod) (CartResponse, error) {
	var url string

	if cano.Type == "snap" {
		url = fmt.Sprintf("%v/api/v1/merchants/%v/%v", BaseURL, cano.MerchantID, "snap/cart")
	} else {
		url = fmt.Sprintf("%v/api/v1/merchants/%v/%v", BaseURL, cano.MerchantID, "cart")
	}

	bodyJson, _ := json.Marshal(payload)
	signature, err := cano.GenerateSignature(bodyJson)
	if err != nil {
		return CartResponse{}, err
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(bodyJson))

	if err != nil {
		return CartResponse{}, err
	}

	if cano.Token == "" {
		cano.GetToken()
	}

	req.Header.Add("Content-Type", "application/json")
	req.Header.Add("X-Signature", signature)
	req.Header.Add("authorization", "Bearer "+cano.Token)

	resp, err := cano.Client.Do(req)
	if err != nil {
		return CartResponse{}, err
	}
	response, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return CartResponse{}, err
	}
	defer resp.Body.Close()

	respResult, err := ValidateResponse(response)
	if err != nil {
		return CartResponse{}, err
	}

	// TODO: cannot varifysignature, return false
	// _, err = VerifySignature(cano.MerchantPem, response, respResult.Signature)
	// if err != nil {
	// 	return CartResponse{}, err
	// }

	var result CartResponse
	switch paymentMethod.Type {
	case "op":
		result.CartID = respResult.Response.Data["cartID"].(string)
		result.PayTo = respResult.Response.Data["checkoutURL"].(string)
	case "va":
		result.Bank = respResult.Response.Data["payment"].(string)
		result.Number = respResult.Response.Data["number"].(string)
		result.Amount = respResult.Response.Data["amount"].(string)
	case "bt":
		result.Bank = respResult.Response.Data["bank"].(string)
		result.Number = respResult.Response.Data["account"].(string)
		result.Amount = respResult.Response.Data["amountTotal"].(string)
	case "cc":
		result.CartID = respResult.Response.Data["cartID"].(string)
		result.PayTo = respResult.Response.Data["checkoutURL"].(string)
	}

	return result, nil
}