Feat/track metrics

Contribution.md

@@ -15,3 +15,7 @@
 - Folders should be named in camel case i.e (peopleData)
 - Typescript files should be named in camel case also
 - Only the index.tsx files should be named in small letters
+
+### Prettier Fixing
+
+- Make sure you run ```yarn run prettier``` to fix prettier error before submitting

README.md

@@ -93,6 +93,24 @@ Meme image upload works with Relay enabled, so a running Relay is required for M
     MEME_URL=
 ```
 
+### Add REDIS for cache
+
+- Create a Redis instance
+- Create a .env file and populate the .env files with these variables
+
+If you have a Redis url add the REDIS_URL variable to .env
+
+```REDIS_URL = ```
+
+else add these variables to the env to enable Redis
+
+```
+    REDIS_HOST =
+    REDIS_DB =
+    REDIS_USER =
+    REDIS_PASS =
+```
+
 ### For Contributions
 
 Read the contribution doc [here](./Contribution.md)

auth/auth.go

@@ -83,6 +83,79 @@ func PubKeyContext(next http.Handler) http.Handler {
 	})
 }
 
+// PubKeyContext parses pukey from signed timestamp
+func PubKeyContextSuperAdmin(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		token := r.URL.Query().Get("token")
+		if token == "" {
+			token = r.Header.Get("x-jwt")
+		}
+
+		if token == "" {
+			fmt.Println("[auth] no token")
+			http.Error(w, http.StatusText(401), 401)
+			return
+		}
+
+		isJwt := strings.Contains(token, ".") && !strings.HasPrefix(token, ".")
+
+		if isJwt {
+			claims, err := DecodeJwt(token)
+
+			if err != nil {
+				fmt.Println("Failed to parse JWT")
+				http.Error(w, http.StatusText(401), 401)
+				return
+			}
+
+			if claims.VerifyExpiresAt(time.Now().UnixNano(), true) {
+				fmt.Println("Token has expired")
+				http.Error(w, http.StatusText(401), 401)
+				return
+			}
+
+			pubkey := fmt.Sprintf("%v", claims["pubkey"])
+			if !AdminCheck(pubkey) {
+				fmt.Println("Not a super admin")
+				http.Error(w, http.StatusText(401), 401)
+				return
+			}
+
+			ctx := context.WithValue(r.Context(), ContextKey, claims["pubkey"])
+			next.ServeHTTP(w, r.WithContext(ctx))
+		} else {
+			pubkey, err := VerifyTribeUUID(token, true)
+
+			if pubkey == "" || err != nil {
+				fmt.Println("[auth] no pubkey || err != nil")
+				if err != nil {
+					fmt.Println(err)
+				}
+				http.Error(w, http.StatusText(401), 401)
+				return
+			}
+
+			if !AdminCheck(pubkey) {
+				fmt.Println("Not a super admin")
+				http.Error(w, http.StatusText(401), 401)
+				return
+			}
+
+			ctx := context.WithValue(r.Context(), ContextKey, pubkey)
+			next.ServeHTTP(w, r.WithContext(ctx))
+		}
+	})
+}
+
+func AdminCheck(pubkey string) bool {
+	for _, val := range config.SuperAdmins {
+		if val == pubkey {
+			return true
+		}
+	}
+	return false
+}
+
 // VerifyTribeUUID takes base64 uuid and returns hex pubkey
 func VerifyTribeUUID(uuid string, checkTimestamp bool) (string, error) {
 

config/config.go

@@ -18,6 +18,7 @@ var RelayUrl string
 var MemeUrl string
 var RelayAuthKey string
 var RelayNodeKey string
+var SuperAdmins []string = []string{""}
 
 // these are constants for the store
 var InvoiceList = "INVOICELIST"
@@ -29,6 +30,9 @@ func InitConfig() {
 	RelayUrl = os.Getenv("RELAY_URL")
 	MemeUrl = os.Getenv("MEME_URL")
 	RelayAuthKey = os.Getenv("RELAY_AUTH_KEY")
+	AdminStrings := os.Getenv("SUPER_ADMINS")
+	// Add to super admins
+	SuperAdmins = StripSuperAdmins(AdminStrings)
 
 	// only make this call if there is a Relay auth key
 	if RelayAuthKey != "" {
@@ -46,7 +50,28 @@ func InitConfig() {
 	if JwtKey == "" {
 		JwtKey = GenerateRandomString()
 	}
+}
+
+func StripSuperAdmins(adminStrings string) []string {
+	superAdmins := []string{}
+	if adminStrings != "" {
+		if strings.Contains(adminStrings, ",") {
+			splitArray := strings.Split(adminStrings, ",")
+			splitLength := len(splitArray)
 
+			for i := 0; i < splitLength; i++ {
+				// append indexes, and skip all the commas
+				if splitArray[i] == "," {
+					continue
+				} else {
+					superAdmins = append(superAdmins, splitArray[i])
+				}
+			}
+		} else {
+			superAdmins = append(superAdmins, adminStrings)
+		}
+	}
+	return superAdmins
 }
 
 func GenerateRandomString() string {

config/config_test.go

@@ -1,6 +1,10 @@
 package config
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
 
 func TestInitConfig(t *testing.T) {
 	InitConfig()
@@ -17,3 +21,21 @@ func TestInitConfig(t *testing.T) {
 		t.Error("Could not load random jwtKey")
 	}
 }
+
+func TestStripSuperAdmins(t *testing.T) {
+	testAdminList := "hello, hi, yes, now"
+	admins := StripSuperAdmins(testAdminList)
+	assert.Equal(t, len(admins), 4)
+
+	testAdminNocomma := "hello"
+	adminsNoComma := StripSuperAdmins(testAdminNocomma)
+	assert.Equal(t, len(adminsNoComma), 1)
+
+	testNoAdmins := ""
+	noAdmins := StripSuperAdmins(testNoAdmins)
+	assert.Equal(t, len(noAdmins), 0)
+
+	test2Admins := "hello, hi"
+	admins2 := StripSuperAdmins(test2Admins)
+	assert.Equal(t, len(admins2), 2)
+}

db/metrics.go

@@ -0,0 +1,146 @@
+package db
+
+import (
+	"fmt"
+	"math"
+	"net/http"
+
+	"github.com/stakwork/sphinx-tribes/utils"
+)
+
+func (db database) TotalPeopleByDateRange(r PaymentDateRange) int64 {
+	var count int64
+	db.db.Model(&Person{}).Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Count(&count)
+	return count
+}
+
+func (db database) TotalOrganizationsByDateRange(r PaymentDateRange) int64 {
+	var count int64
+	db.db.Model(&Organization{}).Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Count(&count)
+	return count
+}
+
+func (db database) TotalPaymentsByDateRange(r PaymentDateRange) uint {
+	var sum uint
+	db.db.Model(&PaymentHistory{}).Where("payment_type = ?", r.PaymentType).Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Select("SUM(amount)").Row().Scan(&sum)
+	return sum
+}
+
+func (db database) TotalSatsPosted(r PaymentDateRange) uint {
+	var sum uint
+	db.db.Model(&Bounty{}).Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Select("SUM(price)").Row().Scan(&sum)
+	return sum
+}
+
+func (db database) TotalSatsPaid(r PaymentDateRange) uint {
+	var sum uint
+	db.db.Model(&Bounty{}).Where("paid = ?", true).Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Select("SUM(price)").Row().Scan(&sum)
+	return sum
+}
+
+func (db database) SatsPaidPercentage(r PaymentDateRange) uint {
+	satsPosted := DB.TotalSatsPosted(r)
+	satsPaid := DB.TotalSatsPaid(r)
+	if satsPaid != 0 && satsPosted != 0 {
+		value := (satsPaid * 100) / satsPosted
+		paidPercentage := math.Round(float64(value))
+		return uint(paidPercentage)
+	}
+	return 0
+}
+
+func (db database) TotalPaidBounties(r PaymentDateRange) int64 {
+	var count int64
+	db.db.Model(&Bounty{}).Where("paid = ?", true).Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Count(&count)
+	return count
+}
+
+func (db database) TotalBountiesPosted(r PaymentDateRange) int64 {
+	var count int64
+	db.db.Model(&Bounty{}).Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Count(&count)
+	return count
+}
+
+func (db database) BountiesPaidPercentage(r PaymentDateRange) uint {
+	bountiesPosted := DB.TotalBountiesPosted(r)
+	bountiesPaid := DB.TotalPaidBounties(r)
+	if bountiesPaid != 0 && bountiesPosted != 0 {
+		value := bountiesPaid * 100 / bountiesPosted
+		paidPercentage := math.Round(float64(value))
+		return uint(paidPercentage)
+	}
+	return 0
+}
+
+func (db database) PaidDifferenceSum(r PaymentDateRange) uint {
+	var sum uint
+	db.db.Model(&Bounty{}).Where("paid_date_difference != ?",
+		"").Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Select("SUM(paid_date_difference)").Row().Scan(&sum)
+	return sum
+}
+
+func (db database) PaidDifferenceCount(r PaymentDateRange) int64 {
+	var count int64
+	db.db.Model(&Bounty{}).Where("paid_date_difference != ?",
+		"").Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Count(&count)
+	return count
+}
+
+func (db database) AveragePaidTime(r PaymentDateRange) uint {
+	paidSum := DB.PaidDifferenceSum(r)
+	paidCount := DB.PaidDifferenceCount(r)
+	if paidCount != 0 && paidSum != 0 {
+		avg := paidSum / uint(paidCount)
+		avgDays := math.Round(float64(avg))
+		return uint(avgDays)
+	}
+	return 0
+}
+
+func (db database) CompletedDifferenceSum(r PaymentDateRange) uint {
+	var sum uint
+	db.db.Model(&Bounty{}).Where("completion_date_difference != ?",
+		"").Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Select("SUM(completion_date_difference)").Row().Scan(&sum)
+	return sum
+}
+
+func (db database) CompletedDifferenceCount(r PaymentDateRange) int64 {
+	var count int64
+	db.db.Model(&Bounty{}).Where("completion_date_difference != ?",
+		"").Where("created >= ?", r.StartDate).Where("created <= ?", r.EndDate).Count(&count)
+	return count
+}
+
+func (db database) AverageCompletedTime(r PaymentDateRange) uint {
+	paidSum := DB.CompletedDifferenceSum(r)
+	paidCount := DB.CompletedDifferenceCount(r)
+	if paidCount != 0 && paidSum != 0 {
+		avg := paidSum / uint(paidCount)
+		avgDays := math.Round(float64(avg))
+		return uint(avgDays)
+	}
+	return 0
+}
+
+func (db database) GetBountiesByDateRange(r PaymentDateRange, re *http.Request) []Bounty {
+	offset, limit, sortBy, direction, _ := utils.GetPaginationParams(re)
+
+	orderQuery := ""
+	limitQuery := ""
+
+	if sortBy != "" && direction != "" {
+		orderQuery = "ORDER BY " + "body." + sortBy + " " + direction
+	} else {
+		orderQuery = " ORDER BY " + "body." + sortBy + "" + "DESC"
+	}
+	if limit != 0 {
+		limitQuery = fmt.Sprintf("LIMIT %d  OFFSET %d", limit, offset)
+	}
+
+	query := `SELECT * public.bounty WHERE created >= '` + r.StartDate + `'  AND created <= '` + r.EndDate + `'`
+	allQuery := query + " " + " " + orderQuery + " " + limitQuery
+
+	b := []Bounty{}
+	db.db.Raw(allQuery).Scan(&b)
+	return b
+}