Merge pull request #19 from code-payments/activity-feed

activity: initial activity feed implementation

Author: jeffyanta

activity/localization.go

@@ -0,0 +1,60 @@
+package activity
+
+import (
+	"context"
+	"errors"
+
+	"golang.org/x/text/language"
+	"golang.org/x/text/message"
+
+	activitypb "github.com/code-payments/flipchat-protobuf-api/generated/go/activity/v1"
+
+	codekin "github.com/code-payments/code-server/pkg/kin"
+)
+
+var (
+	kinAmountPrinter = message.NewPrinter(language.English)
+)
+
+func InjectLocalizedText(ctx context.Context, notification *activitypb.Notification) error {
+	var localizedText string
+	switch typed := notification.AdditionalMetadata.(type) {
+	case *activitypb.Notification_WelcomeBonus:
+		localizedText = kinAmountPrinter.Sprintf("You received ⬢\u00A0%d\u00A0Kin welcome bonus", codekin.FromQuarks(typed.WelcomeBonus.QuarksReceived))
+	case *activitypb.Notification_WeeklyBonus:
+		localizedText = kinAmountPrinter.Sprintf("You received ⬢\u00A0%d\u00A0Kin weekly bonus", codekin.FromQuarks(typed.WeeklyBonus.QuarksReceived))
+	case *activitypb.Notification_CreateGroup:
+		localizedText = kinAmountPrinter.Sprintf("You paid ⬢\u00A0%d\u00A0Kin to create a new Flipchat", codekin.FromQuarks(typed.CreateGroup.QuarksSpent))
+	case *activitypb.Notification_SendListenerMessage:
+		localizedText = kinAmountPrinter.Sprintf("You paid ⬢\u00A0%d\u00A0Kin", codekin.FromQuarks(typed.SendListenerMessage.QuarksSpent))
+	case *activitypb.Notification_SendTip:
+		localizedText = kinAmountPrinter.Sprintf("You tipped ⬢\u00A0%d\u00A0Kin", codekin.FromQuarks(typed.SendTip.TotalQuarksSent))
+	case *activitypb.Notification_ReceivedTip:
+		localizedText = kinAmountPrinter.Sprintf("You received ⬢\u00A0%d\u00A0Kin", codekin.FromQuarks(typed.ReceivedTip.TotalQuarksReceived))
+	/*
+		case *activitypb.Notification_PromotedToSpeaker:
+				profile, err := profiles.GetProfile(ctx, typed.PromotedToSpeaker.PromtedBy)
+				if err != nil {
+					return err
+				}
+
+				chatMd, err := chats.GetChatMetadata(ctx, typed.PromotedToSpeaker.ChatId)
+				if err != nil {
+					return err
+				}
+
+				if len(profile.DisplayName) == 0 {
+					return errors.New("user doesn't have a display name")
+				}
+				if len(chatMd.DisplayName) == 0 {
+					return errors.New("chat doesn't have a display name")
+				}
+
+				localizedText = kinAmountPrinter.Sprintf("%s made you a speaker in %s", profile.DisplayName, chatMd.DisplayName)
+	*/
+	default:
+		return errors.New("unsupported notification type")
+	}
+	notification.LocalizedText = localizedText
+	return nil
+}

activity/memory/server_test.go

@@ -0,0 +1,17 @@
+package memory
+
+import (
+	"testing"
+
+	account "github.com/code-payments/flipchat-server/account/memory"
+	"github.com/code-payments/flipchat-server/activity/tests"
+)
+
+func TestActivity_MemoryServer(t *testing.T) {
+	testStore := NewInMemory()
+	accounts := account.NewInMemory()
+	teardown := func() {
+		testStore.(*InMemoryStore).reset()
+	}
+	tests.RunServerTests(t, accounts, testStore, teardown)
+}

activity/memory/store.go

@@ -0,0 +1,101 @@
+package memory
+
+import (
+	"bytes"
+	"context"
+	"sort"
+	"sync"
+
+	activitypb "github.com/code-payments/flipchat-protobuf-api/generated/go/activity/v1"
+	commonpb "github.com/code-payments/flipchat-protobuf-api/generated/go/common/v1"
+	"google.golang.org/protobuf/proto"
+
+	"github.com/code-payments/flipchat-server/activity"
+	"github.com/code-payments/flipchat-server/protoutil"
+)
+
+type NotificationsByTimestamp []*activitypb.Notification
+
+func (a NotificationsByTimestamp) Len() int      { return len(a) }
+func (a NotificationsByTimestamp) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a NotificationsByTimestamp) Less(i, j int) bool {
+	return a[i].Ts.AsTime().Before(a[j].Ts.AsTime())
+}
+
+type InMemoryStore struct {
+	mu            sync.RWMutex
+	notifications map[string][]*activitypb.Notification
+}
+
+func NewInMemory() activity.Store {
+	return &InMemoryStore{
+		notifications: map[string][]*activitypb.Notification{},
+	}
+}
+
+func (m *InMemoryStore) SaveNotification(ctx context.Context, activityFeedType activitypb.ActivityFeedType, userID *commonpb.UserId, notification *activitypb.Notification) (*activitypb.Notification, error) {
+	if activityFeedType != activitypb.ActivityFeedType_TRANSACTION_HISTORY {
+		return nil, activity.ErrInvalidActivityFeedType
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	var existing *activitypb.Notification
+	for _, n := range m.notifications[string(userID.Value)] {
+		if bytes.Equal(notification.Id.Value, n.Id.Value) {
+			existing = n
+			break
+		}
+	}
+
+	switch typed := notification.AdditionalMetadata.(type) {
+	case
+		*activitypb.Notification_WelcomeBonus,
+		*activitypb.Notification_WeeklyBonus,
+		*activitypb.Notification_CreateGroup,
+		*activitypb.Notification_SendListenerMessage:
+	case *activitypb.Notification_SendTip:
+		if existing != nil {
+			existing.GetSendTip().TotalQuarksSent += typed.SendTip.TotalQuarksSent
+		}
+	case *activitypb.Notification_ReceivedTip:
+		if existing != nil {
+			existing.GetReceivedTip().TotalQuarksReceived += typed.ReceivedTip.TotalQuarksReceived
+		}
+	default:
+		return nil, activity.ErrInvalidNotificationType
+	}
+
+	if existing == nil {
+		existing = proto.Clone(notification).(*activitypb.Notification)
+		m.notifications[string(userID.Value)] = append(m.notifications[string(userID.Value)], proto.Clone(notification).(*activitypb.Notification))
+	}
+	return proto.Clone(existing).(*activitypb.Notification), nil
+}
+
+func (m *InMemoryStore) GetLatestNotifications(ctx context.Context, activityFeedType activitypb.ActivityFeedType, userID *commonpb.UserId, limit int) ([]*activitypb.Notification, error) {
+	if activityFeedType != activitypb.ActivityFeedType_TRANSACTION_HISTORY {
+		return nil, activity.ErrInvalidActivityFeedType
+	}
+
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	res := protoutil.SliceClone(m.notifications[string(userID.Value)])
+
+	sorted := NotificationsByTimestamp(res)
+	sort.Sort(sort.Reverse(sorted))
+
+	if len(sorted) > limit {
+		sorted = sorted[:limit]
+	}
+
+	return sorted, nil
+}
+
+func (m *InMemoryStore) reset() {
+	m.mu.Lock()
+	m.notifications = map[string][]*activitypb.Notification{}
+	m.mu.Unlock()
+}

activity/memory/store_test.go

@@ -0,0 +1,15 @@
+package memory
+
+import (
+	"testing"
+
+	"github.com/code-payments/flipchat-server/activity/tests"
+)
+
+func TestActivity_MemoryStore(t *testing.T) {
+	testStore := NewInMemory()
+	teardown := func() {
+		testStore.(*InMemoryStore).reset()
+	}
+	tests.RunStoreTests(t, testStore, teardown)
+}

activity/model.go

@@ -0,0 +1,59 @@
+package activity
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+
+	activitypb "github.com/code-payments/flipchat-protobuf-api/generated/go/activity/v1"
+	commonpb "github.com/code-payments/flipchat-protobuf-api/generated/go/common/v1"
+)
+
+type NotificationType uint32
+
+const (
+	NotificationTypeUnknown = iota
+	NotificationTypeWelcomeBonus
+	NotificationTypeWeeklyBonus
+	NotificationTypeCreateGroup
+	NotificationTypeSendListenerMessage
+	NotificationTypeSendTip
+	NotificationTypeReceivedTip
+	NotificationTypePromotedToSpeaker
+)
+
+func NotificationIDString(id *activitypb.NotificationId) string {
+	if id == nil {
+		return "<invalid>"
+	}
+	return hex.EncodeToString(id.Value)
+}
+
+func GetNotificationID(notificationType NotificationType, userID *commonpb.UserId, additionalSeeds ...[]byte) (*activitypb.NotificationId, error) {
+	if notificationType == NotificationTypeUnknown {
+		return nil, errors.New("notification type cannot be unknown")
+	}
+
+	var notificationTypeBytes [4]byte
+	binary.LittleEndian.PutUint32(notificationTypeBytes[:], uint32(notificationType))
+
+	hasher := sha256.New()
+	_, err := hasher.Write(notificationTypeBytes[:])
+	if err != nil {
+		return nil, err
+	}
+	_, err = hasher.Write(userID.Value)
+	if err != nil {
+		return nil, err
+	}
+	for _, seed := range additionalSeeds {
+		_, err = hasher.Write(seed)
+		if err != nil {
+			return nil, err
+		}
+	}
+	hashed := hasher.Sum(nil)
+
+	return &activitypb.NotificationId{Value: hashed}, nil
+}