remove currency validation

backend/internal/data/ent/group.go

@@ -25,7 +25,7 @@ type Group struct {
 	// Name holds the value of the "name" field.
 	Name string `json:"name,omitempty"`
 	// Currency holds the value of the "currency" field.
-	Currency group.Currency `json:"currency,omitempty"`
+	Currency string `json:"currency,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
 	// The values are being populated by the GroupQuery when eager-loading is set.
 	Edges        GroupEdges `json:"edges"`
@@ -170,7 +170,7 @@ func (gr *Group) assignValues(columns []string, values []any) error {
 			if value, ok := values[i].(*sql.NullString); !ok {
 				return fmt.Errorf("unexpected type %T for field currency", values[i])
 			} else if value.Valid {
-				gr.Currency = group.Currency(value.String)
+				gr.Currency = value.String
 			}
 		default:
 			gr.selectValues.Set(columns[i], values[i])
@@ -253,7 +253,7 @@ func (gr *Group) String() string {
 	builder.WriteString(gr.Name)
 	builder.WriteString(", ")
 	builder.WriteString("currency=")
-	builder.WriteString(fmt.Sprintf("%v", gr.Currency))
+	builder.WriteString(gr.Currency)
 	builder.WriteByte(')')
 	return builder.String()
 }

backend/internal/data/ent/group/group.go

@@ -3,7 +3,6 @@
 package group
 
 import (
-	"fmt"
 	"time"
 
 	"entgo.io/ent/dialect/sql"
@@ -119,65 +118,12 @@ var (
 	UpdateDefaultUpdatedAt func() time.Time
 	// NameValidator is a validator for the "name" field. It is called by the builders before save.
 	NameValidator func(string) error
+	// DefaultCurrency holds the default value on creation for the "currency" field.
+	DefaultCurrency string
 	// DefaultID holds the default value on creation for the "id" field.
 	DefaultID func() uuid.UUID
 )
 
-// Currency defines the type for the "currency" enum field.
-type Currency string
-
-// CurrencyUsd is the default value of the Currency enum.
-const DefaultCurrency = CurrencyUsd
-
-// Currency values.
-const (
-	CurrencyAed Currency = "aed"
-	CurrencyAud Currency = "aud"
-	CurrencyBgn Currency = "bgn"
-	CurrencyBrl Currency = "brl"
-	CurrencyCad Currency = "cad"
-	CurrencyChf Currency = "chf"
-	CurrencyCzk Currency = "czk"
-	CurrencyDkk Currency = "dkk"
-	CurrencyEur Currency = "eur"
-	CurrencyGbp Currency = "gbp"
-	CurrencyHkd Currency = "hkd"
-	CurrencyIdr Currency = "idr"
-	CurrencyInr Currency = "inr"
-	CurrencyJpy Currency = "jpy"
-	CurrencyKrw Currency = "krw"
-	CurrencyMxn Currency = "mxn"
-	CurrencyNok Currency = "nok"
-	CurrencyNzd Currency = "nzd"
-	CurrencyPln Currency = "pln"
-	CurrencyRmb Currency = "rmb"
-	CurrencyRon Currency = "ron"
-	CurrencyRub Currency = "rub"
-	CurrencySar Currency = "sar"
-	CurrencySek Currency = "sek"
-	CurrencySgd Currency = "sgd"
-	CurrencyThb Currency = "thb"
-	CurrencyTry Currency = "try"
-	CurrencyUsd Currency = "usd"
-	CurrencyXag Currency = "xag"
-	CurrencyXau Currency = "xau"
-	CurrencyZar Currency = "zar"
-)
-
-func (c Currency) String() string {
-	return string(c)
-}
-
-// CurrencyValidator is a validator for the "currency" field enum values. It is called by the builders before save.
-func CurrencyValidator(c Currency) error {
-	switch c {
-	case CurrencyAed, CurrencyAud, CurrencyBgn, CurrencyBrl, CurrencyCad, CurrencyChf, CurrencyCzk, CurrencyDkk, CurrencyEur, CurrencyGbp, CurrencyHkd, CurrencyIdr, CurrencyInr, CurrencyJpy, CurrencyKrw, CurrencyMxn, CurrencyNok, CurrencyNzd, CurrencyPln, CurrencyRmb, CurrencyRon, CurrencyRub, CurrencySar, CurrencySek, CurrencySgd, CurrencyThb, CurrencyTry, CurrencyUsd, CurrencyXag, CurrencyXau, CurrencyZar:
-		return nil
-	default:
-		return fmt.Errorf("group: invalid enum value for currency field: %q", c)
-	}
-}
-
 // OrderOption defines the ordering options for the Group queries.
 type OrderOption func(*sql.Selector)
 

backend/internal/data/ent/group/where.go

@@ -71,6 +71,11 @@ func Name(v string) predicate.Group {
 	return predicate.Group(sql.FieldEQ(FieldName, v))
 }
 
+// Currency applies equality check predicate on the "currency" field. It's identical to CurrencyEQ.
+func Currency(v string) predicate.Group {
+	return predicate.Group(sql.FieldEQ(FieldCurrency, v))
+}
+
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
 func CreatedAtEQ(v time.Time) predicate.Group {
 	return predicate.Group(sql.FieldEQ(FieldCreatedAt, v))
@@ -217,25 +222,70 @@ func NameContainsFold(v string) predicate.Group {
 }
 
 // CurrencyEQ applies the EQ predicate on the "currency" field.
-func CurrencyEQ(v Currency) predicate.Group {
+func CurrencyEQ(v string) predicate.Group {
 	return predicate.Group(sql.FieldEQ(FieldCurrency, v))
 }
 
 // CurrencyNEQ applies the NEQ predicate on the "currency" field.
-func CurrencyNEQ(v Currency) predicate.Group {
+func CurrencyNEQ(v string) predicate.Group {
 	return predicate.Group(sql.FieldNEQ(FieldCurrency, v))
 }
 
 // CurrencyIn applies the In predicate on the "currency" field.
-func CurrencyIn(vs ...Currency) predicate.Group {
+func CurrencyIn(vs ...string) predicate.Group {
 	return predicate.Group(sql.FieldIn(FieldCurrency, vs...))
 }
 
 // CurrencyNotIn applies the NotIn predicate on the "currency" field.
-func CurrencyNotIn(vs ...Currency) predicate.Group {
+func CurrencyNotIn(vs ...string) predicate.Group {
 	return predicate.Group(sql.FieldNotIn(FieldCurrency, vs...))
 }
 
+// CurrencyGT applies the GT predicate on the "currency" field.
+func CurrencyGT(v string) predicate.Group {
+	return predicate.Group(sql.FieldGT(FieldCurrency, v))
+}
+
+// CurrencyGTE applies the GTE predicate on the "currency" field.
+func CurrencyGTE(v string) predicate.Group {
+	return predicate.Group(sql.FieldGTE(FieldCurrency, v))
+}
+
+// CurrencyLT applies the LT predicate on the "currency" field.
+func CurrencyLT(v string) predicate.Group {
+	return predicate.Group(sql.FieldLT(FieldCurrency, v))
+}
+
+// CurrencyLTE applies the LTE predicate on the "currency" field.
+func CurrencyLTE(v string) predicate.Group {
+	return predicate.Group(sql.FieldLTE(FieldCurrency, v))
+}
+
+// CurrencyContains applies the Contains predicate on the "currency" field.
+func CurrencyContains(v string) predicate.Group {
+	return predicate.Group(sql.FieldContains(FieldCurrency, v))
+}
+
+// CurrencyHasPrefix applies the HasPrefix predicate on the "currency" field.
+func CurrencyHasPrefix(v string) predicate.Group {
+	return predicate.Group(sql.FieldHasPrefix(FieldCurrency, v))
+}
+
+// CurrencyHasSuffix applies the HasSuffix predicate on the "currency" field.
+func CurrencyHasSuffix(v string) predicate.Group {
+	return predicate.Group(sql.FieldHasSuffix(FieldCurrency, v))
+}
+
+// CurrencyEqualFold applies the EqualFold predicate on the "currency" field.
+func CurrencyEqualFold(v string) predicate.Group {
+	return predicate.Group(sql.FieldEqualFold(FieldCurrency, v))
+}
+
+// CurrencyContainsFold applies the ContainsFold predicate on the "currency" field.
+func CurrencyContainsFold(v string) predicate.Group {
+	return predicate.Group(sql.FieldContainsFold(FieldCurrency, v))
+}
+
 // HasUsers applies the HasEdge predicate on the "users" edge.
 func HasUsers() predicate.Group {
 	return predicate.Group(func(s *sql.Selector) {

backend/internal/data/ent/group_create.go

@@ -63,15 +63,15 @@ func (gc *GroupCreate) SetName(s string) *GroupCreate {
 }
 
 // SetCurrency sets the "currency" field.
-func (gc *GroupCreate) SetCurrency(gr group.Currency) *GroupCreate {
+func (gc *GroupCreate) SetCurrency(s string) *GroupCreate {
-	gc.mutation.SetCurrency(gr)
+	gc.mutation.SetCurrency(s)
 	return gc
 }
 
 // SetNillableCurrency sets the "currency" field if the given value is not nil.
-func (gc *GroupCreate) SetNillableCurrency(gr *group.Currency) *GroupCreate {
+func (gc *GroupCreate) SetNillableCurrency(s *string) *GroupCreate {
-	if gr != nil {
+	if s != nil {
-		gc.SetCurrency(*gr)
+		gc.SetCurrency(*s)
 	}
 	return gc
 }
@@ -267,11 +267,6 @@ func (gc *GroupCreate) check() error {
 	if _, ok := gc.mutation.Currency(); !ok {
 		return &ValidationError{Name: "currency", err: errors.New(`ent: missing required field "Group.currency"`)}
 	}
-	if v, ok := gc.mutation.Currency(); ok {
-		if err := group.CurrencyValidator(v); err != nil {
-			return &ValidationError{Name: "currency", err: fmt.Errorf(`ent: validator failed for field "Group.currency": %w`, err)}
-		}
-	}
 	return nil
 }
 
@@ -320,7 +315,7 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) {
 		_node.Name = value
 	}
 	if value, ok := gc.mutation.Currency(); ok {
-		_spec.SetField(group.FieldCurrency, field.TypeEnum, value)
+		_spec.SetField(group.FieldCurrency, field.TypeString, value)
 		_node.Currency = value
 	}
 	if nodes := gc.mutation.UsersIDs(); len(nodes) > 0 {

backend/internal/data/ent/group_update.go

@@ -57,15 +57,15 @@ func (gu *GroupUpdate) SetNillableName(s *string) *GroupUpdate {
 }
 
 // SetCurrency sets the "currency" field.
-func (gu *GroupUpdate) SetCurrency(gr group.Currency) *GroupUpdate {
+func (gu *GroupUpdate) SetCurrency(s string) *GroupUpdate {
-	gu.mutation.SetCurrency(gr)
+	gu.mutation.SetCurrency(s)
 	return gu
 }
 
 // SetNillableCurrency sets the "currency" field if the given value is not nil.
-func (gu *GroupUpdate) SetNillableCurrency(gr *group.Currency) *GroupUpdate {
+func (gu *GroupUpdate) SetNillableCurrency(s *string) *GroupUpdate {
-	if gr != nil {
+	if s != nil {
-		gu.SetCurrency(*gr)
+		gu.SetCurrency(*s)
 	}
 	return gu
 }
@@ -370,11 +370,6 @@ func (gu *GroupUpdate) check() error {
 			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "Group.name": %w`, err)}
 		}
 	}
-	if v, ok := gu.mutation.Currency(); ok {
-		if err := group.CurrencyValidator(v); err != nil {
-			return &ValidationError{Name: "currency", err: fmt.Errorf(`ent: validator failed for field "Group.currency": %w`, err)}
-		}
-	}
 	return nil
 }
 
@@ -397,7 +392,7 @@ func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		_spec.SetField(group.FieldName, field.TypeString, value)
 	}
 	if value, ok := gu.mutation.Currency(); ok {
-		_spec.SetField(group.FieldCurrency, field.TypeEnum, value)
+		_spec.SetField(group.FieldCurrency, field.TypeString, value)
 	}
 	if gu.mutation.UsersCleared() {
 		edge := &sqlgraph.EdgeSpec{
@@ -755,15 +750,15 @@ func (guo *GroupUpdateOne) SetNillableName(s *string) *GroupUpdateOne {
 }
 
 // SetCurrency sets the "currency" field.
-func (guo *GroupUpdateOne) SetCurrency(gr group.Currency) *GroupUpdateOne {
+func (guo *GroupUpdateOne) SetCurrency(s string) *GroupUpdateOne {
-	guo.mutation.SetCurrency(gr)
+	guo.mutation.SetCurrency(s)
 	return guo
 }
 
 // SetNillableCurrency sets the "currency" field if the given value is not nil.
-func (guo *GroupUpdateOne) SetNillableCurrency(gr *group.Currency) *GroupUpdateOne {
+func (guo *GroupUpdateOne) SetNillableCurrency(s *string) *GroupUpdateOne {
-	if gr != nil {
+	if s != nil {
-		guo.SetCurrency(*gr)
+		guo.SetCurrency(*s)
 	}
 	return guo
 }
@@ -1081,11 +1076,6 @@ func (guo *GroupUpdateOne) check() error {
 			return &ValidationError{Name: "name", err: fmt.Errorf(`ent: validator failed for field "Group.name": %w`, err)}
 		}
 	}
-	if v, ok := guo.mutation.Currency(); ok {
-		if err := group.CurrencyValidator(v); err != nil {
-			return &ValidationError{Name: "currency", err: fmt.Errorf(`ent: validator failed for field "Group.currency": %w`, err)}
-		}
-	}
 	return nil
 }
 
@@ -1125,7 +1115,7 @@ func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (_node *Group, err error
 		_spec.SetField(group.FieldName, field.TypeString, value)
 	}
 	if value, ok := guo.mutation.Currency(); ok {
-		_spec.SetField(group.FieldCurrency, field.TypeEnum, value)
+		_spec.SetField(group.FieldCurrency, field.TypeString, value)
 	}
 	if guo.mutation.UsersCleared() {
 		edge := &sqlgraph.EdgeSpec{

backend/internal/data/ent/migrate/schema.go

@@ -117,7 +117,7 @@ var (
 		{Name: "created_at", Type: field.TypeTime},
 		{Name: "updated_at", Type: field.TypeTime},
 		{Name: "name", Type: field.TypeString, Size: 255},
-		{Name: "currency", Type: field.TypeEnum, Enums: []string{"aed", "aud", "bgn", "brl", "cad", "chf", "czk", "dkk", "eur", "gbp", "hkd", "idr", "inr", "jpy", "krw", "mxn", "nok", "nzd", "pln", "rmb", "ron", "rub", "sar", "sek", "sgd", "thb", "try", "usd", "xag", "xau", "zar"}, Default: "usd"},
+		{Name: "currency", Type: field.TypeString, Default: "usd"},
 	}
 	// GroupsTable holds the schema information for the "groups" table.
 	GroupsTable = &schema.Table{

backend/internal/data/ent/mutation.go

@@ -2340,7 +2340,7 @@ type GroupMutation struct {
 	created_at               *time.Time
 	updated_at               *time.Time
 	name                     *string
-	currency                 *group.Currency
+	currency                 *string
 	clearedFields            map[string]struct{}
 	users                    map[uuid.UUID]struct{}
 	removedusers             map[uuid.UUID]struct{}
@@ -2581,12 +2581,12 @@ func (m *GroupMutation) ResetName() {
 }
 
 // SetCurrency sets the "currency" field.
-func (m *GroupMutation) SetCurrency(gr group.Currency) {
+func (m *GroupMutation) SetCurrency(s string) {
-	m.currency = &gr
+	m.currency = &s
 }
 
 // Currency returns the value of the "currency" field in the mutation.
-func (m *GroupMutation) Currency() (r group.Currency, exists bool) {
+func (m *GroupMutation) Currency() (r string, exists bool) {
 	v := m.currency
 	if v == nil {
 		return
@@ -2597,7 +2597,7 @@ func (m *GroupMutation) Currency() (r group.Currency, exists bool) {
 // OldCurrency returns the old "currency" field's value of the Group entity.
 // If the Group object wasn't provided to the builder, the object is fetched from the database.
 // An error is returned if the mutation operation is not UpdateOne, or the database query fails.
-func (m *GroupMutation) OldCurrency(ctx context.Context) (v group.Currency, err error) {
+func (m *GroupMutation) OldCurrency(ctx context.Context) (v string, err error) {
 	if !m.op.Is(OpUpdateOne) {
 		return v, errors.New("OldCurrency is only allowed on UpdateOne operations")
 	}
@@ -3105,7 +3105,7 @@ func (m *GroupMutation) SetField(name string, value ent.Value) error {
 		m.SetName(v)
 		return nil
 	case group.FieldCurrency:
-		v, ok := value.(group.Currency)
+		v, ok := value.(string)
 		if !ok {
 			return fmt.Errorf("unexpected type %T for field %s", value, name)
 		}

backend/internal/data/ent/runtime.go

@@ -161,6 +161,10 @@ func init() {
 			return nil
 		}
 	}()
+	// groupDescCurrency is the schema descriptor for currency field.
+	groupDescCurrency := groupFields[1].Descriptor()
+	// group.DefaultCurrency holds the default value on creation for the currency field.
+	group.DefaultCurrency = groupDescCurrency.Default.(string)
 	// groupDescID is the schema descriptor for id field.
 	groupDescID := groupMixinFields0[0].Descriptor()
 	// group.DefaultID holds the default value on creation for the id field.

backend/internal/data/ent/schema/group.go

@@ -27,41 +27,8 @@ func (Group) Fields() []ent.Field {
 		field.String("name").
 			MaxLen(255).
 			NotEmpty(),
-		field.Enum("currency").
+		field.String("currency").
-			Default("usd").
+			Default("usd"),
-			Values(
-				"aed",
-				"aud",
-				"bgn",
-				"brl",
-				"cad",
-				"chf",
-				"czk",
-				"dkk",
-				"eur",
-				"gbp",
-				"hkd",
-				"idr",
-				"inr",
-				"jpy",
-				"krw",
-				"mxn",
-				"nok",
-				"nzd",
-				"pln",
-				"rmb",
-				"ron",
-				"rub",
-				"sar",
-				"sek",
-				"sgd",
-				"thb",
-				"try",
-				"usd",
-				"xag",
-				"xau",
-				"zar",
-			),
 	}
 }
 

backend/internal/data/ent/schema/user.go

@@ -78,7 +78,6 @@ func (g UserMixin) Fields() []ent.Field {
 	}
 
 	return nil
-
 }
 
 func (g UserMixin) Edges() []ent.Edge {

backend/internal/data/repo/repo_group.go

@@ -28,7 +28,7 @@ func NewGroupRepository(db *ent.Client) *GroupRepository {
 			Name:      g.Name,
 			CreatedAt: g.CreatedAt,
 			UpdatedAt: g.UpdatedAt,
-			Currency:  strings.ToUpper(g.Currency.String()),
+			Currency:  strings.ToUpper(g.Currency),
 		}
 	}
 
@@ -265,11 +265,9 @@ func (r *GroupRepository) GroupCreate(ctx context.Context, name string) (Group,
 }
 
 func (r *GroupRepository) GroupUpdate(ctx context.Context, ID uuid.UUID, data GroupUpdate) (Group, error) {
-	currency := group.Currency(strings.ToLower(data.Currency))
-
 	entity, err := r.db.Group.UpdateOneID(ID).
 		SetName(data.Name).
-		SetCurrency(currency).
+		SetCurrency(strings.ToLower(data.Currency)).
 		Save(ctx)
 
 	return r.groupMapper.MapErr(entity, err)