diff --git a/config.yaml.template b/config.yaml.template
index 5dbe533..05d32c2 100644
--- a/config.yaml.template
+++ b/config.yaml.template
@@ -2,6 +2,7 @@ nexus:
   url: "http://127.0.0.1:8081"
   username: "your-nexus-username"
   password: "your-nexus-password"
+  repository: "my-repository"
 
 gitea:
   url: "http://127.0.0.1:3000"
diff --git a/config/config.go b/config/config.go
index 49ee95b..3e2d44d 100644
--- a/config/config.go
+++ b/config/config.go
@@ -1,35 +1,36 @@
 package config
 
 import (
-    "os"
+	"os"
 
-    "gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v3"
 )
 
 type Config struct {
-    Nexus struct {
-        URL      string `yaml:"url"`
-        Username string `yaml:"username"`
-        Password string `yaml:"password"`
-    } `yaml:"nexus"`
-    Gitea struct {
-        URL      string `yaml:"url"`
-        Token    string `yaml:"token"`
-        Username string `yaml:"username"`
-        Repo     string `yaml:"repo"`
-    } `yaml:"gitea"`
+	Nexus struct {
+		URL        string `yaml:"url"`
+		Username   string `yaml:"username"`
+		Password   string `yaml:"password"`
+		Repository string `yaml:"repository"`
+	} `yaml:"nexus"`
+	Gitea struct {
+		URL      string `yaml:"url"`
+		Token    string `yaml:"token"`
+		Username string `yaml:"username"`
+		Repo     string `yaml:"repo"`
+	} `yaml:"gitea"`
 }
 
 func LoadConfig(filename string) (*Config, error) {
-    data, err := os.ReadFile(filename)
-    if err != nil {
-        return nil, err
-    }
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
 
-    var config Config
-    err = yaml.Unmarshal(data, &config)
-    if err != nil {
-        return nil, err
-    }
-    return &config, nil
+	var config Config
+	err = yaml.Unmarshal(data, &config)
+	if err != nil {
+		return nil, err
+	}
+	return &config, nil
 }
diff --git a/core/core.go b/core/core.go
index 142533e..f9c859b 100644
--- a/core/core.go
+++ b/core/core.go
@@ -1,73 +1,94 @@
 package core
 
 import (
-    "flag"
-    "log"
+	"flag"
+	"log"
+	"strings"
 
-    "tvoygit.ru/djam/artmigrator/config"
-    "tvoygit.ru/djam/artmigrator/repository/gitea"
-    "tvoygit.ru/djam/artmigrator/repository/nexus"
+	"tvoygit.ru/djam/artmigrator/config"
+	"tvoygit.ru/djam/artmigrator/repository/gitea"
+	"tvoygit.ru/djam/artmigrator/repository/nexus"
 )
 
 type App struct {
-    Config *config.Config
+	Config *config.Config
 }
 
 func NewApp(configFile string) (*App, error) {
-    log.Println("Загрузка конфигурации из файла", configFile)
-    cfg, err := config.LoadConfig(configFile)
-    if err != nil {
-        return nil, err
-    }
+	log.Println("Загрузка конфигурации из файла", configFile)
+	cfg, err := config.LoadConfig(configFile)
+	if err != nil {
+		return nil, err
+	}
 
-    flag.StringVar(&cfg.Nexus.URL, "nexus-url", cfg.Nexus.URL, "Nexus URL")
-    flag.StringVar(&cfg.Nexus.Username, "nexus-username", cfg.Nexus.Username, "Nexus Username")
-    flag.StringVar(&cfg.Nexus.Password, "nexus-password", cfg.Nexus.Password, "Nexus Password")
-    flag.StringVar(&cfg.Gitea.URL, "gitea-url", cfg.Gitea.URL, "Gitea URL")
-    flag.StringVar(&cfg.Gitea.Token, "gitea-token", cfg.Gitea.Token, "Gitea Token")
-    flag.Parse()
+	flag.StringVar(&cfg.Nexus.URL, "nexus-url", cfg.Nexus.URL, "Nexus URL")
+	flag.StringVar(&cfg.Nexus.Username, "nexus-username", cfg.Nexus.Username, "Nexus Username")
+	flag.StringVar(&cfg.Nexus.Password, "nexus-password", cfg.Nexus.Password, "Nexus Password")
+	flag.StringVar(&cfg.Gitea.URL, "gitea-url", cfg.Gitea.URL, "Gitea URL")
+	flag.StringVar(&cfg.Gitea.Token, "gitea-token", cfg.Gitea.Token, "Gitea Token")
+	flag.Parse()
 
-    return &App{Config: cfg}, nil
+	return &App{Config: cfg}, nil
 }
 
 func (a *App) Run() error {
-    log.Println("Начало процесса загрузки артефакта")
+	log.Println("Начало процесса загрузки артефакта")
 
-    nexusClient := nexus.NewClient(a.Config.Nexus.URL, a.Config.Nexus.Username, a.Config.Nexus.Password)
-    log.Println("Авторизация в Nexus прошла успешно")
+	nexusClient := nexus.NewClient(a.Config.Nexus.URL, a.Config.Nexus.Username, a.Config.Nexus.Password)
+	log.Println("Авторизация в Nexus прошла успешно")
 
-    giteaClient := gitea.NewClient(a.Config.Gitea.URL, a.Config.Gitea.Token, a.Config)
-    log.Println("Авторизация в Gitea прошла успешно")
+	giteaClient := gitea.NewClient(a.Config.Gitea.URL, a.Config.Gitea.Token, a.Config)
+	log.Println("Авторизация в Gitea прошла успешно")
 
-    repository := "your-repository-name"
-    log.Println("Начало процесса загрузки артефактов...")
-    artifacts, err := nexusClient.GetArtifacts(repository)
-    if err != nil {
-        return err
-    }
-    log.Printf("Найдены артефакты для загрузки в Gitea: %v", artifacts)
+	repository := a.Config.Nexus.Repository
+	log.Println("Начало процесса загрузки артефактов...")
+	artifacts, err := nexusClient.GetArtifacts(repository)
+	if err != nil {
+		return err
+	}
+	log.Printf("Найдены артефакты для загрузки в Gitea: %v", artifacts)
 
-    if len(artifacts) == 0 {
-        log.Println("Нет артефактов для загрузки в Gitea")
-    } else {
-        for _, artifact := range artifacts {
-            log.Printf("Загрузка артефакта %s из репозитория Nexus...", artifact)
-            data, err := nexusClient.GetArtifactData(repository, artifact)
-            if err != nil {
-                log.Printf("Ошибка загрузки артефакта %s: %v", artifact, err)
-                continue
-            }
-            log.Printf("Артефакт %s загружен из репозитория Nexus", artifact)
+	if len(artifacts) == 0 {
+		log.Println("Нет артефактов для загрузки в Gitea")
+	} else {
+		for _, artifact := range artifacts {
+			log.Printf("Загрузка артефакта %s из репозитория Nexus...", artifact)
+			data, err := nexusClient.GetArtifactData(repository, artifact)
+			if err != nil {
+				log.Printf("Ошибка загрузки артефакта %s: %v", artifact, err)
+				continue
+			}
+			log.Printf("Артефакт %s загружен из репозитория Nexus", artifact)
 
-            log.Printf("Загрузка артефакта %s в репозиторий Gitea...", artifact)
-            err = giteaClient.UploadArtifact(artifact, data)
-            if err != nil {
-                log.Printf("Ошибка загрузки артефакта %s в Gitea: %v", artifact, err)
-            } else {
-                log.Printf("Артефакт %s успешно загружен в Gitea", artifact)
-            }
-        }
-    }
-    log.Println("Процесс загрузки артефактов завершен.")
-    return nil
+			// Изменение функции Run для загрузки артефактов в Gitea
+			parts := strings.Split(artifact, "/")
+			if len(parts) < 4 {
+				log.Printf("Некорректный формат артефакта %s", artifact)
+				continue
+			}
+			groupId := parts[0]
+			artifactId := parts[1]
+			version := parts[2]
+			fileParts := strings.Split(parts[3], ".")
+			if len(fileParts) < 2 {
+				log.Printf("Некорректный формат файла %s", parts[3])
+				continue
+			}
+			if fileParts[len(fileParts)-1] == "md5" || fileParts[len(fileParts)-1] == "sha1" {
+				log.Printf("Пропускаем файл %s, так как он имеет расширение .md5 или .sha1", artifact)
+				continue
+			}
+			packaging := fileParts[len(fileParts)-1]
+
+			log.Printf("Загрузка артефакта %s в репозиторий Gitea...", artifact)
+			err = giteaClient.UploadArtifact(groupId, artifactId, version, packaging, data)
+			if err != nil {
+				log.Printf("Ошибка загрузки артефакта %s в Gitea: %v", artifact, err)
+			} else {
+				log.Printf("Артефакт %s успешно загружен в Gitea", artifact)
+			}
+		}
+	}
+	log.Println("Процесс загрузки артефактов завершен.")
+	return nil
 }
diff --git a/repository/gitea/gitea.go b/repository/gitea/gitea.go
index 350af39..13867c8 100644
--- a/repository/gitea/gitea.go
+++ b/repository/gitea/gitea.go
@@ -1,106 +1,109 @@
 package gitea
 
 import (
-    "bytes"
-    "encoding/json"
-    "fmt"
-    "io/ioutil"
-    "log"
-    "net/http"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
 
-    "tvoygit.ru/djam/artmigrator/config"
-    "tvoygit.ru/djam/artmigrator/logger"
+	"tvoygit.ru/djam/artmigrator/config"
+	"tvoygit.ru/djam/artmigrator/logger"
 )
 
 type Client struct {
-    BaseURL    string
-    HTTPClient *http.Client
-    Token      string
-    Config     *config.Config
+	BaseURL    string
+	HTTPClient *http.Client
+	Token      string
+	Config     *config.Config
 }
 
 func NewClient(baseURL, token string, config *config.Config) *Client {
-    return &Client{
-        BaseURL:    baseURL,
-        HTTPClient: &http.Client{},
-        Token:      token,
-        Config:     config,
-    }
+	return &Client{
+		BaseURL:    baseURL,
+		HTTPClient: &http.Client{},
+		Token:      token,
+		Config:     config,
+	}
 }
 
 func (c *Client) ArtifactExists(artifact string) (bool, error) {
-    log.Printf("Проверка наличия артефакта %s в репозитории Gitea", artifact)
-    url := fmt.Sprintf("%s/api/v1/repos/%s/%s/contents/%s", c.BaseURL, c.Config.Gitea.Username, c.Config.Gitea.Repo, artifact)
-    req, err := http.NewRequest("GET", url, nil)
-    if err != nil {
-        return false, err
-    }
-    req.Header.Add("Authorization", fmt.Sprintf("token %s", c.Token))
+	log.Printf("Проверка наличия артефакта %s в репозитории Gitea", artifact)
+	url := fmt.Sprintf("%s/api/v1/repos/%s/%s/contents/%s", c.BaseURL, c.Config.Gitea.Username, c.Config.Gitea.Repo, artifact)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return false, err
+	}
+	req.Header.Add("Authorization", fmt.Sprintf("token %s", c.Token))
 
-    resp, err := c.HTTPClient.Do(req)
-    if err != nil {
-        return false, err
-    }
-    defer resp.Body.Close()
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return false, err
+	}
+	defer resp.Body.Close()
 
-    if resp.StatusCode == http.StatusNotFound {
-        log.Printf("Артефакт %s не существует в репозитории Gitea", artifact)
-        return false, nil
-    }
+	if resp.StatusCode == http.StatusNotFound {
+		log.Printf("Артефакт %s не существует в репозитории Gitea", artifact)
+		return false, nil
+	}
 
-    log.Printf("Артефакт %s существует в репозитории Gitea", artifact)
-    return true, nil
+	log.Printf("Артефакт %s существует в репозитории Gitea", artifact)
+	return true, nil
 }
 
 type UploadArtifactRequest struct {
-    Content string `json:"content"`
-    Message string `json:"message"`
+	Content string `json:"content"`
+	Message string `json:"message"`
 }
 
-func (c *Client) UploadArtifact(artifactPath string, data []byte) error {
-    log.Printf("Загрузка артефакта %s в репозиторий Gitea", artifactPath)
-    url := fmt.Sprintf("%s/api/v1/repos/%s/%s/contents/%s?ref=master", c.BaseURL, c.Config.Gitea.Username, c.Config.Gitea.Repo, artifactPath)
-    request := UploadArtifactRequest{
-        Content: string(data),
-        Message: "Upload artifact",
-    }
-    jsonRequest, err := json.Marshal(request)
-    if err != nil {
-        return err
-    }
-    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonRequest))
-    if err != nil {
-        return err
-    }
-    req.Header.Add("Authorization", fmt.Sprintf("token %s", c.Token))
-    req.Header.Add("Content-Type", "application/json")
+func (c *Client) UploadArtifact(groupId, artifactId, version, packaging string, data []byte) error {
+	log.Printf("Загрузка артефакта %s-%s-%s.%s в репозиторий Gitea", groupId, artifactId, version, packaging)
+	url := fmt.Sprintf("%s/api/v1/packages/%s/maven", c.BaseURL, c.Config.Gitea.Repo)
+	request := map[string]string{
+		"groupId":    groupId,
+		"artifactId": artifactId,
+		"version":    version,
+		"packaging":  packaging,
+		"file":       fmt.Sprintf("%s-%s-%s.%s", artifactId, version, packaging, packaging),
+	}
+	jsonRequest, err := json.Marshal(request)
+	if err != nil {
+		return err
+	}
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonRequest))
+	if err != nil {
+		return err
+	}
+	req.Header.Add("Authorization", fmt.Sprintf("token %s", c.Token))
+	req.Header.Add("Content-Type", "application/json")
 
-    logger.Logger.Printf("Upload artifact request: %s", req.URL)
-    logger.Logger.Printf("Upload artifact headers: %v", req.Header)
-    logger.Logger.Printf("Upload artifact body: %s", jsonRequest)
+	logger.Logger.Printf("Upload artifact request: %s", req.URL)
+	logger.Logger.Printf("Upload artifact headers: %v", req.Header)
+	logger.Logger.Printf("Upload artifact body: %s", jsonRequest)
 
-    resp, err := c.HTTPClient.Do(req)
-    if err != nil {
-        logger.Logger.Printf("Upload artifact error: %v", err)
-        return err
-    }
-    defer resp.Body.Close()
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		logger.Logger.Printf("Upload artifact error: %v", err)
+		return err
+	}
+	defer resp.Body.Close()
 
-    logger.Logger.Printf("Upload artifact response status code: %d", resp.StatusCode)
-    logger.Logger.Printf("Upload artifact response headers: %v", resp.Header)
+	logger.Logger.Printf("Upload artifact response status code: %d", resp.StatusCode)
+	logger.Logger.Printf("Upload artifact response headers: %v", resp.Header)
 
-    body, err := ioutil.ReadAll(resp.Body)
-    if err != nil {
-        logger.Logger.Printf("Upload artifact error reading response body: %v", err)
-        return err
-    }
-    logger.Logger.Printf("Upload artifact response body: %s", body)
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		logger.Logger.Printf("Upload artifact error reading response body: %v", err)
+		return err
+	}
+	logger.Logger.Printf("Upload artifact response body: %s", body)
 
-    if resp.StatusCode != http.StatusCreated {
-        logger.Logger.Printf("Failed to upload artifact: %s", body)
-        return fmt.Errorf("failed to upload artifact")
-    }
+	if resp.StatusCode != http.StatusCreated {
+		logger.Logger.Printf("Failed to upload artifact: %s", body)
+		return fmt.Errorf("failed to upload artifact")
+	}
 
-    log.Printf("Артефакт %s загружен в репозиторий Gitea", artifactPath)
-    return nil
+	log.Printf("Артефакт %s-%s-%s.%s загружен в репозиторий Gitea", groupId, artifactId, version, packaging)
+	return nil
 }
diff --git a/repository/nexus/nexus.go b/repository/nexus/nexus.go
index 0ac25a6..391ea40 100644
--- a/repository/nexus/nexus.go
+++ b/repository/nexus/nexus.go
@@ -1,104 +1,117 @@
 package nexus
 
 import (
-    "fmt"
-    "io/ioutil"
-    "log"
-    "net/http"
-    "strings"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
 )
 
 type Client struct {
-    BaseURL    string
-    HTTPClient *http.Client
-    Username   string
-    Password   string
+	BaseURL    string
+	HTTPClient *http.Client
+	Username   string
+	Password   string
 }
 
 func NewClient(baseURL, username, password string) *Client {
-    return &Client{
-        BaseURL:    baseURL,
-        HTTPClient: &http.Client{},
-        Username:   username,
-        Password:   password,
-    }
+	return &Client{
+		BaseURL:    baseURL,
+		HTTPClient: &http.Client{},
+		Username:   username,
+		Password:   password,
+	}
 }
 
 func (c *Client) GetArtifacts(repository string) ([]string, error) {
-    log.Printf("Получение артефактов из репозитория Nexus")
-    url := fmt.Sprintf("%s/repository/%s/", c.BaseURL, repository)
-    req, err := http.NewRequest("GET", url, nil)
-    if err != nil {
-        return nil, err
-    }
-    req.SetBasicAuth(c.Username, c.Password)
+	url := fmt.Sprintf("%s/service/rest/v1/search/assets?sort=repository&repository=%s", c.BaseURL, repository)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.SetBasicAuth(c.Username, c.Password)
 
-    resp, err := c.HTTPClient.Do(req)
-    if err != nil {
-        return nil, err
-    }
-    defer resp.Body.Close()
+	log.Printf("Запрос на получение артефактов: %s", req.URL)
+	log.Printf("Заголовки запроса: %v", req.Header)
 
-    body, err := ioutil.ReadAll(resp.Body)
-    if err != nil {
-        return nil, err
-    }
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
 
-    log.Printf("Артефакты получены из репозитория Nexus")
-    artifacts := strings.Split(string(body), "\n")
-    var result []string
-    for _, artifact := range artifacts {
-        if strings.Contains(artifact, ".jar") || strings.Contains(artifact, ".pom") {
-            result = append(result, artifact)
-        }
-    }
-    return result, nil
+	log.Printf("Код ответа: %d", resp.StatusCode)
+	log.Printf("Заголовки ответа: %v", resp.Header)
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Printf("Тело ответа: %s", string(body))
+
+	var assets struct {
+		Items []struct {
+			DownloadUrl string `json:"downloadUrl"`
+		} `json:"items"`
+	}
+	err = json.Unmarshal(body, &assets)
+	if err != nil {
+		return nil, err
+	}
+
+	var result []string
+	for _, asset := range assets.Items {
+		result = append(result, asset.DownloadUrl)
+	}
+	return result, nil
 }
 
 func (c *Client) GetArtifactData(repository, artifact string) ([]byte, error) {
-    log.Printf("Загрузка артефакта %s из репозитория Nexus", artifact)
-    url := fmt.Sprintf("%s/repository/%s/%s", c.BaseURL, repository, artifact)
-    req, err := http.NewRequest("GET", url, nil)
-    if err != nil {
-        return nil, err
-    }
-    req.SetBasicAuth(c.Username, c.Password)
+	log.Printf("Загрузка артефакта %s из репозитория Nexus", artifact)
+	url := fmt.Sprintf("%s/repository/%s/%s", c.BaseURL, repository, artifact)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.SetBasicAuth(c.Username, c.Password)
 
-    resp, err := c.HTTPClient.Do(req)
-    if err != nil {
-        return nil, err
-    }
-    defer resp.Body.Close()
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
 
-    body, err := ioutil.ReadAll(resp.Body)
-    if err != nil {
-        return nil, err
-    }
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
 
-    log.Printf("Артефакт %s загружен из репозитория Nexus", artifact)
-    return body, nil
+	log.Printf("Артефакт %s загружен из репозитория Nexus", artifact)
+	return body, nil
 }
 
 func (c *Client) ArtifactExists(artifact string) (bool, error) {
-    log.Printf("Проверка наличия артефакта %s в репозитории Nexus", artifact)
-    url := fmt.Sprintf("%s/repository/%s/%s", c.BaseURL, "your-repository-name", artifact)
-    req, err := http.NewRequest("GET", url, nil)
-    if err != nil {
-        return false, err
-    }
-    req.SetBasicAuth(c.Username, c.Password)
+	log.Printf("Проверка наличия артефакта %s в репозитории Nexus", artifact)
+	url := fmt.Sprintf("%s/repository/%s/%s", c.BaseURL, "your-repository-name", artifact)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return false, err
+	}
+	req.SetBasicAuth(c.Username, c.Password)
 
-    resp, err := c.HTTPClient.Do(req)
-    if err != nil {
-        return false, err
-    }
-    defer resp.Body.Close()
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return false, err
+	}
+	defer resp.Body.Close()
 
-    if resp.StatusCode == http.StatusNotFound {
-        log.Printf("Артефакт %s не существует в репозитории Nexus", artifact)
-        return false, nil
-    }
+	if resp.StatusCode == http.StatusNotFound {
+		log.Printf("Артефакт %s не существует в репозитории Nexus", artifact)
+		return false, nil
+	}
 
-    log.Printf("Артефакт %s существует в репозитории Nexus", artifact)
-    return true, nil
+	log.Printf("Артефакт %s существует в репозитории Nexus", artifact)
+	return true, nil
 }