question_gen.go

package service

// Automatically generated by genmodel utility. DO NOT EDIT!

import (
	"context"
	"database/sql"
	"sync"
	"time"

	"github.com/builderscon/octav/octav/cache"

	"github.com/builderscon/octav/octav/db"
	"github.com/builderscon/octav/octav/internal/errors"
	"github.com/builderscon/octav/octav/model"
	"github.com/lestrrat/go-pdebug"
)

var _ = time.Time{}
var _ = cache.WithExpires(time.Minute)
var _ = context.Background
var _ = errors.Wrap
var _ = model.Question{}
var _ = db.Question{}
var _ = sql.ErrNoRows
var _ = pdebug.Enabled

var questionSvc QuestionSvc
var questionOnce sync.Once

func Question() *QuestionSvc {
	questionOnce.Do(questionSvc.Init)
	return &questionSvc
}

func (v *QuestionSvc) LookupFromPayload(ctx context.Context, tx *sql.Tx, m *model.Question, payload *model.LookupQuestionRequest) (err error) {
	if pdebug.Enabled {
		g := pdebug.Marker("service.Question.LookupFromPayload %s", payload.ID).BindError(&err)
		defer g.End()
	}
	if err = v.Lookup(ctx, tx, m, payload.ID); err != nil {
		return errors.Wrap(err, "failed to load model.Question from database")
	}
	return nil
}

func (v *QuestionSvc) Lookup(ctx context.Context, tx *sql.Tx, m *model.Question, id string) (err error) {
	if pdebug.Enabled {
		g := pdebug.Marker("service.Question.Lookup %s", id).BindError(&err)
		defer g.End()
	}

	var r model.Question
	c := Cache()
	key := c.Key("Question", id)
	var cacheMiss bool
	_, err = c.GetOrSet(key, &r, func() (interface{}, error) {
		if pdebug.Enabled {
			cacheMiss = true
		}
		if err := r.Load(tx, id); err != nil {
			return nil, errors.Wrap(err, "failed to load model.Question from database")
		}
		return &r, nil
	}, cache.WithExpires(time.Hour))
	if pdebug.Enabled {
		cacheSt := `HIT`
		if cacheMiss {
			cacheSt = `MISS`
		}
		pdebug.Printf(`CACHE %s: %s`, cacheSt, key)
	}
	*m = r
	return nil
}

// Create takes in the transaction, the incoming payload, and a reference to
// a database row. The database row is initialized/populated so that the
// caller can use it afterwards.
func (v *QuestionSvc) Create(ctx context.Context, tx *sql.Tx, vdb *db.Question, payload *model.CreateQuestionRequest) (err error) {
	if pdebug.Enabled {
		g := pdebug.Marker("service.Question.Create").BindError(&err)
		defer g.End()
	}

	if err := v.populateRowForCreate(ctx, vdb, payload); err != nil {
		return errors.Wrap(err, `failed to populate row`)
	}

	if err := vdb.Create(tx, payload.DatabaseOptions...); err != nil {
		return errors.Wrap(err, `failed to insert into database`)
	}

	return nil
}

func (v *QuestionSvc) Update(tx *sql.Tx, vdb *db.Question) (err error) {
	if pdebug.Enabled {
		g := pdebug.Marker("service.Question.Update (%s)", vdb.EID).BindError(&err)
		defer g.End()
	}

	if vdb.EID == `` {
		return errors.New("vdb.EID is required (did you forget to call vdb.Load(tx) before hand?)")
	}

	if err := vdb.Update(tx); err != nil {
		return errors.Wrap(err, `failed to update database`)
	}
	c := Cache()
	key := c.Key("Question", vdb.EID)
	if pdebug.Enabled {
		pdebug.Printf(`CACHE DEL %s`, key)
	}
	cerr := c.Delete(key)
	if pdebug.Enabled {
		if cerr != nil {
			pdebug.Printf(`CACHE ERR: %s`, cerr)
		}
	}
	return nil
}

func (v *QuestionSvc) UpdateFromPayload(ctx context.Context, tx *sql.Tx, payload *model.UpdateQuestionRequest) (err error) {
	if pdebug.Enabled {
		g := pdebug.Marker("service.Question.UpdateFromPayload (%s)", payload.ID).BindError(&err)
		defer g.End()
	}
	var vdb db.Question
	if err := vdb.LoadByEID(tx, payload.ID); err != nil {
		return errors.Wrap(err, `failed to load from database`)
	}

	if err := v.populateRowForUpdate(ctx, &vdb, payload); err != nil {
		return errors.Wrap(err, `failed to populate row data`)
	}

	if err := v.Update(tx, &vdb); err != nil {
		return errors.Wrap(err, `failed to update row in database`)
	}
	return nil
}

func (v *QuestionSvc) Delete(tx *sql.Tx, id string) error {
	if pdebug.Enabled {
		g := pdebug.Marker("Question.Delete (%s)", id)
		defer g.End()
	}

	vdb := db.Question{EID: id}
	if err := vdb.Delete(tx); err != nil {
		return errors.Wrap(err, `failed to delete from database`)
	}
	c := Cache()
	key := c.Key("Question", id)
	c.Delete(key)
	if pdebug.Enabled {
		pdebug.Printf(`CACHE DEL %s`, key)
	}
	return nil
}