Refactor the system hook code a little

event_parsing.go

@@ -18,9 +18,9 @@ const (
 	EventTypeNote         EventType = "Note Hook"
 	EventTypePipeline     EventType = "Pipeline Hook"
 	EventTypePush         EventType = "Push Hook"
+	EventTypeSystemHook   EventType = "System Hook"
 	EventTypeTagPush      EventType = "Tag Push Hook"
 	EventTypeWikiPage     EventType = "Wiki Page Hook"
-	EventSystemHook       EventType = "System Hook"
 )
 
 const (
@@ -39,6 +39,119 @@ type noteEvent struct {
 
 const eventTypeHeader = "X-Gitlab-Event"
 
+// HookEventType returns the event type for the given request.
+func HookEventType(r *http.Request) EventType {
+	return EventType(r.Header.Get(eventTypeHeader))
+}
+
+// ParseHook tries to parse both web- and system hooks.
+//
+// Example usage:
+//
+// func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+//     payload, err := ioutil.ReadAll(r.Body)
+//     if err != nil { ... }
+//     event, err := gitlab.ParseHook(gitlab.HookEventType(r), payload)
+//     if err != nil { ... }
+//     switch event := event.(type) {
+//     case *gitlab.PushEvent:
+//         processPushEvent(event)
+//     case *gitlab.MergeEvent:
+//         processMergeEvent(event)
+//     ...
+//     }
+// }
+//
+func ParseHook(eventType EventType, payload []byte) (event interface{}, err error) {
+	switch eventType {
+	case EventTypeSystemHook:
+		return ParseSystemhook(payload)
+	default:
+		return ParseWebhook(eventType, payload)
+	}
+}
+
+// ParseSystemhook parses the event payload. For recognized event types, a
+// value of the corresponding struct type will be returned. An error will be
+// returned for unrecognized event types.
+//
+// Example usage:
+//
+// func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+//     payload, err := ioutil.ReadAll(r.Body)
+//     if err != nil { ... }
+//     event, err := gitlab.ParseSystemhook(payload)
+//     if err != nil { ... }
+//     switch event := event.(type) {
+//     case *gitlab.PushSystemEvent:
+//         processPushSystemEvent(event)
+//     case *gitlab.MergeSystemEvent:
+//         processMergeSystemEvent(event)
+//     ...
+//     }
+// }
+//
+func ParseSystemhook(payload []byte) (event interface{}, err error) {
+	e := &systemHookEvent{}
+	err = json.Unmarshal(payload, e)
+	if err != nil {
+		return nil, err
+	}
+
+	switch e.EventName {
+	case "push":
+		event = &PushSystemEvent{}
+	case "tag_push":
+		event = &TagPushSystemEvent{}
+	case "repository_update":
+		event = &RepositoryUpdateSystemEvent{}
+	case
+		"project_create",
+		"project_update",
+		"project_destroy",
+		"project_transfer",
+		"project_rename":
+		event = &ProjectSystemEvent{}
+	case
+		"group_create",
+		"group_destroy",
+		"group_rename":
+		event = &GroupSystemEvent{}
+	case
+		"key_create",
+		"key_destroy":
+		event = &KeySystemEvent{}
+	case
+		"user_create",
+		"user_destroy",
+		"user_rename":
+		event = &UserSystemEvent{}
+	case
+		"user_add_to_group",
+		"user_remove_from_group",
+		"user_update_for_group":
+		event = &UserGroupSystemEvent{}
+	case
+		"user_add_to_team",
+		"user_remove_from_team",
+		"user_update_for_team":
+		event = &UserTeamSystemEvent{}
+	default:
+		switch e.ObjectKind {
+		case "merge_request":
+			event = &MergeEvent{}
+		default:
+			return nil, fmt.Errorf("unexpected system hook type %s", e.EventName)
+		}
+	}
+
+	if err := json.Unmarshal(payload, event); err != nil {
+		return nil, err
+	}
+
+	return event, nil
+}
+
 // WebhookEventType returns the event type for the given request.
 func WebhookEventType(r *http.Request) EventType {
 	return EventType(r.Header.Get(eventTypeHeader))
@@ -53,7 +166,7 @@ func WebhookEventType(r *http.Request) EventType {
 // func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 //     payload, err := ioutil.ReadAll(r.Body)
 //     if err != nil { ... }
-//     event, err := gitlab.ParseWebhook(gitlab.WebhookEventType(r), payload)
+//     event, err := gitlab.ParseWebhook(gitlab.HookEventType(r), payload)
 //     if err != nil { ... }
 //     switch event := event.(type) {
 //     case *gitlab.PushEvent:
@@ -116,89 +229,3 @@ func ParseWebhook(eventType EventType, payload []byte) (event interface{}, err e
 
 	return event, nil
 }
-
-// ParseSystemhook parses the System Hook event payload. For recognized event types, a
-// value of the corresponding struct type will be returned. An error will
-// be returned for unrecognized event types.
-func ParseSystemhook(eventType EventType, payload []byte) (event interface{}, err error) {
-	switch eventType {
-	case EventSystemHook:
-		e := &systemHookEvent{}
-		err := json.Unmarshal(payload, e)
-		if err != nil {
-			return nil, err
-		}
-
-		switch e.EventName {
-		case "push":
-			event = &PushSystemHookEvent{}
-		case "tag_push":
-			event = &TagPushSystemHookEvent{}
-		case "repository_update":
-			event = &RepositoryUpdateSystemHookEvent{}
-		case "project_create":
-			fallthrough
-		case "project_update":
-			fallthrough
-		case "project_destroy":
-			fallthrough
-		case "project_transfer":
-			fallthrough
-		case "project_rename":
-			event = &ProjectSystemHookEvent{}
-		case "group_create":
-			fallthrough
-		case "group_destroy":
-			fallthrough
-		case "group_rename":
-			event = &GroupSystemHookEvent{}
-		case "key_create":
-			fallthrough
-		case "key_destroy":
-			event = &KeySystemHookEvent{}
-		case "user_create":
-			fallthrough
-		case "user_destroy":
-			fallthrough
-		case "user_rename":
-			event = &UserSystemHookEvent{}
-		case "user_add_to_group":
-			fallthrough
-		case "user_remove_from_group":
-			fallthrough
-		case "user_update_for_group":
-			event = &UserGroupSystemHookEvent{}
-		case "user_add_to_team":
-			fallthrough
-		case "user_remove_from_team":
-			fallthrough
-		case "user_update_for_team":
-			event = &UserTeamSystemHookEvent{}
-		default:
-			switch e.ObjectKind {
-			case "merge_request":
-				event = &MergeEvent{}
-			default:
-				return nil, fmt.Errorf("unexpected system hook type %s", e.EventName)
-			}
-		}
-
-	default:
-		return nil, fmt.Errorf("unexpected event type: %s", eventType)
-	}
-
-	if err := json.Unmarshal(payload, event); err != nil {
-		return nil, err
-	}
-
-	return event, nil
-}
-
-// ParseHook processes both ParseWebhook & ParseSystemhook
-func ParseHook(eventType EventType, payload []byte) (event interface{}, err error) {
-	if event, err = ParseWebhook(eventType, payload); err != nil {
-		event, err = ParseSystemhook(eventType, payload)
-		return
-	}
-	return
-}