edit_subscription.go

package main

import (
	"fmt"
	"net/http"

	"github.com/gorilla/mux"

	"github.com/mattermost/mattermost/server/public/model"

	"github.com/mattermost/mattermost-plugin-confluence/server/config"
	"github.com/mattermost/mattermost-plugin-confluence/server/serializer"
	"github.com/mattermost/mattermost-plugin-confluence/server/service"
)

var editChannelSubscription = &Endpoint{
	Path:            "/{channelID:[A-Za-z0-9]+}/subscription/{type:[A-Za-z_]+}",
	Method:          http.MethodPut,
	Execute:         handleEditChannelSubscription,
	IsAuthenticated: true,
}

const subscriptionEditSuccess = "Your subscription has been edited successfully."

func handleEditChannelSubscription(w http.ResponseWriter, r *http.Request, p *Plugin) {
	params := mux.Vars(r)
	channelID := params["channelID"]
	subscriptionType := params["type"]
	userID := r.Header.Get(config.HeaderMattermostUserID)
	var subscription serializer.Subscription
	var err error

	if access := p.checkSubscriptionAccess(userID); !access.Allowed {
		p.client.Log.Error("User does not have access to edit subscription for this channel", "UserID", userID, "ChannelID", channelID, "reason", access.Reason)
		http.Error(w, access.Message, access.StatusCode)
		return
	}

	if !p.hasChannelAccess(userID, channelID) {
		p.client.Log.Error("User does not have access to edit subscription for this channel", "UserID", userID, "ChannelID", channelID)
		http.Error(w, "User does not have access to this channel", http.StatusForbidden)
		return
	}

	var sErr error
	switch subscriptionType {
	case serializer.SubscriptionTypeSpace:
		subscription, sErr = serializer.SpaceSubscriptionFromJSON(r.Body, subscriptionType)
	case serializer.SubscriptionTypePage:
		subscription, sErr = serializer.PageSubscriptionFromJSON(r.Body, subscriptionType)
	default:
		p.client.Log.Error("Error updating channel subscription", "Subscription Type", subscriptionType, "error", "Invalid subscription type")
		http.Error(w, "Invalid subscription type", http.StatusBadRequest)
		return
	}
	if sErr != nil {
		config.Mattermost.LogError("Error decoding request body.", "Error", sErr.Error())
		http.Error(w, fmt.Sprintf("Could not decode request body. %s", sErr.Error()), http.StatusBadRequest)
		return
	}

	pluginConfig := config.GetConfig()
	if pluginConfig.HasPerUserConfluenceAuth() {
		var statusCode int
		if statusCode, err = p.validateUserConfluenceAccess(userID, pluginConfig.ConfluenceURL, subscriptionType, subscription); err != nil {
			p.client.Log.Error("Error validating the user's Confluence access", "Error", err.Error())
			http.Error(w, err.Error(), statusCode) // safe to return the error string directly, as this function ensures all returned errors are user-friendly
			return
		}
	}

	if err := serializer.ValidateEventsForServerVersion(subscription, pluginConfig.ServerVersionGreaterthan9); err != nil {
		p.client.Log.Error("Invalid events for Confluence Server version", "error", err.Error())
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	if nErr := service.EditSubscription(subscription); nErr != nil {
		config.Mattermost.LogError("Error occurred while editing subscription", "Subscription Name", subscription.Name(), "error", nErr.Error())
		http.Error(w, "An error occurred attempting to edit a subscription", http.StatusInternalServerError)
		return
	}

	post := &model.Post{
		UserId:    config.BotUserID,
		ChannelId: channelID,
		Message:   subscriptionEditSuccess,
	}

	_ = config.Mattermost.SendEphemeralPost(userID, post)
	ReturnStatusOK(w)
}