update

handlers/fred.go

@@ -43,25 +43,141 @@ func (h *FREDHandler) buildURL(endpoint string, params map[string]string) string
 	return u.String()
 }
 
-func (h *FREDHandler) fetchData(url string, target interface{}) error {
+func (h *FREDHandler) fetchData(target interface{}, c *gin.Context, endpoint string, params map[string]string) {
+	url := h.buildURL(endpoint, params)
+
 	resp, err := http.Get(url)
 	if err != nil {
-		return err
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{
+			ErrorCode:    "NetworkError",
+			ErrorMessage: err.Error(),
+		})
+		return
 	}
 	defer resp.Body.Close()
 
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return err
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{
+			ErrorCode:    "ReadError",
+			ErrorMessage: err.Error(),
+		})
+		return
 	}
 
 	if resp.StatusCode != http.StatusOK {
 		var errResp models.ErrorResponse
 		json.Unmarshal(body, &errResp)
-		return fmt.Errorf("API error: %s - %s", errResp.ErrorCode, errResp.ErrorMessage)
+		c.JSON(http.StatusBadGateway, models.ErrorResponse{
+			ErrorCode:    "APIError",
+			ErrorMessage: fmt.Sprintf("Status: %d, Error: %s - %s", resp.StatusCode, errResp.ErrorCode, errResp.ErrorMessage),
+		})
+		return
 	}
 
-	return json.Unmarshal(body, target)
+	if err := json.Unmarshal(body, target); err != nil {
+		c.JSON(http.StatusInternalServerError, models.ErrorResponse{
+			ErrorCode:    "ParseError",
+			ErrorMessage: err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, target)
+}
+
+func (h *FREDHandler) HealthCheck(c *gin.Context) {
+	c.JSON(http.StatusOK, gin.H{
+		"status":  "healthy",
+		"service": "FRED API",
+	})
+}
+
+func (h *FREDHandler) GetCategory(c *gin.Context) {
+	categoryID := c.Query("category_id")
+	if categoryID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "category_id is required",
+		})
+		return
+	}
+	h.fetchData(&models.CategoryResponse{}, c, "/category", map[string]string{"category_id": categoryID})
+}
+
+func (h *FREDHandler) GetCategoryChildren(c *gin.Context) {
+	categoryID := c.Query("category_id")
+	if categoryID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "category_id is required",
+		})
+		return
+	}
+	params := map[string]string{"category_id": categoryID}
+	h.fetchData(&models.CategoriesResponse{}, c, "/category/children", params)
+}
+
+func (h *FREDHandler) GetCategoryRelated(c *gin.Context) {
+	categoryID := c.Query("category_id")
+	if categoryID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "category_id is required",
+		})
+		return
+	}
+	h.fetchData(&models.RelatedTagsResponse{}, c, "/category/related", map[string]string{"category_id": categoryID})
+}
+
+func (h *FREDHandler) GetCategorySeries(c *gin.Context) {
+	categoryID := c.Query("category_id")
+	if categoryID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "category_id is required",
+		})
+		return
+	}
+	params := map[string]string{"category_id": categoryID}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order"})
+	h.fetchData(&models.CategorySeriesResponse{}, c, "/category/series", params)
+}
+
+func (h *FREDHandler) GetCategoryTags(c *gin.Context) {
+	categoryID := c.Query("category_id")
+	if categoryID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "category_id is required",
+		})
+		return
+	}
+	params := map[string]string{"category_id": categoryID}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order"})
+	h.fetchData(&models.CategoryTagsResponse{}, c, "/category/tags", params)
+}
+
+func (h *FREDHandler) GetCategoryRelatedTags(c *gin.Context) {
+	categoryID := c.Query("category_id")
+	if categoryID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "category_id is required",
+		})
+		return
+	}
+	tagNames := c.Query("tag_names")
+	if tagNames == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "tag_names is required",
+		})
+		return
+	}
+	params := map[string]string{"category_id": categoryID, "tag_names": tagNames}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order"})
+	h.fetchData(&models.RelatedTagsResponse{}, c, "/category/related_tags", params)
 }
 
 func (h *FREDHandler) GetSeries(c *gin.Context) {
@@ -73,30 +189,23 @@ func (h *FREDHandler) GetSeries(c *gin.Context) {
 		})
 		return
 	}
+	params := map[string]string{"series_id": seriesID}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end"})
+	h.fetchData(&models.SeriesResponse{}, c, "/series", params)
+}
 
-	params := map[string]string{
-		"series_id": seriesID,
-	}
-
-	if realtimeStart := c.Query("realtime_start"); realtimeStart != "" {
-		params["realtime_start"] = realtimeStart
-	}
-	if realtimeEnd := c.Query("realtime_end"); realtimeEnd != "" {
-		params["realtime_end"] = realtimeEnd
-	}
-
-	url := h.buildURL("/series", params)
-
-	var response models.SeriesListResponse
-	if err := h.fetchData(url, &response); err != nil {
-		c.JSON(http.StatusInternalServerError, models.ErrorResponse{
-			ErrorCode:    "InternalError",
-			ErrorMessage: err.Error(),
+func (h *FREDHandler) GetSeriesCategories(c *gin.Context) {
+	seriesID := c.Query("series_id")
+	if seriesID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "series_id is required",
 		})
 		return
 	}
-
-	c.JSON(http.StatusOK, response)
+	params := map[string]string{"series_id": seriesID}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end"})
+	h.fetchData(&models.SeriesCategoriesResponse{}, c, "/series/categories", params)
 }
 
 func (h *FREDHandler) GetObservations(c *gin.Context) {
@@ -108,35 +217,27 @@ func (h *FREDHandler) GetObservations(c *gin.Context) {
 		})
 		return
 	}
-
-	params := map[string]string{
-		"series_id": seriesID,
-	}
-
-	optionalParams := []string{
+	params := map[string]string{"series_id": seriesID}
+	h.addOptionalParams(c, params, []string{
 		"realtime_start", "realtime_end", "limit", "offset", "sort_order",
 		"observation_start", "observation_end", "units", "frequency",
 		"aggregation_method", "output_type", "vintage_dates",
-	}
+	})
+	h.fetchData(&models.ObservationsResponse{}, c, "/series/observations", params)
+}
 
-	for _, param := range optionalParams {
-		if v := c.Query(param); v != "" {
-			params[param] = v
-		}
-	}
-
-	url := h.buildURL("/series/observations", params)
-
-	var response models.ObservationsResponse
-	if err := h.fetchData(url, &response); err != nil {
-		c.JSON(http.StatusInternalServerError, models.ErrorResponse{
-			ErrorCode:    "InternalError",
-			ErrorMessage: err.Error(),
+func (h *FREDHandler) GetSeriesRelease(c *gin.Context) {
+	seriesID := c.Query("series_id")
+	if seriesID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "series_id is required",
 		})
 		return
 	}
-
-	c.JSON(http.StatusOK, response)
+	params := map[string]string{"series_id": seriesID}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end"})
+	h.fetchData(&models.ReleaseResponse{}, c, "/series/release", params)
 }
 
 func (h *FREDHandler) SearchSeries(c *gin.Context) {
@@ -148,90 +249,135 @@ func (h *FREDHandler) SearchSeries(c *gin.Context) {
 		})
 		return
 	}
-
-	params := map[string]string{
-		"search_text": searchText,
-	}
-
-	optionalParams := []string{
+	params := map[string]string{"search_text": searchText}
+	h.addOptionalParams(c, params, []string{
 		"realtime_start", "realtime_end", "limit", "offset", "sort_order",
-		"observation_start", "observation_end", "units", "frequency",
-		"aggregation_method", "output_type",
-	}
+		"order_by", "filter", "" +
+			"" +
+			"" +
+			"" +
+			"" +
+			"",
+	})
+	h.fetchData(&models.SearchResponse{}, c, "/series/search", params)
+}
 
-	for _, param := range optionalParams {
-		if v := c.Query(param); v != "" {
-			params[param] = v
-		}
-	}
-
-	url := h.buildURL("/series/search", params)
-
-	var response models.SearchResponse
-	if err := h.fetchData(url, &response); err != nil {
-		c.JSON(http.StatusInternalServerError, models.ErrorResponse{
-			ErrorCode:    "InternalServerError",
-			ErrorMessage: err.Error(),
+func (h *FREDHandler) SearchSeriesTags(c *gin.Context) {
+	searchText := c.Query("search_text")
+	if searchText == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "search_text is required",
 		})
 		return
 	}
+	params := map[string]string{"search_text": searchText}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order"})
+	h.fetchData(&models.TagsResponse{}, c, "/series/search/tags", params)
+}
 
-	c.JSON(http.StatusOK, response)
+func (h *FREDHandler) SearchSeriesRelatedTags(c *gin.Context) {
+	searchText := c.Query("search_text")
+	if searchText == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "search_text is required",
+		})
+		return
+	}
+	tagNames := c.Query("tag_names")
+	if tagNames == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "tag_names is required",
+		})
+		return
+	}
+	params := map[string]string{"search_text": searchText, "tag_names": tagNames}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order"})
+	h.fetchData(&models.RelatedTagsResponse{}, c, "/series/search/related_tags", params)
+}
+
+func (h *FREDHandler) GetSeriesTags(c *gin.Context) {
+	seriesID := c.Query("series_id")
+	if seriesID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "series_id is required",
+		})
+		return
+	}
+	params := map[string]string{"series_id": seriesID}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order"})
+	h.fetchData(&models.SeriesTagsResponse{}, c, "/series/tags", params)
+}
+
+func (h *FREDHandler) GetSeriesUpdates(c *gin.Context) {
+	params := map[string]string{}
+	h.addOptionalParams(c, params, []string{
+		"realtime_start", "realtime_end", "limit", "offset", "sort_order",
+		"filter", "observation_start", "observation_end",
+	})
+	h.fetchData(&models.SeriesUpdatesResponse{}, c, "/series/updates", params)
+}
+
+func (h *FREDHandler) GetSeriesVintageDates(c *gin.Context) {
+	seriesID := c.Query("series_id")
+	if seriesID == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "series_id is required",
+		})
+		return
+	}
+	params := map[string]string{"series_id": seriesID}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end"})
+	h.fetchData(&models.VintageDatesResponse{}, c, "/series/vintagedates", params)
 }
 
 func (h *FREDHandler) GetReleases(c *gin.Context) {
 	params := map[string]string{}
-
-	optionalParams := []string{
-		"realtime_start", "realtime_end", "limit", "offset", "sort_order",
-	}
-
-	for _, param := range optionalParams {
-		if v := c.Query(param); v != "" {
-			params[param] = v
-		}
-	}
-
-	url := h.buildURL("/releases", params)
-
-	var response models.ReleasesResponse
-	if err := h.fetchData(url, &response); err != nil {
-		c.JSON(http.StatusInternalServerError, models.ErrorResponse{
-			ErrorCode:    "InternalServerError",
-			ErrorMessage: err.Error(),
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, response)
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "sort_order"})
+	h.fetchData(&models.ReleasesResponse{}, c, "/releases", params)
 }
 
 func (h *FREDHandler) GetReleaseDates(c *gin.Context) {
 	params := map[string]string{}
-
-	optionalParams := []string{
+	h.addOptionalParams(c, params, []string{
 		"realtime_start", "realtime_end", "limit", "offset", "sort_order",
 		"release_id", "date", "start_date", "end_date",
-	}
+	})
+	h.fetchData(&models.ReleaseDatesResponse{}, c, "/releases/dates", params)
+}
 
-	for _, param := range optionalParams {
-		if v := c.Query(param); v != "" {
-			params[param] = v
-		}
-	}
-
-	url := h.buildURL("/releases/dates", params)
-
-	var response models.ReleaseDatesResponse
-	if err := h.fetchData(url, &response); err != nil {
-		c.JSON(http.StatusInternalServerError, models.ErrorResponse{
-			ErrorCode:    "InternalServerError",
-			ErrorMessage: err.Error(),
+func (h *FREDHandler) GetRelease(c *gin.Context) {
+	releaseIDStr := c.Query("release_id")
+	if releaseIDStr == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "release_id is required",
 		})
 		return
 	}
+	releaseID, _ := strconv.Atoi(releaseIDStr)
+	params := map[string]string{"release_id": strconv.Itoa(releaseID)}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end"})
+	h.fetchData(&models.ReleaseResponse{}, c, "/release", params)
+}
 
-	c.JSON(http.StatusOK, response)
+func (h *FREDHandler) GetReleaseDates2(c *gin.Context) {
+	releaseIDStr := c.Query("release_id")
+	if releaseIDStr == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "release_id is required",
+		})
+		return
+	}
+	releaseID, _ := strconv.Atoi(releaseIDStr)
+	params := map[string]string{"release_id": strconv.Itoa(releaseID)}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "sort_order", "date", "start_date", "end_date"})
+	h.fetchData(&models.ReleaseDatesResponse{}, c, "/release/dates", params)
 }
 
 func (h *FREDHandler) GetReleaseSeries(c *gin.Context) {
@@ -243,49 +389,171 @@ func (h *FREDHandler) GetReleaseSeries(c *gin.Context) {
 		})
 		return
 	}
+	releaseID, _ := strconv.Atoi(releaseIDStr)
+	params := map[string]string{"release_id": strconv.Itoa(releaseID)}
+	h.addOptionalParams(c, params, []string{
+		"realtime_start", "realtime_end", "limit", "offset", "sort_order",
+		"order_by", "filter", "observation_start", "observation_end", "units", "frequency",
+		"aggregation_method", "output_type",
+	})
+	h.fetchData(&models.SearchResponse{}, c, "/release/series", params)
+}
 
-	releaseID, err := strconv.Atoi(releaseIDStr)
-	if err != nil {
+func (h *FREDHandler) GetReleaseSources(c *gin.Context) {
+	releaseIDStr := c.Query("release_id")
+	if releaseIDStr == "" {
 		c.JSON(http.StatusBadRequest, models.ErrorResponse{
 			ErrorCode:    "BadRequest",
-			ErrorMessage: "release_id must be a number",
+			ErrorMessage: "release_id is required",
 		})
 		return
 	}
+	releaseID, _ := strconv.Atoi(releaseIDStr)
+	params := map[string]string{"release_id": strconv.Itoa(releaseID)}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end"})
+	h.fetchData(&models.ReleaseSourcesResponse{}, c, "/release/sources", params)
+}
 
-	params := map[string]string{
-		"release_id": strings.TrimSpace(strings.Replace(strconv.Itoa(releaseID), " ", "", -1)),
+func (h *FREDHandler) GetReleaseTags(c *gin.Context) {
+	releaseIDStr := c.Query("release_id")
+	if releaseIDStr == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "release_id is required",
+		})
+		return
 	}
+	releaseID, _ := strconv.Atoi(releaseIDStr)
+	params := map[string]string{"release_id": strconv.Itoa(releaseID)}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order"})
+	h.fetchData(&models.ReleaseTagsResponse{}, c, "/release/tags", params)
+}
 
-	optionalParams := []string{
-		"realtime_start", "realtime_end", "limit", "offset", "sort_order",
-		"observation_start", "observation_end", "units", "frequency",
-		"aggregation_method", "output_type",
+func (h *FREDHandler) GetReleaseRelatedTags(c *gin.Context) {
+	releaseIDStr := c.Query("release_id")
+	if releaseIDStr == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "release_id is required",
+		})
+		return
 	}
+	tagNames := c.Query("tag_names")
+	if tagNames == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "tag_names is required",
+		})
+		return
+	}
+	releaseID, _ := strconv.Atoi(releaseIDStr)
+	params := map[string]string{"release_id": strconv.Itoa(releaseID), "tag_names": tagNames}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order"})
+	h.fetchData(&models.RelatedTagsResponse{}, c, "/release/related_tags", params)
+}
 
-	for _, param := range optionalParams {
+func (h *FREDHandler) GetReleaseTables(c *gin.Context) {
+	releaseIDStr := c.Query("release_id")
+	if releaseIDStr == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "release_id is required",
+		})
+		return
+	}
+	releaseID, _ := strconv.Atoi(releaseIDStr)
+	params := map[string]string{"release_id": strconv.Itoa(releaseID)}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end"})
+	h.fetchData(&models.ReleaseTablesResponse{}, c, "/release/tables", params)
+}
+
+func (h *FREDHandler) GetSources(c *gin.Context) {
+	params := map[string]string{}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "sort_order"})
+	h.fetchData(&models.SourcesResponse{}, c, "/sources", params)
+}
+
+func (h *FREDHandler) GetSource(c *gin.Context) {
+	sourceIDStr := c.Query("source_id")
+	if sourceIDStr == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "source_id is required",
+		})
+		return
+	}
+	sourceID, _ := strconv.Atoi(sourceIDStr)
+	params := map[string]string{"source_id": strconv.Itoa(sourceID)}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end"})
+	h.fetchData(&models.SourceResponse{}, c, "/source", params)
+}
+
+func (h *FREDHandler) GetSourceReleases(c *gin.Context) {
+	sourceIDStr := c.Query("source_id")
+	if sourceIDStr == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "source_id is required",
+		})
+		return
+	}
+	sourceID, _ := strconv.Atoi(sourceIDStr)
+	params := map[string]string{"source_id": strconv.Itoa(sourceID)}
+	h.addOptionalParams(c, params, []string{"realtime_start", "realtime_end", "limit", "offset", "sort_order"})
+	h.fetchData(&models.ReleasesResponse{}, c, "/source/releases", params)
+}
+
+func (h *FREDHandler) GetTags(c *gin.Context) {
+	params := map[string]string{}
+	h.addOptionalParams(c, params, []string{
+		"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order",
+		"tag_name", "tag_group_id", "filter",
+	})
+	h.fetchData(&models.TagsResponse{}, c, "/tags", params)
+}
+
+func (h *FREDHandler) GetRelatedTags(c *gin.Context) {
+	tagNames := c.Query("tag_names")
+	if tagNames == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "tag_names is required",
+		})
+		return
+	}
+	params := map[string]string{"tag_names": tagNames}
+	h.addOptionalParams(c, params, []string{
+		"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order",
+	})
+	h.fetchData(&models.RelatedTagsResponse{}, c, "/related_tags", params)
+}
+
+func (h *FREDHandler) GetTagsSeries(c *gin.Context) {
+	tagNames := c.Query("tag_names")
+	if tagNames == "" {
+		c.JSON(http.StatusBadRequest, models.ErrorResponse{
+			ErrorCode:    "BadRequest",
+			ErrorMessage: "tag_names is required",
+		})
+		return
+	}
+	params := map[string]string{"tag_names": tagNames}
+	h.addOptionalParams(c, params, []string{
+		"realtime_start", "realtime_end", "limit", "offset", "order_by", "sort_order",
+		"filter", "" +
+			"" +
+			"" +
+			"" +
+			"" +
+			"",
+	})
+	h.fetchData(&models.SearchResponse{}, c, "/tags/series", params)
+}
+
+func (h *FREDHandler) addOptionalParams(c *gin.Context, params map[string]string, optionals []string) {
+	for _, param := range optionals {
 		if v := c.Query(param); v != "" {
-			params[param] = v
+			params[param] = strings.TrimSpace(v)
 		}
 	}
-
-	url := h.buildURL("/release/series", params)
-
-	var response models.SearchResponse
-	if err := h.fetchData(url, &response); err != nil {
-		c.JSON(http.StatusInternalServerError, models.ErrorResponse{
-			ErrorCode:    "InternalServerError",
-			ErrorMessage: err.Error(),
-		})
-		return
-	}
-
-	c.JSON(http.StatusOK, response)
-}
-
-func (h *FREDHandler) HealthCheck(c *gin.Context) {
-	c.JSON(http.StatusOK, gin.H{
-		"status":  "healthy",
-		"service": "FRED API Proxy",
-	})
 }