status-go/server/qrops.go

package server

import (
	"bytes"
	"encoding/base64"
	"errors"
	"fmt"
	"image"
	"net/url"
	"strconv"

	"github.com/yeqown/go-qrcode/v2"
	"github.com/yeqown/go-qrcode/writer/standard"
	"go.uber.org/zap"

	"github.com/status-im/status-go/images"
	"github.com/status-im/status-go/multiaccounts"
)

type WriterCloserByteBuffer struct {
	*bytes.Buffer
}

func (wc WriterCloserByteBuffer) Close() error {
	return nil
}

func NewWriterCloserByteBuffer() *WriterCloserByteBuffer {
	return &WriterCloserByteBuffer{bytes.NewBuffer([]byte{})}
}

type QRConfig struct {
	DecodedQRURL    string
	WithLogo        bool
	CorrectionLevel qrcode.EncodeOption
	KeyUID          string
	ImageName       string
	Size            int
	Params          url.Values
}

func NewQRConfig(params url.Values, logger *zap.Logger) (*QRConfig, error) {
	config := &QRConfig{}
	config.Params = params
	err := config.setQrURL()

	if err != nil {
		logger.Error("[qrops-error] error in setting QRURL", zap.Error(err))
		return nil, err
	}

	config.setAllowProfileImage()
	config.setErrorCorrectionLevel()
	err = config.setSize()

	if err != nil {
		logger.Error("[qrops-error] could not convert string to int for size param ", zap.Error(err))
		return nil, err
	}

	if config.WithLogo {
		err = config.setKeyUID()

		if err != nil {
			logger.Error(err.Error())
			return nil, err
		}

		config.setImageName()
	}

	return config, nil
}

func (q *QRConfig) setQrURL() error {
	qrURL, ok := q.Params["url"]

	if !ok || len(qrURL) == 0 {
		return errors.New("[qrops-error] no qr url provided")
	}

	decodedURL, err := base64.StdEncoding.DecodeString(qrURL[0])

	if err != nil {
		return err
	}

	q.DecodedQRURL = string(decodedURL)
	return nil
}

func (q *QRConfig) setAllowProfileImage() {
	allowProfileImage, ok := q.Params["allowProfileImage"]

	if !ok || len(allowProfileImage) == 0 {
		// we default to false when this flag was not provided
		// so someone does not want to allowProfileImage on their QR Image
		// fine then :)
		q.WithLogo = false
	}

	LogoOnImage, err := strconv.ParseBool(allowProfileImage[0])

	if err != nil {
		// maybe for fun someone tries to send non-boolean values to this flag
		// we also default to false in that case
		q.WithLogo = false
	}

	// if we reach here its most probably true
	q.WithLogo = LogoOnImage
}

func (q *QRConfig) setErrorCorrectionLevel() {
	level, ok := q.Params["level"]
	if !ok || len(level) == 0 {
		// we default to MediumLevel of error correction when the level flag
		// is not passed.
		q.CorrectionLevel = qrcode.WithErrorCorrectionLevel(qrcode.ErrorCorrectionMedium)
	}

	levelInt, err := strconv.Atoi(level[0])
	if err != nil || levelInt < 0 {
		// if there is any issue with string to int conversion
		// we still default to MediumLevel of error correction
		q.CorrectionLevel = qrcode.WithErrorCorrectionLevel(qrcode.ErrorCorrectionMedium)
	}

	switch levelInt {
	case 1:
		q.CorrectionLevel = qrcode.WithErrorCorrectionLevel(qrcode.ErrorCorrectionLow)
	case 2:
		q.CorrectionLevel = qrcode.WithErrorCorrectionLevel(qrcode.ErrorCorrectionMedium)
	case 3:
		q.CorrectionLevel = qrcode.WithErrorCorrectionLevel(qrcode.ErrorCorrectionQuart)
	case 4:
		q.CorrectionLevel = qrcode.WithErrorCorrectionLevel(qrcode.ErrorCorrectionHighest)
	default:
		q.CorrectionLevel = qrcode.WithErrorCorrectionLevel(qrcode.ErrorCorrectionMedium)
	}
}

func (q *QRConfig) setSize() error {
	size, ok := q.Params["size"]

	if ok {
		imageToBeResized, err := strconv.Atoi(size[0])

		if err != nil {
			return err
		}

		if imageToBeResized <= 0 {
			return errors.New("[qrops-error] Got an invalid size parameter, it should be greater than zero")
		}

		q.Size = imageToBeResized

	}

	return nil
}

func (q *QRConfig) setKeyUID() error {
	keyUID, ok := q.Params["keyUid"]
	// the keyUID was not passed, which is a requirement to get the multiaccount image,
	// so we log this error
	if !ok || len(keyUID) == 0 {
		return errors.New("[qrops-error] A keyUID is required to put logo on image and it was not passed in the parameters")
	}

	q.KeyUID = keyUID[0]
	return nil
}

func (q *QRConfig) setImageName() {
	imageName, ok := q.Params["imageName"]
	//if the imageName was not passed, we default to const images.LargeDimName
	if !ok || len(imageName) == 0 {
		q.ImageName = images.LargeDimName
	}

	q.ImageName = imageName[0]
}

func ToLogoImageFromBytes(imageBytes []byte, padding int) ([]byte, error) {
	img, _, err := image.Decode(bytes.NewReader(imageBytes))
	if err != nil {
		return nil, fmt.Errorf("decoding image failed: %v", err)
	}
	paddedImg := images.AddPadding(img, padding)
	circle := images.CreateCircle(img)
	centeredImg := images.PlaceCircleInCenter(paddedImg, circle)
	resultBytes, err := images.EncodePNG(centeredImg)
	if err != nil {
		return nil, fmt.Errorf("encoding PNG failed: %v", err)
	}
	return resultBytes, nil
}

func GetLogoImage(multiaccountsDB *multiaccounts.Database, keyUID string, imageName string) ([]byte, error) {
	var (
		padding   int
		LogoBytes []byte
	)

	staticImageData, err := images.Asset("_assets/tests/qr/status.png")
	if err != nil { // Asset was not found.
		return nil, err
	}
	identityImageObjectFromDB, err := multiaccountsDB.GetIdentityImage(keyUID, imageName)

	if err != nil {
		return nil, err
	}

	if identityImageObjectFromDB == nil {
		padding = GetPadding(staticImageData)
		LogoBytes, err = ToLogoImageFromBytes(staticImageData, padding)
	} else {
		padding = GetPadding(identityImageObjectFromDB.Payload)
		LogoBytes, err = ToLogoImageFromBytes(identityImageObjectFromDB.Payload, padding)
	}

	return LogoBytes, err
}

func GetPadding(imgBytes []byte) int {
	const (
		defaultPadding = 20
	)
	size, _, err := images.GetImageDimensions(imgBytes)
	if err != nil {
		return defaultPadding
	}
	return size / 5
}

func generateQRBytes(params url.Values, logger *zap.Logger, multiaccountsDB *multiaccounts.Database) []byte {

	qrGenerationConfig, err := NewQRConfig(params, logger)

	if err != nil {
		logger.Error("could not generate QRConfig please rectify the errors with input parameters", zap.Error(err))
		return nil
	}

	qrc, err := qrcode.NewWith(qrGenerationConfig.DecodedQRURL,
		qrcode.WithEncodingMode(qrcode.EncModeAuto),
		qrGenerationConfig.CorrectionLevel,
	)

	if err != nil {
		logger.Error("could not generate QRCode with provided options", zap.Error(err))
		return nil
	}

	buf := NewWriterCloserByteBuffer()
	nw := standard.NewWithWriter(buf)
	err = qrc.Save(nw)

	if err != nil {
		logger.Error("could not save image", zap.Error(err))
		return nil
	}

	payload := buf.Bytes()

	if qrGenerationConfig.WithLogo {
		logo, err := GetLogoImage(multiaccountsDB, qrGenerationConfig.KeyUID, qrGenerationConfig.ImageName)

		if err != nil {
			logger.Error("could not get logo image from multiaccountsDB", zap.Error(err))
			return nil
		}

		qrWidth, qrHeight, err := images.GetImageDimensions(payload)

		if err != nil {
			logger.Error("could not get image dimensions from payload", zap.Error(err))
			return nil
		}

		logo, err = images.ResizeImage(logo, qrWidth/5, qrHeight/5)

		if err != nil {
			logger.Error("could not resize logo image ", zap.Error(err))
			return nil
		}

		payload = images.SuperimposeLogoOnQRImage(payload, logo)
	}

	if qrGenerationConfig.Size > 0 {

		payload, err = images.ResizeImage(payload, qrGenerationConfig.Size, qrGenerationConfig.Size)

		if err != nil {
			logger.Error("could not resize final logo image ", zap.Error(err))
			return nil
		}
	}

	return payload

}