cleanup

include/feed_state.hrl

@@ -3,20 +3,14 @@
         type :: user | group | system | product,
         feed,
         direct,
-        cached_feed,
-        cached_direct,
-        cached_friends,
-        cached_groups }).
-
--record(product_state, {
-        owner = "feed_owner",
-        type :: product,
-        feed,
         blog,
         features,
         specs,
         gallery,
         videos,
         bundles,
-        callback=feed_server_api}).
-
+        callback=feed_server_api,  % tmp field\part of behaviour callback state
+        cached_feed,
+        cached_direct,
+        cached_friends,
+        cached_groups }).

src/feed_server_api.erl

@@ -2,6 +2,6 @@
 -export([handle/3]).
 
 handle([Module|Parameters],Message,State) ->
-    error_logger:info_msg("[feed_server_api]handle_notice Route: ~p Message ~p",[[Module|Parameters],Message]),
+%    error_logger:info_msg("[feed_server_api]handle_notice Route: ~p Message ~p",[[Module|Parameters],Message]),
     M = if is_atom(Module)->Module; true-> list_to_atom(binary_to_list(term_to_binary(Module))) end,
     M:handle_notice([M|Parameters],Message,State).

src/kvs_comment.erl

@@ -17,9 +17,8 @@ add(FId, User, EntryId, ParentComment, CommentId, Content, Medias, _) ->
             {ok, Entry} = kvs:get(entry,{EntryId, FId}),
             {PrevC, E} = case Entry#entry.comments of
                         undefined -> {undefined, Entry#entry{comments_rear = FullId}};
-                        Id -> {ok, PrevTop} = kvs:get(comment, Id),
-                              kvs:put(PrevTop#comment{next = FullId}),
-                              {Id, Entry} end,
+                        Id ->  case kvs:get(comment, Id) of {ok, PrevTop} -> kvs:put(PrevTop#comment{next = FullId}); {error, not_found} -> skip end,
+                          {Id, Entry} end,
             kvs:put(E#entry{comments=FullId}),
             PrevC;
         _ ->

src/kvs_feed.erl

@@ -17,12 +17,7 @@ create() ->
     ok = kvs:put(#feed{id = FId} ),
     FId.
 
-add_entry(FId, User, To, EntryId, Title, Desc,Medias,Type,SharedBy) ->
-    case kvs:get(entry,{EntryId, FId}) of
-        {ok, _} -> ok;
-        _ -> add_entry(FId, User, To, EntryId, Title, Desc, Medias, Type, SharedBy, dont_check) end.
-
-add_entry(FId, User, To, EntryId, Title, Desc, Medias, Type, SharedBy, _) ->
+add_entry(FId, From, To, EntryId, Title, Desc, Medias, Type, SharedBy) ->
   case kvs:get(feed, FId) of
     {ok,Feed} ->
       Id = {EntryId, FId},
@@ -35,16 +30,15 @@ add_entry(FId, User, To, EntryId, Title, Desc, Medias, Type, SharedBy, _) ->
 
       kvs:put(#feed{id = FId, top = {EntryId, FId}}), % update feed top with current
 
-      Entry  = #entry{id = {EntryId, FId}, entry_id = EntryId, feed_id = FId, from = User,
+      Entry  = #entry{id = {EntryId, FId}, entry_id = EntryId, feed_id = FId, from = From,
                     to = To, type = Type, media = Medias, created = now(),
                     title=Title, description = Desc, shared = SharedBy,
                     next = Next, prev = Prev},
 
-      error_logger:info_msg("PUT ENTRY: ~p", [Entry]),
       kvs:put(Entry),
+      error_logger:info_msg("PUT entry: ~p", [Entry]),
       {ok, Entry};
-    {error, not_found} ->
-      error_logger:info_msg("Add entry failed. No feed ~p", [FId])
+    {error, not_found} -> error_logger:info_msg("Add entry failed. No feed ~p", [FId])
   end.
 
 entry_traversal(undefined, _) -> [];
@@ -130,7 +124,7 @@ remove_entry(FeedId, EId) ->
             case kvs:get(entry, Next) of {ok, NE} -> kvs:put(NE#entry{prev = Prev});  _ -> ok end,
             case kvs:get(entry, Prev) of {ok, PE} -> kvs:put(PE#entry{next = Next});  _ -> ok end,
             case TopId of {EId, FeedId} -> kvs:put(Feed#feed{top = Prev}); _ -> ok end;
-        {error, _} -> ?INFO("Not found"), ok
+        {error, _} -> error_logger:info_msg("Not found"), ok
     end,
     kvs:delete(entry, {EId, FeedId}).
 
@@ -184,18 +178,29 @@ purge_unverified_feeds() ->
 
 %% MQ API
 
-handle_notice([kvs_feed, product, To, entry, EntryId, add],
-              [Fid, From, Title, Desc, Medias, Type],
-              #product_state{feed=F, blog=B, features=Ft, specs=S, gallery=G, videos=V, bundles=Bn} = State) ->
-  Member = lists:member(Fid, [F,B,Ft,S,G,V,Bn]),
-  if Member ->
-    add_entry(Fid, From, To, EntryId, Title, Desc, Medias, Type, "");
+handle_notice([kvs_feed, Totype, Toid, entry, EntryId, add],
+              [Fid, From, Title, Desc, Medias, EntryType],
+              #state{owner=Owner, feed=Feed}=State)->
+  if Owner == Toid ->
+    % handle user direct feed
+    add_entry(case Totype of product -> Fid; _ -> Feed end, From, {Toid, Totype}, EntryId, Title, Desc, Medias, EntryType, ""),
+    case Totype of
+      group ->
+          {ok, Group} = kvs:get(group, Toid),
+          GE = Group#group.entries_count,
+          kvs:put(Group#group{entries_count = GE+1}),
+          {ok, Subs} = kvs:get(group_subscription, {From, Toid}),
+          SE = Subs#group_subscription.posts_count,
+          kvs:put(Subs#group_subscription{posts_count = SE+1});
+      _ -> skip
+    end,
+    self() ! {feed_refresh, Fid, ?CACHED_ENTRIES};
     true -> skip end,
   {noreply, State};
 
 handle_notice([kvs_feed, _, _Who, entry, {_, Fid}=Eid, edit],
               [_, _, Title, Desc],
-              #product_state{feed=F, blog=B, features=Ft, specs=S, gallery=G, videos=V, bundles=Bn}=State) ->
+              #state{feed=F, blog=B, features=Ft, specs=S, gallery=G, videos=V, bundles=Bn}=State) ->
   Member = lists:member(Fid, [F,B,Ft,S,G,V,Bn]),
   if Member ->
     case kvs:get(entry, Eid) of {error, notfound}->skip; {ok, Entry} -> kvs:put(Entry#entry{title=Title, description=Desc}) end;
@@ -203,7 +208,8 @@ handle_notice([kvs_feed, _, _Who, entry, {_, Fid}=Eid, edit],
   {noreply, State};
 
 handle_notice([kvs_feed, product, Owner, entry, {Eid, Fid}, delete],
-              [From|_], #product_state{feed=F, blog=B, features=Ft, specs=S, gallery=G, videos=V, bundles=Bn} = State) ->
+              [From|_], #state{feed=F, blog=B, features=Ft, specs=S, gallery=G, videos=V, bundles=Bn} = State) ->
+  error_logger:info_msg("DELETE"),
   %kvs_acl:check_access(From, {feature, admin})
   Member = lists:member(Fid, [F,B,Ft,S,G,V,Bn]),
   if From == Owner andalso Member == true ->
@@ -215,82 +221,16 @@ handle_notice([kvs_feed, product, Owner, entry, {Eid, Fid}, delete],
 
 handle_notice([kvs_feed, product, _EntryOwner, comment, Cid, add],
               [From, {Eid, FFid}, Parent, Content, Medias, _],
-              #product_state{feed=Fid} = State) ->
+              #state{feed=Fid} = State) ->
   if FFid == Fid ->
     error_logger:info_msg("Add comment: ~p ~p ~p", [Fid, Eid, Cid]),
     kvs_comment:add(Fid, From, Eid, Parent, Cid, Content, Medias);
     true -> skip end,
   {noreply, State};
 
-handle_notice(["kvs_feed", "group", GroupId, "entry", EntryId, "add"] = Route, [From|_] = Message, #state{owner = Owner, feed = Feed} = State) ->
-    ?INFO("feed(~p): group message: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
-    [From, _Destinations, Desc, Medias] = Message,
-    kvs_feed:add_entry(Feed, From, [{GroupId, group}], EntryId, Desc, Medias, {group, direct}, ""),
-    case Owner == GroupId of
-        false -> ok;
-        true ->
-            {ok, Group} = kvs:get(group, GroupId),
-            GE = Group#group.entries_count,
-            kvs:put(Group#group{entries_count = GE+1}),
-            {ok, Subs} = kvs:get(group_subscription, {From, GroupId}),
-            SE = Subs#group_subscription.posts_count,
-            kvs:put(Subs#group_subscription{posts_count = SE+1})
-    end,
-    self() ! {feed_refresh,Feed, ?CACHED_ENTRIES},
-    {noreply, State};
-
-
-handle_notice(["kvs_feed", "user", FeedOwner, "entry", EntryId, "add"] = Route,
-    [From|_] = Message, #state{owner = WorkerOwner, feed = Feed, direct = Direct} = State) ->
-    ?INFO("feed(~p): message: Owner=~p, Route=~p, Message=~p", [self(), WorkerOwner, Route, Message]),
-
-    [From, Destinations, Desc, Medias] = Message,
-
-    if
-        %% user added message to own feed
-        FeedOwner == From andalso FeedOwner == WorkerOwner->
-            FilteredDst = [D || {_, group} = D <- Destinations],
-            kvs_feed:add_entry(Feed, From, FilteredDst, EntryId, Desc, Medias, {user, normal},""),
-            self() ! {feed_refresh,Feed, ?CACHED_ENTRIES};
-
-        %% friend added message to public feed
-        FeedOwner == From -> 
-            kvs_feed:add_entry(Feed, From, [], EntryId, Desc, Medias, {user, normal},""),
-            self() ! {feed_refresh,Feed, ?CACHED_ENTRIES};
-
-        %% direct message to worker owner
-        FeedOwner == WorkerOwner -> 
-            kvs_feed:add_entry(Direct, From, [{FeedOwner, user}], EntryId, Desc, Medias, {user,direct}, ""),
-            self() ! {direct_refresh,Direct, ?CACHED_ENTRIES};
-
-        %% user sent direct message to friend, add copy to his direct feed
-        From == WorkerOwner ->
-            kvs_feed:add_entry(Direct, WorkerOwner, Destinations, EntryId, Desc, Medias, {user, direct}, ""),
-            self() ! {direct_refresh,Direct, ?CACHED_ENTRIES};
-
-        true -> ?INFO("not matched case in entry->add")
-    end,
-
-    {noreply, State};
-
-handle_notice(["kvs_feed", "user", _FeedOwner, "entry", EntryId, "add_system"] = Route,
-    [From|_] = Message, #state{owner = WorkerOwner, feed = Feed, direct = _Direct} = State) ->
-    ?INFO("feed(~p): system message: Owner=~p, Route=~p, Message=~p", [self(), WorkerOwner, Route, Message]),
-    [From, _Destinations, Desc, Medias] = Message,
-    kvs_feed:add_entry(Feed, From, [], EntryId, Desc, Medias, {user, system}, ""),
-    {noreply, State};
-
-handle_notice(["kvs_feed", "group", GroupId, "entry", EntryId, "add_system"] = Route,
-              [From|_] = Message, #state{owner = Owner, feed = Feed} = State) ->
-    ?INFO("feed(~p): group system message: Owner=~p, Route=~p, Message=~p",
-          [self(), Owner, Route, Message]),
-    [From, _Destinations, Desc, Medias] = Message,
-    kvs_feed:add_entry(Feed, From, [{GroupId, group}], EntryId, Desc, Medias, {group, system}, ""),
-    {noreply, State};
-
 handle_notice(["feed", "user", UId, "post_note"] = Route,
     Message, #state{owner = Owner, feed = Feed} = State) ->
-     ?INFO("feed(~p): post_note: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
+     error_logger:info_msg("feed(~p): post_note: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
     Note = Message,
     Id = utils:uuid_ex(),
     kvs_feed:add_entry(Feed, UId, [], Id, Note, [], {user, system_note}, ""),
@@ -300,13 +240,13 @@ handle_notice(["kvs_feed", _, WhoShares, "entry", NewEntryId, "share"],
                 #entry{entry_id = _EntryId, description = Desc, media = Medias, to = Destinations,
                 from = From} = E, #state{feed = Feed, type = user} = State) ->
     %% FIXME: sharing is like posting to the wall
-    ?INFO("share: ~p, WhoShares: ~p", [E, WhoShares]),
+    error_logger:info_msg("share: ~p, WhoShares: ~p", [E, WhoShares]),
     kvs_feed:add_entry(Feed, From, Destinations, NewEntryId, Desc, Medias, {user, normal}, WhoShares),
     {noreply, State};
 
 handle_notice(["kvs_feed", "group", _Group, "entry", EntryId, "delete"] = Route,
               Message, #state{owner = Owner, feed = Feed} = State) ->
-    ?INFO("feed(~p): remove entry: Owner=~p, Route=~p, Message=~p",
+    error_logger:info_msg("feed(~p): remove entry: Owner=~p, Route=~p, Message=~p",
           [self(), Owner, Route, Message]),
     %% all group subscribers shold delete entry from their feeds
     kvs_feed:remove_entry(Feed, EntryId),
@@ -318,12 +258,12 @@ handle_notice(["kvs_feed", _Type, EntryOwner, "entry", EntryId, "delete"] = Rout
     case {EntryOwner, Message} of
         %% owner of the antry has deleted entry, we will delete it too
         {_, [EntryOwner|_]} ->
-            ?INFO("feed(~p): remove entry: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
+            error_logger:info_msg("feed(~p): remove entry: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
             kvs_feed:remove_entry(Feed, EntryId),
             kvs_feed:remove_entry(Direct, EntryId);
         %% we are owner of the entry - delete it
         {Owner, _} ->
-            ?INFO("feed(~p): remove entry: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
+            error_logger:info_msg("feed(~p): remove entry: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
             kvs_feed:remove_entry(Feed, EntryId),
             kvs_feed:remove_entry(Direct, EntryId);
         %% one of the friends has deleted some entry from his feed. Ignore
@@ -334,20 +274,20 @@ handle_notice(["kvs_feed", _Type, EntryOwner, "entry", EntryId, "delete"] = Rout
 handle_notice(["kvs_feed", _Type, _EntryOwner, "entry", EntryId, "edit"] = Route,
               Message, #state{owner = Owner, feed=Feed} = State) ->
     [NewDescription|_] = Message,
-    ?INFO("feed(~p): edit: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
+    error_logger:info_msg("feed(~p): edit: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
     kvs_feed:edit_entry(Feed, EntryId, NewDescription),
     {noreply, State};
 
 handle_notice(["kvs_feed", _Type, _EntryOwner, "comment", CommentId, "add"] = Route,
               Message, #state{owner = Owner, feed=Feed} = State) ->
     [From, EntryId, ParentComment, Content, Medias] = Message,
-    ?INFO("feed(~p): add comment: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
+    error_logger:info_msg("feed(~p): add comment: Owner=~p, Route=~p, Message=~p", [self(), Owner, Route, Message]),
     kvs_comment:add(Feed, From, EntryId, ParentComment, CommentId, Content, Medias),
     {noreply, State};
 
 handle_notice(["kvs_feed", "user", UId, "count_entry_in_statistics"] = Route, 
     Message, #state{owner = Owner, type =Type} = State) ->
-    ?INFO("queue_action(~p): count_entry_in_statistics: Owner=~p, Route=~p, Message=~p", [self(), {Type, Owner}, Route, Message]),
+    error_logger:info_msg("queue_action(~p): count_entry_in_statistics: Owner=~p, Route=~p, Message=~p", [self(), {Type, Owner}, Route, Message]),
     case kvs:get(user_etries_count, UId) of
         {ok, UEC} -> 
             kvs:put(UEC#user_etries_count{entries = UEC#user_etries_count.entries+1 }),
@@ -359,7 +299,7 @@ handle_notice(["kvs_feed", "user", UId, "count_entry_in_statistics"] = Route,
 
 handle_notice(["kvs_feed", "user", UId, "count_comment_in_statistics"] = Route, 
     Message, #state{owner = Owner, type =Type} = State) ->
-    ?INFO("queue_action(~p): count_comment_in_statistics: Owner=~p, Route=~p, Message=~p", [self(), {Type, Owner}, Route, Message]),
+    error_logger:info_msg("queue_action(~p): count_comment_in_statistics: Owner=~p, Route=~p, Message=~p", [self(), {Type, Owner}, Route, Message]),
     case kvs:get(user_etries_count, UId) of
         {ok, UEC} -> kvs:put(UEC#user_etries_count{comments = UEC#user_etries_count.comments+1 });
         {error, _} -> kvs:put(#user_etries_count{ user_id = UId, comments = 1 }) end,
@@ -367,10 +307,10 @@ handle_notice(["kvs_feed", "user", UId, "count_comment_in_statistics"] = Route,
 
 handle_notice(["kvs_feed","likes", _, _, "add_like"] = Route,  % _, _ is here beacause of the same message used for comet update
     Message, #state{owner = Owner, type =Type} = State) ->
-    ?INFO("queue_action(~p): add_like: Owner=~p, Route=~p, Message=~p", [self(), {Type, Owner}, Route, Message]),
+    error_logger:info_msg("queue_action(~p): add_like: Owner=~p, Route=~p, Message=~p", [self(), {Type, Owner}, Route, Message]),
     {UId, E} = Message,
     {EId, FId} = E#entry.id,
     kvs_feed:add_like(FId, EId, UId),
     {noreply, State};
 
-handle_notice(_Route, _Message, _State) -> error_logger:error_msg("Unknown FEED notice").
+handle_notice(Route, _Message, State) -> error_logger:error_msg("Unknown FEED notice ~p", [Route]), {noreply, State}.

src/kvs_group.erl

@@ -17,16 +17,17 @@ retrieve_groups(User) ->
                                    _ -> undefined end end || {UC, GId} <- UC_GId],
                [X||X<-Result,X/=undefined] end.
 
-create(Creator, GroupName, GroupFullName, Desc, Publicity) ->
+create(Creator, Id, Name, Desc, Publicity) ->
     Feed = kvs_feed:create(),
     Time = erlang:now(),
-    Group = #group{id = GroupName, name = GroupFullName, description = Desc, scope = Publicity,
+    Group = #group{id = Id, name = Name, description = Desc, scope = Publicity,
                    creator = Creator, created = Time, owner = Creator, feed = Feed},
+    error_logger:info_msg("PUT ~p", [Group]),
     kvs:put(Group),
 %    init_mq(Group),
 %    mqs:notify([group, init], {GroupName, Feed}),
-    add(Creator, GroupName, member),
-    GroupName.
+    add(Creator, Id, member),
+  {ok, Group}.
 
 
 delete(GroupName) ->
@@ -118,7 +119,7 @@ user_has_access(UserName, GroupName) ->
                 {private, member} -> true;
                 _ -> false end end.
 
-handle_notice(["kvs_group", "create"] = Route, 
+handle_notice([kvs_group, create] = Route,
     Message, #state{owner = Owner, type =Type} = State) ->
     ?INFO("queue_action(~p): create_group: Owner=~p, Route=~p, Message=~p", [self(), {Type, Owner}, Route, Message]),
     {Creator, GroupName, FullName, Desc, Publicity} = Message,
@@ -145,22 +146,22 @@ handle_notice(["kvs_group", "remove", GroupName] = Route,
     delete(GroupName),
     {noreply, State};
 
-handle_notice(["kvs_group", "join", GroupName] = Route,
-    Message, #state{owner = Owner, type =Type} = State) ->
-    {GroupName, UserName, Type} = Message,
-    join(UserName, GroupName),
-    subscription_mq(group, add, UserName, GroupName),
-    {noreply, State};
+handle_notice([kvs_group, join, GroupName],
+    {UserName, Type}, #state{type=Type} = State) ->
+  error_logger:info_msg("Join group:  ~p State type:~p", [GroupName, Type]),
+  join(UserName, GroupName),
+%    subscription_mq(group, add, UserName, GroupName),
+  {noreply, State};
 
 handle_notice(["kvs_group", "leave", GroupName] = Route,
     Message, #state{owner = Owner, type =Type} = State) ->
     ?INFO("queue_action(~p): remove_from_group: Owner=~p, Route=~p, Message=~p", [self(), {Type, Owner}, Route, Message]),
     {UserName} = Message,
     leave(UserName,GroupName),
-    subscription_mq(group, remove, UserName, GroupName),
+%    subscription_mq(group, remove, UserName, GroupName),
     {noreply, State};
 
-handle_notice(Route, Message, State) -> error_logger:info_msg("Unknown GROUP notice").
+handle_notice(_Route, _Message, State) -> error_logger:info_msg("Unknown GROUP notice"), {noreply, State}.
 
 build_group_relations(Group) -> [
     mqs:key( [kvs_group, create] ),

src/kvs_products.erl

@@ -13,6 +13,7 @@
 register(#product{} = Registration) ->
     Id = kvs:next_id("product", 1),
     Product = Registration#product{id = Id,
+      name = "product"++integer_to_list(Id),
       feed = kvs_feed:create(),
       blog = kvs_feed:create(),
       features = kvs_feed:create(),
@@ -31,12 +32,12 @@ delete(Name) ->
     case kvs:get(product, Name) of
         {ok, Product} ->
             GIds = kvs_group:participate(Name),
-            [ mqs:notify(["subscription", "product", Name, "remove_from_user"], {GId}) || GId <- GIds ],
+            [ mqs:notify(["subscription", "product", Name, "remove_from_group"], {GId}) || GId <- GIds ],
             F2U = [ {MeId, FrId} || #subscription{who = MeId, whom = FrId} <- subscriptions(Product) ],
             [ unsubscribe(MeId, FrId) || {MeId, FrId} <- F2U ],
             [ unsubscribe(FrId, MeId) || {MeId, FrId} <- F2U ],
-            kvs:delete(user_status, Name),
-            kvs:delete(user, Name),
+%            kvs:delete(user_status, Name),
+            kvs:delete(product, Name),
             {ok, Product};
         E -> E end.
 
@@ -64,8 +65,8 @@ subscription_mq(Type, Action, Who, Whom) ->
     case mqs:open([]) of
         {ok,Channel} ->
             case {Type,Action} of 
-                {user,add}     -> mqs_channel:bind_exchange(Channel, ?USER_EXCHANGE(Who), ?NOTIFICATIONS_EX, rk_user_feed(Whom));
-                {user,remove}  -> mqs_channel:unbind_exchange(Channel, ?USER_EXCHANGE(Who), ?NOTIFICATIONS_EX, rk_user_feed(Whom)) end,
+                {user,add}     -> mqs_channel:bind_exchange(Channel, ?USER_EXCHANGE(Who), ?NOTIFICATIONS_EX, rk_product_feed(Whom));
+                {user,remove}  -> mqs_channel:unbind_exchange(Channel, ?USER_EXCHANGE(Who), ?NOTIFICATIONS_EX, rk_product_feed(Whom)) end,
             mqs_channel:close(Channel);
         {error,Reason} -> ?ERROR("subscription_mq error: ~p",[Reason]) end.
 
@@ -84,16 +85,16 @@ init_mq(Product=#product{}) ->
 
 build_user_relations(Product, Groups) -> [
     mqs:key( [kvs_product, '*', Product]),
-    mqs:key( [kvs_feed, user, Product, '*', '*', '*']),
-    mqs:key( [kvs_feed, user, Product, '*'] ),
-    mqs:key( [kvs_payment, user, Product, '*']),
-    mqs:key( [kvs_account, user, Product, '*']),
-    mqs:key( [kvs_meeting, user, Product, '*']),
-    mqs:key( [kvs_purchase, user, Product, '*']) |
+    mqs:key( [kvs_feed, product, Product, '*', '*', '*']),
+    mqs:key( [kvs_feed, product, Product, '*'] ),
+    mqs:key( [kvs_payment, product, Product, '*']),
+    mqs:key( [kvs_account, product, Product, '*']),
+    mqs:key( [kvs_meeting, product, Product, '*']),
+    mqs:key( [kvs_purchase, product, Product, '*']) |
   [ mqs:key( [kvs_feed, group, G, '*', '*', '*']) || G <- Groups ]
     ].
 
-rk_user_feed(Product) -> mqs:key([kvs_feed, user, Product, '*', '*', '*']).
+rk_product_feed(Product) -> mqs:key([kvs_feed, product, Product, '*', '*', '*']).
 
 retrieve_connections(Id,Type) ->
     Friends = case Type of 
@@ -133,4 +134,6 @@ handle_notice(["kvs_product", "update", _Who],
     kvs:put(NewProduct),
     {noreply, State};
 
-handle_notice(_Route, _Message, _State) -> error_logger:info_msg("Unknown USERS notice").
+handle_notice(_Route, _Message, State) ->
+  %error_logger:info_msg("Unknown USERS notice"),
+  {noreply, State}.

src/kvs_user.erl

@@ -176,4 +176,6 @@ handle_notice(["kvs_user", "update", Who] = Route,
     kvs:put(NewUser),
     {noreply, State};
 
-handle_notice(Route, Message, State) -> error_logger:info_msg("Unknown USERS notice").
+handle_notice(Route, Message, State) -> 
+  %error_logger:info_msg("Unknown USERS notice"), 
+  {noreply, State}.

src/store_mnesia.erl

@@ -165,7 +165,7 @@ exec(Q) -> F = fun() -> qlc:e(Q) end, {atomic, Val} = mnesia:transaction(F), Val
 % index funs
 
 products(UId) -> all_by_index(user_product, #user_product.username, UId).
-subscriptions(UId) -> all_by_index(subsciption, #subscription.who, UId).
+subscriptions(UId) -> all_by_index(subscription, #subscription.who, UId).
 subscribed(Who) -> all_by_index(subscription, #subscription.whom, Who).
 participate(UserName) -> all_by_index(group_subscription, #group_subscription.who, UserName).
 members(GroupName) -> all_by_index(group_subscription, #group_subscription.where, GroupName).