294 lines
7.7 KiB
Go
294 lines
7.7 KiB
Go
package repository
|
||
|
||
import (
|
||
"context"
|
||
"regexp"
|
||
"strings"
|
||
|
||
libmongo "apps/backend/internal/lib/mongo"
|
||
"apps/backend/internal/module/crm/domain"
|
||
|
||
"github.com/zeromicro/go-zero/core/stores/mon"
|
||
"go.mongodb.org/mongo-driver/bson"
|
||
"go.mongodb.org/mongo-driver/mongo"
|
||
"go.mongodb.org/mongo-driver/mongo/options"
|
||
)
|
||
|
||
type MonStore struct {
|
||
contacts *mon.Model
|
||
touches *mon.Model
|
||
followups *mon.Model
|
||
}
|
||
|
||
func NewMonStore(uri, database string) *MonStore {
|
||
uri = libmongo.MustMongoURI(uri)
|
||
return &MonStore{
|
||
contacts: mon.MustNewModel(uri, database, "crm_contacts"),
|
||
touches: mon.MustNewModel(uri, database, "crm_touches"),
|
||
followups: mon.MustNewModel(uri, database, "crm_followups"),
|
||
}
|
||
}
|
||
|
||
func (s *MonStore) UpsertContactByIdentity(ctx context.Context, c *domain.Contact) (*domain.Contact, error) {
|
||
if err := c.Normalize(); err != nil {
|
||
return nil, err
|
||
}
|
||
filter := bson.M{
|
||
"owner_uid": c.OwnerUID,
|
||
"source_platform": c.SourcePlatform,
|
||
"author_handle": c.AuthorHandle,
|
||
}
|
||
var existing domain.Contact
|
||
err := s.contacts.FindOne(ctx, &existing, filter)
|
||
if err == nil {
|
||
// merge
|
||
if existing.RemovedAt > 0 {
|
||
existing.RemovedAt = 0
|
||
existing.Stage = domain.StageNewFound
|
||
existing.NeedsFollowUp = false
|
||
existing.LastTouchAt = c.LastTouchAt
|
||
}
|
||
seen := map[string]bool{}
|
||
for _, id := range existing.OpportunityIDs {
|
||
seen[id] = true
|
||
}
|
||
for _, id := range c.OpportunityIDs {
|
||
if id != "" && !seen[id] {
|
||
existing.OpportunityIDs = append(existing.OpportunityIDs, id)
|
||
}
|
||
}
|
||
if c.TopIntentScore > existing.TopIntentScore {
|
||
existing.TopIntentScore = c.TopIntentScore
|
||
existing.TopIntentBand = c.TopIntentBand
|
||
}
|
||
existing.UpdatedAt = domain.NowNano()
|
||
_, err = s.contacts.ReplaceOne(ctx, bson.M{"_id": existing.ID}, &existing)
|
||
return &existing, err
|
||
}
|
||
if err != mon.ErrNotFound {
|
||
return nil, err
|
||
}
|
||
if c.ID == "" {
|
||
c.ID = domain.NewID()
|
||
}
|
||
now := domain.NowNano()
|
||
if c.CreatedAt == 0 {
|
||
c.CreatedAt = now
|
||
}
|
||
c.UpdatedAt = now
|
||
_, err = s.contacts.InsertOne(ctx, c)
|
||
if err != nil && mongo.IsDuplicateKeyError(err) {
|
||
return s.UpsertContactByIdentity(ctx, c)
|
||
}
|
||
return c, err
|
||
}
|
||
|
||
func (s *MonStore) GetContact(ctx context.Context, id string) (*domain.Contact, error) {
|
||
var c domain.Contact
|
||
err := s.contacts.FindOne(ctx, &c, bson.M{"_id": id})
|
||
if err == mon.ErrNotFound {
|
||
return nil, domain.ErrNotFound
|
||
}
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &c, nil
|
||
}
|
||
|
||
func (s *MonStore) SaveContact(ctx context.Context, c *domain.Contact) error {
|
||
_, err := s.contacts.ReplaceOne(ctx, bson.M{"_id": c.ID}, c, options.Replace().SetUpsert(true))
|
||
return err
|
||
}
|
||
|
||
func (s *MonStore) RemoveContact(ctx context.Context, ownerUID int64, id string, at int64) error {
|
||
if at <= 0 {
|
||
at = domain.NowNano()
|
||
}
|
||
_, err := s.followups.UpdateMany(ctx, bson.M{
|
||
"owner_uid": ownerUID,
|
||
"contact_id": id,
|
||
"status": bson.M{"$in": bson.A{
|
||
domain.FollowUpScheduled,
|
||
domain.FollowUpSnoozed,
|
||
domain.FollowUpNotified,
|
||
}},
|
||
}, bson.M{"$set": bson.M{"status": domain.FollowUpDone, "updated_at": at}})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
res, err := s.contacts.UpdateOne(ctx, bson.M{
|
||
"_id": id,
|
||
"owner_uid": ownerUID,
|
||
"$or": bson.A{
|
||
bson.M{"removed_at": bson.M{"$exists": false}},
|
||
bson.M{"removed_at": 0},
|
||
},
|
||
}, bson.M{"$set": bson.M{
|
||
"removed_at": at,
|
||
"needs_follow_up": false,
|
||
"updated_at": at,
|
||
}})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if res.MatchedCount == 0 {
|
||
return domain.ErrNotFound
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func activeContactQuery(ownerUID int64) bson.M {
|
||
return bson.M{
|
||
"owner_uid": ownerUID,
|
||
"$and": bson.A{bson.M{"$or": bson.A{
|
||
bson.M{"removed_at": bson.M{"$exists": false}},
|
||
bson.M{"removed_at": 0},
|
||
}}},
|
||
}
|
||
}
|
||
|
||
func (s *MonStore) ListContacts(ctx context.Context, ownerUID int64, f domain.ContactListFilter) ([]*domain.Contact, int64, error) {
|
||
q := activeContactQuery(ownerUID)
|
||
if search := strings.TrimSpace(f.Query); search != "" {
|
||
pattern := regexp.QuoteMeta(search)
|
||
q["$and"] = append(q["$and"].(bson.A), bson.M{"$or": bson.A{
|
||
bson.M{"author_handle": bson.M{"$regex": pattern, "$options": "i"}},
|
||
bson.M{"display_name": bson.M{"$regex": pattern, "$options": "i"}},
|
||
}})
|
||
}
|
||
if f.Stage != "" {
|
||
q["stage"] = f.Stage
|
||
}
|
||
if f.FollowUp != nil {
|
||
q["needs_follow_up"] = *f.FollowUp
|
||
}
|
||
if f.Band != "" {
|
||
q["top_intent_band"] = f.Band
|
||
}
|
||
total, err := s.contacts.CountDocuments(ctx, q)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
page, ps := f.Page, f.PageSize
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
if ps < 1 {
|
||
ps = 20
|
||
}
|
||
sortKey := "last_touch_at"
|
||
if f.Sort == "intent_score" {
|
||
sortKey = "top_intent_score"
|
||
}
|
||
var list []*domain.Contact
|
||
err = s.contacts.Find(ctx, &list, q, options.Find().
|
||
SetSort(bson.D{{Key: sortKey, Value: -1}}).
|
||
SetSkip(int64((page-1)*ps)).
|
||
SetLimit(int64(ps)))
|
||
return list, total, err
|
||
}
|
||
|
||
func (s *MonStore) CountByStage(ctx context.Context, ownerUID int64) (map[string]int, error) {
|
||
// Counts describe the complete active pipeline, not just the current page.
|
||
var list []*domain.Contact
|
||
err := s.contacts.Find(ctx, &list, activeContactQuery(ownerUID), options.Find().SetProjection(bson.M{"stage": 1, "needs_follow_up": 1}))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
out := map[string]int{}
|
||
follow := 0
|
||
for _, c := range list {
|
||
out[c.Stage]++
|
||
if c.NeedsFollowUp {
|
||
follow++
|
||
}
|
||
}
|
||
out["needs_follow_up"] = follow
|
||
return out, nil
|
||
}
|
||
|
||
func (s *MonStore) InsertTouch(ctx context.Context, t *domain.ContactTouch) error {
|
||
if t.ID == "" {
|
||
t.ID = domain.NewID()
|
||
}
|
||
_, err := s.touches.InsertOne(ctx, t)
|
||
return err
|
||
}
|
||
|
||
func (s *MonStore) ListTouches(ctx context.Context, ownerUID int64, contactID string, page, pageSize int) ([]*domain.ContactTouch, int64, error) {
|
||
q := bson.M{"owner_uid": ownerUID, "contact_id": contactID}
|
||
total, err := s.touches.CountDocuments(ctx, q)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
if pageSize < 1 {
|
||
pageSize = 20
|
||
}
|
||
var list []*domain.ContactTouch
|
||
err = s.touches.Find(ctx, &list, q, options.Find().
|
||
SetSort(bson.D{{Key: "created_at", Value: -1}}).
|
||
SetSkip(int64((page-1)*pageSize)).
|
||
SetLimit(int64(pageSize)))
|
||
return list, total, err
|
||
}
|
||
|
||
func (s *MonStore) SaveFollowUp(ctx context.Context, f *domain.FollowUp) error {
|
||
_, err := s.followups.ReplaceOne(ctx, bson.M{"_id": f.ID}, f, options.Replace().SetUpsert(true))
|
||
return err
|
||
}
|
||
|
||
func (s *MonStore) GetFollowUp(ctx context.Context, id string) (*domain.FollowUp, error) {
|
||
var f domain.FollowUp
|
||
err := s.followups.FindOne(ctx, &f, bson.M{"_id": id})
|
||
if err == mon.ErrNotFound {
|
||
return nil, domain.ErrNotFound
|
||
}
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return &f, nil
|
||
}
|
||
|
||
func (s *MonStore) ListFollowUps(ctx context.Context, ownerUID int64, f domain.FollowUpListFilter) ([]*domain.FollowUp, int64, error) {
|
||
q := bson.M{"owner_uid": ownerUID}
|
||
if f.Status != "" {
|
||
q["status"] = f.Status
|
||
}
|
||
total, err := s.followups.CountDocuments(ctx, q)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
page, ps := f.Page, f.PageSize
|
||
if page < 1 {
|
||
page = 1
|
||
}
|
||
if ps < 1 {
|
||
ps = 20
|
||
}
|
||
var list []*domain.FollowUp
|
||
err = s.followups.Find(ctx, &list, q, options.Find().
|
||
SetSort(bson.D{{Key: "due_at", Value: 1}}).
|
||
SetSkip(int64((page-1)*ps)).
|
||
SetLimit(int64(ps)))
|
||
return list, total, err
|
||
}
|
||
|
||
func (s *MonStore) ListDueFollowUps(ctx context.Context, now int64, limit int) ([]*domain.FollowUp, error) {
|
||
if limit <= 0 {
|
||
limit = 50
|
||
}
|
||
var list []*domain.FollowUp
|
||
// notified 也要再掃：第二次通知（進而 escalated）靠的是它下一次到期。
|
||
// snoozed 已不再寫入，保留以相容既有資料。
|
||
err := s.followups.Find(ctx, &list, bson.M{
|
||
"status": bson.M{"$in": []string{
|
||
domain.FollowUpScheduled, domain.FollowUpSnoozed, domain.FollowUpNotified,
|
||
}},
|
||
"due_at": bson.M{"$lte": now},
|
||
}, options.Find().SetLimit(int64(limit)))
|
||
return list, err
|
||
}
|