zdam-egzamin-zawodowy
/
backend
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rename/move some of the packages/files

This commit is contained in:
Dawid Wysokiński 2021-05-02 08:36:10 +02:00
parent 5bd09500c1
commit 7de549f183
30 changed files with 241 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
internal/auth/usecase/usecase.go
View File

@ -7,7 +7,7 @@ import (
"github.com/zdam-egzamin-zawodowy/backend/internal/auth/jwt"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/user"
errorutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/error"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/errorutil"
)
type usecase struct {
@ -44,7 +44,7 @@ func (ucase *usecase) SignIn(ctx context.Context, email, password string, staySi
},
})
if err != nil {
return nil, "", errorutils.Wrap(err, messageInvalidCredentials)
return nil, "", errorutil.Wrap(err, messageInvalidCredentials)
}
return u, token, nil
@ -53,7 +53,7 @@ func (ucase *usecase) SignIn(ctx context.Context, email, password string, staySi
func (ucase *usecase) ExtractAccessTokenMetadata(ctx context.Context, accessToken string) (*models.User, error) {
metadata, err := ucase.tokenGenerator.ExtractAccessTokenMetadata(accessToken)
if err != nil {
return nil, errorutils.Wrap(err, messageInvalidAccessToken)
return nil, errorutil.Wrap(err, messageInvalidAccessToken)
}
return ucase.GetUserByCredentials(ctx, metadata.Credentials.Email, metadata.Credentials.Password)
@ -76,7 +76,7 @@ func (ucase *usecase) GetUserByCredentials(ctx context.Context, email, password
u := users[0]
if err := u.CompareHashAndPassword(password); err != nil {
return nil, errorutils.Wrap(err, messageInvalidCredentials)
return nil, errorutil.Wrap(err, messageInvalidCredentials)
}
return u, nil

4
internal/db/db.go
View File

@ -5,7 +5,7 @@ import (
"os"
"github.com/sirupsen/logrus"
envutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/env"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/envutil"
"github.com/Kichiyaki/go-pg-logrus-query-logger/v10"
"github.com/go-pg/pg/v10"
@ -50,7 +50,7 @@ func prepareOptions() *pg.Options {
Password: os.Getenv("DB_PASSWORD"),
Database: os.Getenv("DB_NAME"),
Addr: os.Getenv("DB_HOST") + ":" + os.Getenv("DB_PORT"),
PoolSize: envutils.GetenvInt("DB_POOL_SIZE"),
PoolSize: envutil.GetenvInt("DB_POOL_SIZE"),
}
}

10
internal/graphql/directive/directive.go
View File

@ -7,15 +7,15 @@ import (
"github.com/99designs/gqlgen/graphql"
"github.com/zdam-egzamin-zawodowy/backend/internal/gin/middleware"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
errorutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/error"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/errorutil"
)
type Directive struct{}
func (d *Directive) Authenticated(ctx context.Context, obj interface{}, next graphql.Resolver, yes bool) (interface{}, error) {
func (d *Directive) Authenticated(ctx context.Context, _ interface{}, next graphql.Resolver, yes bool) (interface{}, error) {
_, err := middleware.UserFromContext(ctx)
if yes && err != nil {
return nil, errorutils.Wrap(err, messageMustBeSignedIn)
return nil, errorutil.Wrap(err, messageMustBeSignedIn)
} else if !yes && err == nil {
return nil, errors.New(messageMustBeSignedOut)
}
@ -23,10 +23,10 @@ func (d *Directive) Authenticated(ctx context.Context, obj interface{}, next gra
return next(ctx)
}
func (d *Directive) HasRole(ctx context.Context, obj interface{}, next graphql.Resolver, role models.Role) (interface{}, error) {
func (d *Directive) HasRole(ctx context.Context, _ interface{}, next graphql.Resolver, role models.Role) (interface{}, error) {
user, err := middleware.UserFromContext(ctx)
if err != nil {
return nil, errorutils.Wrap(err, messageMustBeSignedIn)
return nil, errorutil.Wrap(err, messageMustBeSignedIn)
}
if user.Role != role {
return nil, errors.New(messageUnauthorized)

12
internal/graphql/querycomplexity/querycomplexity.go
View File

@ -8,7 +8,7 @@ import (
"github.com/zdam-egzamin-zawodowy/backend/internal/qualification"
"github.com/zdam-egzamin-zawodowy/backend/internal/question"
"github.com/zdam-egzamin-zawodowy/backend/internal/user"
"github.com/zdam-egzamin-zawodowy/backend/pkg/utils"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/safepointer"
)
const (
@ -40,7 +40,7 @@ func GetComplexityRoot() generated.ComplexityRoot {
) int {
return computeComplexity(
childComplexity,
utils.SafeIntPointer(limit, profession.FetchDefaultLimit),
safepointer.SafeIntPointer(limit, profession.FetchDefaultLimit),
professionsTotalFieldComplexity,
1,
)
@ -56,7 +56,7 @@ func GetComplexityRoot() generated.ComplexityRoot {
) int {
return computeComplexity(
childComplexity,
utils.SafeIntPointer(limit, qualification.FetchDefaultLimit),
safepointer.SafeIntPointer(limit, qualification.FetchDefaultLimit),
qualificationsTotalFieldComplexity,
1,
)
@ -72,7 +72,7 @@ func GetComplexityRoot() generated.ComplexityRoot {
) int {
return computeComplexity(
childComplexity,
utils.SafeIntPointer(limit, question.FetchDefaultLimit),
safepointer.SafeIntPointer(limit, question.FetchDefaultLimit),
questionsTotalFieldComplexity,
1,
)
@ -80,7 +80,7 @@ func GetComplexityRoot() generated.ComplexityRoot {
complexityRoot.Query.GenerateTest = func(childComplexity int, qualificationIDs []int, limit *int) int {
return computeComplexity(
childComplexity,
utils.SafeIntPointer(limit, question.TestMaxLimit),
safepointer.SafeIntPointer(limit, question.TestMaxLimit),
0,
3,
)
@ -96,7 +96,7 @@ func GetComplexityRoot() generated.ComplexityRoot {
) int {
return computeComplexity(
childComplexity,
utils.SafeIntPointer(limit, user.FetchMaxLimit),
safepointer.SafeIntPointer(limit, user.FetchMaxLimit),
usersTotalFieldComplexity,
1,
)

6
internal/graphql/resolvers/profession.resolvers.go
View File

@ -6,11 +6,11 @@ package resolvers
import (
"context"
"github.com/zdam-egzamin-zawodowy/backend/internal/gin/middleware"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/safepointer"
"github.com/zdam-egzamin-zawodowy/backend/internal/graphql/generated"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/profession"
"github.com/zdam-egzamin-zawodowy/backend/pkg/utils"
)
func (r *mutationResolver) CreateProfession(ctx context.Context, input models.ProfessionInput) (*models.Profession, error) {
@ -41,8 +41,8 @@ func (r *queryResolver) Professions(
&profession.FetchConfig{
Count: shouldCount(ctx),
Filter: filter,
Limit: utils.SafeIntPointer(limit, profession.FetchDefaultLimit),
Offset: utils.SafeIntPointer(offset, 0),
Limit: safepointer.SafeIntPointer(limit, profession.FetchDefaultLimit),
Offset: safepointer.SafeIntPointer(offset, 0),
Sort: sort,
},
)

10
internal/graphql/resolvers/qualification.resolvers.go
View File

@ -5,11 +5,11 @@ package resolvers
import (
"context"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/safepointer"
"github.com/zdam-egzamin-zawodowy/backend/internal/graphql/generated"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/qualification"
"github.com/zdam-egzamin-zawodowy/backend/pkg/utils"
)
func (r *mutationResolver) CreateQualification(ctx context.Context, input models.QualificationInput) (*models.Qualification, error) {
@ -40,8 +40,8 @@ func (r *queryResolver) Qualifications(
&qualification.FetchConfig{
Count: shouldCount(ctx),
Filter: filter,
Limit: utils.SafeIntPointer(limit, qualification.FetchDefaultLimit),
Offset: utils.SafeIntPointer(offset, 0),
Limit: safepointer.SafeIntPointer(limit, qualification.FetchDefaultLimit),
Offset: safepointer.SafeIntPointer(offset, 0),
Sort: sort,
},
)
@ -62,8 +62,8 @@ func (r *queryResolver) SimilarQualifications(
&qualification.GetSimilarConfig{
Count: shouldCount(ctx),
QualificationID: qualificationID,
Limit: utils.SafeIntPointer(limit, qualification.FetchDefaultLimit),
Offset: utils.SafeIntPointer(offset, 0),
Limit: safepointer.SafeIntPointer(limit, qualification.FetchDefaultLimit),
Offset: safepointer.SafeIntPointer(offset, 0),
Sort: sort,
},
)

10
internal/graphql/resolvers/question.resolvers.go
View File

@ -5,12 +5,12 @@ package resolvers
import (
"context"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/safepointer"
"github.com/zdam-egzamin-zawodowy/backend/internal/gin/middleware"
"github.com/zdam-egzamin-zawodowy/backend/internal/graphql/generated"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/question"
"github.com/zdam-egzamin-zawodowy/backend/pkg/utils"
)
func (r *mutationResolver) CreateQuestion(ctx context.Context, input models.QuestionInput) (*models.Question, error) {
@ -30,7 +30,7 @@ func (r *mutationResolver) DeleteQuestions(ctx context.Context, ids []int) ([]*m
func (r *queryResolver) GenerateTest(ctx context.Context, qualificationIDs []int, limit *int) ([]*models.Question, error) {
return r.QuestionUsecase.GenerateTest(ctx, &question.GenerateTestConfig{
Qualifications: qualificationIDs,
Limit: utils.SafeIntPointer(limit, question.TestMaxLimit),
Limit: safepointer.SafeIntPointer(limit, question.TestMaxLimit),
})
}
@ -48,8 +48,8 @@ func (r *queryResolver) Questions(
&question.FetchConfig{
Count: shouldCount(ctx),
Filter: filter,
Limit: utils.SafeIntPointer(limit, question.FetchDefaultLimit),
Offset: utils.SafeIntPointer(offset, 0),
Limit: safepointer.SafeIntPointer(limit, question.FetchDefaultLimit),
Offset: safepointer.SafeIntPointer(offset, 0),
Sort: sort,
},
)
@ -61,7 +61,7 @@ func (r *questionResolver) Qualification(ctx context.Context, obj *models.Questi
return obj.Qualification, nil
}
if obj != nil || obj.QualificationID > 0 {
if obj != nil && obj.QualificationID > 0 {
if dataloader, err := middleware.DataLoaderFromContext(ctx); err == nil && dataloader != nil {
return dataloader.QualificationByID.Load(obj.QualificationID)
}

12
internal/graphql/resolvers/user.resolvers.go
View File

@ -5,12 +5,12 @@ package resolvers
import (
"context"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/safepointer"
"github.com/zdam-egzamin-zawodowy/backend/internal/gin/middleware"
"github.com/zdam-egzamin-zawodowy/backend/internal/graphql/generated"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/user"
"github.com/zdam-egzamin-zawodowy/backend/pkg/utils"
)
func (r *mutationResolver) CreateUser(ctx context.Context, input models.UserInput) (*models.User, error) {
@ -49,7 +49,7 @@ func (r *mutationResolver) SignIn(
ctx,
email,
password,
utils.SafeBoolPointer(staySignedIn, false),
safepointer.SafeBoolPointer(staySignedIn, false),
)
if err != nil {
return nil, err
@ -71,8 +71,8 @@ func (r *queryResolver) Users(
&user.FetchConfig{
Count: shouldCount(ctx),
Filter: filter,
Limit: utils.SafeIntPointer(limit, user.FetchMaxLimit),
Offset: utils.SafeIntPointer(offset, 0),
Limit: safepointer.SafeIntPointer(limit, user.FetchMaxLimit),
Offset: safepointer.SafeIntPointer(offset, 0),
Sort: sort,
},
)
@ -84,6 +84,6 @@ func (r *queryResolver) User(ctx context.Context, id int) (*models.User, error)
}
func (r *queryResolver) Me(ctx context.Context) (*models.User, error) {
user, _ := middleware.UserFromContext(ctx)
return user, nil
u, _ := middleware.UserFromContext(ctx)
return u, nil
}

42
internal/models/profession.go
View File

@ -2,13 +2,13 @@ package models
import (
"context"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"strings"
"time"
"github.com/go-pg/pg/v10"
"github.com/go-pg/pg/v10/orm"
"github.com/gosimple/slug"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
)
var _ pg.BeforeInsertHook = (*Profession)(nil)
@ -73,10 +73,10 @@ func (input *ProfessionInput) ToProfession() *Profession {
func (input *ProfessionInput) ApplyUpdate(q *orm.Query) (*orm.Query, error) {
if !input.IsEmpty() {
if input.Name != nil {
q = q.Set(sqlutils.BuildConditionEquals("name"), *input.Name)
q = q.Set(sql.BuildConditionEquals("name"), *input.Name)
}
if input.Description != nil {
q = q.Set(sqlutils.BuildConditionEquals("description"), *input.Description)
q = q.Set(sql.BuildConditionEquals("description"), *input.Description)
}
}
@ -113,37 +113,37 @@ func (f *ProfessionFilter) WhereWithAlias(q *orm.Query, alias string) (*orm.Quer
}
if !isZero(f.ID) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("id", alias)), pg.Array(f.ID))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("id", alias)), pg.Array(f.ID))
}
if !isZero(f.IDNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("id", alias)), pg.Array(f.IDNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("id", alias)), pg.Array(f.IDNEQ))
}
if !isZero(f.Slug) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("slug", alias)), pg.Array(f.Slug))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("slug", alias)), pg.Array(f.Slug))
}
if !isZero(f.SlugNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("slug", alias)), pg.Array(f.SlugNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("slug", alias)), pg.Array(f.SlugNEQ))
}
if !isZero(f.Name) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("name", alias)), pg.Array(f.Name))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("name", alias)), pg.Array(f.Name))
}
if !isZero(f.NameNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("name", alias)), pg.Array(f.NameNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("name", alias)), pg.Array(f.NameNEQ))
}
if !isZero(f.NameMATCH) {
q = q.Where(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("name", alias)), f.NameMATCH)
q = q.Where(sql.BuildConditionMatch(sql.AddAliasToColumnName("name", alias)), f.NameMATCH)
}
if !isZero(f.NameIEQ) {
q = q.Where(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("name", alias)), f.NameIEQ)
q = q.Where(sql.BuildConditionIEQ(sql.AddAliasToColumnName("name", alias)), f.NameIEQ)
}
if !isZero(f.DescriptionMATCH) {
q = q.Where(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("description", alias)), f.DescriptionMATCH)
q = q.Where(sql.BuildConditionMatch(sql.AddAliasToColumnName("description", alias)), f.DescriptionMATCH)
}
if !isZero(f.DescriptionIEQ) {
q = q.Where(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("description", alias)), f.DescriptionIEQ)
q = q.Where(sql.BuildConditionIEQ(sql.AddAliasToColumnName("description", alias)), f.DescriptionIEQ)
}
if !isZero(f.QualificationID) {
@ -151,30 +151,30 @@ func (f *ProfessionFilter) WhereWithAlias(q *orm.Query, alias string) (*orm.Quer
subquery := q.
New().
Model(&QualificationToProfession{}).
ColumnExpr(sqlutils.BuildCountColumnExpr("qualification_id", "count")).
ColumnExpr(sql.BuildCountColumnExpr("qualification_id", "count")).
Column("profession_id").
Where(sqlutils.BuildConditionArray("qualification_id"), pg.Array(f.QualificationID)).
Where(sql.BuildConditionArray("qualification_id"), pg.Array(f.QualificationID)).
Group("profession_id")
q = q.
Join(`INNER JOIN (?) AS qualification_to_professions ON qualification_to_professions.profession_id = profession.id`, subquery).
Where(sqlutils.BuildConditionGTE("count"), sliceLength)
Where(sql.BuildConditionGTE("count"), sliceLength)
}
if !isZero(f.CreatedAt) {
q = q.Where(sqlutils.BuildConditionEquals(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAt)
q = q.Where(sql.BuildConditionEquals(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAt)
}
if !isZero(f.CreatedAtGT) {
q = q.Where(sqlutils.BuildConditionGT(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtGT)
q = q.Where(sql.BuildConditionGT(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtGT)
}
if !isZero(f.CreatedAtGTE) {
q = q.Where(sqlutils.BuildConditionGTE(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtGTE)
q = q.Where(sql.BuildConditionGTE(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtGTE)
}
if !isZero(f.CreatedAtLT) {
q = q.Where(sqlutils.BuildConditionLT(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtLT)
q = q.Where(sql.BuildConditionLT(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtLT)
}
if !isZero(f.CreatedAtLTE) {
q = q.Where(sqlutils.BuildConditionLTE(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtLTE)
q = q.Where(sql.BuildConditionLTE(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtLTE)
}
return q, nil

66
internal/models/qualification.go
View File

@ -2,13 +2,13 @@ package models
import (
"context"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"strings"
"time"
"github.com/go-pg/pg/v10"
"github.com/go-pg/pg/v10/orm"
"github.com/gosimple/slug"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
)
var _ pg.BeforeInsertHook = (*Qualification)(nil)
@ -113,16 +113,16 @@ func (input *QualificationInput) ToQualification() *Qualification {
func (input *QualificationInput) ApplyUpdate(q *orm.Query) (*orm.Query, error) {
if !input.IsEmpty() {
if input.Name != nil {
q = q.Set(sqlutils.BuildConditionEquals("name"), *input.Name)
q = q.Set(sql.BuildConditionEquals("name"), *input.Name)
}
if input.Code != nil {
q = q.Set(sqlutils.BuildConditionEquals("code"), *input.Code)
q = q.Set(sql.BuildConditionEquals("code"), *input.Code)
}
if input.Formula != nil {
q = q.Set(sqlutils.BuildConditionEquals("formula"), *input.Formula)
q = q.Set(sql.BuildConditionEquals("formula"), *input.Formula)
}
if input.Description != nil {
q = q.Set(sqlutils.BuildConditionEquals("description"), *input.Description)
q = q.Set(sql.BuildConditionEquals("description"), *input.Description)
}
}
@ -144,17 +144,17 @@ func (f *QualificationFilterOr) WhereWithAlias(q *orm.Query, alias string) *orm.
q = q.WhereGroup(func(q *orm.Query) (*orm.Query, error) {
if !isZero(f.NameMATCH) {
q = q.WhereOr(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("name", alias)), f.NameMATCH)
q = q.WhereOr(sql.BuildConditionMatch(sql.AddAliasToColumnName("name", alias)), f.NameMATCH)
}
if !isZero(f.NameIEQ) {
q = q.WhereOr(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("name", alias)), f.NameIEQ)
q = q.WhereOr(sql.BuildConditionIEQ(sql.AddAliasToColumnName("name", alias)), f.NameIEQ)
}
if !isZero(f.CodeMATCH) {
q = q.WhereOr(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("code", alias)), f.CodeMATCH)
q = q.WhereOr(sql.BuildConditionMatch(sql.AddAliasToColumnName("code", alias)), f.CodeMATCH)
}
if !isZero(f.CodeIEQ) {
q = q.WhereOr(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("code", alias)), f.CodeIEQ)
q = q.WhereOr(sql.BuildConditionIEQ(sql.AddAliasToColumnName("code", alias)), f.CodeIEQ)
}
return q, nil
@ -202,57 +202,57 @@ func (f *QualificationFilter) WhereWithAlias(q *orm.Query, alias string) (*orm.Q
}
if !isZero(f.ID) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("id", alias)), pg.Array(f.ID))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("id", alias)), pg.Array(f.ID))
}
if !isZero(f.IDNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("id", alias)), pg.Array(f.IDNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("id", alias)), pg.Array(f.IDNEQ))
}
if !isZero(f.Slug) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("slug", alias)), pg.Array(f.Slug))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("slug", alias)), pg.Array(f.Slug))
}
if !isZero(f.SlugNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("slug", alias)), pg.Array(f.SlugNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("slug", alias)), pg.Array(f.SlugNEQ))
}
if !isZero(f.Name) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("name", alias)), pg.Array(f.Name))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("name", alias)), pg.Array(f.Name))
}
if !isZero(f.NameNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("name", alias)), pg.Array(f.NameNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("name", alias)), pg.Array(f.NameNEQ))
}
if !isZero(f.NameMATCH) {
q = q.Where(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("name", alias)), f.NameMATCH)
q = q.Where(sql.BuildConditionMatch(sql.AddAliasToColumnName("name", alias)), f.NameMATCH)
}
if !isZero(f.NameIEQ) {
q = q.Where(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("name", alias)), f.NameIEQ)
q = q.Where(sql.BuildConditionIEQ(sql.AddAliasToColumnName("name", alias)), f.NameIEQ)
}
if !isZero(f.Code) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("code", alias)), pg.Array(f.Code))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("code", alias)), pg.Array(f.Code))
}
if !isZero(f.CodeNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("code", alias)), pg.Array(f.CodeNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("code", alias)), pg.Array(f.CodeNEQ))
}
if !isZero(f.CodeMATCH) {
q = q.Where(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("code", alias)), f.CodeMATCH)
q = q.Where(sql.BuildConditionMatch(sql.AddAliasToColumnName("code", alias)), f.CodeMATCH)
}
if !isZero(f.CodeIEQ) {
q = q.Where(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("code", alias)), f.CodeIEQ)
q = q.Where(sql.BuildConditionIEQ(sql.AddAliasToColumnName("code", alias)), f.CodeIEQ)
}
if !isZero(f.Formula) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("formula", alias)), pg.Array(f.Formula))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("formula", alias)), pg.Array(f.Formula))
}
if !isZero(f.FormulaNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("formula", alias)), pg.Array(f.FormulaNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("formula", alias)), pg.Array(f.FormulaNEQ))
}
if !isZero(f.DescriptionMATCH) {
q = q.Where(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("description", alias)), f.DescriptionMATCH)
q = q.Where(sql.BuildConditionMatch(sql.AddAliasToColumnName("description", alias)), f.DescriptionMATCH)
}
if !isZero(f.DescriptionIEQ) {
q = q.Where(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("description", alias)), f.DescriptionIEQ)
q = q.Where(sql.BuildConditionIEQ(sql.AddAliasToColumnName("description", alias)), f.DescriptionIEQ)
}
if !isZero(f.ProfessionID) {
@ -260,30 +260,30 @@ func (f *QualificationFilter) WhereWithAlias(q *orm.Query, alias string) (*orm.Q
subquery := q.
New().
Model(&QualificationToProfession{}).
ColumnExpr(sqlutils.BuildCountColumnExpr("profession_id", "count")).
ColumnExpr(sql.BuildCountColumnExpr("profession_id", "count")).
Column("qualification_id").
Where(sqlutils.BuildConditionArray("profession_id"), pg.Array(f.ProfessionID)).
Where(sql.BuildConditionArray("profession_id"), pg.Array(f.ProfessionID)).
Group("qualification_id")
q = q.
Join(`INNER JOIN (?) AS qualification_to_professions ON qualification_to_professions.qualification_id = qualification.id`, subquery).
Where(sqlutils.BuildConditionGTE("count"), sliceLength)
Where(sql.BuildConditionGTE("count"), sliceLength)
}
if !isZero(f.CreatedAt) {
q = q.Where(sqlutils.BuildConditionEquals(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAt)
q = q.Where(sql.BuildConditionEquals(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAt)
}
if !isZero(f.CreatedAtGT) {
q = q.Where(sqlutils.BuildConditionGT(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtGT)
q = q.Where(sql.BuildConditionGT(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtGT)
}
if !isZero(f.CreatedAtGTE) {
q = q.Where(sqlutils.BuildConditionGTE(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtGTE)
q = q.Where(sql.BuildConditionGTE(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtGTE)
}
if !isZero(f.CreatedAtLT) {
q = q.Where(sqlutils.BuildConditionLT(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtLT)
q = q.Where(sql.BuildConditionLT(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtLT)
}
if !isZero(f.CreatedAtLTE) {
q = q.Where(sqlutils.BuildConditionLTE(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtLTE)
q = q.Where(sql.BuildConditionLTE(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtLTE)
}
if f.Or != nil {

44
internal/models/question.go
View File

@ -2,13 +2,13 @@ package models
import (
"context"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"strings"
"time"
"github.com/99designs/gqlgen/graphql"
"github.com/go-pg/pg/v10"
"github.com/go-pg/pg/v10/orm"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
)
var _ pg.BeforeInsertHook = (*Question)(nil)
@ -157,36 +157,36 @@ func (input *QuestionInput) ApplyUpdate(q *orm.Query) (*orm.Query, error) {
if !input.IsEmpty() {
if input.Content != nil {
q = q.Set(
sqlutils.BuildConditionEquals(sqlutils.WrapStringInDoubleQuotes("content")),
sql.BuildConditionEquals(sql.AddAliasToColumnName("content", "question")),
*input.Content,
)
}
if input.From != nil {
q = q.Set(
sqlutils.BuildConditionEquals(sqlutils.WrapStringInDoubleQuotes("from")),
sql.BuildConditionEquals(sql.AddAliasToColumnName("from", "question")),
*input.From,
)
}
if input.Explanation != nil {
q = q.Set(sqlutils.BuildConditionEquals("explanation"), *input.Explanation)
q = q.Set(sql.BuildConditionEquals("explanation"), *input.Explanation)
}
if input.CorrectAnswer != nil {
q = q.Set(sqlutils.BuildConditionEquals("correct_answer"), *input.CorrectAnswer)
q = q.Set(sql.BuildConditionEquals("correct_answer"), *input.CorrectAnswer)
}
if input.AnswerA != nil {
q = q.Set(sqlutils.BuildConditionEquals("answer_a"), *input.AnswerA)
q = q.Set(sql.BuildConditionEquals("answer_a"), *input.AnswerA)
}
if input.AnswerB != nil {
q = q.Set(sqlutils.BuildConditionEquals("answer_b"), *input.AnswerB)
q = q.Set(sql.BuildConditionEquals("answer_b"), *input.AnswerB)
}
if input.AnswerC != nil {
q = q.Set(sqlutils.BuildConditionEquals("answer_c"), *input.AnswerC)
q = q.Set(sql.BuildConditionEquals("answer_c"), *input.AnswerC)
}
if input.AnswerD != nil {
q = q.Set(sqlutils.BuildConditionEquals("answer_d"), *input.AnswerD)
q = q.Set(sql.BuildConditionEquals("answer_d"), *input.AnswerD)
}
if input.QualificationID != nil {
q = q.Set(sqlutils.BuildConditionEquals("qualification_id"), *input.QualificationID)
q = q.Set(sql.BuildConditionEquals("qualification_id"), *input.QualificationID)
}
}
@ -219,28 +219,28 @@ func (f *QuestionFilter) WhereWithAlias(q *orm.Query, alias string) (*orm.Query,
}
if !isZero(f.ID) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("id", alias)), pg.Array(f.ID))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("id", alias)), pg.Array(f.ID))
}
if !isZero(f.IDNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("id", alias)), pg.Array(f.IDNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("id", alias)), pg.Array(f.IDNEQ))
}
if !isZero(f.From) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("from", alias)), pg.Array(f.From))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("from", alias)), pg.Array(f.From))
}
if !isZero(f.ContentMATCH) {
q = q.Where(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("content", alias)), f.ContentMATCH)
q = q.Where(sql.BuildConditionMatch(sql.AddAliasToColumnName("content", alias)), f.ContentMATCH)
}
if !isZero(f.ContentIEQ) {
q = q.Where(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("content", alias)), f.ContentIEQ)
q = q.Where(sql.BuildConditionIEQ(sql.AddAliasToColumnName("content", alias)), f.ContentIEQ)
}
if !isZero(f.QualificationID) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("qualification_id", alias)), pg.Array(f.QualificationID))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("qualification_id", alias)), pg.Array(f.QualificationID))
}
if !isZero(f.QualificationIDNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("qualification_id", alias)), pg.Array(f.QualificationIDNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("qualification_id", alias)), pg.Array(f.QualificationIDNEQ))
}
if f.QualificationFilter != nil {
@ -249,19 +249,19 @@ func (f *QuestionFilter) WhereWithAlias(q *orm.Query, alias string) (*orm.Query,
}
if !isZero(f.CreatedAt) {
q = q.Where(sqlutils.BuildConditionEquals(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAt)
q = q.Where(sql.BuildConditionEquals(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAt)
}
if !isZero(f.CreatedAtGT) {
q = q.Where(sqlutils.BuildConditionGT(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtGT)
q = q.Where(sql.BuildConditionGT(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtGT)
}
if !isZero(f.CreatedAtGTE) {
q = q.Where(sqlutils.BuildConditionGTE(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtGTE)
q = q.Where(sql.BuildConditionGTE(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtGTE)
}
if !isZero(f.CreatedAtLT) {
q = q.Where(sqlutils.BuildConditionLT(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtLT)
q = q.Where(sql.BuildConditionLT(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtLT)
}
if !isZero(f.CreatedAtLTE) {
q = q.Where(sqlutils.BuildConditionLTE(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtLTE)
q = q.Where(sql.BuildConditionLTE(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtLTE)
}
return q, nil

53
internal/models/user.go
View File

@ -2,11 +2,10 @@ package models
import (
"context"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"strings"
"time"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
"github.com/go-pg/pg/v10"
"github.com/go-pg/pg/v10/orm"
"github.com/pkg/errors"
@ -106,7 +105,7 @@ func (input *UserInput) ToUser() *User {
func (input *UserInput) ApplyUpdate(q *orm.Query) (*orm.Query, error) {
if !input.IsEmpty() {
if input.DisplayName != nil {
q = q.Set(sqlutils.BuildConditionEquals("display_name"), *input.DisplayName)
q = q.Set(sql.BuildConditionEquals("display_name"), *input.DisplayName)
}
if input.Password != nil {
@ -114,19 +113,19 @@ func (input *UserInput) ApplyUpdate(q *orm.Query) (*orm.Query, error) {
if err != nil {
return q, err
}
q = q.Set(sqlutils.BuildConditionEquals("password"), string(hashedPassword))
q = q.Set(sql.BuildConditionEquals("password"), string(hashedPassword))
}
if input.Email != nil {
q = q.Set(sqlutils.BuildConditionEquals("email"), *input.Email)
q = q.Set(sql.BuildConditionEquals("email"), *input.Email)
}
if input.Role != nil {
q = q.Set(sqlutils.BuildConditionEquals("role"), *input.Role)
q = q.Set(sql.BuildConditionEquals("role"), *input.Role)
}
if input.Activated != nil {
q = q.Set(sqlutils.BuildConditionEquals("activated"), *input.Activated)
q = q.Set(sql.BuildConditionEquals("activated"), *input.Activated)
}
}
@ -149,22 +148,22 @@ func (f *UserFilterOr) WhereWithAlias(q *orm.Query, alias string) *orm.Query {
q = q.WhereGroup(func(q *orm.Query) (*orm.Query, error) {
if !isZero(f.DisplayNameMATCH) {
q = q.WhereOr(
sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("display_name", alias)),
sql.BuildConditionMatch(sql.AddAliasToColumnName("display_name", alias)),
f.DisplayNameMATCH,
)
}
if !isZero(f.DisplayNameIEQ) {
q = q.WhereOr(
sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("display_name", alias)),
sql.BuildConditionIEQ(sql.AddAliasToColumnName("display_name", alias)),
f.DisplayNameIEQ,
)
}
if !isZero(f.EmailMATCH) {
q = q.WhereOr(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("email", alias)), f.EmailMATCH)
q = q.WhereOr(sql.BuildConditionMatch(sql.AddAliasToColumnName("email", alias)), f.EmailMATCH)
}
if !isZero(f.EmailIEQ) {
q = q.WhereOr(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("email", alias)), f.EmailIEQ)
q = q.WhereOr(sql.BuildConditionIEQ(sql.AddAliasToColumnName("email", alias)), f.EmailIEQ)
}
return q, nil
@ -206,56 +205,56 @@ func (f *UserFilter) WhereWithAlias(q *orm.Query, alias string) (*orm.Query, err
}
if !isZero(f.ID) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("id", alias)), pg.Array(f.ID))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("id", alias)), pg.Array(f.ID))
}
if !isZero(f.IDNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("id", alias)), pg.Array(f.IDNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("id", alias)), pg.Array(f.IDNEQ))
}
if !isZero(f.Activated) {
q = q.Where(sqlutils.BuildConditionEquals(sqlutils.AddAliasToColumnName("activated", alias)), f.Activated)
q = q.Where(sql.BuildConditionEquals(sql.AddAliasToColumnName("activated", alias)), f.Activated)
}
if !isZero(f.DisplayName) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("display_name", alias)), pg.Array(f.DisplayName))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("display_name", alias)), pg.Array(f.DisplayName))
}
if !isZero(f.DisplayNameNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("display_name", alias)), pg.Array(f.DisplayNameNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("display_name", alias)), pg.Array(f.DisplayNameNEQ))
}
if !isZero(f.DisplayNameMATCH) {
q = q.Where(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("display_name", alias)), f.DisplayNameMATCH)
q = q.Where(sql.BuildConditionMatch(sql.AddAliasToColumnName("display_name", alias)), f.DisplayNameMATCH)
}
if !isZero(f.DisplayNameIEQ) {
q = q.Where(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("display_name", alias)), f.DisplayNameIEQ)
q = q.Where(sql.BuildConditionIEQ(sql.AddAliasToColumnName("display_name", alias)), f.DisplayNameIEQ)
}
if !isZero(f.Email) {
q = q.Where(sqlutils.BuildConditionArray(sqlutils.AddAliasToColumnName("email", alias)), pg.Array(f.Email))
q = q.Where(sql.BuildConditionArray(sql.AddAliasToColumnName("email", alias)), pg.Array(f.Email))
}
if !isZero(f.EmailNEQ) {
q = q.Where(sqlutils.BuildConditionNotInArray(sqlutils.AddAliasToColumnName("email", alias)), pg.Array(f.EmailNEQ))
q = q.Where(sql.BuildConditionNotInArray(sql.AddAliasToColumnName("email", alias)), pg.Array(f.EmailNEQ))
}
if !isZero(f.EmailMATCH) {
q = q.Where(sqlutils.BuildConditionMatch(sqlutils.AddAliasToColumnName("email", alias)), f.EmailMATCH)
q = q.Where(sql.BuildConditionMatch(sql.AddAliasToColumnName("email", alias)), f.EmailMATCH)
}
if !isZero(f.EmailIEQ) {
q = q.Where(sqlutils.BuildConditionIEQ(sqlutils.AddAliasToColumnName("email", alias)), f.EmailIEQ)
q = q.Where(sql.BuildConditionIEQ(sql.AddAliasToColumnName("email", alias)), f.EmailIEQ)
}
if !isZero(f.CreatedAt) {
q = q.Where(sqlutils.BuildConditionEquals(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAt)
q = q.Where(sql.BuildConditionEquals(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAt)
}
if !isZero(f.CreatedAtGT) {
q = q.Where(sqlutils.BuildConditionGT(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtGT)
q = q.Where(sql.BuildConditionGT(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtGT)
}
if !isZero(f.CreatedAtGTE) {
q = q.Where(sqlutils.BuildConditionGTE(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtGTE)
q = q.Where(sql.BuildConditionGTE(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtGTE)
}
if !isZero(f.CreatedAtLT) {
q = q.Where(sqlutils.BuildConditionLT(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtLT)
q = q.Where(sql.BuildConditionLT(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtLT)
}
if !isZero(f.CreatedAtLTE) {
q = q.Where(sqlutils.BuildConditionLTE(sqlutils.AddAliasToColumnName("created_at", alias)), f.CreatedAtLTE)
q = q.Where(sql.BuildConditionLTE(sql.AddAliasToColumnName("created_at", alias)), f.CreatedAtLTE)
}
if f.Or != nil {

16
internal/profession/repository/pg_repository.go
View File

@ -3,10 +3,10 @@ package repository
import (
"context"
"github.com/pkg/errors"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"strings"
errorutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/error"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/errorutil"
"github.com/go-pg/pg/v10"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
@ -69,7 +69,7 @@ func (repo *pgRepository) Delete(ctx context.Context, f *models.ProfessionFilter
Returning("*").
Apply(f.Where).
Delete(); err != nil && err != pg.ErrNoRows {
return nil, errorutils.Wrap(err, messageFailedToDeleteModel)
return nil, errorutil.Wrap(err, messageFailedToDeleteModel)
}
return items, nil
}
@ -92,7 +92,7 @@ func (repo *pgRepository) Fetch(ctx context.Context, cfg *profession.FetchConfig
err = query.Select()
}
if err != nil && err != pg.ErrNoRows {
return nil, 0, errorutils.Wrap(err, messageFailedToFetchModel)
return nil, 0, errorutil.Wrap(err, messageFailedToFetchModel)
}
return items, total, nil
}
@ -109,11 +109,11 @@ func (repo *pgRepository) GetAssociatedQualifications(
if err := repo.
Model(&qualificationToProfession).
Context(ctx).
Where(sqlutils.BuildConditionArray("profession_id"), pg.Array(ids)).
Where(sql.BuildConditionArray("profession_id"), pg.Array(ids)).
Relation("Qualification").
Order("qualification.formula ASC", "qualification.code ASC").
Select(); err != nil {
return nil, errorutils.Wrap(err, messageFailedToFetchAssociatedQualifications)
return nil, errorutil.Wrap(err, messageFailedToFetchAssociatedQualifications)
}
for _, record := range qualificationToProfession {
m[record.ProfessionID] = append(m[record.ProfessionID], record.Qualification)
@ -123,7 +123,7 @@ func (repo *pgRepository) GetAssociatedQualifications(
func handleInsertAndUpdateError(err error) error {
if strings.Contains(err.Error(), "name") || strings.Contains(err.Error(), "slug") {
return errorutils.Wrap(err, messageNameIsAlreadyTaken)
return errorutil.Wrap(err, messageNameIsAlreadyTaken)
}
return errorutils.Wrap(err, messageFailedToSaveModel)
return errorutil.Wrap(err, messageFailedToSaveModel)
}

4
internal/profession/usecase/usecase.go
View File

@ -3,10 +3,10 @@ package usecase
import (
"context"
"github.com/pkg/errors"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/profession"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
)
type usecase struct {
@ -65,7 +65,7 @@ func (ucase *usecase) Fetch(ctx context.Context, cfg *profession.FetchConfig) ([
Count: true,
}
}
cfg.Sort = sqlutils.SanitizeSorts(cfg.Sort)
cfg.Sort = sql.SanitizeOrders(cfg.Sort)
return ucase.professionRepository.Fetch(ctx, cfg)
}

27
internal/qualification/repository/pg_repository.go
View File

@ -3,11 +3,10 @@ package repository
import (
"context"
"github.com/pkg/errors"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"strings"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
errorutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/error"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/errorutil"
"github.com/go-pg/pg/v10"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
@ -88,8 +87,8 @@ func (repo *pgRepository) UpdateMany(
if len(input.DissociateProfession) > 0 {
_, err := tx.
Model(&models.QualificationToProfession{}).
Where(sqlutils.BuildConditionArray("profession_id"), pg.Array(input.DissociateProfession)).
Where(sqlutils.BuildConditionArray("qualification_id"), pg.Array(qualificationIDs)).
Where(sql.BuildConditionArray("profession_id"), pg.Array(input.DissociateProfession)).
Where(sql.BuildConditionArray("qualification_id"), pg.Array(qualificationIDs)).
Delete()
if err != nil {
return handleInsertAndUpdateError(err)
@ -116,7 +115,7 @@ func (repo *pgRepository) Delete(ctx context.Context, f *models.QualificationFil
Returning("*").
Apply(f.Where).
Delete(); err != nil && err != pg.ErrNoRows {
return nil, errorutils.Wrap(err, messageFailedToDeleteModel)
return nil, errorutil.Wrap(err, messageFailedToDeleteModel)
}
return items, nil
}
@ -139,7 +138,7 @@ func (repo *pgRepository) Fetch(ctx context.Context, cfg *qualification.FetchCon
err = query.Select()
}
if err != nil && err != pg.ErrNoRows {
return nil, 0, errorutils.Wrap(err, messageFailedToFetchModel)
return nil, 0, errorutil.Wrap(err, messageFailedToFetchModel)
}
return items, total, nil
}
@ -149,7 +148,7 @@ func (repo *pgRepository) GetSimilar(ctx context.Context, cfg *qualification.Get
subquery := repo.
Model(&models.QualificationToProfession{}).
Context(ctx).
Where(sqlutils.BuildConditionEquals("qualification_id"), cfg.QualificationID).
Where(sql.BuildConditionEquals("qualification_id"), cfg.QualificationID).
Column("profession_id")
qualificationIDs := []int{}
err = repo.
@ -157,11 +156,11 @@ func (repo *pgRepository) GetSimilar(ctx context.Context, cfg *qualification.Get
Context(ctx).
Column("qualification_id").
With("prof", subquery).
Where(sqlutils.BuildConditionIn("profession_id"), pg.Safe("SELECT profession_id FROM prof")).
Where(sqlutils.BuildConditionNEQ("qualification_id"), cfg.QualificationID).
Where(sql.BuildConditionIn("profession_id"), pg.Safe("SELECT profession_id FROM prof")).
Where(sql.BuildConditionNEQ("qualification_id"), cfg.QualificationID).
Select(&qualificationIDs)
if err != nil {
return nil, 0, errorutils.Wrap(err, messageFailedToFetchModel)
return nil, 0, errorutil.Wrap(err, messageFailedToFetchModel)
}
if len(qualificationIDs) == 0 {
@ -195,9 +194,9 @@ func (repo *pgRepository) associateQualificationWithProfession(tx *pg.Tx, qualif
func handleInsertAndUpdateError(err error) error {
if strings.Contains(err.Error(), "name") {
return errorutils.Wrap(err, messageNameIsAlreadyTaken)
return errorutil.Wrap(err, messageNameIsAlreadyTaken)
} else if strings.Contains(err.Error(), "code") || strings.Contains(err.Error(), "slug") {
return errorutils.Wrap(err, messageCodeIsAlreadyTaken)
return errorutil.Wrap(err, messageCodeIsAlreadyTaken)
}
return errorutils.Wrap(err, messageFailedToSaveModel)
return errorutil.Wrap(err, messageFailedToSaveModel)
}

6
internal/qualification/usecase/usecase.go
View File

@ -3,10 +3,10 @@ package usecase
import (
"context"
"github.com/pkg/errors"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/qualification"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
)
type usecase struct {
@ -65,7 +65,7 @@ func (ucase *usecase) Fetch(ctx context.Context, cfg *qualification.FetchConfig)
Count: true,
}
}
cfg.Sort = sqlutils.SanitizeSorts(cfg.Sort)
cfg.Sort = sql.SanitizeOrders(cfg.Sort)
return ucase.qualificationRepository.Fetch(ctx, cfg)
}
@ -107,7 +107,7 @@ func (ucase *usecase) GetSimilar(ctx context.Context, cfg *qualification.GetSimi
if cfg == nil || cfg.QualificationID <= 0 {
return nil, 0, errors.New(messageQualificationIDIsRequired)
}
cfg.Sort = sqlutils.SanitizeSorts(cfg.Sort)
cfg.Sort = sql.SanitizeOrders(cfg.Sort)
return ucase.qualificationRepository.GetSimilar(ctx, cfg)
}

25
internal/question/repository/pg_repository.go
View File

@ -3,17 +3,16 @@ package repository
import (
"context"
"github.com/pkg/errors"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"strings"
"time"
"github.com/zdam-egzamin-zawodowy/backend/pkg/filestorage"
errorutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/error"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
"github.com/go-pg/pg/v10"
"github.com/zdam-egzamin-zawodowy/backend/internal/db"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/question"
"github.com/zdam-egzamin-zawodowy/backend/pkg/filestorage"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/errorutil"
)
type pgRepository struct {
@ -60,7 +59,7 @@ func (repo *pgRepository) Store(ctx context.Context, input *models.QuestionInput
Set("answer_c_image = ?", item.AnswerCImage).
Set("answer_d_image = ?", item.AnswerDImage).
Update(); err != nil && err != pg.ErrNoRows {
return nil, errorutils.Wrap(err, messageFailedToSaveModel)
return nil, errorutil.Wrap(err, messageFailedToSaveModel)
}
return item, nil
@ -72,7 +71,7 @@ func (repo *pgRepository) UpdateOneByID(ctx context.Context, id int, input *mode
Model(item).
Context(ctx).
Returning("*").
Where(sqlutils.BuildConditionEquals(sqlutils.AddAliasToColumnName("id", "question")), id).
Where(sql.BuildConditionEquals(sql.AddAliasToColumnName("id", "question")), id).
Set("updated_at = ?", time.Now())
if _, err := baseQuery.
@ -107,7 +106,7 @@ func (repo *pgRepository) Delete(ctx context.Context, f *models.QuestionFilter)
Returning("*").
Apply(f.Where).
Delete(); err != nil && err != pg.ErrNoRows {
return nil, errorutils.Wrap(err, messageFailedToDeleteModel)
return nil, errorutil.Wrap(err, messageFailedToDeleteModel)
}
go repo.getAllImagesAndDelete(items)
@ -138,7 +137,7 @@ func (repo *pgRepository) Fetch(ctx context.Context, cfg *question.FetchConfig)
err = query.Select()
}
if err != nil && err != pg.ErrNoRows {
return nil, 0, errorutils.Wrap(err, messageFailedToFetchModel)
return nil, 0, errorutil.Wrap(err, messageFailedToFetchModel)
}
return items, total, nil
}
@ -147,23 +146,23 @@ func (repo *pgRepository) GenerateTest(ctx context.Context, cfg *question.Genera
subquery := repo.
Model(&models.Question{}).
Column("id").
Where(sqlutils.BuildConditionArray("qualification_id"), pg.Array(cfg.Qualifications)).
Where(sql.BuildConditionArray("qualification_id"), pg.Array(cfg.Qualifications)).
OrderExpr("random()").
Limit(cfg.Limit)
items := []*models.Question{}
if err := repo.
Model(&items).
Context(ctx).
Where(sqlutils.BuildConditionIn("id"), subquery).
Where(sql.BuildConditionIn("id"), subquery).
Select(); err != nil && err != pg.ErrNoRows {
return nil, errorutils.Wrap(err, messageFailedToFetchModel)
return nil, errorutil.Wrap(err, messageFailedToFetchModel)
}
return items, nil
}
func handleInsertAndUpdateError(err error) error {
if strings.Contains(err.Error(), "questions_from_content_correct_answer_qualification_id_key") {
return errorutils.Wrap(err, messageSimilarRecordExists)
return errorutil.Wrap(err, messageSimilarRecordExists)
}
return errorutils.Wrap(err, messageFailedToSaveModel)
return errorutil.Wrap(err, messageFailedToSaveModel)
}

4
internal/question/repository/repository.go
View File

@ -1,12 +1,12 @@
package repository
import (
"github.com/zdam-egzamin-zawodowy/backend/pkg/filestorage/filestorageutil"
"path/filepath"
"github.com/99designs/gqlgen/graphql"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/pkg/filestorage"
"github.com/zdam-egzamin-zawodowy/backend/pkg/utils"
)
type repository struct {
@ -34,7 +34,7 @@ func (repo *repository) saveImages(destination *models.Question, input *models.Q
generated := false
if filenames[index] == "" {
generated = true
filenames[index] = utils.GenerateFilename(filepath.Ext(file.Filename))
filenames[index] = filestorageutil.GenerateFilename(filepath.Ext(file.Filename))
}
err := repo.fileStorage.Put(file.File, filenames[index])
if err != nil && generated {

4
internal/question/usecase/usecase.go
View File

@ -5,7 +5,7 @@ import (
"github.com/pkg/errors"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/question"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
)
var (
@ -73,7 +73,7 @@ func (ucase *usecase) Fetch(ctx context.Context, cfg *question.FetchConfig) ([]*
if cfg.Limit > question.FetchMaxLimit {
cfg.Limit = question.FetchMaxLimit
}
cfg.Sort = sqlutils.SanitizeSorts(cfg.Sort)
cfg.Sort = sql.SanitizeOrders(cfg.Sort)
return ucase.questionRepository.Fetch(ctx, cfg)
}

10
internal/user/repository/pg_repository.go
View File

@ -5,7 +5,7 @@ import (
"github.com/pkg/errors"
"strings"
errorutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/error"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/errorutil"
"github.com/go-pg/pg/v10"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
@ -68,7 +68,7 @@ func (repo *pgRepository) Delete(ctx context.Context, f *models.UserFilter) ([]*
Returning("*").
Apply(f.Where).
Delete(); err != nil && err != pg.ErrNoRows {
return nil, errorutils.Wrap(err, messageFailedToDeleteModel)
return nil, errorutil.Wrap(err, messageFailedToDeleteModel)
}
return items, nil
}
@ -91,14 +91,14 @@ func (repo *pgRepository) Fetch(ctx context.Context, cfg *user.FetchConfig) ([]*
err = query.Select()
}
if err != nil && err != pg.ErrNoRows {
return nil, 0, errorutils.Wrap(err, messageFailedToFetchModel)
return nil, 0, errorutil.Wrap(err, messageFailedToFetchModel)
}
return items, total, nil
}
func handleInsertAndUpdateError(err error) error {
if strings.Contains(err.Error(), "email") {
return errorutils.Wrap(err, messageEmailIsAlreadyTaken)
return errorutil.Wrap(err, messageEmailIsAlreadyTaken)
}
return errorutils.Wrap(err, messageFailedToSaveModel)
return errorutil.Wrap(err, messageFailedToSaveModel)
}

8
internal/user/usecase/usecase.go
View File

@ -3,11 +3,11 @@ package usecase
import (
"context"
"github.com/pkg/errors"
"github.com/zdam-egzamin-zawodowy/backend/pkg/sql"
"github.com/zdam-egzamin-zawodowy/backend/pkg/validator"
"github.com/zdam-egzamin-zawodowy/backend/internal/models"
"github.com/zdam-egzamin-zawodowy/backend/internal/user"
"github.com/zdam-egzamin-zawodowy/backend/pkg/utils"
sqlutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/sql"
)
type usecase struct {
@ -82,7 +82,7 @@ func (ucase *usecase) Fetch(ctx context.Context, cfg *user.FetchConfig) ([]*mode
if cfg.Limit > user.FetchMaxLimit || cfg.Limit <= 0 {
cfg.Limit = user.FetchMaxLimit
}
cfg.Sort = sqlutils.SanitizeSorts(cfg.Sort)
cfg.Sort = sql.SanitizeOrders(cfg.Sort)
return ucase.userRepository.Fetch(ctx, cfg)
}
@ -144,7 +144,7 @@ func validateInput(input *models.UserInput, opts validateOptions) error {
}
if input.Email != nil {
if !utils.IsEmailValid(*input.Email) {
if !validator.IsEmailValid(*input.Email) {
return errors.New(messageEmailIsInvalid)
}
} else if !opts.acceptNilValues {

4
main.go
View File

@ -33,7 +33,7 @@ import (
"github.com/sirupsen/logrus"
"github.com/zdam-egzamin-zawodowy/backend/pkg/filestorage"
"github.com/zdam-egzamin-zawodowy/backend/pkg/mode"
envutils "github.com/zdam-egzamin-zawodowy/backend/pkg/utils/env"
"github.com/zdam-egzamin-zawodowy/backend/pkg/util/envutil"
)
func init() {
@ -52,7 +52,7 @@ func main() {
})
dbConn, err := db.Connect(&db.Config{
LogQueries: envutils.GetenvBool("LOG_DB_QUERIES"),
LogQueries: envutil.GetenvBool("LOG_DB_QUERIES"),
})
if err != nil {
logrus.Fatal(errors.Wrap(err, "Couldn't connect to the db"))

2
pkg/utils/generate_filename.go → pkg/filestorage/filestorageutil/generate_filename.go
View File

@ -1,4 +1,4 @@
package utils
package filestorageutil
import (
"strings"

16
pkg/sql/alias.go Normal file
View File

@ -0,0 +1,16 @@
package sql
import "strings"
func AddAliasToColumnName(column, alias string) string {
if alias != "" && !strings.HasPrefix(column, alias+".") {
column = wrapStringInDoubleQuotes(alias) + "." + wrapStringInDoubleQuotes(column)
} else {
column = wrapStringInDoubleQuotes(column)
}
return column
}
func wrapStringInDoubleQuotes(str string) string {
return `"` + str + `"`
}

16
pkg/utils/sql/sql.go → pkg/sql/conditions_and_expressions.go
View File

@ -1,23 +1,9 @@
package sqlutils
package sql
import (
"fmt"
"strings"
)
func AddAliasToColumnName(column, alias string) string {
if alias != "" && !strings.HasPrefix(column, alias+".") {
column = WrapStringInDoubleQuotes(alias) + "." + WrapStringInDoubleQuotes(column)
} else {
column = WrapStringInDoubleQuotes(column)
}
return column
}
func WrapStringInDoubleQuotes(str string) string {
return `"` + str + `"`
}
func BuildConditionEquals(column string) string {
return column + " = ?"
}

30
pkg/utils/sql/sanitize_sort.go → pkg/sql/sanitize_sort.go
View File

@ -1,4 +1,4 @@
package sqlutils
package sql
import (
"regexp"
@ -11,39 +11,39 @@ var (
sortRegex = regexp.MustCompile(`^[\p{L}\_\.]+$`)
)
func SanitizeSort(sort string) string {
splitted := strings.Split(strings.TrimSpace(sort), " ")
length := len(splitted)
func SanitizeOrder(order string) string {
parts := strings.Split(strings.TrimSpace(order), " ")
length := len(parts)
if length != 2 || !sortRegex.Match([]byte(splitted[0])) {
if length != 2 || !sortRegex.Match([]byte(parts[0])) {
return ""
}
table := ""
column := splitted[0]
if strings.Contains(splitted[0], ".") {
columnAndTable := strings.Split(splitted[0], ".")
column := parts[0]
if strings.Contains(parts[0], ".") {
columnAndTable := strings.Split(parts[0], ".")
table = underscore(columnAndTable[0]) + "."
column = columnAndTable[1]
}
direction := "ASC"
if strings.ToUpper(splitted[1]) == "DESC" {
if strings.ToUpper(parts[1]) == "DESC" {
direction = "DESC"
}
return strings.ToLower(table+underscore(column)) + " " + direction
}
func SanitizeSorts(sorts []string) []string {
sanitizedSorts := []string{}
for _, sort := range sorts {
sanitized := SanitizeSort(sort)
func SanitizeOrders(orders []string) []string {
var sanitizedOrders []string
for _, sort := range orders {
sanitized := SanitizeOrder(sort)
if sanitized != "" {
sanitizedSorts = append(sanitizedSorts, sanitized)
sanitizedOrders = append(sanitizedOrders, sanitized)
}
}
return sanitizedSorts
return sanitizedOrders
}
type buffer struct {

10
pkg/utils/env/env.go → pkg/util/envutil/env.go
View File

@ -1,4 +1,4 @@
package envutils
package envutil
import (
"os"
@ -6,7 +6,7 @@ import (
)
func GetenvInt(key string) int {
str := os.Getenv(key)
str := GetenvString(key)
if str == "" {
return 0
}
@ -18,9 +18,13 @@ func GetenvInt(key string) int {
}
func GetenvBool(key string) bool {
str := os.Getenv(key)
str := GetenvString(key)
if str == "" {
return false
}
return str == "true" || str == "1"
}
func GetenvString(key string) string {
return os.Getenv(key)
}

2
pkg/utils/error/error.go → pkg/util/errorutil/error.go
View File

@ -1,4 +1,4 @@
package errorutils
package errorutil
import (
"github.com/pkg/errors"

9
pkg/utils/safe_pointer.go → pkg/util/safepointer/safe_pointer.go
View File

@ -1,4 +1,4 @@
package utils
package safepointer
func SafeBoolPointer(v *bool, def bool) bool {
if v == nil {
@ -13,3 +13,10 @@ func SafeIntPointer(s *int, def int) int {
}
return *s
}
func SafeStringPointer(s *string, def string) string {
if s == nil {
return def
}
return *s
}

2
pkg/utils/is_email_valid.go → pkg/validator/is_email_valid.go
View File

@ -1,4 +1,4 @@
package utils
package validator
import (
"net"