GoEthemineTelegramBot/internal/database/handlers.go

package database

import (
	"fmt"
	"time"
	"math"

	ethmineapi "gogs.veloe.link/toomanysugar/GoEthemineTelegramBot/api/ethermineapi"
	"gogs.veloe.link/toomanysugar/GoEthemineTelegramBot/cmd/settings"
	log "gogs.veloe.link/toomanysugar/GoEthemineTelegramBot/internal/logger"
)

func (c *Connection) AddUser(chatId int64) (string, error) {
	// Check if user already registered
	var userCount int64
	result := c.GormDb.Model(&User{}).
		Where("chat_id = ?", chatId).
		Count(&userCount)
	if result.Error != nil {
		return "", fmt.Errorf("failed creating user: %w", result.Error)
	}
	if userCount != 0 {
		return "Already registered", nil
	}

	// Adding new user to database
	newUser := User{ChatId: chatId}
	result = c.GormDb.Create(newUser)
	if result.Error != nil {
		return "", fmt.Errorf("failed creating user: %w", result.Error)
	}
	log.LogInfo.Println("User was created:", newUser)
	return "Added new user to database. Now you can connect your miner wallet using command /setwallet <address>", nil
}

func (c *Connection) DeleteUser(chatId int64) (string, error) {
	// Check for user existance
	var userCount int64
	result := c.GormDb.Model(&User{}).
		Where("chat_id = ?", chatId).
		Count(&userCount)
	if result.Error != nil {
		return "", fmt.Errorf("failed creating user: %w", result.Error)
	}
	if userCount == 0 {
		return "Already deleted", nil
	}

	// Taking target for deletion
	var user User
	result = c.GormDb.Take(&user, "chat_id = ?", chatId)
	if result.Error != nil {
		return "", fmt.Errorf("failed querying user: %w", result.Error)
	}

	var walletHoldersCount int64
	result = c.GormDb.Model(&User{}).
		Where("wallet = ?", user.Wallet).
		Count(&walletHoldersCount)
	if result.Error != nil {
		return "", fmt.Errorf("failed querying user: %w", result.Error)
	}

	// TODO Remove code repition
	if walletHoldersCount > 1 {
		// Wallet in multiple chats
		result = c.GormDb.Where("chat_id = ?", chatId).Delete(User{})
		if result.Error != nil {
			return "", fmt.Errorf("failed deleting user: %w", result.Error)
		}
	} else {
		// Wallet in single chat
		result = c.GormDb.Where("chat_id = ?", chatId).Delete(User{})
		if result.Error != nil {
			return "", fmt.Errorf("failed deleting user: %w", result.Error)
		}

		result = c.GormDb.Where("wallet = ?", user.Wallet).Delete(Miner{})
		if result.Error != nil {
			return "", fmt.Errorf("failed deleting miner: %w", result.Error)
		}
		log.LogInfo.Println("Miners deleted with wallet:", user.Wallet)

		result = c.GormDb.Where("wallet = ?", user.Wallet).Delete(Worker{})
		if result.Error != nil {
			return "", fmt.Errorf("failed deleting workers: %w", result.Error)
		}
		log.LogInfo.Println("Workers deleted with wallet:", user.Wallet)

		result = c.GormDb.Where("wallet = ?", user.Wallet).Delete(Payout{})
		if result.Error != nil {
			return "", fmt.Errorf("failed deleting payouts: %w", result.Error)
		}
		log.LogInfo.Println("Payouts deleted for wallet:", user.Wallet)
	}

	log.LogInfo.Println("User was deleted:", user)
	return "Done!", nil
}

func (c *Connection) GetLastPayout(chatId int64) string {
	errMsgToUser := "An exception occurred on sending messages while executing /actual command"

	var wallet string
	result := c.GormDb.Model(&User{}).
		Where(User{ChatId: chatId}).
		Select("wallet").
		Scan(&wallet)
	if result.Error != nil {
		log.LogError.Println(result.Error)
		return errMsgToUser
	}
	if wallet == "" {
		return "Set wallet at first! Use /setwallet"
	}

	var payoutTime int64
	result = c.GormDb.Model(&Payout{}).
		Where(&Payout{Wallet: wallet}).
		Order("time desc").
		Limit(1).
		Select("time").
		Scan(&payoutTime)
	if result.Error != nil {
		log.LogInfo.Printf("No payouts data for %s! Time is set to 0!", wallet)
		log.LogError.Println(result.Error)
		payoutTime = 0
	}

	// NOTE Pointless if previous 'if' statement occurs
	// Must go from the start to line 235
	var dbPayoutRecords []Payout
	result = c.GormDb.
		Where(&Payout{Wallet: wallet, Time: payoutTime}).
		Find(&dbPayoutRecords)
	//Line 560 of Program.cs
	if len(dbPayoutRecords) == 0 {
		url := fmt.Sprintf("%s/miner/%s/payouts", settings.ApiUrl(), wallet)
		var payouts ethmineapi.JsonPayouts
		err := ethmineapi.UnmasrshalFromUrl(url, &payouts)
		if err != nil {
			log.LogError.Println(err)
			return fmt.Sprintf("No payout data for %s", wallet)
		}
		lastPayout := payouts.Data[0]

		message := fmt.Sprintf("Payout date: %s\n", time.Unix(lastPayout.PaidOn, 0).Format("Monday, January 2, 2006 3:04 PM"))
		message += fmt.Sprintf("Amount: %.5f %s\n", float64(lastPayout.Amount)/math.Pow10(18), settings.Currency())
		message += "Data source: Ethermine API \n"

		return message
	}
	if result.Error != nil {
		log.LogError.Println(result.Error)
		return errMsgToUser
	}

	//Line 545 of Program.cs
	message := fmt.Sprintf("Payout date: %s\n", time.Unix(dbPayoutRecords[0].Time, 0).Format("Monday, January 2, 2006 3:04 PM"))
	message += fmt.Sprintf("Amount: %.5f ETH\n", float64(dbPayoutRecords[0].Amount)/math.Pow10(18))

	for _, payoutRecord := range dbPayoutRecords {
		message += fmt.Sprintf("Worker %s paid: %.5f %s\n",
			payoutRecord.Worker,
			float64(payoutRecord.Amount)/math.Pow10(18),
			settings.Currency())
	}

	message += "Data source: Bot database \n"

	return message
}