Refactor server to go-sqlite and ginext [WIP]

scnserver/api/handler/apiSubscription.go

@@ -3,6 +3,7 @@ package handler
 import (
 	"blackforestbytes.com/simplecloudnotifier/api/apierr"
 	"blackforestbytes.com/simplecloudnotifier/api/ginresp"
+	"blackforestbytes.com/simplecloudnotifier/logic"
 	"blackforestbytes.com/simplecloudnotifier/models"
 	"database/sql"
 	"errors"
@@ -64,71 +65,75 @@ func (h APIHandler) ListUserSubscriptions(pctx ginext.PreContext) ginext.HTTPRes
 
 	var u uri
 	var q query
-	ctx, g, errResp := h.app.StartRequest(pctx.URI(&u).Query(&q).Start())
+	ctx, g, errResp := pctx.URI(&u).Query(&q).Start()
 	if errResp != nil {
 		return *errResp
 	}
 	defer ctx.Cancel()
 
-	if permResp := ctx.CheckPermissionUserRead(u.UserID); permResp != nil {
-		return *permResp
-	}
+	return h.app.DoRequest(ctx, g, func(ctx *logic.AppContext, finishSuccess func(r ginext.HTTPResponse) ginext.HTTPResponse) ginext.HTTPResponse {
 
-	filter := models.SubscriptionFilter{}
-	filter.AnyUserID = langext.Ptr(u.UserID)
-
-	if q.Direction != nil {
-		if strings.EqualFold(*q.Direction, "incoming") {
-			filter.ChannelOwnerUserID = langext.Ptr([]models.UserID{u.UserID})
-		} else if strings.EqualFold(*q.Direction, "outgoing") {
-			filter.SubscriberUserID = langext.Ptr([]models.UserID{u.UserID})
-		} else if strings.EqualFold(*q.Direction, "both") {
-			// both
-		} else {
-			return ginresp.APIError(g, 400, apierr.BINDFAIL_QUERY_PARAM, "Invalid value for param 'direction'", nil)
+		if permResp := ctx.CheckPermissionUserRead(u.UserID); permResp != nil {
+			return *permResp
 		}
-	}
 
-	if q.Confirmation != nil {
-		if strings.EqualFold(*q.Confirmation, "confirmed") {
-			filter.Confirmed = langext.PTrue
-		} else if strings.EqualFold(*q.Confirmation, "unconfirmed") {
-			filter.Confirmed = langext.PFalse
-		} else if strings.EqualFold(*q.Confirmation, "all") {
-			// both
-		} else {
-			return ginresp.APIError(g, 400, apierr.BINDFAIL_QUERY_PARAM, "Invalid value for param 'confirmation'", nil)
+		filter := models.SubscriptionFilter{}
+		filter.AnyUserID = langext.Ptr(u.UserID)
+
+		if q.Direction != nil {
+			if strings.EqualFold(*q.Direction, "incoming") {
+				filter.ChannelOwnerUserID = langext.Ptr([]models.UserID{u.UserID})
+			} else if strings.EqualFold(*q.Direction, "outgoing") {
+				filter.SubscriberUserID = langext.Ptr([]models.UserID{u.UserID})
+			} else if strings.EqualFold(*q.Direction, "both") {
+				// both
+			} else {
+				return ginresp.APIError(g, 400, apierr.BINDFAIL_QUERY_PARAM, "Invalid value for param 'direction'", nil)
+			}
 		}
-	}
 
-	if q.External != nil {
-		if strings.EqualFold(*q.External, "true") {
-			filter.SubscriberIsChannelOwner = langext.PFalse
-		} else if strings.EqualFold(*q.External, "false") {
-			filter.SubscriberIsChannelOwner = langext.PTrue
-		} else if strings.EqualFold(*q.External, "all") {
-			// both
-		} else {
-			return ginresp.APIError(g, 400, apierr.BINDFAIL_QUERY_PARAM, "Invalid value for param 'external'", nil)
+		if q.Confirmation != nil {
+			if strings.EqualFold(*q.Confirmation, "confirmed") {
+				filter.Confirmed = langext.PTrue
+			} else if strings.EqualFold(*q.Confirmation, "unconfirmed") {
+				filter.Confirmed = langext.PFalse
+			} else if strings.EqualFold(*q.Confirmation, "all") {
+				// both
+			} else {
+				return ginresp.APIError(g, 400, apierr.BINDFAIL_QUERY_PARAM, "Invalid value for param 'confirmation'", nil)
+			}
 		}
-	}
 
-	if q.SubscriberUserID != nil {
-		filter.SubscriberUserID2 = langext.Ptr([]models.UserID{*q.SubscriberUserID})
-	}
+		if q.External != nil {
+			if strings.EqualFold(*q.External, "true") {
+				filter.SubscriberIsChannelOwner = langext.PFalse
+			} else if strings.EqualFold(*q.External, "false") {
+				filter.SubscriberIsChannelOwner = langext.PTrue
+			} else if strings.EqualFold(*q.External, "all") {
+				// both
+			} else {
+				return ginresp.APIError(g, 400, apierr.BINDFAIL_QUERY_PARAM, "Invalid value for param 'external'", nil)
+			}
+		}
 
-	if q.ChannelOwnerUserID != nil {
-		filter.ChannelOwnerUserID2 = langext.Ptr([]models.UserID{*q.ChannelOwnerUserID})
-	}
+		if q.SubscriberUserID != nil {
+			filter.SubscriberUserID2 = langext.Ptr([]models.UserID{*q.SubscriberUserID})
+		}
 
-	res, err := h.database.ListSubscriptions(ctx, filter)
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscriptions", err)
-	}
+		if q.ChannelOwnerUserID != nil {
+			filter.ChannelOwnerUserID2 = langext.Ptr([]models.UserID{*q.ChannelOwnerUserID})
+		}
 
-	jsonres := langext.ArrMap(res, func(v models.Subscription) models.SubscriptionJSON { return v.JSON() })
+		res, err := h.database.ListSubscriptions(ctx, filter)
+		if err != nil {
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscriptions", err)
+		}
 
-	return ctx.FinishSuccess(ginext.JSON(http.StatusOK, response{Subscriptions: jsonres}))
+		jsonres := langext.ArrMap(res, func(v models.Subscription) models.SubscriptionJSON { return v.JSON() })
+
+		return finishSuccess(ginext.JSON(http.StatusOK, response{Subscriptions: jsonres}))
+
+	})
 }
 
 // ListChannelSubscriptions swaggerdoc
@@ -157,32 +162,36 @@ func (h APIHandler) ListChannelSubscriptions(pctx ginext.PreContext) ginext.HTTP
 	}
 
 	var u uri
-	ctx, g, errResp := h.app.StartRequest(pctx.URI(&u).Start())
+	ctx, g, errResp := pctx.URI(&u).Start()
 	if errResp != nil {
 		return *errResp
 	}
 	defer ctx.Cancel()
 
-	if permResp := ctx.CheckPermissionUserRead(u.UserID); permResp != nil {
-		return *permResp
-	}
+	return h.app.DoRequest(ctx, g, func(ctx *logic.AppContext, finishSuccess func(r ginext.HTTPResponse) ginext.HTTPResponse) ginext.HTTPResponse {
 
-	_, err := h.database.GetChannel(ctx, u.UserID, u.ChannelID, true)
-	if errors.Is(err, sql.ErrNoRows) {
-		return ginresp.APIError(g, 404, apierr.CHANNEL_NOT_FOUND, "Channel not found", err)
-	}
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err)
-	}
+		if permResp := ctx.CheckPermissionUserRead(u.UserID); permResp != nil {
+			return *permResp
+		}
 
-	clients, err := h.database.ListSubscriptions(ctx, models.SubscriptionFilter{AnyUserID: langext.Ptr(u.UserID), ChannelID: langext.Ptr([]models.ChannelID{u.ChannelID})})
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscriptions", err)
-	}
+		_, err := h.database.GetChannel(ctx, u.UserID, u.ChannelID, true)
+		if errors.Is(err, sql.ErrNoRows) {
+			return ginresp.APIError(g, 404, apierr.CHANNEL_NOT_FOUND, "Channel not found", err)
+		}
+		if err != nil {
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err)
+		}
 
-	res := langext.ArrMap(clients, func(v models.Subscription) models.SubscriptionJSON { return v.JSON() })
+		clients, err := h.database.ListSubscriptions(ctx, models.SubscriptionFilter{AnyUserID: langext.Ptr(u.UserID), ChannelID: langext.Ptr([]models.ChannelID{u.ChannelID})})
+		if err != nil {
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscriptions", err)
+		}
 
-	return ctx.FinishSuccess(ginext.JSON(http.StatusOK, response{Subscriptions: res}))
+		res := langext.ArrMap(clients, func(v models.Subscription) models.SubscriptionJSON { return v.JSON() })
+
+		return finishSuccess(ginext.JSON(http.StatusOK, response{Subscriptions: res}))
+
+	})
 }
 
 // GetSubscription swaggerdoc
@@ -208,28 +217,32 @@ func (h APIHandler) GetSubscription(pctx ginext.PreContext) ginext.HTTPResponse
 	}
 
 	var u uri
-	ctx, g, errResp := h.app.StartRequest(pctx.URI(&u).Start())
+	ctx, g, errResp := pctx.URI(&u).Start()
 	if errResp != nil {
 		return *errResp
 	}
 	defer ctx.Cancel()
 
-	if permResp := ctx.CheckPermissionUserRead(u.UserID); permResp != nil {
-		return *permResp
-	}
+	return h.app.DoRequest(ctx, g, func(ctx *logic.AppContext, finishSuccess func(r ginext.HTTPResponse) ginext.HTTPResponse) ginext.HTTPResponse {
 
-	subscription, err := h.database.GetSubscription(ctx, u.SubscriptionID)
-	if errors.Is(err, sql.ErrNoRows) {
-		return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_NOT_FOUND, "Subscription not found", err)
-	}
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err)
-	}
-	if subscription.SubscriberUserID != u.UserID && subscription.ChannelOwnerUserID != u.UserID {
-		return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_USER_MISMATCH, "Subscription not found", nil)
-	}
+		if permResp := ctx.CheckPermissionUserRead(u.UserID); permResp != nil {
+			return *permResp
+		}
 
-	return ctx.FinishSuccess(ginext.JSON(http.StatusOK, subscription.JSON()))
+		subscription, err := h.database.GetSubscription(ctx, u.SubscriptionID)
+		if errors.Is(err, sql.ErrNoRows) {
+			return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_NOT_FOUND, "Subscription not found", err)
+		}
+		if err != nil {
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err)
+		}
+		if subscription.SubscriberUserID != u.UserID && subscription.ChannelOwnerUserID != u.UserID {
+			return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_USER_MISMATCH, "Subscription not found", nil)
+		}
+
+		return finishSuccess(ginext.JSON(http.StatusOK, subscription.JSON()))
+
+	})
 }
 
 // CancelSubscription swaggerdoc
@@ -255,33 +268,37 @@ func (h APIHandler) CancelSubscription(pctx ginext.PreContext) ginext.HTTPRespon
 	}
 
 	var u uri
-	ctx, g, errResp := h.app.StartRequest(pctx.URI(&u).Start())
+	ctx, g, errResp := pctx.URI(&u).Start()
 	if errResp != nil {
 		return *errResp
 	}
 	defer ctx.Cancel()
 
-	if permResp := ctx.CheckPermissionUserAdmin(u.UserID); permResp != nil {
-		return *permResp
-	}
+	return h.app.DoRequest(ctx, g, func(ctx *logic.AppContext, finishSuccess func(r ginext.HTTPResponse) ginext.HTTPResponse) ginext.HTTPResponse {
 
-	subscription, err := h.database.GetSubscription(ctx, u.SubscriptionID)
-	if errors.Is(err, sql.ErrNoRows) {
-		return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_NOT_FOUND, "Subscription not found", err)
-	}
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err)
-	}
-	if subscription.SubscriberUserID != u.UserID && subscription.ChannelOwnerUserID != u.UserID {
-		return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_USER_MISMATCH, "Subscription not found", nil)
-	}
+		if permResp := ctx.CheckPermissionUserAdmin(u.UserID); permResp != nil {
+			return *permResp
+		}
 
-	err = h.database.DeleteSubscription(ctx, u.SubscriptionID)
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to delete subscription", err)
-	}
+		subscription, err := h.database.GetSubscription(ctx, u.SubscriptionID)
+		if errors.Is(err, sql.ErrNoRows) {
+			return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_NOT_FOUND, "Subscription not found", err)
+		}
+		if err != nil {
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err)
+		}
+		if subscription.SubscriberUserID != u.UserID && subscription.ChannelOwnerUserID != u.UserID {
+			return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_USER_MISMATCH, "Subscription not found", nil)
+		}
 
-	return ctx.FinishSuccess(ginext.JSON(http.StatusOK, subscription.JSON()))
+		err = h.database.DeleteSubscription(ctx, u.SubscriptionID)
+		if err != nil {
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to delete subscription", err)
+		}
+
+		return finishSuccess(ginext.JSON(http.StatusOK, subscription.JSON()))
+
+	})
 }
 
 // CreateSubscription swaggerdoc
@@ -317,76 +334,80 @@ func (h APIHandler) CreateSubscription(pctx ginext.PreContext) ginext.HTTPRespon
 	var u uri
 	var q query
 	var b body
-	ctx, g, errResp := h.app.StartRequest(pctx.URI(&u).Query(&q).Body(&b).Start())
+	ctx, g, errResp := pctx.URI(&u).Query(&q).Body(&b).Start()
 	if errResp != nil {
 		return *errResp
 	}
 	defer ctx.Cancel()
 
-	if permResp := ctx.CheckPermissionUserAdmin(u.UserID); permResp != nil {
-		return *permResp
-	}
+	return h.app.DoRequest(ctx, g, func(ctx *logic.AppContext, finishSuccess func(r ginext.HTTPResponse) ginext.HTTPResponse) ginext.HTTPResponse {
 
-	var channel models.Channel
-
-	if b.ChannelOwnerUserID != nil && b.ChannelInternalName != nil && b.ChannelID == nil {
-
-		channelInternalName := h.app.NormalizeChannelInternalName(*b.ChannelInternalName)
-
-		outchannel, err := h.database.GetChannelByName(ctx, *b.ChannelOwnerUserID, channelInternalName)
-		if err != nil {
-			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err)
-		}
-		if outchannel == nil {
-			return ginresp.APIError(g, 400, apierr.CHANNEL_NOT_FOUND, "Channel not found", err)
+		if permResp := ctx.CheckPermissionUserAdmin(u.UserID); permResp != nil {
+			return *permResp
 		}
 
-		channel = *outchannel
+		var channel models.Channel
 
-	} else if b.ChannelOwnerUserID == nil && b.ChannelInternalName == nil && b.ChannelID != nil {
+		if b.ChannelOwnerUserID != nil && b.ChannelInternalName != nil && b.ChannelID == nil {
 
-		outchannel, err := h.database.GetChannelByID(ctx, *b.ChannelID)
-		if err != nil {
-			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err)
-		}
-		if outchannel == nil {
-			return ginresp.APIError(g, 400, apierr.CHANNEL_NOT_FOUND, "Channel not found", err)
-		}
+			channelInternalName := h.app.NormalizeChannelInternalName(*b.ChannelInternalName)
 
-		channel = *outchannel
-
-	} else {
-
-		return ginresp.APIError(g, 400, apierr.INVALID_BODY_PARAM, "Must either supply [channel_owner_user_id, channel_internal_name] or [channel_id]", nil)
-
-	}
-
-	if channel.OwnerUserID != u.UserID && (q.ChanSubscribeKey == nil || *q.ChanSubscribeKey != channel.SubscribeKey) {
-		return ginresp.APIError(g, 401, apierr.USER_AUTH_FAILED, "You are not authorized for this action", nil)
-	}
-
-	existingSub, err := h.database.GetSubscriptionBySubscriber(ctx, u.UserID, channel.ChannelID)
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query existing subscription", err)
-	}
-	if existingSub != nil {
-		if !existingSub.Confirmed && channel.OwnerUserID == u.UserID {
-			err = h.database.UpdateSubscriptionConfirmed(ctx, existingSub.SubscriptionID, true)
+			outchannel, err := h.database.GetChannelByName(ctx, *b.ChannelOwnerUserID, channelInternalName)
 			if err != nil {
-				return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to update subscription", err)
+				return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err)
 			}
-			existingSub.Confirmed = true
+			if outchannel == nil {
+				return ginresp.APIError(g, 400, apierr.CHANNEL_NOT_FOUND, "Channel not found", err)
+			}
+
+			channel = *outchannel
+
+		} else if b.ChannelOwnerUserID == nil && b.ChannelInternalName == nil && b.ChannelID != nil {
+
+			outchannel, err := h.database.GetChannelByID(ctx, *b.ChannelID)
+			if err != nil {
+				return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query channel", err)
+			}
+			if outchannel == nil {
+				return ginresp.APIError(g, 400, apierr.CHANNEL_NOT_FOUND, "Channel not found", err)
+			}
+
+			channel = *outchannel
+
+		} else {
+
+			return ginresp.APIError(g, 400, apierr.INVALID_BODY_PARAM, "Must either supply [channel_owner_user_id, channel_internal_name] or [channel_id]", nil)
+
 		}
 
-		return ctx.FinishSuccess(ginext.JSON(http.StatusOK, existingSub.JSON()))
-	}
+		if channel.OwnerUserID != u.UserID && (q.ChanSubscribeKey == nil || *q.ChanSubscribeKey != channel.SubscribeKey) {
+			return ginresp.APIError(g, 401, apierr.USER_AUTH_FAILED, "You are not authorized for this action", nil)
+		}
 
-	sub, err := h.database.CreateSubscription(ctx, u.UserID, channel, channel.OwnerUserID == u.UserID)
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create subscription", err)
-	}
+		existingSub, err := h.database.GetSubscriptionBySubscriber(ctx, u.UserID, channel.ChannelID)
+		if err != nil {
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query existing subscription", err)
+		}
+		if existingSub != nil {
+			if !existingSub.Confirmed && channel.OwnerUserID == u.UserID {
+				err = h.database.UpdateSubscriptionConfirmed(ctx, existingSub.SubscriptionID, true)
+				if err != nil {
+					return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to update subscription", err)
+				}
+				existingSub.Confirmed = true
+			}
 
-	return ctx.FinishSuccess(ginext.JSON(http.StatusOK, sub.JSON()))
+			return finishSuccess(ginext.JSON(http.StatusOK, existingSub.JSON()))
+		}
+
+		sub, err := h.database.CreateSubscription(ctx, u.UserID, channel, channel.OwnerUserID == u.UserID)
+		if err != nil {
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to create subscription", err)
+		}
+
+		return finishSuccess(ginext.JSON(http.StatusOK, sub.JSON()))
+
+	})
 }
 
 // UpdateSubscription swaggerdoc
@@ -417,43 +438,47 @@ func (h APIHandler) UpdateSubscription(pctx ginext.PreContext) ginext.HTTPRespon
 
 	var u uri
 	var b body
-	ctx, g, errResp := h.app.StartRequest(pctx.URI(&u).Body(&b).Start())
+	ctx, g, errResp := pctx.URI(&u).Body(&b).Start()
 	if errResp != nil {
 		return *errResp
 	}
 	defer ctx.Cancel()
 
-	if permResp := ctx.CheckPermissionUserAdmin(u.UserID); permResp != nil {
-		return *permResp
-	}
+	return h.app.DoRequest(ctx, g, func(ctx *logic.AppContext, finishSuccess func(r ginext.HTTPResponse) ginext.HTTPResponse) ginext.HTTPResponse {
 
-	userid := *ctx.GetPermissionUserID()
-
-	subscription, err := h.database.GetSubscription(ctx, u.SubscriptionID)
-	if errors.Is(err, sql.ErrNoRows) {
-		return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_NOT_FOUND, "Subscription not found", err)
-	}
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err)
-	}
-	if subscription.SubscriberUserID != u.UserID && subscription.ChannelOwnerUserID != u.UserID {
-		return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_USER_MISMATCH, "Subscription not found", nil)
-	}
-
-	if b.Confirmed != nil {
-		if subscription.ChannelOwnerUserID != userid {
-			return ginresp.APIError(g, 401, apierr.USER_AUTH_FAILED, "You are not authorized for this action", nil)
+		if permResp := ctx.CheckPermissionUserAdmin(u.UserID); permResp != nil {
+			return *permResp
+		}
+
+		userid := *ctx.GetPermissionUserID()
+
+		subscription, err := h.database.GetSubscription(ctx, u.SubscriptionID)
+		if errors.Is(err, sql.ErrNoRows) {
+			return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_NOT_FOUND, "Subscription not found", err)
 		}
-		err = h.database.UpdateSubscriptionConfirmed(ctx, u.SubscriptionID, *b.Confirmed)
 		if err != nil {
-			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to update subscription", err)
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err)
+		}
+		if subscription.SubscriberUserID != u.UserID && subscription.ChannelOwnerUserID != u.UserID {
+			return ginresp.APIError(g, 404, apierr.SUBSCRIPTION_USER_MISMATCH, "Subscription not found", nil)
 		}
-	}
 
-	subscription, err = h.database.GetSubscription(ctx, u.SubscriptionID)
-	if err != nil {
-		return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err)
-	}
+		if b.Confirmed != nil {
+			if subscription.ChannelOwnerUserID != userid {
+				return ginresp.APIError(g, 401, apierr.USER_AUTH_FAILED, "You are not authorized for this action", nil)
+			}
+			err = h.database.UpdateSubscriptionConfirmed(ctx, u.SubscriptionID, *b.Confirmed)
+			if err != nil {
+				return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to update subscription", err)
+			}
+		}
 
-	return ctx.FinishSuccess(ginext.JSON(http.StatusOK, subscription.JSON()))
+		subscription, err = h.database.GetSubscription(ctx, u.SubscriptionID)
+		if err != nil {
+			return ginresp.APIError(g, 500, apierr.DATABASE_ERROR, "Failed to query subscription", err)
+		}
+
+		return finishSuccess(ginext.JSON(http.StatusOK, subscription.JSON()))
+
+	})
 }