internal/api/client.go - main - nekstep/gvcli

internal/api/client.go
974 строки34 KB
kst
feat: implement PR management (view, files, comments, diff, merge --check, list filters)
26 июл 2026, 19:43
26 июл 2026, 19:4335a5ed9
package api

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"strings"

	"gitverse-cli/internal/auth"
	"gitverse-cli/internal/config"
	"gitverse-cli/internal/debug"
	generated_api "gitverse-cli/internal/generated-api"

	openapi_types "github.com/oapi-codegen/runtime/types"
)

// API constants
const (
	AcceptHeader = "application/vnd.gitverse.object+json;version=1"
)

// getHTTPStatusMessage returns a standard HTTP status message for a given status code
func getHTTPStatusMessage(statusCode int) string {
	switch statusCode {
	case 200:
		return "OK"
	case 201:
		return "Created"
	case 204:
		return "No Content"
	case 400:
		return "Bad Request"
	case 401:
		return "Unauthorized"
	case 403:
		return "Forbidden"
	case 404:
		return "Not Found"
	case 409:
		return "Conflict"
	case 422:
		return "Unprocessable Entity"
	case 429:
		return "Too Many Requests"
	case 500:
		return "Internal Server Error"
	case 502:
		return "Bad Gateway"
	case 503:
		return "Service Unavailable"
	default:
		return "Unknown"
	}
}

// Client handles API requests using the generated OpenAPI client.
type Client struct {
	config        *config.Config
	auth          *auth.Service
	debug         *debug.Logger
	openapiClient *generated_api.ClientWithResponses
}

func NewClient(cfg *config.Config, authSvc *auth.Service, dbg *debug.Logger) *Client {
	c := &Client{
		config: cfg,
		auth:   authSvc,
		debug:  dbg,
	}
	c.initializeOpenAPIClient()
	return c
}

func (c *Client) initializeOpenAPIClient() {
	customClient := &http.Client{
		Transport: &authTransport{
			base:  http.DefaultTransport,
			auth:  c.auth,
			debug: c.debug,
			cfg:   c.config,
		},
	}

	openapiClient, err := generated_api.NewClientWithResponses(
		"https://api.gitverse.ru",
		generated_api.WithHTTPClient(customClient),
	)
	if err != nil {
		panic(fmt.Sprintf("Failed to initialize OpenAPI client: %v", err))
	}
	c.openapiClient = openapiClient
}

type authTransport struct {
	base  http.RoundTripper
	auth  *auth.Service
	debug *debug.Logger
	cfg   *config.Config
}

func (t *authTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	token, err := t.auth.GetToken()
	if err != nil {
		return nil, fmt.Errorf("JWT токен не найден. Выполните вход командой 'gv login' или добавьте токен в конфиг.")
	}
	if token == "" {
		return nil, fmt.Errorf("JWT токен не найден. Выполните вход командой 'gv login' или добавьте токен в конфиг.")
	}
	req.Header.Set("Authorization", "Bearer "+token)

	req.Header.Set("Accept", AcceptHeader)

	if t.cfg.DebugHTTP {
		t.debug.DebugHTTP("--- HTTP REQUEST ---")
		t.debug.DebugHTTP("%s %s", req.Method, req.URL)
		t.debug.DebugHTTP("Headers:")
		for k, v := range req.Header {
			headerVal := strings.Join(v, ", ")
			if strings.ToLower(k) == "authorization" && !t.cfg.DebugPasswords && len(v) > 0 {
				if strings.HasPrefix(headerVal, "Bearer ") {
					headerVal = "Bearer " + strings.Repeat("*", len(headerVal)-7)
				} else {
					headerVal = strings.Repeat("*", len(headerVal))
				}
			}
			t.debug.DebugHTTP("  %s: %s", k, headerVal)
		}
	}

	resp, err := t.base.RoundTrip(req)
	if err != nil {
		return nil, err
	}

	if t.cfg.DebugHTTP {
		t.debug.DebugHTTP("--- HTTP RESPONSE ---")
		t.debug.DebugHTTP("Status: %s", resp.Status)
		t.debug.DebugHTTP("Headers:")
		for k, v := range resp.Header {
			if strings.ToLower(k) == "authorization" && !t.cfg.DebugPasswords && len(v) > 0 {
				masked := v[0]
				if strings.HasPrefix(masked, "Bearer ") {
					masked = "Bearer " + strings.Repeat("*", len(v[0])-7)
				} else {
					masked = strings.Repeat("*", len(v[0]))
				}
				t.debug.DebugHTTP("  %s: %s", k, masked)
			} else {
				t.debug.DebugHTTP("  %s: %s", k, strings.Join(v, ", "))
			}
		}
	}

	return resp, nil
}

// GetUserInfo fetches the current user info from the API.
func (c *Client) GetUserInfo() (map[string]interface{}, error) {
	params := &generated_api.GetUserParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetUserWithResponse(context.Background(), params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}

	userMap := make(map[string]interface{})
	userBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации: %v", err)
	}
	if err := json.Unmarshal(userBytes, &userMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации: %v", err)
	}
	return userMap, nil
}

// GetRepoInfo fetches repository info by owner and repo name.
func (c *Client) GetRepoInfo(owner, repo string) (map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoWithResponse(context.Background(), owner, repo, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}

	repoMap := make(map[string]interface{})
	repoBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации: %v", err)
	}
	if err := json.Unmarshal(repoBytes, &repoMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации: %v", err)
	}
	return repoMap, nil
}

// GetRepoContents fetches file or directory contents from a repo.
func (c *Client) GetRepoContents(owner, repo, path string) (interface{}, error) {
	params := &generated_api.GetReposOwnerRepoContentsPathParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoContentsPathWithResponse(context.Background(), owner, repo, path, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}

	var result interface{}
	if err := json.Unmarshal(resp.Body, &result); err != nil {
		return nil, fmt.Errorf("Ошибка разбора ответа: %v", err)
	}
	return result, nil
}

// PutRepoFile creates or updates a file in the repo.
func (c *Client) PutRepoFile(owner, repo, filename string, body map[string]interface{}) (map[string]interface{}, error) {
	params := &generated_api.PutReposOwnerRepoContentsFilenameParams{
		Accept: AcceptHeader,
	}

	bodyBytes, err := json.Marshal(body)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации тела запроса: %v", err)
	}

	var requestBody generated_api.PutReposOwnerRepoContentsFilenameJSONRequestBody
	if err := json.Unmarshal(bodyBytes, &requestBody); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации тела запроса: %v", err)
	}

	resp, err := c.openapiClient.PutReposOwnerRepoContentsFilenameWithResponse(context.Background(), owner, repo, filename, params, requestBody)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}

	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// GetUserEmails fetches the current user's email addresses.
func (c *Client) GetUserEmails() ([]map[string]interface{}, error) {
	params := &generated_api.GetUserEmailsParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetUserEmailsWithResponse(context.Background(), params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}

	var emails []map[string]interface{}
	for _, email := range *resp.JSON200 {
		emailMap := make(map[string]interface{})
		emailBytes, err := json.Marshal(email)
		if err != nil {
			return nil, fmt.Errorf("Ошибка сериализации email: %v", err)
		}
		if err := json.Unmarshal(emailBytes, &emailMap); err != nil {
			return nil, fmt.Errorf("Ошибка десериализации email: %v", err)
		}
		emails = append(emails, emailMap)
	}
	return emails, nil
}

// AddUserEmails adds new email addresses to the current user.
func (c *Client) AddUserEmails(emails []string) ([]map[string]interface{}, error) {
	params := &generated_api.PostUserEmailsParams{
		Accept: AcceptHeader,
	}

	var openapiEmails []openapi_types.Email
	for _, email := range emails {
		openapiEmails = append(openapiEmails, openapi_types.Email(email))
	}

	requestBody := generated_api.PostUserEmailsJSONRequestBody{
		Emails: &openapiEmails,
	}

	resp, err := c.openapiClient.PostUserEmailsWithResponse(context.Background(), params, requestBody)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}

	if resp.StatusCode() == 200 && resp.JSON200 != nil {
		var resultEmails []map[string]interface{}
		for _, email := range *resp.JSON200 {
			emailMap := make(map[string]interface{})
			emailBytes, err := json.Marshal(email)
			if err != nil {
				return nil, fmt.Errorf("Ошибка сериализации email: %v", err)
			}
			if err := json.Unmarshal(emailBytes, &emailMap); err != nil {
				return nil, fmt.Errorf("Ошибка десериализации email: %v", err)
			}
			resultEmails = append(resultEmails, emailMap)
		}
		return resultEmails, nil
	} else if resp.StatusCode() == 201 {
		var resultEmails []map[string]interface{}
		for _, email := range emails {
			resultEmails = append(resultEmails, map[string]interface{}{
				"email":    email,
				"primary":  false,
				"verified": false,
			})
		}
		return resultEmails, nil
	}

	return nil, fmt.Errorf("Неожиданный ответ API: %s", status.String())
}

// CreatePullRequest creates a new Pull Request in the specified repository.
func (c *Client) CreatePullRequest(owner, repo, title, head, base, body string) (map[string]interface{}, error) {
	params := &generated_api.PostReposOwnerRepoPullsParams{
		Accept: AcceptHeader,
	}

	requestBody := generated_api.PostReposOwnerRepoPullsJSONRequestBody{
		Title: &title,
		Head:  &head,
		Base:  &base,
	}
	if body != "" {
		requestBody.Body = &body
	}

	resp, err := c.openapiClient.PostReposOwnerRepoPullsWithResponse(context.Background(), owner, repo, params, requestBody)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON201 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}

	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON201)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// ListPullRequests returns the list of Pull Requests (issues) for the specified repository.
func (c *Client) ListPullRequests(owner, repo string) ([]map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoIssuesParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoIssuesWithResponse(context.Background(), owner, repo, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}

	var result []map[string]interface{}
	for _, pr := range *resp.JSON200 {
		prMap := make(map[string]interface{})
		prBytes, err := json.Marshal(pr)
		if err != nil {
			return nil, fmt.Errorf("Ошибка сериализации PR: %v", err)
		}
		if err := json.Unmarshal(prBytes, &prMap); err != nil {
			return nil, fmt.Errorf("Ошибка десериализации PR: %v", err)
		}
		result = append(result, prMap)
	}
	return result, nil
}

// GetPullRequest fetches detailed information about a specific Pull Request.
func (c *Client) GetPullRequest(owner, repo string, pullNumber int) (map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoPullsPullNumberParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoPullsPullNumberWithResponse(context.Background(), owner, repo, pullNumber, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// ListPullRequestFiles returns the list of files changed in a Pull Request.
func (c *Client) ListPullRequestFiles(owner, repo string, pullNumber int) ([]map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoPullsPullNumberFilesParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoPullsPullNumberFilesWithResponse(context.Background(), owner, repo, pullNumber, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}
	var result []map[string]interface{}
	for _, file := range *resp.JSON200 {
		fileMap := make(map[string]interface{})
		fileBytes, err := json.Marshal(file)
		if err != nil {
			return nil, fmt.Errorf("Ошибка сериализации файла: %v", err)
		}
		if err := json.Unmarshal(fileBytes, &fileMap); err != nil {
			return nil, fmt.Errorf("Ошибка десериализации файла: %v", err)
		}
		result = append(result, fileMap)
	}
	return result, nil
}

// ListIssueComments returns comments for an issue or Pull Request by its number.
func (c *Client) ListIssueComments(owner, repo string, index int) ([]map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoIssuesIndexCommentsParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoIssuesIndexCommentsWithResponse(context.Background(), owner, repo, index, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}
	var result []map[string]interface{}
	for _, comment := range *resp.JSON200 {
		commentMap := make(map[string]interface{})
		commentBytes, err := json.Marshal(comment)
		if err != nil {
			return nil, fmt.Errorf("Ошибка сериализации комментария: %v", err)
		}
		if err := json.Unmarshal(commentBytes, &commentMap); err != nil {
			return nil, fmt.Errorf("Ошибка десериализации комментария: %v", err)
		}
		result = append(result, commentMap)
	}
	return result, nil
}

// CompareCommits compares two commits, branches, or tags.
func (c *Client) CompareCommits(owner, repo, basehead string) (map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoCompareBaseheadParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoCompareBaseheadWithResponse(context.Background(), owner, repo, basehead, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// GetMergeStatus checks the merge status of a Pull Request without performing merge.
func (c *Client) GetMergeStatus(owner, repo string, pullNumber int) (map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoPullsPullNumberMergeParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoPullsPullNumberMergeWithResponse(context.Background(), owner, repo, pullNumber, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// ListPulls returns the list of Pull Requests using GET /pulls endpoint.
func (c *Client) ListPulls(owner, repo string) ([]map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoPullsParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoPullsWithResponse(context.Background(), owner, repo, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}
	var result []map[string]interface{}
	for _, pr := range *resp.JSON200 {
		prMap := make(map[string]interface{})
		prBytes, err := json.Marshal(pr)
		if err != nil {
			return nil, fmt.Errorf("Ошибка сериализации PR: %v", err)
		}
		if err := json.Unmarshal(prBytes, &prMap); err != nil {
			return nil, fmt.Errorf("Ошибка десериализации PR: %v", err)
		}
		result = append(result, prMap)
	}
	return result, nil
}

// GetUserByUsername fetches user info by login.
func (c *Client) GetUserByUsername(username string) (map[string]interface{}, error) {
	params := &generated_api.GetUsersUsernameParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetUsersUsernameWithResponse(context.Background(), username, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// ListMyRepos returns the list of repositories for the authenticated user.
func (c *Client) ListMyRepos() ([]map[string]interface{}, error) {
	params := &generated_api.GetUserReposParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetUserReposWithResponse(context.Background(), params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		return nil, fmt.Errorf("Неожиданный ответ API: %s", status.String())
	}
	var result []map[string]interface{}
	for _, repo := range *resp.JSON200 {
		repoMap := make(map[string]interface{})
		repoBytes, err := json.Marshal(repo)
		if err != nil {
			return nil, fmt.Errorf("Ошибка сериализации репозитория: %v", err)
		}
		if err := json.Unmarshal(repoBytes, &repoMap); err != nil {
			return nil, fmt.Errorf("Ошибка десериализации репозитория: %v", err)
		}
		result = append(result, repoMap)
	}
	return result, nil
}

// CreateRepo creates a new repository for the authenticated user.
func (c *Client) CreateRepo(name, description string, private, autoInit bool) (map[string]interface{}, error) {
	params := &generated_api.PostUserReposParams{
		Accept: AcceptHeader,
	}
	requestBody := generated_api.PostUserReposJSONRequestBody{
		Name:        &name,
		Description: &description,
		Private:     &private,
		AutoInit:    &autoInit,
	}
	resp, err := c.openapiClient.PostUserReposWithResponse(context.Background(), params, requestBody)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		return nil, fmt.Errorf("Неожиданный ответ API: %s", status.String())
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// DeleteRepoFile deletes a file from the repository.
func (c *Client) DeleteRepoFile(owner, repo, filename, sha, branch, message string) (map[string]interface{}, error) {
	params := &generated_api.DeleteReposOwnerRepoContentsFilenameParams{
		Accept: AcceptHeader,
	}
	requestBody := generated_api.DeleteReposOwnerRepoContentsFilenameJSONRequestBody{
		Sha:     &sha,
		Branch:  &branch,
		Message: &message,
	}
	resp, err := c.openapiClient.DeleteReposOwnerRepoContentsFilenameWithResponse(context.Background(), owner, repo, filename, params, requestBody)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		return nil, fmt.Errorf("Неожиданный ответ API: %s", status.String())
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// GetGitTree returns the git tree for a repository.
func (c *Client) GetGitTree(owner, repo, treeSha string, recursive bool) (map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoGitTreesTreeShaParams{
		Accept:    AcceptHeader,
		Recursive: &recursive,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoGitTreesTreeShaWithResponse(context.Background(), owner, repo, treeSha, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		return nil, fmt.Errorf("Неожиданный ответ API: %s", status.String())
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// ListBranches returns the list of branches for a repository.
func (c *Client) ListBranches(owner, repo string) ([]map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoBranchesParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoBranchesWithResponse(context.Background(), owner, repo, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		return nil, fmt.Errorf("Неожиданный ответ API: %s", status.String())
	}
	var result []map[string]interface{}
	for _, branch := range *resp.JSON200 {
		branchMap := make(map[string]interface{})
		branchBytes, err := json.Marshal(branch)
		if err != nil {
			return nil, fmt.Errorf("Ошибка сериализации ветки: %v", err)
		}
		if err := json.Unmarshal(branchBytes, &branchMap); err != nil {
			return nil, fmt.Errorf("Ошибка десериализации ветки: %v", err)
		}
		result = append(result, branchMap)
	}
	return result, nil
}

// GetLanguages returns the language statistics for a repository.
func (c *Client) GetLanguages(owner, repo string) (map[string]interface{}, error) {
	params := &generated_api.GetReposOwnerRepoLanguagesParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetReposOwnerRepoLanguagesWithResponse(context.Background(), owner, repo, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		return nil, fmt.Errorf("Неожиданный ответ API: %s", status.String())
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// ForkRepo creates a fork of the specified repository for the current user.
func (c *Client) ForkRepo(owner, repo string) (map[string]interface{}, error) {
	params := &generated_api.PostReposOwnerRepoForksParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.PostReposOwnerRepoForksWithResponse(context.Background(), owner, repo, params)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		return nil, fmt.Errorf("Неожиданный ответ API: %s", status.String())
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// AddCollaborator adds or updates a collaborator on a repository.
func (c *Client) AddCollaborator(owner, repo, username, permission string) (map[string]interface{}, error) {
	params := &generated_api.PutReposOwnerRepoCollaboratorsUsernameParams{
		Accept: AcceptHeader,
	}
	perm := generated_api.PutReposOwnerRepoCollaboratorsUsernameJSONBodyPermission(permission)
	requestBody := generated_api.PutReposOwnerRepoCollaboratorsUsernameJSONRequestBody{
		Permission: &perm,
	}
	resp, err := c.openapiClient.PutReposOwnerRepoCollaboratorsUsernameWithResponse(context.Background(), owner, repo, username, params, requestBody)
	if err != nil {
		return nil, fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		return nil, fmt.Errorf("Неожиданный ответ API: %s", status.String())
	}
	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}

// StarRepo stars a repository for the authenticated user.
func (c *Client) StarRepo(owner, repo string) error {
	params := &generated_api.PutUserStarredOwnerRepoParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.PutUserStarredOwnerRepoWithResponse(context.Background(), owner, repo, params)
	if err != nil {
		return fmt.Errorf("Ошибка запроса: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return status.Error()
	}
	return nil
}

// IsStarred checks if the authenticated user has starred a repository.
func (c *Client) IsStarred(owner, repo string) (bool, error) {
	params := &generated_api.GetUserStarredOwnerRepoParams{
		Accept: AcceptHeader,
	}
	resp, err := c.openapiClient.GetUserStarredOwnerRepoWithResponse(context.Background(), owner, repo, params)
	if err != nil {
		return false, fmt.Errorf("Ошибка запроса: %v", err)
	}
	if resp.StatusCode() == 204 {
		return true, nil
	}
	if resp.StatusCode() == 404 {
		return false, nil
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	return false, status.Error()
}

// DeleteUserEmails removes email addresses from the current user.
func (c *Client) DeleteUserEmails(emails []string) (map[string]interface{}, error) {
	params := &generated_api.DeleteUserEmailsParams{
		Accept: AcceptHeader,
	}

	var openapiEmails []openapi_types.Email
	for _, email := range emails {
		openapiEmails = append(openapiEmails, openapi_types.Email(email))
	}

	requestBody := generated_api.DeleteUserEmailsJSONRequestBody{
		Emails: &openapiEmails,
	}

	resp, err := c.openapiClient.DeleteUserEmailsWithResponse(context.Background(), params, requestBody)
	if err != nil {
		return nil, fmt.Errorf("Ошибка API: %v", err)
	}
	status := NewHTTPStatus(resp.StatusCode(), getHTTPStatusMessage(resp.StatusCode()))
	if status.IsError() {
		return nil, status.Error()
	}
	if resp.JSON200 == nil {
		statusCode := resp.StatusCode()
		statusMsg := getHTTPStatusMessage(statusCode)
		return nil, fmt.Errorf("Неожиданный ответ API: %d %s", statusCode, statusMsg)
	}

	resultMap := make(map[string]interface{})
	resultBytes, err := json.Marshal(resp.JSON200)
	if err != nil {
		return nil, fmt.Errorf("Ошибка сериализации ответа: %v", err)
	}
	if err := json.Unmarshal(resultBytes, &resultMap); err != nil {
		return nil, fmt.Errorf("Ошибка десериализации ответа: %v", err)
	}
	return resultMap, nil
}