feat: add ability of user to manage old tokens

logic/utils/handler.go

@@ -39,12 +39,12 @@ type Handler interface {
 }
 
 type Handle struct {
-	Db      *sql.DB
-	gets    []HandleFunc
-	posts   []HandleFunc
-	deletes []HandleFunc
-	Config  Config
-    validate *validator.Validate
+	Db       *sql.DB
+	gets     []HandleFunc
+	posts    []HandleFunc
+	deletes  []HandleFunc
+	Config   Config
+	validate *validator.Validate
 }
 
 func decodeBody(r *http.Request) (string, *Error) {
@@ -83,35 +83,71 @@ func (x *Handle) Post(path string, fn func(c *Context) *Error) {
 
 func (x *Handle) PostAuth(path string, authLevel int, fn func(c *Context) *Error) {
 	inner_fn := func(c *Context) *Error {
-        if !c.CheckAuthLevel(authLevel) {
-            return nil
-        }
-        return fn(c)
+		if !c.CheckAuthLevel(authLevel) {
+			return nil
+		}
+		return fn(c)
 	}
 	x.posts = append(x.posts, HandleFunc{path, inner_fn})
 }
 
+func PostAuthJson[T interface{}](x *Handle, path string, authLevel int, fn func(c *Context, obj *T) *Error) {
+	inner_fn := func(c *Context) *Error {
+		if !c.CheckAuthLevel(authLevel) {
+			return nil
+		}
+
+		obj := new(T)
+
+		if err := c.ToJSON(obj); err != nil {
+			return err
+		}
+
+		return fn(c, obj)
+	}
+
+	x.posts = append(x.posts, HandleFunc{path, inner_fn})
+}
+
 func (x *Handle) Delete(path string, fn func(c *Context) *Error) {
 	x.deletes = append(x.deletes, HandleFunc{path, fn})
 }
 
 func (x *Handle) DeleteAuth(path string, authLevel int, fn func(c *Context) *Error) {
 	inner_fn := func(c *Context) *Error {
-        if !c.CheckAuthLevel(authLevel) {
-            return nil
-        }
-        return fn(c)
+		if !c.CheckAuthLevel(authLevel) {
+			return nil
+		}
+		return fn(c)
 	}
 	x.posts = append(x.posts, HandleFunc{path, inner_fn})
 }
 
+func DeleteAuthJson[T interface{}](x *Handle, path string, authLevel int, fn func(c *Context, obj *T) *Error) {
+	inner_fn := func(c *Context) *Error {
+		if !c.CheckAuthLevel(authLevel) {
+			return nil
+		}
+
+		obj := new(T)
+
+		if err := c.ToJSON(obj); err != nil {
+			return err
+		}
+
+		return fn(c, obj)
+	}
+
+	x.deletes = append(x.deletes, HandleFunc{path, inner_fn})
+}
+
 func (x *Handle) handleGets(context *Context) {
-    defer func() {
-        if r := recover(); r != nil { 
-            context.Logger.Error("Something went very wrong", "Error", r)
-	        handleError(&Error{500, "500"}, context)
-        }
-    }()
+	defer func() {
+		if r := recover(); r != nil {
+			context.Logger.Error("Something went very wrong", "Error", r)
+			handleError(&Error{500, "500"}, context)
+		}
+	}()
 
 	for _, s := range x.gets {
 		if s.path == context.R.URL.Path {
@@ -124,12 +160,12 @@ func (x *Handle) handleGets(context *Context) {
 }
 
 func (x *Handle) handlePosts(context *Context) {
-    defer func() {
-        if r := recover(); r != nil { 
-            context.Logger.Error("Something went very wrong", "Error", r)
-	        handleError(&Error{500, "500"}, context)
-        }
-    }()
+	defer func() {
+		if r := recover(); r != nil {
+			context.Logger.Error("Something went very wrong", "Error", r)
+			handleError(&Error{500, "500"}, context)
+		}
+	}()
 
 	for _, s := range x.posts {
 		if s.path == context.R.URL.Path {
@@ -142,12 +178,12 @@ func (x *Handle) handlePosts(context *Context) {
 }
 
 func (x *Handle) handleDeletes(context *Context) {
-    defer func() {
-        if r := recover(); r != nil { 
-            context.Logger.Error("Something went very wrong", "Error", r)
-	        handleError(&Error{500, "500"}, context)
-        }
-    }()
+	defer func() {
+		if r := recover(); r != nil {
+			context.Logger.Error("Something went very wrong", "Error", r)
+			handleError(&Error{500, "500"}, context)
+		}
+	}()
 
 	for _, s := range x.deletes {
 		if s.path == context.R.URL.Path {
@@ -185,20 +221,18 @@ type Context struct {
 	Handle      *Handle
 }
 
-
-func (c Context) GetDb() (*sql.DB) {
-    return c.Db
+func (c Context) GetDb() *sql.DB {
+	return c.Db
 }
 
-func (c Context) GetLogger() (*log.Logger) {
-    return c.Logger
+func (c Context) GetLogger() *log.Logger {
+	return c.Logger
 }
 
 func (c Context) Query(query string, args ...any) (*sql.Rows, error) {
-    return c.Db.Query(query, args...)
+	return c.Db.Query(query, args...)
 }
 
-
 func (c Context) Prepare(str string) (*sql.Stmt, error) {
 	if c.Tx == nil {
 		return c.Db.Prepare(str)
@@ -245,31 +279,31 @@ func (c *Context) RollbackTx() error {
 
 /**
 * Parse and vailidates the json
-*/
+ */
 func (c Context) ParseJson(dat any, str string) *Error {
 	decoder := json.NewDecoder(strings.NewReader(str))
 
-    return c.decodeAndValidade(decoder, dat)
+	return c.decodeAndValidade(decoder, dat)
 }
 
 func (c Context) ToJSON(dat any) *Error {
 	decoder := json.NewDecoder(c.R.Body)
-    
-    return c.decodeAndValidade(decoder, dat)
+
+	return c.decodeAndValidade(decoder, dat)
 }
 
 func (c Context) decodeAndValidade(decoder *json.Decoder, dat any) *Error {
 	err := decoder.Decode(dat)
 	if err != nil {
-        c.Logger.Error("Failed to decode json", "dat", dat, "err", err)
-        return c.JsonBadRequest("Bad Request! Invalid json passed!");
+		c.Logger.Error("Failed to decode json", "dat", dat, "err", err)
+		return c.JsonBadRequest("Bad Request! Invalid json passed!")
 	}
 
-    err = c.Handle.validate.Struct(dat)
-    if err != nil {
-        c.Logger.Error("Failed invalid json passed", "dat", dat, "err", err)
-        return c.JsonBadRequest("Bad Request! Invalid json passed!");
-    }
+	err = c.Handle.validate.Struct(dat)
+	if err != nil {
+		c.Logger.Error("Failed invalid json passed", "dat", dat, "err", err)
+		return c.JsonBadRequest("Bad Request! Invalid json passed!")
+	}
 
 	return nil
 }
@@ -303,7 +337,7 @@ func (c Context) JsonBadRequest(dat any) *Error {
 	c.SetReportCaller(true)
 	c.Logger.Warn("Request failed with a bad request", "dat", dat)
 	c.SetReportCaller(false)
-    return c.ErrorCode(nil, 404, dat)
+	return c.ErrorCode(nil, 404, dat)
 }
 
 func (c Context) JsonErrorBadRequest(err error, dat any) *Error {
@@ -556,7 +590,7 @@ func NewHandler(db *sql.DB, config Config) *Handle {
 	var gets []HandleFunc
 	var posts []HandleFunc
 	var deletes []HandleFunc
-    validate := validator.New()
+	validate := validator.New()
 	x := &Handle{db, gets, posts, deletes, config, validate}
 
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {