func (h DeleteHandler) ServeHTTP(w http.ResponseWriter, request *http.Request, context stack.Context) { splitURL := strings.Split(request.URL.Path, "/") templateID := splitURL[len(splitURL)-1] database := context.Get("database").(collections.DatabaseInterface) clientID := context.Get("client_id").(string) _, err := h.deleter.Get(database.Connection(), templateID, clientID) if err != nil { switch err.(type) { case collections.NotFoundError: w.WriteHeader(http.StatusNotFound) default: w.WriteHeader(http.StatusInternalServerError) } fmt.Fprintf(w, `{"errors": [%q]}`, err) return } err = h.deleter.Delete(database.Connection(), templateID) if err != nil { switch err.(type) { case collections.NotFoundError: w.WriteHeader(http.StatusNotFound) default: w.WriteHeader(http.StatusInternalServerError) } fmt.Fprintf(w, `{"errors": [%q]}`, err) return } w.WriteHeader(http.StatusNoContent) }
func (h GetHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { templateID := strings.Split(req.URL.Path, "/templates/")[1] template, err := h.finder.FindByID(context.Get("database").(DatabaseInterface), templateID) if err != nil { h.errorWriter.Write(w, err) return } var metadata map[string]interface{} err = json.Unmarshal([]byte(template.Metadata), &metadata) if err != nil { h.errorWriter.Write(w, err) return } templateOutput := TemplateOutput{ Name: template.Name, Subject: template.Subject, HTML: template.HTML, Text: template.Text, Metadata: metadata, } writeJSON(w, http.StatusOK, templateOutput) }
func (h ListHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request, context stack.Context) { clientID := context.Get("client_id").(string) database := context.Get("database").(DatabaseInterface) senderList, err := h.collection.List(database.Connection(), clientID) if err != nil { writer.WriteHeader(http.StatusInternalServerError) fmt.Fprintf(writer, `{ "errors": [ %q ] }`, err) return } responseList := []interface{}{} for _, sender := range senderList { responseList = append(responseList, map[string]interface{}{ "id": sender.ID, "name": sender.Name, }) } listResponse, _ := json.Marshal(map[string]interface{}{ "senders": responseList, }) writer.Write(listResponse) }
func (m Middleware) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) bool { str := fmt.Sprintf("Middleware: %s\n", m.Name) context.Set(m.Name, fmt.Sprintf("I'm a middleware %s\n", m.Name)) w.Header().Add("X-Middleware", m.Name) w.Write([]byte(str)) return true }
func (h GetHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { splitURL := strings.Split(req.URL.Path, "/") senderID := splitURL[len(splitURL)-3] campaignID := splitURL[len(splitURL)-1] clientID := context.Get("client_id").(string) database := context.Get("database").(collections.DatabaseInterface) campaign, err := h.campaigns.Get(database.Connection(), campaignID, senderID, clientID) if err != nil { switch err.(type) { case collections.NotFoundError: w.WriteHeader(http.StatusNotFound) default: w.WriteHeader(http.StatusInternalServerError) } fmt.Fprintf(w, `{ "errors": [%q] }`, err) return } getResponse, _ := json.Marshal(map[string]interface{}{ "id": campaign.ID, "send_to": campaign.SendTo, "campaign_type_id": campaign.CampaignTypeID, "text": campaign.Text, "html": campaign.HTML, "subject": campaign.Subject, "template_id": campaign.TemplateID, "reply_to": campaign.ReplyTo, }) w.Write(getResponse) }
func (ware Authenticator) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) bool { rawToken := ware.getToken(req) if rawToken == "" { return ware.Error(w, http.StatusUnauthorized, "Authorization header is invalid: missing") } token, err := jwt.Parse(rawToken, func(t *jwt.Token) (interface{}, error) { return []byte(ware.UAAPublicKey), nil }) if err != nil { if strings.Contains(err.Error(), "expired") { return ware.Error(w, http.StatusUnauthorized, "Authorization header is invalid: expired") } return ware.Error(w, http.StatusUnauthorized, "Authorization header is invalid: corrupt") } if !ware.containsATokenScope(w, token) { return false } context.Set("token", token) context.Set("client_id", token.Claims["client_id"]) return true }
func (h ListHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { templates, err := h.lister.List(context.Get("database").(DatabaseInterface)) if err != nil { h.errorWriter.Write(w, err) return } writeJSON(w, http.StatusOK, templates) }
func (h RegistrationHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { database := context.Get("database").(DatabaseInterface) connection := database.Connection() parameters, err := NewRegistrationParams(req.Body) if err != nil { h.errorWriter.Write(w, err) return } err = parameters.Validate() if err != nil { h.errorWriter.Write(w, err) return } token := context.Get("token").(*jwt.Token) clientID := token.Claims["client_id"].(string) client := models.Client{ ID: clientID, Description: parameters.SourceDescription, } kinds, err := h.ValidateCriticalScopes(token.Claims["scope"], parameters.Kinds, client) if err != nil { h.errorWriter.Write(w, err) return } transaction := connection.Transaction() transaction.Begin() err = h.registrar.Register(transaction, client, kinds) if err != nil { transaction.Rollback() h.errorWriter.Write(w, err) return } if parameters.IncludesKinds { err = h.registrar.Prune(transaction, client, kinds) if err != nil { transaction.Rollback() h.errorWriter.Write(w, err) return } } err = transaction.Commit() if err != nil { h.errorWriter.Write(w, err) return } }
func (h Handler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { var output string for _, key := range context.Keys() { output += context.Get(key).(string) } output += fmt.Sprintf("Handler\n") w.Header().Add("X-Handler", "my-handler") w.Write([]byte(output)) }
func (h DeleteHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { templateID := strings.Split(req.URL.Path, "/templates/")[1] err := h.deleter.Delete(context.Get("database").(DatabaseInterface), templateID) if err != nil { h.errorWriter.Write(w, err) } w.WriteHeader(http.StatusNoContent) }
func (h ShowHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request, context stack.Context) { splitURL := strings.Split(request.URL.Path, "/") campaignTypeID := splitURL[len(splitURL)-1] senderID := splitURL[len(splitURL)-3] if senderID == "" { writer.WriteHeader(http.StatusBadRequest) fmt.Fprintf(writer, `{"errors": [%q]}`, "missing sender id") return } if campaignTypeID == "" { headers := writer.Header() headers.Set("Location", fmt.Sprintf("/senders/%s/campaign_types", senderID)) writer.WriteHeader(http.StatusMovedPermanently) return } clientID := context.Get("client_id") if clientID == "" { writer.WriteHeader(http.StatusUnauthorized) fmt.Fprintf(writer, `{"errors": [%q]}`, "missing client id") return } database := context.Get("database").(DatabaseInterface) campaignType, err := h.collection.Get(database.Connection(), campaignTypeID, senderID, context.Get("client_id").(string)) if err != nil { switch err.(type) { case collections.NotFoundError: writer.WriteHeader(http.StatusNotFound) default: writer.WriteHeader(http.StatusInternalServerError) } fmt.Fprintf(writer, `{"errors": [%q]}`, err) return } jsonMap := map[string]interface{}{ "id": campaignType.ID, "name": campaignType.Name, "description": campaignType.Description, "critical": campaignType.Critical, "template_id": campaignType.TemplateID, } jsonBody, err := json.Marshal(jsonMap) if err != nil { panic(err) } writer.Write([]byte(jsonBody)) }
func (h GetUserPreferencesHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { userGUID := strings.TrimPrefix(req.URL.Path, "/user_preferences/") parsed, err := h.preferences.Find(context.Get("database").(DatabaseInterface), userGUID) if err != nil { h.errorWriter.Write(w, err) return } writeJSON(w, http.StatusOK, parsed) }
func (h ListAssociationsHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { templateID := h.parseTemplateID(req.URL.Path) associations, err := h.lister.List(context.Get("database").(DatabaseInterface), templateID) if err != nil { h.errorWriter.Write(w, err) return } templateAssociationsDocument := h.mapToJSON(associations) writeJSON(w, http.StatusOK, templateAssociationsDocument) }
func (h ListHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { clients, notifications, err := h.finder.AllClientsAndNotifications(context.Get("database").(DatabaseInterface)) if err != nil { h.errorWriter.Write(w, err) return } notificationsByClient := h.constructNotifications(clients, notifications) writeJSON(w, http.StatusOK, notificationsByClient) }
func (h UpdateHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { splitURL := strings.Split(req.URL.Path, "/") senderID := splitURL[len(splitURL)-1] var updateRequest struct { Name string `json:"name"` } err := json.NewDecoder(req.Body).Decode(&updateRequest) if err != nil { w.WriteHeader(http.StatusBadRequest) w.Write([]byte(`{"errors": ["invalid json body"]}`)) return } database := context.Get("database").(DatabaseInterface) clientID := context.Get("client_id").(string) _, err = h.senders.Get(database.Connection(), senderID, clientID) if err != nil { switch err.(type) { case collections.NotFoundError: w.WriteHeader(http.StatusNotFound) default: w.WriteHeader(http.StatusInternalServerError) } w.Write([]byte(fmt.Sprintf(`{ "errors": [ %q ]}`, err))) return } sender, err := h.senders.Set(database.Connection(), collections.Sender{ ID: senderID, Name: updateRequest.Name, ClientID: clientID, }) if err != nil { switch err.(type) { case collections.DuplicateRecordError: w.WriteHeader(422) default: w.WriteHeader(http.StatusInternalServerError) } w.Write([]byte(fmt.Sprintf(`{ "errors": [ %q ]}`, err))) return } updateResponse, _ := json.Marshal(map[string]string{ "id": sender.ID, "name": sender.Name, }) w.Write(updateResponse) }
func (h EveryoneHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { connection := context.Get("database").(DatabaseInterface).Connection() vcapRequestID := context.Get(VCAPRequestIDKey).(string) output, err := h.notify.Execute(connection, req, context, "", h.strategy, GUIDValidator{}, vcapRequestID) if err != nil { h.errorWriter.Write(w, err) return } w.WriteHeader(http.StatusOK) w.Write(output) }
func (h UpdatePreferencesHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { database := context.Get("database").(DatabaseInterface) connection := database.Connection() token := context.Get("token").(*jwt.Token) if _, ok := token.Claims["user_id"]; !ok { h.errorWriter.Write(w, webutil.MissingUserTokenError("Missing user_id from token claims.")) return } userID := token.Claims["user_id"].(string) builder := services.NewPreferencesBuilder() validator := valiant.NewValidator(req.Body) err := validator.Validate(&builder) if err != nil { h.errorWriter.Write(w, webutil.ValidationError([]string{err.Error()})) return } preferences, err := builder.ToPreferences() if err != nil { h.errorWriter.Write(w, webutil.ValidationError([]string{err.Error()})) return } transaction := connection.Transaction() transaction.Begin() err = h.preferences.Update(transaction, preferences, builder.GlobalUnsubscribe, userID) if err != nil { transaction.Rollback() switch err.(type) { case services.MissingKindOrClientError, services.CriticalKindError: h.errorWriter.Write(w, webutil.ValidationError([]string{err.Error()})) default: h.errorWriter.Write(w, err) } return } err = transaction.Commit() if err != nil { h.errorWriter.Write(w, models.NewTransactionCommitError(err.Error())) return } w.WriteHeader(http.StatusNoContent) }
func (h UAAScopeHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { conn := context.Get("database").(DatabaseInterface).Connection() scope := strings.TrimPrefix(req.URL.Path, "/uaa_scopes/") vcapRequestID := context.Get(VCAPRequestIDKey).(string) output, err := h.notify.Execute(conn, req, context, scope, h.strategy, GUIDValidator{}, vcapRequestID) if err != nil { h.errorWriter.Write(w, err) return } w.WriteHeader(http.StatusOK) w.Write(output) }
func (h UpdateDefaultHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { template, err := NewTemplateParams(req.Body) if err != nil { h.errorWriter.Write(w, err) return } err = h.updater.Update(context.Get("database").(DatabaseInterface), models.DefaultTemplateID, template.ToModel()) if err != nil { h.errorWriter.Write(w, err) } w.WriteHeader(http.StatusNoContent) }
func (h GetHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { messageID := strings.Split(req.URL.Path, "/messages/")[1] message, err := h.finder.Find(context.Get("database").(DatabaseInterface), messageID) if err != nil { h.errorWriter.Write(w, err) return } var document struct { Status string `json:"status"` } document.Status = message.Status writeJSON(w, http.StatusOK, document) }
func (h UpdateHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { templateID := strings.Split(req.URL.String(), "/templates/")[1] templateParams, err := NewTemplateParams(req.Body) if err != nil { h.errorWriter.Write(w, err) return } err = h.updater.Update(context.Get("database").(DatabaseInterface), templateID, templateParams.ToModel()) if err != nil { h.errorWriter.Write(w, err) return } w.WriteHeader(http.StatusNoContent) }
func (h CreateHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { templateParams, err := NewTemplateParams(req.Body) if err != nil { h.errorWriter.Write(w, err) return } template := templateParams.ToModel() templateID, err := h.creator.Create(context.Get("database").(DatabaseInterface), template) if err != nil { h.errorWriter.Write(w, webutil.TemplateCreateError{}) return } w.WriteHeader(http.StatusCreated) w.Write([]byte(`{"template_id":"` + templateID + `"}`)) }
func (h GetPreferencesHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { token := context.Get("token").(*jwt.Token) if _, ok := token.Claims["user_id"]; !ok { h.errorWriter.Write(w, webutil.MissingUserTokenError("Missing user_id from token claims.")) return } userID := token.Claims["user_id"].(string) parsed, err := h.preferences.Find(context.Get("database").(DatabaseInterface), userID) if err != nil { h.errorWriter.Write(w, err) return } writeJSON(w, http.StatusOK, parsed) }
func (h AssignTemplateHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { clientID, notificationID := h.parseURL(req.URL.Path) var templateAssignment TemplateAssignment err := json.NewDecoder(req.Body).Decode(&templateAssignment) if err != nil { h.errorWriter.Write(w, webutil.ParseError{}) return } database := context.Get("database").(DatabaseInterface) err = h.templateAssigner.AssignToNotification(database, clientID, notificationID, templateAssignment.Template) if err != nil { h.errorWriter.Write(w, err) return } w.WriteHeader(http.StatusNoContent) }
func (h UpdateUserPreferencesHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { database := context.Get("database").(DatabaseInterface) connection := database.Connection() userGUID := regexp.MustCompile(".*/user_preferences/(.*)").FindStringSubmatch(req.URL.Path)[1] builder := services.NewPreferencesBuilder() validator := valiant.NewValidator(req.Body) err := validator.Validate(&builder) if err != nil { h.errorWriter.Write(w, webutil.ValidationError([]string{err.Error()})) return } preferences, err := builder.ToPreferences() if err != nil { h.errorWriter.Write(w, err) return } transaction := connection.Transaction() transaction.Begin() err = h.preferences.Update(transaction, preferences, builder.GlobalUnsubscribe, userGUID) if err != nil { transaction.Rollback() switch err.(type) { case services.MissingKindOrClientError, services.CriticalKindError: h.errorWriter.Write(w, webutil.ValidationError([]string{err.Error()})) default: h.errorWriter.Write(w, err) } return } err = transaction.Commit() if err != nil { h.errorWriter.Write(w, models.NewTransactionCommitError(err.Error())) return } w.WriteHeader(http.StatusNoContent) }
func (h AssignTemplateHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { routeRegex := regexp.MustCompile("/clients/(.*)/template") clientID := routeRegex.FindStringSubmatch(req.URL.Path)[1] var templateAssignment TemplateAssignment err := json.NewDecoder(req.Body).Decode(&templateAssignment) if err != nil { h.errorWriter.Write(w, webutil.ParseError{}) return } database := context.Get("database").(DatabaseInterface) err = h.templateAssigner.AssignToClient(database, clientID, templateAssignment.Template) if err != nil { h.errorWriter.Write(w, err) return } w.WriteHeader(http.StatusNoContent) }
func (h UpdateHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { var updateParams NotificationUpdateParams updateParams, err := NewNotificationParams(req.Body) if err != nil { h.errorWriter.Write(w, err) return } regex := regexp.MustCompile("/clients/(.*)/notifications/(.*)") matches := regex.FindStringSubmatch(req.URL.Path) clientID, notificationID := matches[1], matches[2] err = h.updater.Update(context.Get("database").(DatabaseInterface), updateParams.ToModel(clientID, notificationID)) if err != nil { h.errorWriter.Write(w, err) return } w.WriteHeader(http.StatusNoContent) }
func (h DeleteHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { splitURL := strings.Split(req.URL.Path, "/") senderID := splitURL[len(splitURL)-1] conn := context.Get("database").(collections.DatabaseInterface).Connection() clientID := context.Get("client_id").(string) err := h.senders.Delete(conn, senderID, clientID) if err != nil { switch err.(type) { case collections.NotFoundError: w.WriteHeader(http.StatusNotFound) default: w.WriteHeader(http.StatusInternalServerError) } w.Write([]byte(fmt.Sprintf(`{ "errors": [ %q ]}`, err))) return } w.WriteHeader(http.StatusNoContent) }
func (h DeleteHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { splitURL := strings.Split(req.URL.Path, "/") campaignTypeID := splitURL[len(splitURL)-1] senderID := splitURL[len(splitURL)-3] database := context.Get("database").(DatabaseInterface) if err := h.collection.Delete(database.Connection(), campaignTypeID, senderID, context.Get("client_id").(string)); err != nil { switch err.(type) { case collections.NotFoundError: w.WriteHeader(http.StatusNotFound) fmt.Fprintf(w, `{"errors": [%q]}`, err) return default: w.WriteHeader(http.StatusInternalServerError) fmt.Fprintf(w, `{"errors": ["Delete failed with error: %s"]}`, err) return } } w.WriteHeader(http.StatusNoContent) }
func (h ListHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, context stack.Context) { connection := context.Get("database").(collections.DatabaseInterface).Connection() clientID := context.Get("client_id").(string) templates, err := h.templates.List(connection, clientID) if err != nil { w.WriteHeader(http.StatusInternalServerError) fmt.Fprintf(w, `{"errors": [ %q ] }`, err) return } responseList := []interface{}{} for _, template := range templates { var metadata map[string]interface{} err = json.Unmarshal([]byte(template.Metadata), &metadata) if err != nil { panic(err) } responseList = append(responseList, map[string]interface{}{ "id": template.ID, "name": template.Name, "text": template.Text, "html": template.HTML, "subject": template.Subject, "metadata": metadata, }) } listResponse, _ := json.Marshal(map[string]interface{}{ "templates": responseList, }) w.Write(listResponse) }