Handle listActivities on server

server/src/session_server.erl

@@ -63,12 +63,18 @@ handle_request(Request) ->
 
 map_request({ping, 'NULL'}) ->
 	{response, {ack, 'NULL'}};
+map_request({listActivities, 'NULL'}) ->
+	{activities, Activities} = subject_router:get_activities(),
+	SortedActivities = lists:reverse(lists:keysort(3, Activities)),
+	{response, {activities,
+				[{'Activity', Subject, Type, round(Priority * 100)}
+				 || {Subject, Type, Priority} <- SortedActivities]}};
 map_request({logSession, {'Session', Subject, Type, Timestamp, Minutes}}) ->
 	Session = {unicode:characters_to_list(Subject),
 			   Type, Timestamp, Minutes},
 	case subject_router:log_session(Session) of
 		ok -> {response, {ack, 'NULL'}};
-		{error, invalid_subject} -> {response, {error, invalidArguments}}
+		{error, _Error} -> {response, {error, invalidArguments}}
 	end;
 map_request(_) ->
 	{response, {error, invalidArguments}}.

server/src/subject_router.erl

@@ -4,7 +4,7 @@
 -module(subject_router).
 -behaviour(gen_server).
 
--export([start_link/0, log_session/1]).
+-export([start_link/0, log_session/1, get_activities/0]).
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2,
 		 terminate/2, code_change/3]).
 
@@ -14,6 +14,9 @@ start_link() ->
 log_session(Session) ->
 	gen_server:call(?MODULE, {log_session, Session}).
 
+get_activities() ->
+	gen_server:call(?MODULE, get_activities).
+
 init([]) ->
 	{MonitorRef, Pids} = pg:monitor(study_system_server, subject_servers),
 	SubjectTable = ets:new(subject_table, [private]),
@@ -25,11 +28,19 @@ handle_call({log_session, {Subject, Type, Timestamp, Minutes}},
 			_From, State = #{subject_table := SubjectTable}) ->
 	case ets:lookup(SubjectTable, Subject) of
 		[{Subject, Pid}] ->
-			Pid ! {new_session, Type, Timestamp, Minutes},
+			{reply,
-			{reply, ok, State};
+			 subject_server:log_session(Pid, Type, Timestamp, Minutes),
+			 State};
 		[] ->
 			{reply, {error, invalid_subject}, State}
 	end;
+handle_call(get_activities, _From,
+			State = #{subject_table := SubjectTable}) ->
+	Pids = lists:flatten(ets:match(SubjectTable, {'_', '$1'})),
+	Activities = lists:flatmap(
+				   fun(Pid) -> subject_server:get_activities(Pid) end,
+				   Pids),
+	{reply, {activities, Activities}, State};
 handle_call(_Request, _From, State) ->
 	{reply, ok, State}.
 
@@ -62,7 +73,7 @@ register_servers(SubjectTable, Pids) ->
 
 register_server(SubjectTable, Pid) ->
 	try
-		{subject, Subject} = gen_server:call(Pid, get_subject),
+		{subject, Subject} = subject_server:get_subject(Pid),
 		ets:insert(SubjectTable, {Subject, Pid})
 	catch
 		_:_ -> ok

server/src/subject_server.erl

@@ -4,31 +4,52 @@
 -module(subject_server).
 -behaviour(gen_server).
 
--export([start_link/1]).
+-export([start_link/1, get_subject/1, get_activities/1, log_session/4]).
 -export([init/1, handle_call/3, handle_cast/2, handle_info/2,
 		 terminate/2, code_change/3]).
 
 start_link(Subject) ->
 	gen_server:start_link(?MODULE, Subject, []).
 
+get_subject(Pid) ->
+	gen_server:call(Pid, get_subject).
+
+get_activities(Pid) ->
+	gen_server:call(Pid, get_activities).
+
+log_session(Pid, Type, Timestamp, Minutes) ->
+	gen_server:call(Pid, {log_session, {Type, Timestamp, Minutes}}).
+
 init(Subject) ->
 	pg:join(study_system_server, subject_servers, self()),
-	{ok, #{subject => Subject}}.
+	{ok, #{subject => Subject,
+		   priorities => #{reading => rand:uniform(),
+						   exercises => rand:uniform()}}}.
 
 handle_call(get_subject, _From, State = #{subject := Subject}) ->
 	{reply, {subject, Subject}, State};
+handle_call(get_activities, _From,
+			State = #{subject := Subject,
+					  priorities := #{reading := ReadingPriority,
+									  exercises := ExercisesPriority}}) ->
+	Reading = {Subject, reading, ReadingPriority},
+	Exercises = {Subject, exercises, ExercisesPriority},
+	{reply, [Reading, Exercises], State};
+handle_call({log_session, {Type, Timestamp, Minutes}}, _From,
+			State = #{subject := Subject, priorities := Priorities}) ->
+	case Priorities of
+		#{Type := Priority} ->
+			UpdatedPriorities = Priorities#{Type := Priority * 0.667},
+			{reply, ok, State#{priorities := UpdatedPriorities}};
+		_ ->
+			{reply, {error, invalid_type}, State}
+	end;
 handle_call(_Request, _From, State) ->
 	{reply, ok, State}.
 
 handle_cast(_Msg, State) ->
 	{noreply, State}.
 
-handle_info({new_session, Type, Timestamp, Minutes},
-			State = #{subject := Subject}) ->
-	io:format(
-	  "Received new ~p session: type ~p, timestamp ~p, minutes ~p~n",
-	  [Subject, Type, Timestamp, Minutes]),
-	{noreply, State};
 handle_info(_Info, State) ->
 	{noreply, State}.