first commit

main/main.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"Zadanie2Project/main/models"
+	"Zadanie2Project/main/repository"
+	"github.com/labstack/echo/v4"
+	echoSwagger "github.com/swaggo/echo-swagger"
+	"net/http"
+	"strconv"
+)
+
+const connectionURL = "postgres://tgbot:pass@localhost:5432/vyatsu"
+
+func main() {
+	e := echo.New()
+	e.GET("/programs", getPrograms)
+	e.GET("/versions", getVersions)
+	e.GET("/swagger/*", echoSwagger.WrapHandler)
+	// Start server
+	e.Logger.Fatal(e.Start(":8080"))
+}
+func getPrograms(e echo.Context) error {
+	db, err := repository.New(connectionURL)
+	offset, err := strconv.Atoi(e.QueryParam("offset"))
+	limit, err := strconv.Atoi(e.QueryParam("limit"))
+	var programsDto []models.ProgramDto
+	if limit == 0 {
+		limit = 10
+	}
+	programsDto, err = db.GetPrograms(offset, limit)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
+	}
+	return e.JSON(http.StatusOK, programsDto)
+}
+
+func getVersions(e echo.Context) error {
+	db, err := repository.New(connectionURL)
+	offset, err := strconv.Atoi(e.QueryParam("offset"))
+	limit, err := strconv.Atoi(e.QueryParam("limit"))
+	var versionsDto []models.ProgramVersionsDto
+	if limit == 0 {
+		limit = 10
+	}
+	versionsDto, err = db.GetProgramVersions(offset, limit)
+	if err != nil {
+		return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
+	}
+	return e.JSON(http.StatusOK, versionsDto)
+}

main/mappers/ProgramMapper.go

@@ -0,0 +1,14 @@
+package mappers
+
+import "Zadanie2Project/main/models"
+
+func ConvertProgramToDto(program models.Program) models.ProgramDto {
+	programDto := models.ProgramDto{
+		ID:          program.ID,
+		Name:        program.Name,
+		Publisher:   program.Publisher,
+		Description: program.Description,
+		URL:         program.URL,
+	}
+	return programDto
+}

main/mappers/VersionMapper.go

@@ -0,0 +1,15 @@
+package mappers
+
+import "Zadanie2Project/main/models"
+
+func ConvertProgramVersionToDto(versions models.ProgramVersions) models.ProgramVersionsDto {
+	versionDto := models.ProgramVersionsDto{
+		ProgramID:          versions.ProgramID,
+		Version:            versions.Version,
+		SystemRequirements: versions.SystemRequirements,
+		URL:                versions.URL,
+		Date:               versions.Date,
+	}
+	return versionDto
+
+}

main/models/models.go

@@ -0,0 +1,48 @@
+package models
+
+type Program struct {
+	ID            int
+	Publisher     string
+	Name          string
+	CategoryId    int
+	LicenseTypeId int
+	Description   string
+	URL           string
+}
+
+type ProgramDto struct {
+	ID          int
+	Publisher   string
+	Name        string
+	Category    Category
+	LicenseType License
+	Description string
+	URL         string
+}
+
+type ProgramVersions struct {
+	ProgramID          int
+	Version            string
+	SystemRequirements string
+	LicenseTypeId      int
+	URL                string
+	Date               string
+}
+type ProgramVersionsDto struct {
+	ProgramID          int
+	Version            string
+	SystemRequirements string
+	LicenseType        License
+	URL                string
+	Date               string
+}
+
+type Category struct {
+	ID   int
+	Name string
+}
+
+type License struct {
+	ID   int
+	Name string
+}

main/repository/pgsql.go

@@ -0,0 +1,20 @@
+package repository
+
+import (
+	"context"
+	"github.com/jackc/pgx/v5/pgxpool"
+	"sync"
+)
+
+type PGrepo struct {
+	mu   sync.Mutex
+	pool *pgxpool.Pool
+}
+
+func New(connStr string) (*PGrepo, error) {
+	pool, err := pgxpool.New(context.Background(), connStr)
+	if err != nil {
+		panic(err)
+	}
+	return &PGrepo{mu: sync.Mutex{}, pool: pool}, nil
+}

main/repository/programs.go

@@ -0,0 +1,106 @@
+package repository
+
+import (
+	"Zadanie2Project/main/mappers"
+	"Zadanie2Project/main/models"
+	"context"
+	"fmt"
+	"log"
+)
+
+func (repo *PGrepo) GetPrograms(offset int, limit int) ([]models.ProgramDto, error) {
+	rows, err := repo.pool.Query(context.Background(), "select * from Program LIMIT $1 OFFSET $2", limit, offset)
+	if err != nil {
+		log.Fatal(err)
+		return nil, err
+	}
+	defer rows.Close()
+	var programsDto []models.ProgramDto
+	for rows.Next() {
+		program := models.Program{}
+		err := rows.Scan(&program.ID, &program.Publisher, &program.Name, &program.CategoryId, &program.LicenseTypeId,
+			&program.Description, &program.URL)
+		category, err := repo.GetCategoryWithId(program.CategoryId)
+		license, err := repo.GetLicenseWithId(program.LicenseTypeId)
+		programDto := mappers.ConvertProgramToDto(program)
+		programDto.Category = category
+		programDto.LicenseType = license
+
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
+
+		programsDto = append(programsDto, programDto)
+	}
+	return programsDto, nil
+}
+func (repo *PGrepo) GetEmployeesWithFilterByPosition(offset int, limit int, position string) ([]models.Program, error) {
+	rows, err := repo.pool.Query(context.Background(), "select * from Program where position = $3 LIMIT $1 OFFSET $2", limit, offset, position)
+	if err != nil {
+		log.Fatal(err)
+		return nil, err
+	}
+	defer rows.Close()
+	var programs []models.Program
+	for rows.Next() {
+		program := models.Program{}
+		err := rows.Scan(&program.ID, &program.Publisher, &program.Name, &program.CategoryId, &program.LicenseTypeId,
+			&program.Description, &program.URL)
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
+		programs = append(programs, program)
+	}
+	return programs, nil
+}
+func (repo *PGrepo) GetProgramVersions(offset int, limit int) ([]models.ProgramVersionsDto, error) {
+	rows, err := repo.pool.Query(context.Background(), "select * from ProgramVersions LIMIT $1 OFFSET $2", limit, offset)
+	if err != nil {
+		log.Fatal(err)
+		return nil, err
+	}
+	defer rows.Close()
+	var programVersions []models.ProgramVersionsDto
+	for rows.Next() {
+		version := models.ProgramVersions{}
+		err := rows.Scan(&version.ProgramID, &version.Version, &version.SystemRequirements, &version.LicenseTypeId, &version.URL,
+			&version.Date)
+		versionDto := mappers.ConvertProgramVersionToDto(version)
+		license, err := repo.GetLicenseWithId(version.LicenseTypeId)
+		versionDto.LicenseType = license
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
+		programVersions = append(programVersions, versionDto)
+	}
+	return programVersions, nil
+}
+func (repo *PGrepo) GetLicenseWithId(id int) (models.License, error) {
+	rows, err := repo.pool.Query(context.Background(), "select * from License where id = $1", id)
+	if err != nil {
+		panic(err)
+	}
+	defer rows.Close()
+	var license models.License
+	err = rows.Scan(&license.ID, &license.Name)
+	if err != nil {
+		fmt.Println(err)
+	}
+	return license, nil
+}
+func (repo *PGrepo) GetCategoryWithId(id int) (models.Category, error) {
+	rows, err := repo.pool.Query(context.Background(), "select * from Category where id = $1", id)
+	if err != nil {
+		panic(err)
+	}
+	defer rows.Close()
+	var category models.Category
+	err = rows.Scan(&category.ID, &category.Name)
+	if err != nil {
+		fmt.Println(err)
+	}
+	return category, nil
+}