Using pointers

internal/config/forms.go

@@ -19,6 +19,7 @@ type Forms struct {
 	Period            time.Duration
 	MinAbnormalPeriod time.Duration
 	MaxAbnormalPeriod time.Duration
+	ResendFormsCount  uint64
 	db                *sql.DB
 }
 
@@ -27,6 +28,7 @@ type formsConfig struct {
 	Period            time.Duration `fig:"period,required"`
 	MinAbnormalPeriod time.Duration `fig:"min_abnormal_period,required"`
 	MaxAbnormalPeriod time.Duration `fig:"max_abnormal_period,required"`
+	ResendFormsCount  uint64        `fig:"resend_forms_count,required"`
 	URL               string        `fig:"url,required"`
 }
 
@@ -51,12 +53,13 @@ func (c *config) Forms() *Forms {
 			Period:            cfg.Period,
 			MinAbnormalPeriod: cfg.MinAbnormalPeriod,
 			MaxAbnormalPeriod: cfg.MaxAbnormalPeriod,
+			ResendFormsCount:  cfg.ResendFormsCount,
 			db:                db,
 		}
 	}).(*Forms)
 }
 
-func (f *Forms) SendForms(forms ...data.Form) error {
+func (f *Forms) SendForms(forms ...*data.Form) error {
 	if len(forms) == 0 {
 		return nil
 	}
@@ -79,6 +82,9 @@ func (f *Forms) SendForms(forms ...data.Form) error {
 	)
 
 	for _, form := range forms {
+		if form == nil {
+			continue
+		}
 		stmt = stmt.Values(
 			form.Name,
 			form.Surname,

internal/data/forms.go

@@ -27,19 +27,20 @@ type Form struct {
 	Postal    string    `db:"postal"`
 	Phone     string    `db:"phone"`
 	Email     string    `db:"email"`
-	Image     string    `db:"image"`
+	Image     *string   `db:"image"`
 	CreatedAt time.Time `db:"created_at"`
 }
 
 type FormsQ interface {
 	New() FormsQ
-	Insert(Form) (*Form, error)
+	Insert(*Form) (string, error)
 	Update(status string) error
 
-	Select() ([]Form, error)
+	Select() ([]*Form, error)
 	Get() (*Form, error)
 	// last returns the most recent form
 	Last() (*Form, error)
+	Limit(uint64) FormsQ
 
 	FilterByID(ids ...string) FormsQ
 	FilterByNullifier(nullifier string) FormsQ

internal/data/pg/forms.go

@@ -32,8 +32,8 @@ func (q *formsQ) New() data.FormsQ {
 	return NewForms(q.db)
 }
 
-func (q *formsQ) Insert(form data.Form) (*data.Form, error) {
-	var res data.Form
+func (q *formsQ) Insert(form *data.Form) (string, error) {
+	var res string
 	stmt := squirrel.Insert(formsTable).SetMap(map[string]interface{}{
 		"nullifier": form.Nullifier,
 		"status":    form.Status,
@@ -51,13 +51,13 @@ func (q *formsQ) Insert(form data.Form) (*data.Form, error) {
 		"phone":     form.Phone,
 		"email":     form.Email,
 		"image":     form.Image,
-	}).Suffix("RETURNING *")
+	}).Suffix("RETURNING id")
 
 	if err := q.db.Get(&res, stmt); err != nil {
-		return nil, fmt.Errorf("insert form [%+v]: %w", form, err)
+		return "", fmt.Errorf("insert form [%+v]: %w", form, err)
 	}
 
-	return &res, nil
+	return res, nil
 }
 
 func (q *formsQ) Update(status string) error {
@@ -68,8 +68,8 @@ func (q *formsQ) Update(status string) error {
 	return nil
 }
 
-func (q *formsQ) Select() ([]data.Form, error) {
-	var res []data.Form
+func (q *formsQ) Select() ([]*data.Form, error) {
+	var res []*data.Form
 
 	if err := q.db.Select(&res, q.selector); err != nil {
 		return nil, fmt.Errorf("select forms: %w", err)
@@ -104,6 +104,11 @@ func (q *formsQ) Last() (*data.Form, error) {
 	return &res, nil
 }
 
+func (q *formsQ) Limit(limit uint64) data.FormsQ {
+	q.selector = q.selector.Limit(limit)
+	return q
+}
+
 func (q *formsQ) FilterByID(ids ...string) data.FormsQ {
 	return q.applyCondition(squirrel.Eq{"id": ids})
 }

internal/service/handlers/get_form.go

@@ -34,5 +34,5 @@ func GetForm(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	ape.Render(w, newFormResponse(form))
+	ape.Render(w, newFormResponse(form.ID))
 }

internal/service/handlers/submit_form.go

@@ -63,53 +63,36 @@ func SubmitForm(w http.ResponseWriter, r *http.Request) {
 		Postal:    userData.Postal,
 		Phone:     userData.Phone,
 		Email:     userData.Email,
-		Image:     userData.Image,
+		Image:     &userData.Image,
 	}
 
 	Log(r).Debug("Start mysql insert query")
-	err = Forms(r).SendForms(*form)
+	err = Forms(r).SendForms(form)
 	if err != nil {
 		Log(r).WithError(err).Error("failed to send form")
 		form.Status = data.AcceptedStatus
 	}
 	Log(r).Debug("Finished mysql insert query")
 
 	Log(r).Debug("Start postgresql insert query")
-	form, err = FormsQ(r).Insert(*form)
+	formID, err := FormsQ(r).Insert(form)
 	if err != nil {
 		Log(r).WithError(err).Error("failed to insert form")
 		ape.RenderErr(w, problems.InternalError())
 		return
 	}
 	Log(r).Debug("Finished postgresql insert query")
 
-	ape.Render(w, newFormResponse(form))
+	ape.Render(w, newFormResponse(formID))
 }
 
-func newFormResponse(form *data.Form) resources.FormResponse {
+func newFormResponse(formID string) resources.FormResponse {
 	return resources.FormResponse{
 		Data: resources.Form{
 			Key: resources.Key{
-				ID:   form.ID,
+				ID:   formID,
 				Type: resources.FORM,
 			},
-			Attributes: resources.FormAttributes{
-				Name:     form.Name,
-				Surname:  form.Surname,
-				IdNum:    form.IDNum,
-				Birthday: form.Birthday,
-				Citizen:  form.Citizen,
-				Visited:  form.Visited,
-				Purpose:  form.Purpose,
-				Country:  form.Country,
-				City:     form.City,
-				Address:  form.Address,
-				Postal:   form.Postal,
-				Phone:    form.Phone,
-				Email:    form.Email,
-				Image:    "",
-				Status:   form.Status,
-			},
 		},
 	}
 }

internal/service/workers/formsender/main.go

@@ -25,7 +25,7 @@ func Run(ctx context.Context, cfg config.Config) {
 		log,
 		"resender",
 		func(context.Context) error {
-			forms, err := db.FormsQ().FilterByStatus(data.AcceptedStatus).Select()
+			forms, err := db.FormsQ().FilterByStatus(data.AcceptedStatus).Limit(formsCfg.ResendFormsCount).Select()
 			if err != nil {
 				return fmt.Errorf("failed to get unsended forms: %w", err)
 			}