v7.8.0

Gruntfile.js

@@ -38,7 +38,8 @@ module.exports = function(grunt) {
             },
             dist_progress: {
                 src: [
-                    'public/javascripts/Progress/src/*.js'
+                    'public/javascripts/Progress/src/*.js',
+                    'public/javascripts/common/Utilities.js'
                 ],
                 dest: 'public/javascripts/Progress/build/Progress.js'
             },

app/controllers/AdminController.scala

@@ -9,14 +9,15 @@ import com.mohiva.play.silhouette.api.{Environment, Silhouette}
 import com.mohiva.play.silhouette.impl.authenticators.SessionAuthenticator
 import com.vividsolutions.jts.geom.Coordinate
 import controllers.headers.ProvidesHeader
+import formats.json.LabelFormat
 import formats.json.TaskFormats._
 import formats.json.UserRoleSubmissionFormats._
 import formats.json.LabelFormat._
 import models.attribute.{GlobalAttribute, GlobalAttributeTable}
 import models.audit.{AuditTaskInteractionTable, AuditTaskTable, AuditedStreetWithTimestamp, InteractionWithLabel}
 import models.daos.slick.DBTableDefinitions.UserTable
 import models.gsv.GSVDataTable
-import models.label.LabelTable.{LabelMetadata, LabelCVMetadata}
+import models.label.LabelTable.{LabelCVMetadata, LabelMetadata}
 import models.label.{LabelPointTable, LabelTable, LabelTypeTable, LabelValidationTable}
 import models.mission.MissionTable
 import models.region.RegionCompletionTable
@@ -355,7 +356,7 @@ class AdminController @Inject() (implicit val env: Environment[User, SessionAuth
         case Some(labelPointObj) =>
           val userId: String = request.identity.get.userId.toString
           val labelMetadata: LabelMetadata = LabelTable.getSingleLabelMetadata(labelId, userId)
-          val labelMetadataJson: JsObject = LabelTable.labelMetadataWithValidationToJsonAdmin(labelMetadata)
+          val labelMetadataJson: JsObject = LabelFormat.labelMetadataWithValidationToJsonAdmin(labelMetadata)
           Future.successful(Ok(labelMetadataJson))
         case _ => Future.successful(Ok(Json.obj("error" -> "no such label")))
       }
@@ -372,7 +373,7 @@ class AdminController @Inject() (implicit val env: Environment[User, SessionAuth
       case Some(labelPointObj) =>
         val userId: String = request.identity.map(_.userId.toString).getOrElse("")
         val labelMetadata: LabelMetadata = LabelTable.getSingleLabelMetadata(labelId, userId)
-        val labelMetadataJson: JsObject = LabelTable.labelMetadataWithValidationToJson(labelMetadata)
+        val labelMetadataJson: JsObject = LabelFormat.labelMetadataWithValidationToJson(labelMetadata)
         Future.successful(Ok(labelMetadataJson))
       case _ => Future.successful(Ok(Json.obj("error" -> "no such label")))
     }

app/controllers/ForgotPasswordController.scala

@@ -44,7 +44,7 @@ class ForgotPasswordController @Inject() (
     ForgotPasswordForm.form.bindFromRequest.fold (
       form => Future.successful(BadRequest(views.html.forgotPassword(form))),
       email => {
-        val loginInfo = LoginInfo(CredentialsProvider.ID, email)
+        val loginInfo = LoginInfo(CredentialsProvider.ID, email.toLowerCase)
         val result = Redirect(routes.UserController.forgotPassword()).flashing("info" -> Messages("reset.pw.email.reset.pw.sent"))
         userService.retrieve(loginInfo).flatMap {
           case Some(user) =>

app/controllers/GalleryController.scala

@@ -9,10 +9,11 @@ import models.label.{LabelTable, LabelTypeTable}
 import models.label.LabelTable._
 import com.mohiva.play.silhouette.api.{Environment, Silhouette}
 import com.mohiva.play.silhouette.impl.authenticators.SessionAuthenticator
+import formats.json.LabelFormat
 import play.api.Play
 import play.api.Play.current
 import play.api.mvc._
-import play.api.libs.json.{JsObject, Json, JsError}
+import play.api.libs.json.{JsError, JsObject, Json}
 import scala.concurrent.Future
 
 
@@ -65,7 +66,7 @@ class GalleryController @Inject() (implicit val env: Environment[User, SessionAu
               } else labels
 
             val jsonList: Seq[JsObject] = realLabels.map(l => Json.obj(
-                "label" -> LabelTable.validationLabelMetadataToJson(l),
+                "label" -> LabelFormat.validationLabelMetadataToJson(l),
                 "imageUrl" -> GoogleMapsHelper.getImageUrl(l.gsvPanoramaId, l.canvasWidth, l.canvasHeight, l.heading, l.pitch, l.zoom)
               )
             )

app/controllers/UserProfileController.scala

@@ -8,12 +8,13 @@ import com.mohiva.play.silhouette.api.{Environment, Silhouette}
 import com.mohiva.play.silhouette.impl.authenticators.SessionAuthenticator
 import com.vividsolutions.jts.geom.Coordinate
 import controllers.headers.ProvidesHeader
+import formats.json.LabelFormat.labelMetadataUserDashToJson
 import models.audit.AuditTaskTable
 import models.mission.MissionTable
 import models.user.UserOrgTable
 import models.label.{LabelTable, LabelValidationTable}
-import models.user.{User, WebpageActivityTable, WebpageActivity}
-import play.api.libs.json.{JsObject, Json}
+import models.user.{User, WebpageActivity, WebpageActivityTable}
+import play.api.libs.json.{JsObject, JsValue, Json}
 import play.extras.geojson
 import play.api.i18n.Messages
 import scala.concurrent.Future
@@ -35,13 +36,14 @@ class UserProfileController @Inject() (implicit val env: Environment[User, Sessi
       Future.successful(Redirect(s"/signIn?url=/"))
     } else {
       val user: User = request.identity.get
-      // Get distance audited by the user. If using metric units, convert from miles to kilometers.
-      val auditedDistance: Float =
-        if (Messages("measurement.system") == "metric") MissionTable.getDistanceAudited(user.userId) * 1.60934.toFloat
-        else MissionTable.getDistanceAudited(user.userId)
       val timestamp: Timestamp = new Timestamp(Instant.now.toEpochMilli)
       val ipAddress: String = request.remoteAddress
       WebpageActivityTable.save(WebpageActivity(0, user.userId.toString, ipAddress, "Visit_UserDashboard", timestamp))
+      // Get distance audited by the user. If using metric units, convert from miles to kilometers.
+      val auditedDistance: Float = {
+        if (Messages("measurement.system") == "metric") MissionTable.getDistanceAudited(user.userId) * 1.60934.toFloat
+        else MissionTable.getDistanceAudited(user.userId)
+      }
       Future.successful(Ok(views.html.userProfile(s"Project Sidewalk", Some(user), auditedDistance)))
     }
   }
@@ -154,6 +156,20 @@ class UserProfileController @Inject() (implicit val env: Environment[User, Sessi
     Future.successful(Ok(json))
   }
 
+  /**
+   * Get up `n` recent mistakes for each label type, using validations provided by other users.
+   * @param n Number of mistakes to retrieve for each label type.
+   * @return
+   */
+  def getRecentMistakes(n: Int) = UserAwareAction.async {implicit request =>
+    val labelTypes: List[String] = List("CurbRamp", "NoCurbRamp", "Obstacle", "SurfaceProblem", "Crosswalk", "Signal")
+    val validations = LabelTable.getRecentValidatedLabelsForUser(request.identity.get.userId, n, labelTypes)
+    val validationJson: JsValue = Json.toJson(labelTypes.map { t =>
+      t -> validations.filter(_.labelType == t).map(labelMetadataUserDashToJson)
+    }.toMap)
+    Future.successful(Ok(validationJson))
+  }
+
   /**
    * Sets the org of the given user. 
    *

app/controllers/ValidationController.scala

@@ -9,12 +9,13 @@ import com.mohiva.play.silhouette.api.{Environment, Silhouette}
 import com.mohiva.play.silhouette.impl.authenticators.SessionAuthenticator
 import controllers.headers.ProvidesHeader
 import formats.json.CommentSubmissionFormats._
+import formats.json.LabelFormat
 import models.amt.AMTAssignmentTable
 import models.daos.slick.DBTableDefinitions.{DBUser, UserTable}
 import models.label.LabelTable
 import models.label.LabelTable.LabelValidationMetadata
 import models.label.LabelValidationTable
-import models.mission.{Mission, MissionTable, MissionSetProgress}
+import models.mission.{Mission, MissionSetProgress, MissionTable}
 import models.validation._
 import models.user._
 import play.api.libs.json._
@@ -138,7 +139,7 @@ class ValidationController @Inject() (implicit val env: Environment[User, Sessio
     val labelsToRetrieve: Int = labelsToValidate - labelsProgress
 
     val labelMetadata: Seq[LabelValidationMetadata] = LabelTable.retrieveLabelListForValidation(userId, labelsToRetrieve, labelType, skippedLabelId = None)
-    val labelMetadataJsonSeq: Seq[JsObject] = labelMetadata.map(label => LabelTable.validationLabelMetadataToJson(label))
+    val labelMetadataJsonSeq: Seq[JsObject] = labelMetadata.map(label => LabelFormat.validationLabelMetadataToJson(label))
     val labelMetadataJson : JsValue = Json.toJson(labelMetadataJsonSeq)
     labelMetadataJson
   }

app/controllers/ValidationTaskController.scala

@@ -16,11 +16,10 @@ import models.validation._
 import play.api.libs.json._
 import play.api.Logger
 import play.api.mvc._
-
 import scala.concurrent.Future
 import scala.collection.mutable.ListBuffer
 import formats.json.CommentSubmissionFormats._
-
+import formats.json.LabelFormat
 import java.time.Instant
 
 /**
@@ -259,7 +258,7 @@ class ValidationTaskController @Inject() (implicit val env: Environment[User, Se
     */
   def getLabelListForValidation(userId: UUID, n: Int, labelTypeId: Int): JsValue = {
     val labelMetadata: Seq[LabelValidationMetadata] = LabelTable.retrieveLabelListForValidation(userId, n, labelTypeId, skippedLabelId = None)
-    val labelMetadataJsonSeq: Seq[JsObject] = labelMetadata.map(LabelTable.validationLabelMetadataToJson)
+    val labelMetadataJsonSeq: Seq[JsObject] = labelMetadata.map(LabelFormat.validationLabelMetadataToJson)
     val labelMetadataJson : JsValue = Json.toJson(labelMetadataJsonSeq)
     labelMetadataJson
   }
@@ -288,7 +287,7 @@ class ValidationTaskController @Inject() (implicit val env: Environment[User, Se
 
           val userId: UUID = request.identity.get.userId
           val labelMetadata: LabelValidationMetadata = LabelTable.retrieveLabelListForValidation(userId, n = 1, labelTypeId, Some(skippedLabelId)).head
-          LabelTable.validationLabelMetadataToJson(labelMetadata)
+          LabelFormat.validationLabelMetadataToJson(labelMetadata)
         }
         Future.successful(Ok(labelMetadataJson.head))
       }

app/formats/json/LabelFormat.scala

@@ -1,7 +1,8 @@
 package formats.json
 
+import controllers.helper.GoogleMapsHelper
+import models.label.LabelTable.{LabelMetadata, LabelMetadataUserDash, LabelValidationMetadata}
 import java.sql.Timestamp
-
 import models.label._
 import play.api.libs.json._
 import play.api.libs.functional.syntax._
@@ -52,4 +53,102 @@ object LabelFormat {
       (__ \ "photographer_heading").write[Float] and
       (__ \ "photographer_pitch").write[Float]
   )(unlift(LabelTable.LabelCVMetadata.unapply _))
+
+  def validationLabelMetadataToJson(labelMetadata: LabelValidationMetadata): JsObject = {
+    Json.obj(
+      "label_id" -> labelMetadata.labelId,
+      "label_type" -> labelMetadata.labelType,
+      "gsv_panorama_id" -> labelMetadata.gsvPanoramaId,
+      "image_date" -> labelMetadata.imageDate,
+      "label_timestamp" -> labelMetadata.timestamp,
+      "heading" -> labelMetadata.heading,
+      "pitch" -> labelMetadata.pitch,
+      "zoom" -> labelMetadata.zoom,
+      "canvas_x" -> labelMetadata.canvasX,
+      "canvas_y" -> labelMetadata.canvasY,
+      "canvas_width" -> labelMetadata.canvasWidth,
+      "canvas_height" -> labelMetadata.canvasHeight,
+      "severity" -> labelMetadata.severity,
+      "temporary" -> labelMetadata.temporary,
+      "description" -> labelMetadata.description,
+      "user_validation" -> labelMetadata.userValidation.map(LabelValidationTable.validationOptions.get),
+      "tags" -> labelMetadata.tags
+    )
+  }
+
+  def labelMetadataWithValidationToJsonAdmin(labelMetadata: LabelMetadata): JsObject = {
+    Json.obj(
+      "label_id" -> labelMetadata.labelId,
+      "gsv_panorama_id" -> labelMetadata.gsvPanoramaId,
+      "tutorial" -> labelMetadata.tutorial,
+      "image_date" -> labelMetadata.imageDate,
+      "heading" -> labelMetadata.heading,
+      "pitch" -> labelMetadata.pitch,
+      "zoom" -> labelMetadata.zoom,
+      "canvas_x" -> labelMetadata.canvasXY._1,
+      "canvas_y" -> labelMetadata.canvasXY._2,
+      "canvas_width" -> labelMetadata.canvasWidth,
+      "canvas_height" -> labelMetadata.canvasHeight,
+      "audit_task_id" -> labelMetadata.auditTaskId,
+      "user_id" -> labelMetadata.userId,
+      "username" -> labelMetadata.username,
+      "timestamp" -> labelMetadata.timestamp,
+      "label_type_key" -> labelMetadata.labelTypeKey,
+      "label_type_value" -> labelMetadata.labelTypeValue,
+      "severity" -> labelMetadata.severity,
+      "temporary" -> labelMetadata.temporary,
+      "description" -> labelMetadata.description,
+      "user_validation" -> labelMetadata.userValidation.map(LabelValidationTable.validationOptions.get),
+      "num_agree" -> labelMetadata.validations("agree"),
+      "num_disagree" -> labelMetadata.validations("disagree"),
+      "num_notsure" -> labelMetadata.validations("notsure"),
+      "tags" -> labelMetadata.tags
+    )
+  }
+
+  // Has the label metadata excluding username, user_id, and audit_task_id.
+  def labelMetadataWithValidationToJson(labelMetadata: LabelMetadata): JsObject = {
+    Json.obj(
+      "label_id" -> labelMetadata.labelId,
+      "gsv_panorama_id" -> labelMetadata.gsvPanoramaId,
+      "tutorial" -> labelMetadata.tutorial,
+      "image_date" -> labelMetadata.imageDate,
+      "heading" -> labelMetadata.heading,
+      "pitch" -> labelMetadata.pitch,
+      "zoom" -> labelMetadata.zoom,
+      "canvas_x" -> labelMetadata.canvasXY._1,
+      "canvas_y" -> labelMetadata.canvasXY._2,
+      "canvas_width" -> labelMetadata.canvasWidth,
+      "canvas_height" -> labelMetadata.canvasHeight,
+      "timestamp" -> labelMetadata.timestamp,
+      "label_type_key" -> labelMetadata.labelTypeKey,
+      "label_type_value" -> labelMetadata.labelTypeValue,
+      "severity" -> labelMetadata.severity,
+      "temporary" -> labelMetadata.temporary,
+      "description" -> labelMetadata.description,
+      "user_validation" -> labelMetadata.userValidation.map(LabelValidationTable.validationOptions.get),
+      "num_agree" -> labelMetadata.validations("agree"),
+      "num_disagree" -> labelMetadata.validations("disagree"),
+      "num_notsure" -> labelMetadata.validations("notsure"),
+      "tags" -> labelMetadata.tags
+    )
+  }
+
+  def labelMetadataUserDashToJson(label: LabelMetadataUserDash): JsObject = {
+    Json.obj(
+      "label_id" -> label.labelId,
+      "gsv_panorama_id" -> label.gsvPanoramaId,
+      "heading" -> label.heading,
+      "pitch" -> label.pitch,
+      "zoom" -> label.zoom,
+      "canvas_x" -> label.canvasX,
+      "canvas_y" -> label.canvasY,
+      "canvas_width" -> label.canvasWidth,
+      "canvas_height" -> label.canvasHeight,
+      "label_type" -> label.labelType,
+      "time_validated" -> label.timeValidated,
+      "validator_comment" -> label.validatorComment,
+      "image_url" -> GoogleMapsHelper.getImageUrl(label.gsvPanoramaId, label.canvasWidth, label.canvasHeight, label.heading, label.pitch, label.zoom)
+    )
+  }
 }

app/models/audit/AuditTaskCommentTable.scala

@@ -4,6 +4,7 @@ import java.sql.Timestamp
 import models.daos.slick.DBTableDefinitions.UserTable
 import models.mission.{Mission, MissionTable}
 import models.utils.MyPostgresDriver.simple._
+import models.utils.CommonUtils.ordered
 import models.validation.ValidationTaskCommentTable
 import play.api.Play.current
 import scala.slick.lifted.ForeignKeyQuery
@@ -80,10 +81,4 @@ object AuditTaskCommentTable {
 
     (auditComments ++ validationComments).sortBy(_.timestamp).reverse.take(n)
   }
-
-  // Defining ordered method for Timestamp so they can be used in sortBy.
-  // https://stackoverflow.com/questions/29985911/sort-scala-arraybuffer-of-timestamp
-  implicit def ordered: Ordering[Timestamp] = new Ordering[Timestamp] {
-    def compare(x: Timestamp, y: Timestamp): Int = x compareTo y
-  }
 }

app/models/daos/slick/UserDAOSlick.scala

@@ -9,7 +9,7 @@ import models.daos.UserDAO
 import models.label.LabelValidationTable
 import models.label.LabelTable
 import models.mission.MissionTable
-import models.user.{RoleTable, WebpageActivityTable}
+import models.user.{RoleTable, WebpageActivityTable, UserStatTable}
 import models.user.{UserRoleTable, User}
 import play.api.db.slick._
 import play.api.db.slick.Config.driver.simple._
@@ -22,7 +22,7 @@ case class UserStatsForAdminPage(userId: String, username: String, email: String
                                  signUpTime: Option[Timestamp], lastSignInTime: Option[Timestamp], signInCount: Int,
                                  completedMissions: Int, completedAudits: Int, labels: Int, ownValidated: Int,
                                  ownValidatedAgreedPct: Double, ownValidatedDisagreedPct: Double, ownValidatedNotsurePct: Double,
-                                 othersValidated: Int, othersValidatedAgreedPct: Double)
+                                 othersValidated: Int, othersValidatedAgreedPct: Double, highQuality: Boolean)
 
 class UserDAOSlick extends UserDAO {
   /**
@@ -509,8 +509,11 @@ object UserDAOSlick {
       (valCount._1, (valCount._2, valCount._3))
     }.toMap
 
+    val userHighQuality =
+      UserStatTable.userStats.map { x => (x.userId, x.highQuality) }.list.toMap
+
     // Now left join them all together and put into UserStatsForAdminPage objects.
-    usersMinusAnonUsersWithNoLabels.list.map{ u =>
+    usersMinusAnonUsersWithNoLabels.list.map { u =>
       val ownValidatedCounts = validatedCounts.getOrElse(u.userId, ("", 0, 0, 0, 0))
       val ownValidatedTotal = ownValidatedCounts._2
       val ownValidatedAgreed = ownValidatedCounts._3
@@ -550,7 +553,8 @@ object UserDAOSlick {
         ownValidatedDisagreedPct,
         ownValidatedNotsurePct,
         otherValidatedTotal,
-        otherValidatedAgreedPct
+        otherValidatedAgreedPct,
+        userHighQuality.getOrElse(u.userId, true)
       )
     }
   }