signet-backend/endpoints/createrewardfund.go

package endpoints

import (
	"encoding/json"
	"fmt"
	"net/http"

	"github.com/imosed/signet/auth"
	. "github.com/imosed/signet/data"
	"github.com/imosed/signet/utils"
	"github.com/rs/zerolog/log"
	"github.com/stellar/go/clients/horizonclient"
)

type CreateRewardFundRequest struct {
	Asset           string  `json:"asset"`
	FundWallet      string  `json:"fundWallet"`
	FundSecret      string  `json:"fundSecret"`
	SellingWallet   string  `json:"sellingWallet"`
	IssuerWallet    string  `json:"issuerWallet"`
	Memo            string  `json:"memo"`
	MinContribution float64 `gorm:"type:decimal(19,7)" json:"minContribution"`
	TelegramLink    string  `json:"telegramLink"`
	QueueID         uint    `json:"queueID"`
	Bonuses         []Bonus `json:"bonuses"`
}

type SuccessResponse struct {
	Success bool `json:"success"`
}

func CreateRewardFund(resp http.ResponseWriter, req *http.Request) {
	var fund CreateRewardFundRequest
	dec := json.NewDecoder(req.Body)
	err := dec.Decode(&fund)
	if err != nil {
		log.Error().Err(err).Msg("Could not read submitted reward fund")
		return
	}

	var bonuses []Bonus

	rewardFund := RewardFund{
		Asset:           fund.Asset,
		FundWallet:      fund.FundWallet,
		FundSecret:      fund.FundSecret,
		SellingWallet:   fund.SellingWallet,
		IssuerWallet:    fund.IssuerWallet,
		Memo:            fund.Memo,
		Price:           0,
		AmountAvailable: 0,
		MinContribution: fund.MinContribution,
		TelegramLink:    fund.TelegramLink,
		Contributions:   nil,
	}

	var fundsInQueue []RewardFund
	Db.Table("queue_reward_funds").Where("queue_id = ?", fund.QueueID).Scan(&fundsInQueue)
	next := uint16(len(fundsInQueue))

	joinRecord := QueueOrder{QueueID: fund.QueueID, RewardFundID: rewardFund.ID, Order: next}

	offerReq := horizonclient.OfferRequest{
		Seller:  rewardFund.SellingWallet,
		Selling: fmt.Sprintf("%s:%s", rewardFund.Asset, rewardFund.IssuerWallet),
		Order:   horizonclient.OrderDesc,
	}

	if err, ok := utils.FindOffer(offerReq, &rewardFund); !ok {
		err = json.NewEncoder(resp).Encode(&SuccessResponse{Success: ok})
		if err != nil {
			log.Error().Err(err).Msg("Could not deliver response after failing to find issuer offer")
		}
		return
	}
	if err != nil {
		log.Error().Err(err).Msg("Could not find issuer offer")
		return
	}

	var claims *auth.Claims
	claims, err = auth.GetUserClaims(req)
	if err != nil {
		log.Error().Err(err).Msg("Could not determine if user is authenticated")
		return
	}

	if claims == nil {
		resp.WriteHeader(401)
		return
	}
	if claims.Privileges > Admin {
		resp.WriteHeader(403)
		return
	}

	Db.Create(&rewardFund)
	Db.Create(&joinRecord)

	for _, cancel := range cancellations {
		cancel()
	}
	go InitializeContributionStreams()

	for _, bonus := range fund.Bonuses {
		bonus.RewardFundID = rewardFund.ID
		bonuses = append(bonuses, bonus)
	}
	Db.Create(&bonuses)

	err = json.NewEncoder(resp).Encode(&SuccessResponse{Success: true})
	if err != nil {
		log.Error().Err(err).Msg("Could not create response for created reward fund")
	}
}