Release 1.5.3 (#116)

* correct totalRecords count since it could be -1 (when firewhennotzero not set)

* correctly handle unsubscribe myannotation with token (#99)

correctly handle unsubscribe myannotation with token

* Updated email template, set pageSize=300 for records query

* updated email template
* explicitly set page size so we can get all records in one call

* release 1.5.2 (#104)

* 1.5.3-SNAPSHOT

* create user when addMyAnnotation is called by user not exists (#107)

* create user when addMyAnnotation is called by user not exists

* changed add/delete myannotaion to subscribe/unsubscribe myannotaion. (#109)

* run a myannotation query after it's added (#112)

* need to run a myannotation query after it's added
* print error witg log.error() instead of println

* if user subscribed to 'My Annotation' and changes frequency, we need to trigger a query for 'my annotation' (#114)

* update 'my annotation' QueryResult instead of delete + add when frequency changes

* release 1.5.3

Co-authored-by: Rita <rita.chen@csiro.au>

Author: alexhuang091

build.gradle

@@ -28,7 +28,7 @@ plugins {
     id "com.gorylenko.gradle-git-properties" version "1.4.17"
 }
 
-version "1.5.2"
+version "1.5.3"
 group "au.org.ala"
 
 apply plugin:"eclipse"

grails-app/controllers/au/org/ala/alerts/NotificationController.groovy

@@ -43,24 +43,24 @@ class NotificationController {
         }
     }
 
-    def addMyAnnotation = {
+    def subscribeMyAnnotation = {
         def user = getUser()
         try {
-            notificationService.addMyAnnotation(user)
+            notificationService.subscribeMyAnnotation(user)
             render ([success: true] as JSON)
         } catch (ignored) {
-            response.sendError(HttpStatus.SC_INTERNAL_SERVER_ERROR, "failed to add 'my annotation' alert for user " + user?.getUserId())
+            response.sendError(HttpStatus.SC_INTERNAL_SERVER_ERROR, "failed to subscribe to 'my annotation' alert for user " + user?.getUserId())
         }
 
     }
 
-    def deleteMyAnnotation = {
+    def unsubscribeMyAnnotation = {
         def user = getUser()
         try {
-            notificationService.deleteMyAnnotation(user)
+            notificationService.unsubscribeMyAnnotation(user)
             render ([success: true] as JSON)
         } catch (ignored) {
-            response.sendError(HttpStatus.SC_INTERNAL_SERVER_ERROR, "failed to delete 'my annotation' alert for user " + user?.getUserId())
+            response.sendError(HttpStatus.SC_INTERNAL_SERVER_ERROR, "failed to unsubscribe 'my annotation' alert for user " + user?.getUserId())
         }
     }
 
@@ -96,8 +96,7 @@ class NotificationController {
     def changeFrequency = {
         def user = userService.getUser()
         log.debug("Changing frequency to: " + params.frequency + " for user ${user}")
-        user.frequency = Frequency.findByName(params.frequency)
-        user.save(flush: true)
+        notificationService.updateFrequency(user, params.frequency)
         return null
     }
 

grails-app/controllers/au/org/ala/alerts/UnsubscribeController.groovy

@@ -47,7 +47,7 @@ class UnsubscribeController {
                 // for my annotation, we also need to delete the query and query result
                 String myAnnotationQueryPath = queryService.constructMyAnnotationQueryPath(userAndNotifications.user.userId)
                 if (userAndNotifications.notifications.any { it.query.queryPath == myAnnotationQueryPath }) {
-                    notificationService.deleteMyAnnotation(userAndNotifications.user)
+                    notificationService.unsubscribeMyAnnotation(userAndNotifications.user)
                 }
 
                 render view: "unsubscribed"

grails-app/controllers/au/org/ala/alerts/WebserviceController.groovy

@@ -373,7 +373,7 @@ class WebserviceController {
             response.status = HttpStatus.SC_BAD_REQUEST
             response.sendError(HttpStatus.SC_BAD_REQUEST, "userId is a required parameter")
         } else {
-            def user = User.findByUserId(params.userId)
+            def user = userService.getUserById(params.userId)
             if (!user) {
                 Map userDetails = ["userId": params.userId, "email": params.email, "userDisplayName": params.firstName + " " + params.lastName]
                 user = userService.getUser(userDetails)
@@ -401,41 +401,41 @@ class WebserviceController {
     def getUserAlertsWS() {
         User user = userService.getUserById(params.userId)
         if (user == null) {
-            response.status = 404
+            response.status = HttpStatus.SC_NOT_FOUND
             render ([error : "can't find a user with userId " + params.userId] as JSON)
         } else {
             render (userService.getUserAlertsConfig(user) as JSON)
         }
     }
 
     @RequireApiKey
-    def addMyAnnotationAlertWS() {
-        User user = userService.getUserById(params.userId)
+    def subscribeMyAnnotationWS() {
+        User user = userService.getUser((String)params.userId)
         if (user == null) {
-            response.status = 404
+            response.status = HttpStatus.SC_NOT_FOUND
             render ([error : "can't find a user with userId " + params.userId] as JSON)
         } else {
             try {
-                notificationService.addMyAnnotation(user)
+                notificationService.subscribeMyAnnotation(user)
                 render([success: true] as JSON)
             } catch (ignored) {
-                render "failed to add my annotation for user " + params.userId, contentType: 'text/plain', status: 500
+                render text: "failed to subscribe to my annotation for user " + params.userId, contentType: 'text/plain', status: 500
             }
         }
     }
 
     @RequireApiKey
-    def deleteMyAnnotationAlertWS() {
+    def unsubscribeMyAnnotationWS() {
         User user = userService.getUserById(params.userId)
         if (user == null) {
-            response.status = 404
+            response.status = HttpStatus.SC_NOT_FOUND
             render ([error : "can't find a user with userId " + params.userId] as JSON)
         } else {
             try {
-                notificationService.deleteMyAnnotation(user)
+                notificationService.unsubscribeMyAnnotation(user)
                 render([success: true] as JSON)
             } catch (ignored) {
-                render "failed to delete my annotation for user " + params.userId, contentType: 'text/plain', status: 500
+                render text: "failed to unsubscribe my annotation for user " + params.userId, contentType: 'text/plain', status: 500
             }
         }
     }

grails-app/init/au/org/ala/alerts/BootStrap.groovy

@@ -14,11 +14,11 @@ class BootStrap {
         // if my annotation feature turned on, add url mapping to handle add/remove alert requests
         if (grailsApplication.config.getProperty('myannotation.enabled', Boolean, false)) {
             grailsUrlMappingsHolder.addMappings({
-                "/admin/user/addMyAnnotation/"(controller: 'notification', action: 'addMyAnnotation')
-                "/admin/user/deleteMyAnnotation/"(controller: 'notification', action: 'deleteMyAnnotation')
+                "/admin/user/subscribeMyAnnotation/"(controller: 'notification', action: 'subscribeMyAnnotation')
+                "/admin/user/unsubscribeMyAnnotation/"(controller: 'notification', action: 'unsubscribeMyAnnotation')
 
-                "/api/alerts/user/$userId/addMyAnnotationAlert"(controller: 'webservice', action: [POST: 'addMyAnnotationAlertWS'])
-                "/api/alerts/user/$userId/deleteMyAnnotationAlert"(controller: 'webservice', action: [POST: 'deleteMyAnnotationAlertWS'])
+                "/api/alerts/user/$userId/subscribeMyAnnotation"(controller: 'webservice', action: [POST: 'subscribeMyAnnotationWS'])
+                "/api/alerts/user/$userId/unsubscribeMyAnnotation"(controller: 'webservice', action: [POST: 'unsubscribeMyAnnotationWS'])
             })
         }
 

grails-app/services/au/org/ala/alerts/NotificationService.groovy

@@ -32,7 +32,7 @@ class NotificationService {
      * @param frequency
      * @return
      */
-    boolean checkStatus(Query query, Frequency frequency) {
+    boolean checkStatus(Query query, Frequency frequency, boolean flushResult = false) {
 
         QueryResult qr = getQueryResult(query, frequency)
 
@@ -68,7 +68,7 @@ class NotificationService {
                 qr.lastChanged = new Date()
             }
 
-            qr.save(true)
+            qr.save(validate: true, flush: flushResult)
             qr.hasChanged
         } catch (Exception e){
             log.error("[QUERY " + query.id + "] There was a problem checking the URL: " + urlString, e)
@@ -581,12 +581,19 @@ class NotificationService {
         }
     }
 
-    def addMyAnnotation(User user) {
+    def subscribeMyAnnotation(User user) {
         Query myAnnotationQuery = queryService.createMyAnnotationQuery(user?.userId)
-        queryService.createQueryForUserIfNotExists(myAnnotationQuery, user, false)
+        boolean newQueryCreated = queryService.createQueryForUserIfNotExists(myAnnotationQuery, user, false)
+        // trigger a check for this query to generate query result
+        // user could call multiple subscribeMyAnnotation, only the first one will create a new query so it's
+        // triggered only once.
+        if (newQueryCreated) {
+            Query savedQuery = Query.findByBaseUrlAndQueryPath(myAnnotationQuery.baseUrl, myAnnotationQuery.queryPath)
+            checkStatus(savedQuery, user.frequency, true)
+        }
     }
 
-    def deleteMyAnnotation(User user) {
+    def unsubscribeMyAnnotation(User user) {
         String myAnnotationQueryPath = queryService.constructMyAnnotationQueryPath(user?.userId)
         Query retrievedQuery = Query.findByQueryPath(myAnnotationQueryPath)
 
@@ -607,4 +614,35 @@ class NotificationService {
             retrievedQuery.delete(flush: true)
         }
     }
+
+    // update user to new frequency
+    // there are some special work if user is subscribed to 'My Annotation' alert
+    def updateFrequency(User user, String newFrequency) {
+        def oldFrequency = user.frequency
+        user.frequency = Frequency.findByName(newFrequency)
+
+        String myAnnotationQueryPath = queryService.constructMyAnnotationQueryPath(user?.userId)
+        Query query = Query.findByQueryPath(myAnnotationQueryPath)
+
+        // my annotation generates alert(diff) by comparing QueryResult at 2 time points.
+        // first QueryResult will be inserted when user subscribes to my annotation
+        // every time user changes the frequency, we also need to create a new QueryResult
+        // here we update the frequency of existing QueryResult instead of delete old + create new for below reason
+        // suppose
+        // 1. we have an hourly QueryResult
+        // 2. some changes happened
+        // 3. user changes frequency to daily
+        // 4. if now we create a daily QueryResult which reflects current verifications status (at time position 4)
+        //  and is used to do diff, then changes in 2 will be lost. So we directly update existing hourly QueryResult to be daily
+        //  so next time scheduled daily task runs, it compares with status at time 1 so changes at time 2 will be captured
+        if (query) {
+            QueryResult qr = QueryResult.findByQueryAndFrequency(query, oldFrequency)
+            if (qr) {
+                qr.frequency = user.frequency
+                qr.save(flush: true)
+            }
+        }
+
+        user.save(flush: true)
+    }
 }

grails-app/services/au/org/ala/alerts/QueryService.groovy

@@ -88,12 +88,15 @@ class QueryService {
     toBeRemoved.size()
   }
 
-  def createQueryForUserIfNotExists(Query newQuery, User user, boolean setPropertyPath = true){
+  // return true if a new query is created, otherwise return false
+  boolean createQueryForUserIfNotExists(Query newQuery, User user, boolean setPropertyPath = true) {
+    boolean newQueryCreated = false
     //find the query
     Query retrievedQuery = Query.findByBaseUrlAndQueryPath(newQuery.baseUrl, newQuery.queryPath)
     if (retrievedQuery == null) {
       try {
         newQuery = newQuery.save(true)
+        newQueryCreated = true
         if (setPropertyPath) {
           new PropertyPath([name: "totalRecords", jsonPath: "totalRecords", query: newQuery, fireWhenNotZero: true]).save(true)
           new PropertyPath([name: "last_loaded_record", jsonPath: "occurrences[0].rowKey", query: newQuery]).save(true)
@@ -112,10 +115,12 @@ class QueryService {
       Notification n = new Notification([query: newQuery, user: user])
       n.save(true)
 
-      if(n.hasErrors()){
-        n.errors.allErrors.each { e -> println(e)}
+      if (n.hasErrors()) {
+        n.errors.allErrors.each { e -> log.error(e) }
       }
     }
+
+    newQueryCreated
   }
 
   /**

grails-app/services/au/org/ala/alerts/UserService.groovy

@@ -151,6 +151,27 @@ class UserService {
         user
     }
 
+    // get user via userId, if not found in database create one
+    User getUser(String userId) {
+        if (!userId) {
+            return null
+        }
+
+        // try to find in User database
+        User user = User.findByUserId(userId)
+        // if not in database try to create it
+        if (user == null) {
+            UserDetails userDetails = authService.getUserForUserId(userId)
+            if (userDetails?.userId && userDetails?.email) {
+                log.debug "User is not in user table - creating new record for " + userDetails
+                user = new User([email: userDetails.email, userId: userDetails.userId, locked: userDetails.locked, frequency: Frequency.findByName("weekly")])
+                user.save(flush:true, failOnError: true)
+            }
+        }
+
+        user
+    }
+
     User getUserById(userId) {
         User.findByUserId(userId)
     }

grails-app/views/notification/myAlerts.gsp

@@ -143,8 +143,8 @@
           var deleteMyAlertUrl = 'deleteMyAlert/';
           var deleteMyAlertWRUrl ='deleteMyAlertWR/';
 
-          var addMyAnnotationUrl = 'addMyAnnotation/'
-          var deleteMyAnnotationUrl = 'deleteMyAnnotation/'
+          var subscribeMyAnnotationUrl = 'subscribeMyAnnotation/'
+          var unsubscribeMyAnnotationUrl = 'unsubscribeMyAnnotation/'
 
           $(document).ready( function(){
 
@@ -177,7 +177,7 @@
 
                           var url = '';
                           if ($(this).attr('data-type') === 'myannotation') {
-                              url = (state ? addMyAnnotationUrl : deleteMyAnnotationUrl) + '?userId=${userId}';
+                              url = (state ? subscribeMyAnnotationUrl : unsubscribeMyAnnotationUrl) + '?userId=${userId}';
                           } else {
                               url = (state ? addMyAlertUrl : deleteMyAlertUrl) + $(this).attr('id') + '?userId=${userId}';
                           }

src/test/groovy/au/org/ala/alerts/UnsubscribeControllerSpec.groovy

@@ -315,7 +315,7 @@ class UnsubscribeControllerSpec extends Specification {
 
         then:
         log.info "token = ${params.token}"
-        1 * controller.notificationService.deleteMyAnnotation(user)
+        1 * controller.notificationService.unsubscribeMyAnnotation(user)
         response.status == HttpStatus.SC_OK
     }