package repository_{name}

import (
	"context"
	"online-order/ent"
	"online-order/ent/{name}"
	"online-order/entity"
)

type {Name}Repository struct {
	client         *ent.Client
	activeBusiness *entity.ActiveBusiness
}

func New{Name}Repository(client *ent.Client, activeBusiness *entity.ActiveBusiness) *{Name}Repository {
	return &{Name}Repository{
		client:         client,
		activeBusiness: activeBusiness,
	}
}

// List all {name}s
func (c *{Name}Repository) List() ([]*entity.{Name}Display, error) {
	var u []*entity.{Name}Display
	ctx := context.Background()

	err := c.client.{Name}.
		Query().
		Where({name}.BusinessID(c.activeBusiness.BusinessID)).
		Select({name}.FieldID, {name}.FieldCreatedAt, {name}.FieldUpdatedAt).
		Scan(ctx, &u)

	if err != nil {
		return nil, err
	}

	return u, nil
}

// Create a {name}
func (c *{Name}Repository) Create(p *entity.{Name}CreateUpdate) error {
	ctx := context.Background()

	resp, err := c.client.{Name}.
		Create().
		SetBusinessID(c.activeBusiness.BusinessID).
		SetUserID(p.UserID).
		Save(ctx)

	if err != nil {
		return err
	}

	return nil
}

func (c *{Name}Repository) GetByID(id int) (*entity.{Name}Display, error) {
	var p entity.{Name}Display
	ctx := context.Background()

	resp := c.client.{Name}.
		Query().
		Where({name}.BusinessID(c.activeBusiness.BusinessID)).
		Where({name}.ID(id)).
		AllX(ctx)

	if len(resp) > 0 {
		p.ID = resp[0].ID
		p.CreatedAt = resp[0].CreatedAt
		p.UpdatedAt = resp[0].UpdatedAt
	} else {
		return nil, entity.ErrNotFound
	}

	return &p, nil
}

// Update {name} information
func (c *{Name}Repository) Update(p *entity.{Name}CreateUpdate) error {
	ctx := context.Background()

	_, err := c.client.{Name}.UpdateOneID(p.ID).
		Save(ctx)
	if err != nil {
		return err
	}
	return nil
}

// Update user information, except password
func (c *{Name}Repository) Delete(id int) error {
	ctx := context.Background()

	err := c.client.{Name}.
		DeleteOneID(id).
		Exec(ctx)
	return err
}