How to use Run method of http Package

Best Venom code snippet using http.Run

playbook_runs.go

Source:playbook_runs.go

...15	"github.com/mattermost/mattermost-plugin-playbooks/server/app"16	"github.com/mattermost/mattermost-plugin-playbooks/server/bot"17	"github.com/mattermost/mattermost-plugin-playbooks/server/config"18)19// PlaybookRunHandler is the API handler.20type PlaybookRunHandler struct {21	*ErrorHandler22	config             config.Service23	playbookRunService app.PlaybookRunService24	playbookService    app.PlaybookService25	permissions        *app.PermissionsService26	licenseChecker     app.LicenseChecker27	pluginAPI          *pluginapi.Client28	poster             bot.Poster29	log                bot.Logger30}31// NewPlaybookRunHandler Creates a new Plugin API handler.32func NewPlaybookRunHandler(33	router *mux.Router,34	playbookRunService app.PlaybookRunService,35	playbookService app.PlaybookService,36	permissions *app.PermissionsService,37	licenseChecker app.LicenseChecker,38	api *pluginapi.Client,39	poster bot.Poster,40	log bot.Logger,41	configService config.Service,42) *PlaybookRunHandler {43	handler := &PlaybookRunHandler{44		ErrorHandler:       &ErrorHandler{log: log},45		playbookRunService: playbookRunService,46		playbookService:    playbookService,47		pluginAPI:          api,48		poster:             poster,49		log:                log,50		config:             configService,51		permissions:        permissions,52		licenseChecker:     licenseChecker,53	}54	playbookRunsRouter := router.PathPrefix("/runs").Subrouter()55	playbookRunsRouter.HandleFunc("", handler.getPlaybookRuns).Methods(http.MethodGet)56	playbookRunsRouter.HandleFunc("", handler.createPlaybookRunFromPost).Methods(http.MethodPost)57	playbookRunsRouter.HandleFunc("/dialog", handler.createPlaybookRunFromDialog).Methods(http.MethodPost)58	playbookRunsRouter.HandleFunc("/add-to-timeline-dialog", handler.addToTimelineDialog).Methods(http.MethodPost)59	playbookRunsRouter.HandleFunc("/owners", handler.getOwners).Methods(http.MethodGet)60	playbookRunsRouter.HandleFunc("/channels", handler.getChannels).Methods(http.MethodGet)61	playbookRunsRouter.HandleFunc("/checklist-autocomplete", handler.getChecklistAutocomplete).Methods(http.MethodGet)62	playbookRunsRouter.HandleFunc("/checklist-autocomplete-item", handler.getChecklistAutocompleteItem).Methods(http.MethodGet)63	playbookRunRouter := playbookRunsRouter.PathPrefix("/{id:[A-Za-z0-9]+}").Subrouter()64	playbookRunRouter.HandleFunc("", handler.getPlaybookRun).Methods(http.MethodGet)65	playbookRunRouter.HandleFunc("/metadata", handler.getPlaybookRunMetadata).Methods(http.MethodGet)66	playbookRunRouterAuthorized := playbookRunRouter.PathPrefix("").Subrouter()67	playbookRunRouterAuthorized.Use(handler.checkEditPermissions)68	playbookRunRouterAuthorized.HandleFunc("", handler.updatePlaybookRun).Methods(http.MethodPatch)69	playbookRunRouterAuthorized.HandleFunc("/owner", handler.changeOwner).Methods(http.MethodPost)70	playbookRunRouterAuthorized.HandleFunc("/status", handler.status).Methods(http.MethodPost)71	playbookRunRouterAuthorized.HandleFunc("/finish", handler.finish).Methods(http.MethodPut)72	playbookRunRouterAuthorized.HandleFunc("/finish-dialog", handler.finishDialog).Methods(http.MethodPost)73	playbookRunRouterAuthorized.HandleFunc("/update-status-dialog", handler.updateStatusDialog).Methods(http.MethodPost)74	playbookRunRouterAuthorized.HandleFunc("/reminder/button-update", handler.reminderButtonUpdate).Methods(http.MethodPost)75	playbookRunRouterAuthorized.HandleFunc("/reminder", handler.reminderReset).Methods(http.MethodPost)76	playbookRunRouterAuthorized.HandleFunc("/no-retrospective-button", handler.noRetrospectiveButton).Methods(http.MethodPost)77	playbookRunRouterAuthorized.HandleFunc("/timeline/{eventID:[A-Za-z0-9]+}", handler.removeTimelineEvent).Methods(http.MethodDelete)78	playbookRunRouterAuthorized.HandleFunc("/update-description", handler.updateDescription).Methods(http.MethodPut)79	playbookRunRouterAuthorized.HandleFunc("/restore", handler.restore).Methods(http.MethodPut)80	channelRouter := playbookRunsRouter.PathPrefix("/channel").Subrouter()81	channelRouter.HandleFunc("/{channel_id:[A-Za-z0-9]+}", handler.getPlaybookRunByChannel).Methods(http.MethodGet)82	checklistsRouter := playbookRunRouterAuthorized.PathPrefix("/checklists").Subrouter()83	checklistsRouter.HandleFunc("", handler.addChecklist).Methods(http.MethodPost)84	checklistsRouter.HandleFunc("/move", handler.moveChecklist).Methods(http.MethodPost)85	checklistsRouter.HandleFunc("/move-item", handler.moveChecklistItem).Methods(http.MethodPost)86	checklistRouter := checklistsRouter.PathPrefix("/{checklist:[0-9]+}").Subrouter()87	checklistRouter.HandleFunc("", handler.removeChecklist).Methods(http.MethodDelete)88	checklistRouter.HandleFunc("/add", handler.addChecklistItem).Methods(http.MethodPost)89	checklistRouter.HandleFunc("/rename", handler.renameChecklist).Methods(http.MethodPut)90	checklistRouter.HandleFunc("/add-dialog", handler.addChecklistItemDialog).Methods(http.MethodPost)91	checklistItem := checklistRouter.PathPrefix("/item/{item:[0-9]+}").Subrouter()92	checklistItem.HandleFunc("", handler.itemDelete).Methods(http.MethodDelete)93	checklistItem.HandleFunc("", handler.itemEdit).Methods(http.MethodPut)94	checklistItem.HandleFunc("/skip", handler.itemSkip).Methods(http.MethodPut)95	checklistItem.HandleFunc("/restore", handler.itemRestore).Methods(http.MethodPut)96	checklistItem.HandleFunc("/state", handler.itemSetState).Methods(http.MethodPut)97	checklistItem.HandleFunc("/assignee", handler.itemSetAssignee).Methods(http.MethodPut)98	checklistItem.HandleFunc("/command", handler.itemSetCommand).Methods(http.MethodPut)99	checklistItem.HandleFunc("/run", handler.itemRun).Methods(http.MethodPost)100	checklistItem.HandleFunc("/duplicate", handler.itemDuplicate).Methods(http.MethodPost)101	checklistItem.HandleFunc("/duedate", handler.itemSetDueDate).Methods(http.MethodPut)102	retrospectiveRouter := playbookRunRouterAuthorized.PathPrefix("/retrospective").Subrouter()103	retrospectiveRouter.HandleFunc("", handler.updateRetrospective).Methods(http.MethodPost)104	retrospectiveRouter.HandleFunc("/publish", handler.publishRetrospective).Methods(http.MethodPost)105	followersRouter := playbookRunRouter.PathPrefix("/followers").Subrouter()106	followersRouter.HandleFunc("", handler.follow).Methods(http.MethodPut)107	followersRouter.HandleFunc("", handler.unfollow).Methods(http.MethodDelete)108	followersRouter.HandleFunc("", handler.getFollowers).Methods(http.MethodGet)109	return handler110}111func (h *PlaybookRunHandler) checkEditPermissions(next http.Handler) http.Handler {112	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {113		vars := mux.Vars(r)114		userID := r.Header.Get("Mattermost-User-ID")115		playbookRun, err := h.playbookRunService.GetPlaybookRun(vars["id"])116		if err != nil {117			h.HandleError(w, err)118			return119		}120		if !h.PermissionsCheck(w, h.permissions.RunManageProperties(userID, playbookRun.ID)) {121			return122		}123		next.ServeHTTP(w, r)124	})125}126// createPlaybookRunFromPost handles the POST /runs endpoint127func (h *PlaybookRunHandler) createPlaybookRunFromPost(w http.ResponseWriter, r *http.Request) {128	userID := r.Header.Get("Mattermost-User-ID")129	var playbookRunCreateOptions client.PlaybookRunCreateOptions130	if err := json.NewDecoder(r.Body).Decode(&playbookRunCreateOptions); err != nil {131		h.HandleErrorWithCode(w, http.StatusBadRequest, "unable to decode playbook run create options", err)132		return133	}134	playbookRun, err := h.createPlaybookRun(135		app.PlaybookRun{136			OwnerUserID: playbookRunCreateOptions.OwnerUserID,137			TeamID:      playbookRunCreateOptions.TeamID,138			ChannelID:   playbookRunCreateOptions.ChannelID,139			Name:        playbookRunCreateOptions.Name,140			Summary:     playbookRunCreateOptions.Description,141			PostID:      playbookRunCreateOptions.PostID,142			PlaybookID:  playbookRunCreateOptions.PlaybookID,143		},144		userID,145	)146	if errors.Is(err, app.ErrNoPermissions) {147		h.HandleErrorWithCode(w, http.StatusForbidden, "unable to create playbook run", err)148		return149	}150	if errors.Is(err, app.ErrMalformedPlaybookRun) {151		h.HandleErrorWithCode(w, http.StatusBadRequest, "unable to create playbook run", err)152		return153	}154	if err != nil {155		h.HandleError(w, errors.Wrapf(err, "unable to create playbook run"))156		return157	}158	h.poster.PublishWebsocketEventToUser(app.PlaybookRunCreatedWSEvent, map[string]interface{}{159		"playbook_run": playbookRun,160	}, userID)161	w.Header().Add("Location", fmt.Sprintf("/api/v0/runs/%s", playbookRun.ID))162	ReturnJSON(w, &playbookRun, http.StatusCreated)163}164// Note that this currently does nothing. This is temporary given the removal of stages. Will be used by status.165func (h *PlaybookRunHandler) updatePlaybookRun(w http.ResponseWriter, r *http.Request) {166	vars := mux.Vars(r)167	playbookRunID := vars["id"]168	//userID := r.Header.Get("Mattermost-User-ID")169	oldPlaybookRun, err := h.playbookRunService.GetPlaybookRun(playbookRunID)170	if err != nil {171		h.HandleError(w, err)172		return173	}174	var updates app.UpdateOptions175	if err = json.NewDecoder(r.Body).Decode(&updates); err != nil {176		h.HandleErrorWithCode(w, http.StatusBadRequest, "unable to decode payload", err)177		return178	}179	updatedPlaybookRun := oldPlaybookRun180	ReturnJSON(w, updatedPlaybookRun, http.StatusOK)181}182// createPlaybookRunFromDialog handles the interactive dialog submission when a user presses confirm on183// the create playbook run dialog.184func (h *PlaybookRunHandler) createPlaybookRunFromDialog(w http.ResponseWriter, r *http.Request) {185	userID := r.Header.Get("Mattermost-User-ID")186	var request *model.SubmitDialogRequest187	err := json.NewDecoder(r.Body).Decode(&request)188	if err != nil || request == nil {189		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to decode SubmitDialogRequest", err)190		return191	}192	if userID != request.UserId {193		h.HandleErrorWithCode(w, http.StatusBadRequest, "interactive dialog's userID must be the same as the requester's userID", nil)194		return195	}196	var state app.DialogState197	err = json.Unmarshal([]byte(request.State), &state)198	if err != nil {199		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal dialog state", err)200		return201	}202	var playbookID, name string203	if rawPlaybookID, ok := request.Submission[app.DialogFieldPlaybookIDKey].(string); ok {204		playbookID = rawPlaybookID205	}206	if rawName, ok := request.Submission[app.DialogFieldNameKey].(string); ok {207		name = rawName208	}209	playbookRun, err := h.createPlaybookRun(210		app.PlaybookRun{211			OwnerUserID: request.UserId,212			TeamID:      request.TeamId,213			Name:        name,214			PostID:      state.PostID,215			PlaybookID:  playbookID,216		},217		request.UserId,218	)219	if err != nil {220		if errors.Is(err, app.ErrMalformedPlaybookRun) {221			h.HandleErrorWithCode(w, http.StatusBadRequest, "unable to create playbook run", err)222			return223		}224		if errors.Is(err, app.ErrNoPermissions) {225			h.HandleErrorWithCode(w, http.StatusForbidden, "not authorized to make runs from this playbook", err)226			return227		}228		var msg string229		if errors.Is(err, app.ErrChannelDisplayNameInvalid) {230			msg = "The name is invalid or too long. Please use a valid name with fewer than 64 characters."231		}232		if msg != "" {233			resp := &model.SubmitDialogResponse{234				Errors: map[string]string{235					app.DialogFieldNameKey: msg,236				},237			}238			respBytes, _ := json.Marshal(resp)239			_, _ = w.Write(respBytes)240			return241		}242		h.HandleError(w, err)243		return244	}245	// If the dialog was spawn from a prompt post (the one that is automatically sent when246	// certain keywords are posted in a channel), then we need to edit that original post247	if state.PromptPostID != "" {248		if err := h.editPromptPost(state.PromptPostID, playbookID, playbookRun.ID, userID, name); err != nil {249			h.log.Warnf("failed editing the prompt post; error: %s", err.Error())250		}251	}252	channel, err := h.pluginAPI.Channel.Get(playbookRun.ChannelID)253	if err != nil {254		h.HandleErrorWithCode(w, http.StatusInternalServerError, "unable to get new channel", err)255		return256	}257	// Delay sending the websocket message because the front end may try to change to the newly created258	// channel, and the server may respond with a "channel not found" error. This happens in e2e tests,259	// and possibly in the wild.260	go func() {261		time.Sleep(1 * time.Second) // arbitrary 1 second magic number262		h.poster.PublishWebsocketEventToUser(app.PlaybookRunCreatedWSEvent, map[string]interface{}{263			"client_id":    state.ClientID,264			"playbook_run": playbookRun,265			"channel_name": channel.Name,266		}, request.UserId)267	}()268	if err := h.postPlaybookRunCreatedMessage(playbookRun, request.ChannelId); err != nil {269		h.HandleError(w, err)270		return271	}272	w.Header().Add("Location", fmt.Sprintf("/api/v0/runs/%s", playbookRun.ID))273	w.WriteHeader(http.StatusCreated)274}275func (h *PlaybookRunHandler) editPromptPost(promptPostID string, playbookID string, runID string, userID string, runName string) error {276	post, err := h.pluginAPI.Post.GetPost(promptPostID)277	if err != nil {278		return errors.Wrapf(err, "unable to retrieve the post with ID %q", promptPostID)279	}280	playbook, err := h.playbookService.Get(playbookID)281	if err != nil {282		return errors.Wrapf(err, "unable to retrieve the playbook with ID %q", playbookID)283	}284	user, err := h.pluginAPI.User.Get(userID)285	if err != nil {286		return errors.Wrapf(err, "unable to retrieve the user with ID %q", userID)287	}288	// Update the message and remove the attachments; i.e., the buttons289	post.Message = fmt.Sprintf("@%s started the run [%s](%s) using the [%s](%s) playbook.",290		user.Username, runName, app.GetRunDetailsRelativeURL(runID), playbook.Title, app.GetPlaybookDetailsRelativeURL(playbookID))291	model.ParseSlackAttachment(post, []*model.SlackAttachment{})292	if err := h.pluginAPI.Post.UpdatePost(post); err != nil {293		return errors.Wrapf(err, "unable to update the post with ID %q", post.Id)294	}295	return nil296}297// addToTimelineDialog handles the interactive dialog submission when a user clicks the298// corresponding post action.299func (h *PlaybookRunHandler) addToTimelineDialog(w http.ResponseWriter, r *http.Request) {300	if !h.licenseChecker.TimelineAllowed() {301		h.HandleErrorWithCode(w, http.StatusForbidden, "timeline feature is not covered by current server license", nil)302		return303	}304	userID := r.Header.Get("Mattermost-User-ID")305	var request *model.SubmitDialogRequest306	err := json.NewDecoder(r.Body).Decode(&request)307	if err != nil || request == nil {308		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to decode SubmitDialogRequest", err)309		return310	}311	if userID != request.UserId {312		h.HandleErrorWithCode(w, http.StatusBadRequest, "interactive dialog's userID must be the same as the requester's userID", nil)313		return314	}315	var playbookRunID, summary string316	if rawPlaybookRunID, ok := request.Submission[app.DialogFieldPlaybookRunKey].(string); ok {317		playbookRunID = rawPlaybookRunID318	}319	if rawSummary, ok := request.Submission[app.DialogFieldSummary].(string); ok {320		summary = rawSummary321	}322	playbookRun, incErr := h.playbookRunService.GetPlaybookRun(playbookRunID)323	if incErr != nil {324		h.HandleError(w, incErr)325		return326	}327	if !h.PermissionsCheck(w, h.permissions.RunManageProperties(userID, playbookRun.ID)) {328		return329	}330	var state app.DialogStateAddToTimeline331	err = json.Unmarshal([]byte(request.State), &state)332	if err != nil {333		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal dialog state", err)334		return335	}336	if err = h.playbookRunService.AddPostToTimeline(playbookRunID, userID, state.PostID, summary); err != nil {337		h.HandleError(w, errors.Wrap(err, "failed to add post to timeline"))338		return339	}340	w.WriteHeader(http.StatusOK)341}342func (h *PlaybookRunHandler) createPlaybookRun(playbookRun app.PlaybookRun, userID string) (*app.PlaybookRun, error) {343	if playbookRun.ID != "" {344		return nil, errors.Wrap(app.ErrMalformedPlaybookRun, "playbook run already has an id")345	}346	if playbookRun.CreateAt != 0 {347		return nil, errors.Wrap(app.ErrMalformedPlaybookRun, "playbook run channel already has created at date")348	}349	if playbookRun.TeamID == "" && playbookRun.ChannelID == "" {350		return nil, errors.Wrap(app.ErrMalformedPlaybookRun, "must provide team or channel to create playbook run")351	}352	// If a channel is specified, ensure it's from the given team (if one provided), or353	// just grab the team for that channel.354	var channel *model.Channel355	var err error356	if playbookRun.ChannelID != "" {357		channel, err = h.pluginAPI.Channel.Get(playbookRun.ChannelID)358		if err != nil {359			return nil, errors.Wrapf(err, "failed to get channel")360		}361		if playbookRun.TeamID == "" {362			playbookRun.TeamID = channel.TeamId363		} else if channel.TeamId != playbookRun.TeamID {364			return nil, errors.Wrap(app.ErrMalformedPlaybookRun, "channel not in given team")365		}366	}367	if playbookRun.OwnerUserID == "" {368		return nil, errors.Wrap(app.ErrMalformedPlaybookRun, "missing owner user id of playbook run")369	}370	if strings.TrimSpace(playbookRun.Name) == "" && playbookRun.ChannelID == "" {371		return nil, errors.Wrap(app.ErrMalformedPlaybookRun, "missing name of playbook run")372	}373	public := true374	var playbook *app.Playbook375	if playbookRun.PlaybookID != "" {376		pb, err := h.playbookService.Get(playbookRun.PlaybookID)377		if err != nil {378			return nil, errors.Wrapf(err, "failed to get playbook")379		}380		if pb.DeleteAt != 0 {381			return nil, errors.New("playbook is archived, cannot create a new run using an archived playbook")382		}383		if err := h.permissions.RunCreate(userID, pb); err != nil {384			return nil, err385		}386		playbookRun.Checklists = pb.Checklists387		public = pb.CreatePublicPlaybookRun388		if pb.RunSummaryTemplateEnabled {389			playbookRun.Summary = pb.RunSummaryTemplate390		}391		playbookRun.ReminderMessageTemplate = pb.ReminderMessageTemplate392		playbookRun.StatusUpdateEnabled = pb.StatusUpdateEnabled393		playbookRun.PreviousReminder = time.Duration(pb.ReminderTimerDefaultSeconds) * time.Second394		playbookRun.ReminderTimerDefaultSeconds = pb.ReminderTimerDefaultSeconds395		playbookRun.InvitedUserIDs = []string{}396		playbookRun.InvitedGroupIDs = []string{}397		if pb.InviteUsersEnabled {398			playbookRun.InvitedUserIDs = pb.InvitedUserIDs399			playbookRun.InvitedGroupIDs = pb.InvitedGroupIDs400		}401		if pb.DefaultOwnerEnabled {402			playbookRun.DefaultOwnerID = pb.DefaultOwnerID403		}404		if pb.BroadcastEnabled {405			playbookRun.BroadcastChannelIDs = pb.BroadcastChannelIDs406		}407		playbookRun.WebhookOnCreationURLs = []string{}408		if pb.WebhookOnCreationEnabled {409			playbookRun.WebhookOnCreationURLs = pb.WebhookOnCreationURLs410		}411		playbookRun.WebhookOnStatusUpdateURLs = []string{}412		if pb.WebhookOnStatusUpdateEnabled {413			playbookRun.WebhookOnStatusUpdateURLs = pb.WebhookOnStatusUpdateURLs414		}415		playbookRun.RetrospectiveEnabled = pb.RetrospectiveEnabled416		if pb.RetrospectiveEnabled {417			playbookRun.RetrospectiveReminderIntervalSeconds = pb.RetrospectiveReminderIntervalSeconds418			playbookRun.Retrospective = pb.RetrospectiveTemplate419		}420		playbook = &pb421	}422	if channel == nil {423		permission := model.PermissionCreatePrivateChannel424		permissionMessage := "You are not able to create a private channel"425		if public {426			permission = model.PermissionCreatePublicChannel427			permissionMessage = "You are not able to create a public channel"428		}429		if !h.pluginAPI.User.HasPermissionToTeam(userID, playbookRun.TeamID, permission) {430			return nil, errors.Wrap(app.ErrNoPermissions, permissionMessage)431		}432	} else {433		permission := model.PermissionManagePublicChannelProperties434		permissionMessage := "You are not able to manage public channel properties"435		if channel.Type == model.ChannelTypePrivate {436			permission = model.PermissionManagePrivateChannelProperties437			permissionMessage = "You are not able to manage private channel properties"438		} else if channel.Type == model.ChannelTypeDirect || channel.Type == model.ChannelTypeGroup {439			permission = model.PermissionReadChannel440			permissionMessage = "You do not have access to this channel"441		}442		if !h.pluginAPI.User.HasPermissionToChannel(userID, channel.Id, permission) {443			return nil, errors.Wrap(app.ErrNoPermissions, permissionMessage)444		}445	}446	if playbookRun.PostID != "" {447		post, err := h.pluginAPI.Post.GetPost(playbookRun.PostID)448		if err != nil {449			return nil, errors.Wrapf(err, "failed to get playbook run original post")450		}451		if !h.pluginAPI.User.HasPermissionToChannel(userID, post.ChannelId, model.PermissionReadChannel) {452			return nil, errors.New("user does not have access to the channel containing the playbook run's original post")453		}454	}455	return h.playbookRunService.CreatePlaybookRun(&playbookRun, playbook, userID, public)456}457func (h *PlaybookRunHandler) getRequesterInfo(userID string) (app.RequesterInfo, error) {458	return app.GetRequesterInfo(userID, h.pluginAPI)459}460// getPlaybookRuns handles the GET /runs endpoint.461func (h *PlaybookRunHandler) getPlaybookRuns(w http.ResponseWriter, r *http.Request) {462	userID := r.Header.Get("Mattermost-User-ID")463	filterOptions, err := parsePlaybookRunsFilterOptions(r.URL, userID)464	if err != nil {465		h.HandleErrorWithCode(w, http.StatusBadRequest, "Bad parameter", err)466		return467	}468	requesterInfo, err := h.getRequesterInfo(userID)469	if err != nil {470		h.HandleError(w, err)471		return472	}473	results, err := h.playbookRunService.GetPlaybookRuns(requesterInfo, *filterOptions)474	if err != nil {475		h.HandleError(w, err)476		return477	}478	ReturnJSON(w, results, http.StatusOK)479}480// getPlaybookRun handles the /runs/{id} endpoint.481func (h *PlaybookRunHandler) getPlaybookRun(w http.ResponseWriter, r *http.Request) {482	vars := mux.Vars(r)483	playbookRunID := vars["id"]484	userID := r.Header.Get("Mattermost-User-ID")485	if !h.PermissionsCheck(w, h.permissions.RunView(userID, playbookRunID)) {486		return487	}488	playbookRunToGet, err := h.playbookRunService.GetPlaybookRun(playbookRunID)489	if err != nil {490		h.HandleError(w, err)491		return492	}493	ReturnJSON(w, playbookRunToGet, http.StatusOK)494}495// getPlaybookRunMetadata handles the /runs/{id}/metadata endpoint.496func (h *PlaybookRunHandler) getPlaybookRunMetadata(w http.ResponseWriter, r *http.Request) {497	vars := mux.Vars(r)498	playbookRunID := vars["id"]499	userID := r.Header.Get("Mattermost-User-ID")500	if !h.PermissionsCheck(w, h.permissions.RunView(userID, playbookRunID)) {501		return502	}503	playbookRunMetadata, err := h.playbookRunService.GetPlaybookRunMetadata(playbookRunID)504	if err != nil {505		h.HandleError(w, err)506		return507	}508	ReturnJSON(w, playbookRunMetadata, http.StatusOK)509}510// getPlaybookRunByChannel handles the /runs/channel/{channel_id} endpoint.511func (h *PlaybookRunHandler) getPlaybookRunByChannel(w http.ResponseWriter, r *http.Request) {512	vars := mux.Vars(r)513	channelID := vars["channel_id"]514	userID := r.Header.Get("Mattermost-User-ID")515	if err := h.permissions.RunViewByChannel(userID, channelID); err != nil {516		h.log.Warnf("User %s does not have permissions to get playbook run for channel %s", userID, channelID)517		h.HandleErrorWithCode(w, http.StatusNotFound, "Not found",518			errors.Errorf("playbook run for channel id %s not found", channelID))519		return520	}521	playbookRunID, err := h.playbookRunService.GetPlaybookRunIDForChannel(channelID)522	if err != nil {523		if errors.Is(err, app.ErrNotFound) {524			h.HandleErrorWithCode(w, http.StatusNotFound, "Not found",525				errors.Errorf("playbook run for channel id %s not found", channelID))526			return527		}528		h.HandleError(w, err)529		return530	}531	playbookRunToGet, err := h.playbookRunService.GetPlaybookRun(playbookRunID)532	if err != nil {533		h.HandleError(w, err)534		return535	}536	ReturnJSON(w, playbookRunToGet, http.StatusOK)537}538// getOwners handles the /runs/owners api endpoint.539func (h *PlaybookRunHandler) getOwners(w http.ResponseWriter, r *http.Request) {540	teamID := r.URL.Query().Get("team_id")541	userID := r.Header.Get("Mattermost-User-ID")542	options := app.PlaybookRunFilterOptions{543		TeamID: teamID,544	}545	requesterInfo, err := h.getRequesterInfo(userID)546	if err != nil {547		h.HandleError(w, err)548		return549	}550	owners, err := h.playbookRunService.GetOwners(requesterInfo, options)551	if err != nil {552		h.HandleError(w, errors.Wrapf(err, "failed to get owners"))553		return554	}555	if owners == nil {556		owners = []app.OwnerInfo{}557	}558	ReturnJSON(w, owners, http.StatusOK)559}560func (h *PlaybookRunHandler) getChannels(w http.ResponseWriter, r *http.Request) {561	userID := r.Header.Get("Mattermost-User-ID")562	filterOptions, err := parsePlaybookRunsFilterOptions(r.URL, userID)563	if err != nil {564		h.HandleErrorWithCode(w, http.StatusBadRequest, "Bad parameter", err)565		return566	}567	requesterInfo, err := h.getRequesterInfo(userID)568	if err != nil {569		h.HandleError(w, err)570		return571	}572	playbookRuns, err := h.playbookRunService.GetPlaybookRuns(requesterInfo, *filterOptions)573	if err != nil {574		h.HandleError(w, errors.Wrapf(err, "failed to get owners"))575		return576	}577	channelIds := make([]string, 0, len(playbookRuns.Items))578	for _, playbookRun := range playbookRuns.Items {579		channelIds = append(channelIds, playbookRun.ChannelID)580	}581	ReturnJSON(w, channelIds, http.StatusOK)582}583// changeOwner handles the /runs/{id}/change-owner api endpoint.584func (h *PlaybookRunHandler) changeOwner(w http.ResponseWriter, r *http.Request) {585	vars := mux.Vars(r)586	userID := r.Header.Get("Mattermost-User-ID")587	var params struct {588		OwnerID string `json:"owner_id"`589	}590	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {591		h.HandleErrorWithCode(w, http.StatusBadRequest, "could not decode request body", err)592		return593	}594	playbookRun, err := h.playbookRunService.GetPlaybookRun(vars["id"])595	if err != nil {596		h.HandleError(w, err)597		return598	}599	// Check if the target user (params.OwnerID) has permissions600	if !h.PermissionsCheck(w, h.permissions.RunManageProperties(params.OwnerID, playbookRun.ID)) {601		return602	}603	if err := h.playbookRunService.ChangeOwner(vars["id"], userID, params.OwnerID); err != nil {604		h.HandleError(w, err)605		return606	}607	ReturnJSON(w, map[string]interface{}{}, http.StatusOK)608}609// updateStatusD handles the POST /runs/{id}/status endpoint, user has edit permissions610func (h *PlaybookRunHandler) status(w http.ResponseWriter, r *http.Request) {611	playbookRunID := mux.Vars(r)["id"]612	userID := r.Header.Get("Mattermost-User-ID")613	playbookRunToModify, err := h.playbookRunService.GetPlaybookRun(playbookRunID)614	if err != nil {615		h.HandleError(w, err)616		return617	}618	if !app.CanPostToChannel(userID, playbookRunToModify.ChannelID, h.pluginAPI) {619		h.HandleErrorWithCode(w, http.StatusForbidden, "Not authorized", fmt.Errorf("user %s cannot post to playbook run channel %s", userID, playbookRunToModify.ChannelID))620		return621	}622	var options app.StatusUpdateOptions623	if err = json.NewDecoder(r.Body).Decode(&options); err != nil {624		h.HandleErrorWithCode(w, http.StatusBadRequest, "unable to decode body into StatusUpdateOptions", err)625		return626	}627	if publicMsg, internalErr := h.updateStatus(playbookRunID, userID, options); internalErr != nil {628		h.HandleErrorWithCode(w, http.StatusBadRequest, publicMsg, internalErr)629		return630	}631	w.WriteHeader(http.StatusOK)632	_, _ = w.Write([]byte(`{"status":"OK"}`))633}634// updateStatus returns a publicMessage and an internal error635func (h *PlaybookRunHandler) updateStatus(playbookRunID, userID string, options app.StatusUpdateOptions) (string, error) {636	options.Message = strings.TrimSpace(options.Message)637	if options.Message == "" {638		return "message must not be empty", errors.New("message field empty")639	}640	if options.Reminder <= 0 && !options.FinishRun {641		return "the reminder must be set and not 0", errors.New("reminder was 0")642	}643	if options.Reminder < 0 || options.FinishRun {644		options.Reminder = 0645	}646	options.Reminder = options.Reminder * time.Second647	if err := h.playbookRunService.UpdateStatus(playbookRunID, userID, options); err != nil {648		return "An internal error has occurred. Check app server logs for details.", err649	}650	if options.FinishRun {651		if err := h.playbookRunService.FinishPlaybookRun(playbookRunID, userID); err != nil {652			return "An internal error has occurred. Check app server logs for details.", err653		}654	}655	return "", nil656}657// updateStatusD handles the POST /runs/{id}/finish endpoint, user has edit permissions658func (h *PlaybookRunHandler) finish(w http.ResponseWriter, r *http.Request) {659	playbookRunID := mux.Vars(r)["id"]660	userID := r.Header.Get("Mattermost-User-ID")661	if err := h.playbookRunService.FinishPlaybookRun(playbookRunID, userID); err != nil {662		h.HandleError(w, err)663		return664	}665	w.WriteHeader(http.StatusOK)666	_, _ = w.Write([]byte(`{"status":"OK"}`))667}668// restore "un-finishes" a playbook run669func (h *PlaybookRunHandler) restore(w http.ResponseWriter, r *http.Request) {670	playbookRunID := mux.Vars(r)["id"]671	userID := r.Header.Get("Mattermost-User-ID")672	if err := h.playbookRunService.RestorePlaybookRun(playbookRunID, userID); err != nil {673		h.HandleError(w, err)674		return675	}676	w.WriteHeader(http.StatusOK)677	_, _ = w.Write([]byte(`{"status":"OK"}`))678}679// updateStatusDialog handles the POST /runs/{id}/finish-dialog endpoint, called when a680// user submits the Finish Run dialog.681func (h *PlaybookRunHandler) finishDialog(w http.ResponseWriter, r *http.Request) {682	playbookRunID := mux.Vars(r)["id"]683	userID := r.Header.Get("Mattermost-User-ID")684	playbookRun, incErr := h.playbookRunService.GetPlaybookRun(playbookRunID)685	if incErr != nil {686		h.HandleError(w, incErr)687		return688	}689	if !h.PermissionsCheck(w, h.permissions.RunManageProperties(userID, playbookRun.ID)) {690		return691	}692	if err := h.playbookRunService.FinishPlaybookRun(playbookRunID, userID); err != nil {693		h.HandleError(w, err)694		return695	}696}697// updateStatusDialog handles the POST /runs/{id}/update-status-dialog endpoint, called when a698// user submits the Update Status dialog.699func (h *PlaybookRunHandler) updateStatusDialog(w http.ResponseWriter, r *http.Request) {700	playbookRunID := mux.Vars(r)["id"]701	userID := r.Header.Get("Mattermost-User-ID")702	playbookRunToModify, err := h.playbookRunService.GetPlaybookRun(playbookRunID)703	if err != nil {704		h.HandleError(w, err)705		return706	}707	if !app.CanPostToChannel(userID, playbookRunToModify.ChannelID, h.pluginAPI) {708		h.HandleErrorWithCode(w, http.StatusForbidden, "Not authorized", fmt.Errorf("user %s cannot post to playbook run channel %s", userID, playbookRunToModify.ChannelID))709		return710	}711	var request *model.SubmitDialogRequest712	err = json.NewDecoder(r.Body).Decode(&request)713	if err != nil || request == nil {714		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to decode SubmitDialogRequest", err)715		return716	}717	var options app.StatusUpdateOptions718	if message, ok := request.Submission[app.DialogFieldMessageKey]; ok {719		options.Message = message.(string)720	}721	if reminderI, ok := request.Submission[app.DialogFieldReminderInSecondsKey]; ok {722		var reminder int723		reminder, err = strconv.Atoi(reminderI.(string))724		if err != nil {725			h.HandleError(w, err)726			return727		}728		options.Reminder = time.Duration(reminder)729	}730	if finishB, ok := request.Submission[app.DialogFieldFinishRun]; ok {731		var finish bool732		if finish, ok = finishB.(bool); ok {733			options.FinishRun = finish734		}735	}736	if publicMsg, internalErr := h.updateStatus(playbookRunID, userID, options); internalErr != nil {737		h.HandleErrorWithCode(w, http.StatusBadRequest, publicMsg, internalErr)738		return739	}740	w.WriteHeader(http.StatusOK)741}742// reminderButtonUpdate handles the POST /runs/{id}/reminder/button-update endpoint, called when a743// user clicks on the reminder interactive button744func (h *PlaybookRunHandler) reminderButtonUpdate(w http.ResponseWriter, r *http.Request) {745	var requestData *model.PostActionIntegrationRequest746	err := json.NewDecoder(r.Body).Decode(&requestData)747	if err != nil || requestData == nil {748		h.HandleErrorWithCode(w, http.StatusBadRequest, "missing request data", nil)749		return750	}751	playbookRunID, err := h.playbookRunService.GetPlaybookRunIDForChannel(requestData.ChannelId)752	if err != nil {753		h.HandleErrorWithCode(w, http.StatusInternalServerError, "error getting playbook run",754			errors.Wrapf(err, "reminderButtonUpdate failed to find playbookRunID for channelID: %s", requestData.ChannelId))755		return756	}757	if !h.PermissionsCheck(w, h.permissions.RunManageProperties(requestData.UserId, playbookRunID)) {758		return759	}760	if err = h.playbookRunService.OpenUpdateStatusDialog(playbookRunID, requestData.TriggerId); err != nil {761		h.HandleError(w, errors.New("reminderButtonUpdate failed to open update status dialog"))762		return763	}764	ReturnJSON(w, nil, http.StatusOK)765}766// reminderButtonDismiss handles the POST /runs/{id}/reminder endpoint, called when a767// user clicks on the reminder custom_update_status time selector768func (h *PlaybookRunHandler) reminderReset(w http.ResponseWriter, r *http.Request) {769	playbookRunID := mux.Vars(r)["id"]770	userID := r.Header.Get("Mattermost-User-ID")771	var payload struct {772		NewReminderSeconds int `json:"new_reminder_seconds"`773	}774	if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {775		h.HandleError(w, err)776		return777	}778	if payload.NewReminderSeconds <= 0 {779		h.HandleErrorWithCode(w, http.StatusBadRequest, "new_reminder_seconds must be > 0", errors.New("new_reminder_seconds was <= 0"))780		return781	}782	storedPlaybookRun, err := h.playbookRunService.GetPlaybookRun(playbookRunID)783	if err != nil {784		err = errors.Wrapf(err, "reminderReset: no playbook run for path's playbookRunID: %s", playbookRunID)785		h.HandleErrorWithCode(w, http.StatusBadRequest, "no playbook run for path's playbookRunID", err)786		return787	}788	if !h.PermissionsCheck(w, h.permissions.RunManageProperties(userID, storedPlaybookRun.ID)) {789		return790	}791	if err = h.playbookRunService.SetNewReminder(playbookRunID, time.Duration(payload.NewReminderSeconds)*time.Second); err != nil {792		err = errors.Wrapf(err, "reminderReset: error setting new reminder for playbookRunID %s", playbookRunID)793		h.HandleErrorWithCode(w, http.StatusBadRequest, "error removing reminder post", err)794		return795	}796	w.WriteHeader(http.StatusNoContent)797}798func (h *PlaybookRunHandler) noRetrospectiveButton(w http.ResponseWriter, r *http.Request) {799	playbookRunID := mux.Vars(r)["id"]800	userID := r.Header.Get("Mattermost-User-ID")801	playbookRunToCancelRetro, err := h.playbookRunService.GetPlaybookRun(playbookRunID)802	if err != nil {803		h.HandleError(w, err)804		return805	}806	if !h.PermissionsCheck(w, h.permissions.RunManageProperties(userID, playbookRunToCancelRetro.ID)) {807		return808	}809	if err := h.playbookRunService.CancelRetrospective(playbookRunToCancelRetro.ID, userID); err != nil {810		h.HandleErrorWithCode(w, http.StatusInternalServerError, "unable to cancel retrospective", err)811		return812	}813	ReturnJSON(w, nil, http.StatusOK)814}815// removeTimelineEvent handles the DELETE /runs/{id}/timeline/{eventID} endpoint.816// User has been authenticated to edit the playbook run.817func (h *PlaybookRunHandler) removeTimelineEvent(w http.ResponseWriter, r *http.Request) {818	vars := mux.Vars(r)819	id := vars["id"]820	userID := r.Header.Get("Mattermost-User-ID")821	eventID := vars["eventID"]822	if err := h.playbookRunService.RemoveTimelineEvent(id, userID, eventID); err != nil {823		h.HandleError(w, err)824		return825	}826	w.WriteHeader(http.StatusNoContent)827}828func (h *PlaybookRunHandler) updateDescription(w http.ResponseWriter, r *http.Request) {829	playbookRunID := mux.Vars(r)["id"]830	userID := r.Header.Get("Mattermost-User-ID")831	playbookRun, err := h.playbookRunService.GetPlaybookRun(playbookRunID)832	if err != nil {833		h.HandleError(w, err)834		return835	}836	var requestBody struct {837		Description string `json:"description"`838	}839	if err2 := json.NewDecoder(r.Body).Decode(&requestBody); err2 != nil {840		h.HandleErrorWithCode(w, http.StatusBadRequest, "unable to decode playbook run description", err2)841		return842	}843	if !h.PermissionsCheck(w, h.permissions.RunManageProperties(userID, playbookRun.ID)) {844		return845	}846	if err := h.playbookRunService.UpdateDescription(playbookRunID, requestBody.Description); err != nil {847		h.HandleErrorWithCode(w, http.StatusInternalServerError, "unable to update description", err)848		return849	}850	ReturnJSON(w, nil, http.StatusOK)851}852func (h *PlaybookRunHandler) getChecklistAutocompleteItem(w http.ResponseWriter, r *http.Request) {853	query := r.URL.Query()854	channelID := query.Get("channel_id")855	userID := r.Header.Get("Mattermost-User-ID")856	if !h.PermissionsCheck(w, h.permissions.RunViewByChannel(userID, channelID)) {857		return858	}859	playbookRunID, err := h.playbookRunService.GetPlaybookRunIDForChannel(channelID)860	if err != nil {861		h.HandleError(w, err)862		return863	}864	data, err := h.playbookRunService.GetChecklistItemAutocomplete(playbookRunID)865	if err != nil {866		h.HandleError(w, err)867		return868	}869	ReturnJSON(w, data, http.StatusOK)870}871func (h *PlaybookRunHandler) getChecklistAutocomplete(w http.ResponseWriter, r *http.Request) {872	query := r.URL.Query()873	channelID := query.Get("channel_id")874	userID := r.Header.Get("Mattermost-User-ID")875	if !h.PermissionsCheck(w, h.permissions.RunViewByChannel(userID, channelID)) {876		return877	}878	playbookRunID, err := h.playbookRunService.GetPlaybookRunIDForChannel(channelID)879	if err != nil {880		h.HandleError(w, err)881		return882	}883	data, err := h.playbookRunService.GetChecklistAutocomplete(playbookRunID)884	if err != nil {885		h.HandleError(w, err)886		return887	}888	ReturnJSON(w, data, http.StatusOK)889}890func (h *PlaybookRunHandler) itemSetState(w http.ResponseWriter, r *http.Request) {891	vars := mux.Vars(r)892	id := vars["id"]893	checklistNum, err := strconv.Atoi(vars["checklist"])894	if err != nil {895		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)896		return897	}898	itemNum, err := strconv.Atoi(vars["item"])899	if err != nil {900		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)901		return902	}903	userID := r.Header.Get("Mattermost-User-ID")904	var params struct {905		NewState string `json:"new_state"`906	}907	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {908		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal", err)909		return910	}911	if !app.IsValidChecklistItemState(params.NewState) {912		h.HandleErrorWithCode(w, http.StatusBadRequest, "bad parameter new state", nil)913		return914	}915	if err := h.playbookRunService.ModifyCheckedState(id, userID, params.NewState, checklistNum, itemNum); err != nil {916		h.HandleError(w, err)917		return918	}919	ReturnJSON(w, map[string]interface{}{}, http.StatusOK)920}921func (h *PlaybookRunHandler) itemSetAssignee(w http.ResponseWriter, r *http.Request) {922	vars := mux.Vars(r)923	id := vars["id"]924	checklistNum, err := strconv.Atoi(vars["checklist"])925	if err != nil {926		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)927		return928	}929	itemNum, err := strconv.Atoi(vars["item"])930	if err != nil {931		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)932		return933	}934	userID := r.Header.Get("Mattermost-User-ID")935	var params struct {936		AssigneeID string `json:"assignee_id"`937	}938	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {939		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal", err)940		return941	}942	if err := h.playbookRunService.SetAssignee(id, userID, params.AssigneeID, checklistNum, itemNum); err != nil {943		h.HandleError(w, err)944		return945	}946	ReturnJSON(w, map[string]interface{}{}, http.StatusOK)947}948func (h *PlaybookRunHandler) itemSetDueDate(w http.ResponseWriter, r *http.Request) {949	vars := mux.Vars(r)950	id := vars["id"]951	checklistNum, err := strconv.Atoi(vars["checklist"])952	if err != nil {953		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)954		return955	}956	itemNum, err := strconv.Atoi(vars["item"])957	if err != nil {958		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)959		return960	}961	userID := r.Header.Get("Mattermost-User-ID")962	var params struct {963		DueDate int64 `json:"due_date"`964	}965	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {966		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal", err)967		return968	}969	if err := h.playbookRunService.SetDueDate(id, userID, params.DueDate, checklistNum, itemNum); err != nil {970		h.HandleError(w, err)971		return972	}973	ReturnJSON(w, map[string]interface{}{}, http.StatusOK)974}975func (h *PlaybookRunHandler) itemSetCommand(w http.ResponseWriter, r *http.Request) {976	vars := mux.Vars(r)977	id := vars["id"]978	checklistNum, err := strconv.Atoi(vars["checklist"])979	if err != nil {980		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)981		return982	}983	itemNum, err := strconv.Atoi(vars["item"])984	if err != nil {985		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)986		return987	}988	userID := r.Header.Get("Mattermost-User-ID")989	var params struct {990		Command string `json:"command"`991	}992	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {993		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal", err)994		return995	}996	if err := h.playbookRunService.SetCommandToChecklistItem(id, userID, checklistNum, itemNum, params.Command); err != nil {997		h.HandleError(w, err)998		return999	}1000	ReturnJSON(w, map[string]interface{}{}, http.StatusOK)1001}1002func (h *PlaybookRunHandler) itemRun(w http.ResponseWriter, r *http.Request) {1003	vars := mux.Vars(r)1004	playbookRunID := vars["id"]1005	checklistNum, err := strconv.Atoi(vars["checklist"])1006	if err != nil {1007		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1008		return1009	}1010	itemNum, err := strconv.Atoi(vars["item"])1011	if err != nil {1012		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)1013		return1014	}1015	userID := r.Header.Get("Mattermost-User-ID")1016	triggerID, err := h.playbookRunService.RunChecklistItemSlashCommand(playbookRunID, userID, checklistNum, itemNum)1017	if err != nil {1018		h.HandleError(w, err)1019		return1020	}1021	ReturnJSON(w, map[string]interface{}{"trigger_id": triggerID}, http.StatusOK)1022}1023func (h *PlaybookRunHandler) itemDuplicate(w http.ResponseWriter, r *http.Request) {1024	vars := mux.Vars(r)1025	playbookRunID := vars["id"]1026	checklistNum, err := strconv.Atoi(vars["checklist"])1027	if err != nil {1028		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1029		return1030	}1031	itemNum, err := strconv.Atoi(vars["item"])1032	if err != nil {1033		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)1034		return1035	}1036	userID := r.Header.Get("Mattermost-User-ID")1037	if err := h.playbookRunService.DuplicateChecklistItem(playbookRunID, userID, checklistNum, itemNum); err != nil {1038		h.HandleError(w, err)1039		return1040	}1041	w.WriteHeader(http.StatusCreated)1042}1043func (h *PlaybookRunHandler) addChecklist(w http.ResponseWriter, r *http.Request) {1044	vars := mux.Vars(r)1045	id := vars["id"]1046	userID := r.Header.Get("Mattermost-User-ID")1047	var checklist app.Checklist1048	if err := json.NewDecoder(r.Body).Decode(&checklist); err != nil {1049		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to decode Checklist", err)1050		return1051	}1052	checklist.Title = strings.TrimSpace(checklist.Title)1053	if checklist.Title == "" {1054		h.HandleErrorWithCode(w, http.StatusBadRequest, "bad parameter: checklist title",1055			errors.New("checklist title must not be blank"))1056		return1057	}1058	if err := h.playbookRunService.AddChecklist(id, userID, checklist); err != nil {1059		h.HandleError(w, err)1060		return1061	}1062	w.WriteHeader(http.StatusCreated)1063}1064func (h *PlaybookRunHandler) removeChecklist(w http.ResponseWriter, r *http.Request) {1065	vars := mux.Vars(r)1066	id := vars["id"]1067	checklistNum, err := strconv.Atoi(vars["checklist"])1068	if err != nil {1069		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1070		return1071	}1072	userID := r.Header.Get("Mattermost-User-ID")1073	if err := h.playbookRunService.RemoveChecklist(id, userID, checklistNum); err != nil {1074		h.HandleError(w, err)1075		return1076	}1077	w.WriteHeader(http.StatusCreated)1078}1079func (h *PlaybookRunHandler) addChecklistItem(w http.ResponseWriter, r *http.Request) {1080	vars := mux.Vars(r)1081	id := vars["id"]1082	checklistNum, err := strconv.Atoi(vars["checklist"])1083	if err != nil {1084		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1085		return1086	}1087	userID := r.Header.Get("Mattermost-User-ID")1088	var checklistItem app.ChecklistItem1089	if err := json.NewDecoder(r.Body).Decode(&checklistItem); err != nil {1090		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to decode ChecklistItem", err)1091		return1092	}1093	checklistItem.Title = strings.TrimSpace(checklistItem.Title)1094	if checklistItem.Title == "" {1095		h.HandleErrorWithCode(w, http.StatusBadRequest, "bad parameter: checklist item title",1096			errors.New("checklist item title must not be blank"))1097		return1098	}1099	if err := h.playbookRunService.AddChecklistItem(id, userID, checklistNum, checklistItem); err != nil {1100		h.HandleError(w, err)1101		return1102	}1103	w.WriteHeader(http.StatusCreated)1104}1105// addChecklistItemDialog handles the interactive dialog submission when a user clicks add new task1106func (h *PlaybookRunHandler) addChecklistItemDialog(w http.ResponseWriter, r *http.Request) {1107	userID := r.Header.Get("Mattermost-User-ID")1108	vars := mux.Vars(r)1109	playbookRunID := vars["id"]1110	checklistNum, err := strconv.Atoi(vars["checklist"])1111	if err != nil {1112		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1113		return1114	}1115	var request *model.SubmitDialogRequest1116	err = json.NewDecoder(r.Body).Decode(&request)1117	if err != nil || request == nil {1118		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to decode SubmitDialogRequest", err)1119		return1120	}1121	if userID != request.UserId {1122		h.HandleErrorWithCode(w, http.StatusBadRequest, "interactive dialog's userID must be the same as the requester's userID", nil)1123		return1124	}1125	var name, description string1126	if rawName, ok := request.Submission[app.DialogFieldItemNameKey].(string); ok {1127		name = rawName1128	}1129	if rawDescription, ok := request.Submission[app.DialogFieldItemDescriptionKey].(string); ok {1130		description = rawDescription1131	}1132	checklistItem := app.ChecklistItem{1133		Title:       name,1134		Description: description,1135	}1136	checklistItem.Title = strings.TrimSpace(checklistItem.Title)1137	if checklistItem.Title == "" {1138		h.HandleErrorWithCode(w, http.StatusBadRequest, "bad parameter: checklist item title",1139			errors.New("checklist item title must not be blank"))1140		return1141	}1142	if err := h.playbookRunService.AddChecklistItem(playbookRunID, userID, checklistNum, checklistItem); err != nil {1143		h.HandleError(w, err)1144		return1145	}1146	w.WriteHeader(http.StatusOK)1147}1148func (h *PlaybookRunHandler) itemDelete(w http.ResponseWriter, r *http.Request) {1149	vars := mux.Vars(r)1150	id := vars["id"]1151	checklistNum, err := strconv.Atoi(vars["checklist"])1152	if err != nil {1153		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1154		return1155	}1156	itemNum, err := strconv.Atoi(vars["item"])1157	if err != nil {1158		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)1159		return1160	}1161	userID := r.Header.Get("Mattermost-User-ID")1162	if err := h.playbookRunService.RemoveChecklistItem(id, userID, checklistNum, itemNum); err != nil {1163		h.HandleError(w, err)1164		return1165	}1166	w.WriteHeader(http.StatusNoContent)1167}1168func (h *PlaybookRunHandler) itemSkip(w http.ResponseWriter, r *http.Request) {1169	vars := mux.Vars(r)1170	id := vars["id"]1171	checklistNum, err := strconv.Atoi(vars["checklist"])1172	if err != nil {1173		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1174		return1175	}1176	itemNum, err := strconv.Atoi(vars["item"])1177	if err != nil {1178		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)1179		return1180	}1181	userID := r.Header.Get("Mattermost-User-ID")1182	if err := h.playbookRunService.SkipChecklistItem(id, userID, checklistNum, itemNum); err != nil {1183		h.HandleError(w, err)1184		return1185	}1186	w.WriteHeader(http.StatusNoContent)1187}1188func (h *PlaybookRunHandler) itemRestore(w http.ResponseWriter, r *http.Request) {1189	vars := mux.Vars(r)1190	id := vars["id"]1191	checklistNum, err := strconv.Atoi(vars["checklist"])1192	if err != nil {1193		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1194		return1195	}1196	itemNum, err := strconv.Atoi(vars["item"])1197	if err != nil {1198		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)1199		return1200	}1201	userID := r.Header.Get("Mattermost-User-ID")1202	if err := h.playbookRunService.RestoreChecklistItem(id, userID, checklistNum, itemNum); err != nil {1203		h.HandleError(w, err)1204		return1205	}1206	w.WriteHeader(http.StatusNoContent)1207}1208func (h *PlaybookRunHandler) itemEdit(w http.ResponseWriter, r *http.Request) {1209	vars := mux.Vars(r)1210	id := vars["id"]1211	checklistNum, err := strconv.Atoi(vars["checklist"])1212	if err != nil {1213		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1214		return1215	}1216	itemNum, err := strconv.Atoi(vars["item"])1217	if err != nil {1218		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse item", err)1219		return1220	}1221	userID := r.Header.Get("Mattermost-User-ID")1222	var params struct {1223		Title       string `json:"title"`1224		Command     string `json:"command"`1225		Description string `json:"description"`1226	}1227	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {1228		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal edit params state", err)1229		return1230	}1231	if err := h.playbookRunService.EditChecklistItem(id, userID, checklistNum, itemNum, params.Title, params.Command, params.Description); err != nil {1232		h.HandleError(w, err)1233		return1234	}1235	w.WriteHeader(http.StatusOK)1236}1237func (h *PlaybookRunHandler) renameChecklist(w http.ResponseWriter, r *http.Request) {1238	vars := mux.Vars(r)1239	id := vars["id"]1240	checklistNum, err := strconv.Atoi(vars["checklist"])1241	if err != nil {1242		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to parse checklist", err)1243		return1244	}1245	userID := r.Header.Get("Mattermost-User-ID")1246	var modificationParams struct {1247		NewTitle string `json:"title"`1248	}1249	if err := json.NewDecoder(r.Body).Decode(&modificationParams); err != nil {1250		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal new title", err)1251		return1252	}1253	if modificationParams.NewTitle == "" {1254		h.HandleErrorWithCode(w, http.StatusBadRequest, "bad parameter: checklist title",1255			errors.New("checklist title must not be blank"))1256		return1257	}1258	if err := h.playbookRunService.RenameChecklist(id, userID, checklistNum, modificationParams.NewTitle); err != nil {1259		h.HandleError(w, err)1260		return1261	}1262	w.WriteHeader(http.StatusOK)1263}1264func (h *PlaybookRunHandler) moveChecklist(w http.ResponseWriter, r *http.Request) {1265	vars := mux.Vars(r)1266	id := vars["id"]1267	userID := r.Header.Get("Mattermost-User-ID")1268	var params struct {1269		SourceChecklistIdx int `json:"source_checklist_idx"`1270		DestChecklistIdx   int `json:"dest_checklist_idx"`1271	}1272	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {1273		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal edit params", err)1274		return1275	}1276	if err := h.playbookRunService.MoveChecklist(id, userID, params.SourceChecklistIdx, params.DestChecklistIdx); err != nil {1277		h.HandleError(w, err)1278		return1279	}1280	w.WriteHeader(http.StatusOK)1281}1282func (h *PlaybookRunHandler) moveChecklistItem(w http.ResponseWriter, r *http.Request) {1283	vars := mux.Vars(r)1284	id := vars["id"]1285	userID := r.Header.Get("Mattermost-User-ID")1286	var params struct {1287		SourceChecklistIdx int `json:"source_checklist_idx"`1288		SourceItemIdx      int `json:"source_item_idx"`1289		DestChecklistIdx   int `json:"dest_checklist_idx"`1290		DestItemIdx        int `json:"dest_item_idx"`1291	}1292	if err := json.NewDecoder(r.Body).Decode(&params); err != nil {1293		h.HandleErrorWithCode(w, http.StatusBadRequest, "failed to unmarshal edit params", err)1294		return1295	}1296	if err := h.playbookRunService.MoveChecklistItem(id, userID, params.SourceChecklistIdx, params.SourceItemIdx, params.DestChecklistIdx, params.DestItemIdx); err != nil {1297		h.HandleError(w, err)1298		return1299	}1300	w.WriteHeader(http.StatusOK)1301}1302func (h *PlaybookRunHandler) postPlaybookRunCreatedMessage(playbookRun *app.PlaybookRun, channelID string) error {1303	channel, err := h.pluginAPI.Channel.Get(playbookRun.ChannelID)1304	if err != nil {1305		return err1306	}1307	post := &model.Post{1308		Message: fmt.Sprintf("Playbook run %s started in ~%s", playbookRun.Name, channel.Name),1309	}1310	h.poster.EphemeralPost(playbookRun.OwnerUserID, channelID, post)1311	return nil1312}1313func (h *PlaybookRunHandler) updateRetrospective(w http.ResponseWriter, r *http.Request) {1314	vars := mux.Vars(r)1315	playbookRunID := vars["id"]1316	userID := r.Header.Get("Mattermost-User-ID")1317	var retroUpdate app.RetrospectiveUpdate1318	if err := json.NewDecoder(r.Body).Decode(&retroUpdate); err != nil {1319		h.HandleErrorWithCode(w, http.StatusBadRequest, "unable to decode payload", err)1320		return1321	}1322	if err := h.playbookRunService.UpdateRetrospective(playbookRunID, userID, retroUpdate); err != nil {1323		h.HandleErrorWithCode(w, http.StatusInternalServerError, "unable to update retrospective", err)1324		return1325	}1326	w.WriteHeader(http.StatusOK)1327}1328func (h *PlaybookRunHandler) publishRetrospective(w http.ResponseWriter, r *http.Request) {1329	vars := mux.Vars(r)1330	playbookRunID := vars["id"]1331	userID := r.Header.Get("Mattermost-User-ID")1332	var retroUpdate app.RetrospectiveUpdate1333	if err := json.NewDecoder(r.Body).Decode(&retroUpdate); err != nil {1334		h.HandleErrorWithCode(w, http.StatusBadRequest, "unable to decode payload", err)1335		return1336	}1337	if err := h.playbookRunService.PublishRetrospective(playbookRunID, userID, retroUpdate); err != nil {1338		h.HandleErrorWithCode(w, http.StatusInternalServerError, "unable to publish retrospective", err)1339		return1340	}1341	w.WriteHeader(http.StatusOK)1342}1343func (h *PlaybookRunHandler) follow(w http.ResponseWriter, r *http.Request) {1344	playbookRunID := mux.Vars(r)["id"]1345	userID := r.Header.Get("Mattermost-User-ID")1346	if !h.PermissionsCheck(w, h.permissions.RunView(userID, playbookRunID)) {1347		return1348	}1349	if err := h.playbookRunService.Follow(playbookRunID, userID); err != nil {1350		h.HandleError(w, err)1351		return1352	}1353	w.WriteHeader(http.StatusOK)1354}1355func (h *PlaybookRunHandler) unfollow(w http.ResponseWriter, r *http.Request) {1356	playbookRunID := mux.Vars(r)["id"]1357	userID := r.Header.Get("Mattermost-User-ID")1358	if err := h.playbookRunService.Unfollow(playbookRunID, userID); err != nil {1359		h.HandleError(w, err)1360		return1361	}1362	w.WriteHeader(http.StatusOK)1363}1364func (h *PlaybookRunHandler) getFollowers(w http.ResponseWriter, r *http.Request) {1365	playbookRunID := mux.Vars(r)["id"]1366	userID := r.Header.Get("Mattermost-User-ID")1367	if !h.PermissionsCheck(w, h.permissions.RunView(userID, playbookRunID)) {1368		return1369	}1370	var followers []string1371	var err error1372	if followers, err = h.playbookRunService.GetFollowers(playbookRunID); err != nil {1373		h.HandleError(w, err)1374		return1375	}1376	ReturnJSON(w, followers, http.StatusOK)1377}1378// parsePlaybookRunsFilterOptions is only for parsing. Put validation logic in app.validateOptions.1379func parsePlaybookRunsFilterOptions(u *url.URL, currentUserID string) (*app.PlaybookRunFilterOptions, error) {1380	teamID := u.Query().Get("team_id")1381	pageParam := u.Query().Get("page")1382	if pageParam == "" {1383		pageParam = "0"1384	}1385	page, err := strconv.Atoi(pageParam)1386	if err != nil {1387		return nil, errors.Wrapf(err, "bad parameter 'page'")1388	}1389	perPageParam := u.Query().Get("per_page")1390	if perPageParam == "" {1391		perPageParam = "0"1392	}1393	perPage, err := strconv.Atoi(perPageParam)1394	if err != nil {1395		return nil, errors.Wrapf(err, "bad parameter 'per_page'")1396	}1397	sort := u.Query().Get("sort")1398	direction := u.Query().Get("direction")1399	// Parse statuses= query string parameters as an array.1400	statuses := u.Query()["statuses"]1401	ownerID := u.Query().Get("owner_user_id")1402	if ownerID == client.Me {1403		ownerID = currentUserID1404	}1405	searchTerm := u.Query().Get("search_term")1406	participantID := u.Query().Get("participant_id")1407	if participantID == client.Me {1408		participantID = currentUserID1409	}1410	participantOrFollowerID := u.Query().Get("participant_or_follower_id")1411	if participantOrFollowerID == client.Me {1412		participantOrFollowerID = currentUserID1413	}1414	playbookID := u.Query().Get("playbook_id")1415	activeGTEParam := u.Query().Get("active_gte")1416	if activeGTEParam == "" {1417		activeGTEParam = "0"1418	}1419	activeGTE, _ := strconv.ParseInt(activeGTEParam, 10, 64)1420	activeLTParam := u.Query().Get("active_lt")1421	if activeLTParam == "" {1422		activeLTParam = "0"1423	}1424	activeLT, _ := strconv.ParseInt(activeLTParam, 10, 64)1425	startedGTEParam := u.Query().Get("started_gte")1426	if startedGTEParam == "" {1427		startedGTEParam = "0"1428	}1429	startedGTE, _ := strconv.ParseInt(startedGTEParam, 10, 64)1430	startedLTParam := u.Query().Get("started_lt")1431	if startedLTParam == "" {1432		startedLTParam = "0"1433	}1434	startedLT, _ := strconv.ParseInt(startedLTParam, 10, 64)1435	options := app.PlaybookRunFilterOptions{1436		TeamID:                  teamID,1437		Page:                    page,1438		PerPage:                 perPage,1439		Sort:                    app.SortField(sort),1440		Direction:               app.SortDirection(direction),1441		Statuses:                statuses,1442		OwnerID:                 ownerID,1443		SearchTerm:              searchTerm,1444		ParticipantID:           participantID,1445		ParticipantOrFollowerID: participantOrFollowerID,1446		PlaybookID:              playbookID,1447		ActiveGTE:               activeGTE,1448		ActiveLT:                activeLT,1449		StartedGTE:              startedGTE,...

gin_integration_test.go

Source:gin_integration_test.go

...19	assert.NoError(t, ioerr)20	assert.Equal(t, "it worked", string(body), "resp body should match")21	assert.Equal(t, "200 OK", resp.Status, "should get a 200")22}23func TestRunEmpty(t *testing.T) {24	os.Setenv("PORT", "")25	router := New()26	go func() {27		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })28		assert.NoError(t, router.Run())29	}()30	// have to wait for the goroutine to start and run the server31	// otherwise the main thread will complete32	time.Sleep(5 * time.Millisecond)33	assert.Error(t, router.Run(":8080"))34	testRequest(t, "http://localhost:8080/example")35}36func TestRunEmptyWithEnv(t *testing.T) {37	os.Setenv("PORT", "3123")38	router := New()39	go func() {40		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })41		assert.NoError(t, router.Run())42	}()43	// have to wait for the goroutine to start and run the server44	// otherwise the main thread will complete45	time.Sleep(5 * time.Millisecond)46	assert.Error(t, router.Run(":3123"))47	testRequest(t, "http://localhost:3123/example")48}49func TestRunTooMuchParams(t *testing.T) {50	router := New()51	assert.Panics(t, func() {52		router.Run("2", "2")53	})54}55func TestRunWithPort(t *testing.T) {56	router := New()57	go func() {58		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })59		assert.NoError(t, router.Run(":5150"))60	}()61	// have to wait for the goroutine to start and run the server62	// otherwise the main thread will complete63	time.Sleep(5 * time.Millisecond)64	assert.Error(t, router.Run(":5150"))65	testRequest(t, "http://localhost:5150/example")66}67func TestUnixSocket(t *testing.T) {68	router := New()69	go func() {70		router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })71		assert.NoError(t, router.RunUnix("/tmp/unix_unit_test"))72	}()73	// have to wait for the goroutine to start and run the server74	// otherwise the main thread will complete75	time.Sleep(5 * time.Millisecond)76	c, err := net.Dial("unix", "/tmp/unix_unit_test")77	assert.NoError(t, err)78	fmt.Fprintf(c, "GET /example HTTP/1.0\r\n\r\n")79	scanner := bufio.NewScanner(c)80	var response string81	for scanner.Scan() {82		response += scanner.Text()83	}84	assert.Contains(t, response, "HTTP/1.0 200", "should get a 200")85	assert.Contains(t, response, "it worked", "resp body should match")86}87func TestBadUnixSocket(t *testing.T) {88	router := New()89	assert.Error(t, router.RunUnix("#/tmp/unix_unit_test"))90}91func TestWithHttptestWithAutoSelectedPort(t *testing.T) {92	router := New()93	router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })94	ts := httptest.NewServer(router)95	defer ts.Close()96	testRequest(t, ts.URL+"/example")97}98func TestWithHttptestWithSpecifiedPort(t *testing.T) {99	router := New()100	router.GET("/example", func(c *Context) { c.String(http.StatusOK, "it worked") })101	l, _ := net.Listen("tcp", ":8033")102	ts := httptest.Server{103		Listener: l,...

Run

Using AI Code Generation

1import (2func main() {3    http.HandleFunc("/", handler)4    http.ListenAndServe(":8080", nil)5}6func handler(w http.ResponseWriter, r *http.Request) {7    fmt.Fprintf(w, "Hello World")8}9import (10func main() {11    http.HandleFunc("/", handler)12    http.ListenAndServe(":8080", nil)13}14func handler(w http.ResponseWriter, r *http.Request) {15    fmt.Fprintf(w, "Hello World")16}17import (18func main() {19    http.HandleFunc("/", handler)20    http.ListenAndServe(":8080", nil)21}22func handler(w http.ResponseWriter, r *http.Request) {23    fmt.Fprintf(w, "Hello World")24}25import (26func main() {27    http.HandleFunc("/", handler)28    http.ListenAndServe(":8080", nil)29}30func handler(w http.ResponseWriter, r *http.Request) {31    fmt.Fprintf(w, "Hello World")32}33import (34func main() {35    http.HandleFunc("/", handler)36    http.ListenAndServe(":8080", nil)37}38func handler(w http.ResponseWriter, r *http.Request) {39    fmt.Fprintf(w, "Hello World")40}41import (42func main() {43    http.HandleFunc("/", handler)44    http.ListenAndServe(":8080", nil)45}46func handler(w http.ResponseWriter, r *http.Request) {47    fmt.Fprintf(w, "Hello World")48}49import (50func main() {51    http.HandleFunc("/", handler)52    http.ListenAndServe(":8080", nil)53}54func handler(w http.ResponseWriter, r *http.Request) {

Run

Using AI Code Generation

1import (2func main() {3	http.HandleFunc("/", handler)4	http.ListenAndServe(":8080", nil)5}6func handler(w http.ResponseWriter, r *http.Request) {7	fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])8}9import (10func main() {11	http.HandleFunc("/", handler)12	http.ListenAndServe(":8080", nil)13}14func handler(w http.ResponseWriter, r *http.Request) {15	fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])16}17import (18func main() {19	http.HandleFunc("/", handler)20	http.ListenAndServe(":8080", nil)21}22func handler(w http.ResponseWriter, r *http.Request) {23	fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])24}25import (26func main() {27	http.HandleFunc("/", handler)28	http.ListenAndServe(":8080", nil)29}30func handler(w http.ResponseWriter, r *http.Request) {31	fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])32}33import (34func main() {35	http.HandleFunc("/", handler)36	http.ListenAndServe(":8080", nil)37}38func handler(w http.ResponseWriter, r *http.Request) {39	fmt.Fprintf(w, "Hi there, I love %s!", r.URL.Path[1:])40}41import (42func main() {43	http.HandleFunc("/", handler)44	http.ListenAndServe(":8080", nil)45}46func handler(w http.ResponseWriter, r *http.Request) {47	fmt.Fprintf(w,

Run

Using AI Code Generation

1import (2func main() {3    http.HandleFunc("/", handler)4    http.ListenAndServe(":8080", nil)5}6func handler(w http.ResponseWriter, r *http.Request) {7    w.Write([]byte("Hello World"))8}9import (10func main() {11    http.HandleFunc("/", handler)12    http.ListenAndServe(":8080", nil)13}14func handler(w http.ResponseWriter, r *http.Request) {15    w.Write([]byte("Hello World"))16}17import (18func main() {19    http.HandleFunc("/", handler)20    http.ListenAndServe(":8080", nil)21}22func handler(w http.ResponseWriter, r *http.Request) {23    w.Write([]byte("Hello World"))24}25import (26func main() {27    http.HandleFunc("/", handler)28    http.ListenAndServe(":8080", nil)29}30func handler(w http.ResponseWriter, r *http.Request) {31    w.Write([]byte("Hello World"))32}33import (34func main() {35    http.HandleFunc("/", handler)36    http.ListenAndServe(":8080", nil)37}38func handler(w http.ResponseWriter, r *http.Request) {39    w.Write([]byte("Hello World"))40}41import (42func main() {43    http.HandleFunc("/", handler)44    http.ListenAndServe(":8080", nil)45}46func handler(w http.ResponseWriter, r *http.Request) {47    w.Write([]byte("Hello World"))48}49import (50func main() {51    http.HandleFunc("/", handler)52    http.ListenAndServe(":8080", nil)53}54func handler(w http.ResponseWriter, r *http.Request) {55    w.Write([]byte("Hello World"))56}

Run

Using AI Code Generation

1import (2func main() {3    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {4        fmt.Fprintf(w, "Hello, %q", r.URL.Path)5    })6    http.ListenAndServe(":8080", nil)7}8import (9func main() {10    http.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {11        fmt.Fprintf(w, "Hello, %q", r.URL.Path)12    }))13    http.ListenAndServe(":8080", nil)14}15import (16func main() {17    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {18        fmt.Fprintf(w, "Hello, %q", r.URL.Path)19    })20    http.ListenAndServe(":8080", nil)21}22import (23func main() {24    http.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {25        fmt.Fprintf(w, "Hello, %q", r.URL.Path)26    }))27    http.ListenAndServe(":8080", nil)28}29import (30func main() {31    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {32        fmt.Fprintf(w, "Hello, %q", r.URL.Path)33    })34    http.ListenAndServe(":8080", nil

Run

Using AI Code Generation

1import (2func main() {3    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {4        fmt.Fprintf(w, "Hello, you've requested: %s5    })6    http.ListenAndServe(":8080", nil)7}8import (9func main() {10    mux := http.NewServeMux()11    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {12        fmt.Fprintf(w, "Hello, you've requested: %s13    })14    http.ListenAndServe(":8080", mux)15}16import (17func main() {18    http.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {19        fmt.Fprintf(w, "Hello, you've requested: %s20    }))21    http.ListenAndServe(":8080", nil)22}23import (24func main() {25    mux := http.NewServeMux()26    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {27        fmt.Fprintf(w, "Hello, you've requested: %s28    })29    http.ListenAndServe(":8080", mux)30}31import (32func main() {33    mux := http.NewServeMux()34    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {35        fmt.Fprintf(w, "Hello, you've requested: %s36    })37    http.ListenAndServe(":8080", mux)38}39import (40func main() {41    mux := http.NewServeMux()42    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

Run

Using AI Code Generation

1import "net/http"2import "fmt"3func main() {4    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {5        fmt.Fprintf(w, "Hello, you've requested: %s6    })7    http.ListenAndServe(":8080", nil)8}9import "net/http"10import "fmt"11func main() {12    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {13        fmt.Fprintf(w, "Hello, you've requested: %s14    })15    http.ListenAndServe(":8080", nil)16}17import "net/http"18import "fmt"19func main() {20    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {21        fmt.Fprintf(w, "Hello, you've requested: %s22    })23    http.ListenAndServe(":8080", nil)24}25import "net/http"26import "fmt"27func main() {28    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {29        fmt.Fprintf(w, "Hello, you've requested: %s30    })31    http.ListenAndServe(":8080", nil)32}33import "net/http"34import "fmt"35func main() {36    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {37        fmt.Fprintf(w, "Hello, you've requested: %s38    })39    http.ListenAndServe(":8080", nil)40}41import "net/http"42import "fmt"43func main() {44    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {45        fmt.Fprintf(w, "Hello, you've requested: %s46    })47    http.ListenAndServe(":8080", nil)48}49import "net/http"50import "fmt"51func main() {52    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

Run

Using AI Code Generation

1import "net/http"2func main() {3http.ListenAndServe(":8080", nil)4}5import (6func main() {7err := http.ListenAndServe(":8080", nil)8if err != nil {9log.Fatal(err)10}11}12import (13func main() {14err := http.ListenAndServe(":8080", nil)15if err != nil {16log.Fatal(err)17}18}19import (20func main() {21err := http.ListenAndServe(":8080", nil)22if err != nil {23log.Fatal(err)24}25}26import (27func main() {28err := http.ListenAndServe(":8080", nil)29if err != nil {30log.Fatal(err)31}32}33import (34func main() {35err := http.ListenAndServe(":8080", nil)36if err != nil {37log.Fatal(err)38}39}40import (41func main() {42err := http.ListenAndServe(":8080", nil)43if err != nil {44log.Fatal(err)45}46}47import (48func main() {49err := http.ListenAndServe(":8080", nil)50if err != nil {51log.Fatal(err)52}53}54import (55func main() {56err := http.ListenAndServe(":8080", nil)57if err != nil {58log.Fatal(err)59}60}61import (62func main() {63err := http.ListenAndServe(":8080", nil)

Run

Using AI Code Generation

1import (2func main() {3	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {4		fmt.Fprintf(w, "Hello World")5	})6	http.ListenAndServe(":8080", nil)7}8import (9func main() {10	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {11		http.ServeFile(w, r, "index.html")12	})13	http.ListenAndServe(":8080", nil)14}15import (16func main() {17	mux := http.NewServeMux()18	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {19		fmt.Fprintf(w, "Hello World")20	})21	http.ListenAndServe(":8080", mux)22}23import (24type MyHandler struct{}25func main() {26	http.Handle("/", new(MyHandler))27	http.ListenAndServe(":8080", nil)28}29func (this *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {30	fmt.Fprintf(w, "Hello World")31}32import (33type MyHandler struct{}34func main() {35	http.Handle("/", new(MyHandler))36	http.ListenAndServe(":8080", nil)37}38func (this *MyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {39	fmt.Fprintf(w, "Hello World")40}

Run

Using AI Code Generation

1import (2func main(){3	http.HandleFunc("/", index)4	http.HandleFunc("/about", about)5	http.HandleFunc("/contact", contact)6	http.HandleFunc("/apply", apply)7	http.ListenAndServe(":8080", nil)8}9func index(w http.ResponseWriter, r *http.Request){10	io.WriteString(w, "Welcome to my website!")11}12func about(w http.ResponseWriter, r *http.Request){13	io.WriteString(w, "About us")14}15func contact(w http.ResponseWriter, r *http.Request){16	io.WriteString(w, "Contact us")17}18func apply(w http.ResponseWriter, r *http.Request){19	io.WriteString(w, "Apply here")20}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.