I1027 Add Contest Clock To WTI

projects/WTI-API/src/main/controllers/ContestController.java

@@ -5,6 +5,7 @@
 import java.net.URISyntaxException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Calendar;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Properties;
@@ -25,6 +26,8 @@
 import config.ServerInit;
 import edu.csus.ecs.pc2.api.IClarification;
 import edu.csus.ecs.pc2.api.IClient;
+import edu.csus.ecs.pc2.api.IContest;
+import edu.csus.ecs.pc2.api.IContestClock;
 import edu.csus.ecs.pc2.api.IJudgement;
 import edu.csus.ecs.pc2.api.ILanguage;
 import edu.csus.ecs.pc2.api.IProblem;
@@ -48,6 +51,7 @@
 import io.swagger.annotations.ApiResponses;
 import io.swagger.annotations.Authorization;
 import models.ClarificationModel;
+import models.ContestClockModel;
 import models.LanguageModel;
 import models.ProblemModel;
 import models.ServerErrorResponseModel;
@@ -325,16 +329,23 @@ public Response problems(
 			if (userInformation == null) {
 				throw new NotLoggedInException();
 			} else {
-				// make sure that the contest is running (problems are not allowed to be seen when the contest is not running)
-				if (!userInformation.getContest().isContestClockRunning()) {
+				// make sure that the contest has been started (problems are not allowed to be seen before the contest starts)
+				// Note that starting the contest results in setting the "contest start time" in the ContestClock object to
+				// the Unix Epoch time at which the contest was started; prior to starting the contest that value will be null.
+				if (userInformation.getContest().getContestClock().getContestStartTime()==null) {
 					return Response.status(Response.Status.UNAUTHORIZED).entity(
-							new ServerErrorResponseModel(Response.Status.UNAUTHORIZED, "Unauthorized user request"))
+							new ServerErrorResponseModel(Response.Status.UNAUTHORIZED, "Unauthorized user request - contest has not started."))
 							.type(MediaType.APPLICATION_JSON).build();
 				}
 			}
 		} catch (NotLoggedInException e1) {
 			return Response.status(Response.Status.UNAUTHORIZED)
-					.entity(new ServerErrorResponseModel(Response.Status.UNAUTHORIZED, "Unauthorized user request"))
+					.entity(new ServerErrorResponseModel(Response.Status.UNAUTHORIZED, "Unauthorized user request -- not logged in."))
+					.type(MediaType.APPLICATION_JSON).build();
+		} catch (Exception e2) {
+			logger.severe("Exception in ContestController /problems endppoint: " + e2.getMessage());
+			return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+					.entity(new ServerErrorResponseModel(Response.Status.INTERNAL_SERVER_ERROR, "Exception in ContestController /problems endppoint: " + e2.getMessage()))
 					.type(MediaType.APPLICATION_JSON).build();
 		}
 
@@ -411,6 +422,107 @@ public Response isRunning(
 				.type(MediaType.APPLICATION_JSON).build();
 	}
 
+
+			/***
+			 *  This method returns a "ContestClock" object encapsulating the current state of the PC2 contest clock 
+			 *  as maintained by the PC2 class "ContestTime".  
+			 *  It first checks to see that the user (team) specified by the received "key" is currently logged in. If so, the method
+			 *  returns the current contest time information, obtained from the PC2 {@link ServerConnection} for the team.
+			 * 
+			 * @param key a String containing a key which uniquely identifies the team making the request.  
+			 * 				The value of "key" is obtained from the HTTP header parameter "team_id".
+			 * 
+			 * @return Response of:
+			 *				401 (unauthorized) if team's credentials are incorrect (i.e. the team is not logged in or is not allowed to make such a request);
+			 * 				500 (INTERNAL_SERVER_ERROR) if an error occurs in fetching the requested data from the PC2 server;
+			 * 				otherwise 200 (OK) and a JSON string containing a {@link ContestClock} is returned.
+			 */
+			@Path("/contestclock")
+			@GET
+			@ApiOperation(value = "contestclock",
+			notes = "Gets the PC2 contest clock (time info).")
+			@ApiResponses({
+				@ApiResponse(code = 200, message = "Returns a contest clock object.", response = ContestClockModel.class), 
+				@ApiResponse(code = 401, message = "Returned if invalid credentials are supplied", response = ServerErrorResponseModel.class)
+			})
+
+			public Response contestClock(@ApiParam(value="token used by logged in users to access teams information", 
+											required = true) @HeaderParam("team_id")String key) {
+
+				if (connections == null) {
+					System.err.println ("SEVERE: ContestController.contestClock(): team connections map in MainController is null!");
+					logger.severe("ContestController.contestClock(): team connections map in MainController is null!");
+					throw new NullPointerException("Team connections map in MainController is null in ContestController.contestClock()");
+				}
+				ServerConnection userInformation = connections.get(key);
+
+				//verify the user is logged in
+				try {
+					// make sure we have connection information for this user (i.e. that the user is logged in)
+					if (userInformation == null) {
+						throw new NotLoggedInException();
+					} 
+				} catch (NotLoggedInException e1) {
+					return Response.status(Response.Status.UNAUTHORIZED)
+							.entity(new ServerErrorResponseModel(Response.Status.UNAUTHORIZED, "Unauthorized user request"))
+							.type(MediaType.APPLICATION_JSON).build();
+				}
+
+				//the ContestClock object to be returned in the response to the HTTP request
+				ContestClockModel returnableContestClock ;
+
+				try {
+					//get the contest clock from the PC2 Server via the PC2 API ServerConnection
+//					IContestClock contestClock = userInformation.getContest().getContestClock();
+
+					IContest contest = userInformation.getContest();
+					if (contest == null) {
+						System.err.println ("SEVERE: ContestController.contestClock(): ServerConnection.getContest() returned null!");
+						logger.severe("ContestController.contestClock(): ServerConnection.getContest() returned null!");
+						throw new NullPointerException("ServerConnection.getContest() returned null in ContestController.contestClock()");
+					}
+					IContestClock contestClock = contest.getContestClock();
+					if (contestClock == null) {
+						System.err.println ("SEVERE: ContestController.contestClock(): ServerConnection.getContest().getContestClock() returned null!");
+						logger.severe("ContestController.contestClock(): ServerConnection.getContest().getContestClock() returned null!");
+						throw new NullPointerException("ServerConnection.getContest().getContestClock() returned null in ContestController.contestClock()");
+					}
+
+					//retrieve the relevant fields from the PC2 contest clock
+					boolean isRunning = contestClock.isContestClockRunning();
+					long contestLengthInSecs = contestClock.getContestLengthSecs();
+					long elapsedSecs = contestClock.getElapsedSecs();
+					long wallClockStartTime ;
+					//"contest start time" is a Calendar object and might be null if the contest has never been started
+					Calendar startTimeCalendar = contestClock.getContestStartTime();
+					if (startTimeCalendar == null) {
+						wallClockStartTime = 0;
+					} else {
+						wallClockStartTime = startTimeCalendar.getTimeInMillis();
+					}
+
+					//construct a ContestClock containing the PC2 Server clock values
+					returnableContestClock = new ContestClockModel(isRunning,contestLengthInSecs, elapsedSecs, wallClockStartTime);
+
+				}
+				catch(NotLoggedInException e) {
+					return Response.status(Response.Status.UNAUTHORIZED)
+							.entity(new ServerErrorResponseModel(Response.Status.UNAUTHORIZED, "Unauthorized user request"))
+							.type(MediaType.APPLICATION_JSON).build();
+				}
+				catch(NullPointerException e) {
+					logger.severe(e.getMessage());
+					return Response.status(Response.Status.INTERNAL_SERVER_ERROR)
+							.entity(new ServerErrorResponseModel(Response.Status.INTERNAL_SERVER_ERROR, "NullPointerException in ContestController.contestClock()"))
+							.type(MediaType.APPLICATION_JSON).build();
+				}		
+
+				//return the PC2 ContestClock, mapped into JSON
+				return Response.ok()
+						.entity(returnableContestClock)
+						.type(MediaType.APPLICATION_JSON).build();
+			}
+
 	/***
 	 *  This method returns a list of all the clarifications in the PC^2 contest submitted by the specified team.  
 	 *  It first checks to see that the user (team) specified by the received "key" is currently logged in and that the 
@@ -444,17 +556,10 @@ public Response clarifications(@ApiParam(value="token used by logged in users to
 			// make sure we have connection information for this user (i.e. that the user is logged in)
 			if (userInformation == null) {
 				throw new NotLoggedInException();
-			} else {
-				// make sure that the contest is running (problems are not allowed to be seen when the contest is not running)
-				if (!userInformation.getContest().isContestClockRunning()) {
-					return Response.status(Response.Status.UNAUTHORIZED).entity(
-							new ServerErrorResponseModel(Response.Status.UNAUTHORIZED, "Unauthorized user request"))
-							.type(MediaType.APPLICATION_JSON).build();
-				}
 			}
 		} catch (NotLoggedInException e1) {
 			return Response.status(Response.Status.UNAUTHORIZED)
-					.entity(new ServerErrorResponseModel(Response.Status.UNAUTHORIZED, "Unauthorized user request"))
+					.entity(new ServerErrorResponseModel(Response.Status.UNAUTHORIZED, "Unauthorized user request - not logged in."))
 					.type(MediaType.APPLICATION_JSON).build();
 		}
 

projects/WTI-API/src/main/models/ContestClockModel.java

@@ -0,0 +1,44 @@
+package models;
+
+import edu.csus.ecs.pc2.core.model.ContestTime;
+
+/**
+ * This class encapsulates the features of the PC2 "contest clock" (class {@link ContestTime}) which need to be able to be passed
+ * to the WTI-UI.
+ * 
+ * @author JohnC
+ *
+ */
+public class ContestClockModel {
+
+	private boolean isRunning;
+	private long contestLengthInSecs;
+	private long elapsedSecs;  			//total time in seconds that the contest has been running -- does NOT include time during any "pauses" 
+	private long wallClockStartTime;	//unix timestamp when the contest actually started (msec since the Epoch),
+										// or zero if contest has not ever been started.  Does not change due to "pauses".
+
+	public ContestClockModel(boolean isRunning, long contestLengthInSecs, long elapsedSecs, long wallClockStartTime) {
+			this.isRunning = isRunning;
+			this.contestLengthInSecs = contestLengthInSecs;
+			this.elapsedSecs = elapsedSecs;
+			this.wallClockStartTime = wallClockStartTime;
+	}
+
+	public ContestClockModel() { }
+
+	public boolean isRunning() {
+		return isRunning;
+	}
+
+	public long getContestLengthInSecs() {
+		return contestLengthInSecs;
+	}
+
+	public long getElapsedSecs() {
+		return elapsedSecs;
+	}
+
+	public long getWallClockStartTime() {
+		return wallClockStartTime;
+	}
+}

projects/WTI-UI/src/app/app-routing.module.ts

@@ -8,6 +8,17 @@ import { LogoutComponent } from './modules/login/components/logout/logout.compon
 import { ClarificationsPageComponent } from './modules/clarifications/components/clarifications-page/clarifications-page.component';
 import { ScoreboardPageComponent } from './modules/scoreboard/components/scoreboard-page/scoreboard-page.component';
 
+/**
+ * This class defines the "routes" which the Angular application (specifically, the Angular Router) knows how to follow.
+ * Note that ORDER MATTERS; the Router searches the 'Routes' array from the beginning to find a route which matches the
+ * path it has been told to attempt to follow.  For this reason, the "login" page will always be the default route.
+ * Note that remaining routes are protected by a "canActivate: [AuthGuard]" clause; the effect of this is that if the Router
+ * decides to attempt to follow that route, it first invokes the "AuthGuard" class, which determines whether following that
+ * route is 'allowed'.  (The criterion defined in "AuthGuard" is that the user is logged in.)
+ * If the route specified by the user does not match any other route defined here, the Router defaults to the LAST route, 
+ * the one with a "path" of "**".  The effect of this is that any attempt by the user to enter any undefined route in the 
+ * browser will cause a transfer to the "/runs" page.
+ */
 const routes: Routes = [
   {
     path: 'login',

projects/WTI-UI/src/app/app.component.ts

@@ -159,7 +159,7 @@ export class AppComponent implements OnInit {
 						console.log (this._contestService);
 					}
 					this._contestService.isContestRunning = val;
-					this._contestService.contestClock.next();
+					this._contestService.contestClockEvent.next();
 				});
 
         //get the most recently saved Option values from sessionStorage
@@ -180,14 +180,19 @@ export class AppComponent implements OnInit {
         	}
         }
 
+		//restore the contest clock on-screen display values (elapsed and remaining)
+	    if (DEBUG_MODE) {
+	    	console.log ('Updating local contest clock values from server');
+	    }
+		this._contestService.updateLocalContestClockFromServer();
+
 	    // transfer to the (former) "current page".
 	    let page = getCurrentPage();
 	    if (DEBUG_MODE) {
 	    	console.log ('...navigating to previous page: ' + page);
 	    }
 
 	    //navigate to the most recently saved page
-	    // TODO:  consider whether using history.pushState()/popState() is a better solution for this...
 	    this.router.navigate([page])
 	      .then(nav => {
 	         if (DEBUG_MODE) {

projects/WTI-UI/src/app/modules/core/abstract-services/i-contest.service.ts

@@ -2,17 +2,36 @@ import { Injectable } from '@angular/core';
 import { Observable, Subject } from 'rxjs';
 import { ContestLanguage } from '../models/contest-language';
 import { ContestProblem } from '../models/contest-problem';
+import { ContestClock } from '../models/contest-clock';
 import { Clarification } from '../models/clarification';
 import { DEBUG_MODE } from 'src/constants';
 
 @Injectable({
 	providedIn: 'root'   //forces the service to be a singleton across all app components ('root' == "root injector")
 })
 export abstract class IContestService {
+
+  //need to document how the "clarificationsUpdated" Subject works (see the description of contestClockEvent, below; 
+  //this operates similarly although it is used in more places) 
   clarificationsUpdated = new Subject<void>();
-  contestClock = new Subject<void>();
+
+  //The contestClockEvent "Subject" is used as a toggle to indicate when contest clock-related events have occured.
+  //It is "subscribed to" by the "ProblemSelectorComponent.ngOnInit()" method (meaning, that component will get a callback
+  //whenever the contestClockEvent's "next()" method is invoked). The contestClockEvent's "next()" method is invoked in exactly one
+  //place:  IWebsocketService.incomingMessage(), when a message of type "contest_clock" is received by the WTI-UI from the WTI-API
+  //(which in turn happens when the WTI-API receives a "contest clock configuration update" notice via the PC2 API).
+  //The effect of all this is that the ProblemSelectorComponent gets notified when "some change" has occurred in the state of the
+  //PC2 contest clock.  This causes the ProblemSelectorComponent to execute its "loadProblems()" method; that method in turn checks
+  //whether the contest is currently RUNNING; if so, it loads the problem names; if not, it blanks out problem names.
+  //note that contestClockEvent is a WTI-UI-specific object used to coordinate with Websocket "clock" messages; 
+  //it is NOT a "ContestClock" object in the sense of classes defined in core/models, nor an "Event" it PC2 terms.
+  contestClockEvent = new Subject<void>();  
+
   standingsUpdated = new Subject<void>();
   isContestRunning = false;
+
+  //the WTI-UI representation of the PC2 Server's ContestClock (PC2 class ContestTime)
+  contestClock: ContestClock = new ContestClock();  
 
   //give each instance of IContestService a unique ID for debugging purposes
   private static nextId: number = 1;
@@ -35,7 +54,15 @@ export abstract class IContestService {
   abstract getClarifications(): Observable<Clarification[]>;
 
   abstract getIsContestRunning(): Observable<boolean>;
+
+  abstract getContestClock(): Observable<ContestClock>;		//note this refers to a "ContestClock" model object, not the "contestClockEvent" Subject above
 
+  abstract updateLocalContestClockFromServer (): void;		//update the WTI-UI representation of the PC2 contest clock
+
+  abstract getElapsedSecs(): number;
+
+  abstract getRemainingSecs(): number;
+
   abstract getStandings(): Observable<String>;
 
   abstract markStandingsOutOfDate(): void;

projects/WTI-UI/src/app/modules/core/abstract-services/i-websocket.service.ts

@@ -43,19 +43,28 @@ export abstract class IWebsocketService {
         break;
       }
       case 'contest_clock': {
+    	  /* This case is invoked when the WTI Server gets a "Contest_Clock" message from the PC2 Server
+    	   * (via the PC2 API "ConfigurationItemUpdated()" listener in the WTI class "ConfigurationService").
+    	   * Such a message from the PC2 Server causes the WTI Server to send a "contest_clock" message through
+    	   * the websocket to this client. 
+    	   */
     	  if (DEBUG_MODE) {
-    		  console.log ("Got '", message.type, "' websocket message in IWebsocketService.incomingMessage()");
+    		  console.log ("IWebsocketService.incomingMessage(): got websocket message '", message.type);
+              console.log ("IWebsocketService.incomingMessage(): invoking ContestService.getIsContestRunning() and");
+              console.log ("  subscribing to callback from HTTP GET");
     	  }
         this._contestService.getIsContestRunning()
           .subscribe((val: any) => {
         	  if (DEBUG_MODE) {
         		  console.log ("IWebsocketService.incomingMessage(): callback from ContestService.getIsContestRunning() returned '", val, "'");
-        		  console.log ("Setting ContestService.isContestRunning to '", val, "'") ;
-        		  console.log ("  and invoking ContestService.contestClock.next()") ;
+        		  console.log ("Setting ContestService.isContestRunning to '", val, "',") ;
+        		  console.log ("  invoking ContestService.contestClockEvent.next()") ;
+                  console.log ("  and invoking ContestService.updateLocalContestClockFromServer()");
         	  }
 
             this._contestService.isContestRunning = val;
-            this._contestService.contestClock.next();
+            this._contestService.contestClockEvent.next();
+			this._contestService.updateLocalContestClockFromServer();
           });
         break;
       }

projects/WTI-UI/src/app/modules/core/core.module.ts

@@ -16,6 +16,7 @@ import { IWebsocketService } from './abstract-services/i-websocket.service';
 import { UiHelperService } from './services/ui-helper.service';
 import { SharedModule } from '../shared/shared.module';
 import { DEBUG_MODE } from 'src/constants';
+import { DisplayTimePipe } from './services/displayTimePipe.service';
 
 export function TeamsServiceFactory(http: HttpClient) {
   if (DEBUG_MODE) {
@@ -83,18 +84,23 @@ export function WebsocketServiceFactory(injector: Injector,
   providers: [
     { provide: ITeamsService, useFactory: TeamsServiceFactory, deps: [HttpClient] },
     { provide: IContestService, useFactory: ContestServiceFactory, deps: [HttpClient] },
+    { provide: ContestService, useFactory: ContestServiceFactory, deps: [HttpClient] },
     { provide: AuthService, useClass: AuthService },
     { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true },
     { provide: IWebsocketService, useFactory: WebsocketServiceFactory, deps: [Injector, UiHelperService, IContestService, ITeamsService, AuthService] },
     AuthGuard,
+    DisplayTimePipe,
 	//TODO:  should the following two still be declared here since they are now listed in the above "deps" list?
     UiHelperService,
     ContestService
   ],
   imports: [
     HttpClientModule,
-    SharedModule
+    SharedModule,
+    DisplayTimePipe
   ],
-  exports: [],
+  exports: [
+    DisplayTimePipe
+  ]
 })
 export class CoreModule { }