Send inactive users notification (#552)

* Add functionality to query notebook apps and count them in the get apps endpoint

* add the send inactive user mail reminder  endpoint

* send the inactive users an email notification

Author: CHRISTOPHERKADOGO

api_docs.yml

@@ -776,35 +776,84 @@ paths:
         500:
           description: "Internal Server Error"
   "/users/inactive_user_reminder":
-    post:
+    get:
       tags:
         - inactive_user_reminder
+      summary: "Get inactive users with pagination and optional time filtering"
+      consumes:
+        - application/json
+      produces:
+        - application/json
       parameters:
         - in: header
           name: Authorization
           required: true
           type: string
           description: "Bearer [token]"
+        - in: query
+          name: page
+          required: false
+          type: integer
+          description: "Page number (default: 1)"
+        - in: query
+          name: per_page
+          required: false
+          type: integer
+          description: "Results per page (default: 10)"
         - in: query
           name: value
-          required: true
+          required: false
           type: integer
           description: "Numeric value for the time period"
         - in: query
           name: unit
-          required: true
+          required: false
           type: string
           enum: [hours, days, months]
           description: "Unit of time (hours/days/months)"
+      responses:
+        200:
+          description: "Success - Returns paginated list of inactive users"
+        400:
+          description: "Bad request - Invalid parameters"
+        401:
+          description: "Unauthorized - Admin access required"
+        500:
+          description: "Internal Server Error"
+    post:
+      tags:
+        - inactive_user_reminder
+      summary: "Send reminder emails to inactive users"
+      consumes:
+        - application/json
       produces:
         - application/json
+      parameters:
+        - in: header
+          name: Authorization
+          required: true
+          description: "Bearer [token]"
+          type: string
+        - in: body
+          name: inactive_user_reminder
+          schema:
+            type: object
+            required:
+              - inactive_users
+            properties:
+              inactive_users:
+                type: array
+                items:
+                  type: string
+                  description: "User UUID"
       responses:
-        200:
-          description: "Success"
+        201:
+          description: "Success - Emails sent"
         400:
           description: "Bad request - Invalid parameters"
         500:
           description: "Internal Server Error"
+
   "/clusters":
     post:
       tags:

app/controllers/project.py

@@ -180,7 +180,6 @@ def post(self):
                          description='Created project Successfully',
                          a_project=project.id,
                          a_cluster_id=cluster_id,
-
                          )
 
             return dict(status='success', data=dict(project=new_project_data)), 201
@@ -637,20 +636,20 @@ def get(self, user_id):
             }
 
         user_projects, errors = project_schema.dumps(projects)
- 
+
         pinned_projects, errs = project_schema.dumps(pinned_projects)
 
         parsed_pinned_projects = json.loads(pinned_projects)
 
         if errors or errs:
             return dict(status='fail', message='Internal server error'), 500
-
         return dict(
             status='success',
             data=dict(
                 pagination={**pagination_data,
                             'pinned_count': len(parsed_pinned_projects)},
                 pinned=parsed_pinned_projects,
+
                 projects=json.loads(user_projects),
             )
         ), 200

app/controllers/users.py

@@ -1340,69 +1340,118 @@ def get(self, user_id):
 
 class SendInactiveUserMailReminder(Resource):
     @admin_required
-    def post(self):
+    def get(self):
+        user_schema = UserSchema(many=True)
+        page = request.args.get('page', 1, type=int)
+        per_page = request.args.get('per_page', 10, type=int)
 
-        parser = reqparse.RequestParser()
-        parser.add_argument('value', type=int, required=True, 
-                          help='Time period value is required')
-        parser.add_argument('unit', type=str, required=True, 
-                          choices=('hours', 'days', 'months'),
-                          help='Time unit must be hours, days, or months')
+        value = request.args.get('value', type=int)
+        unit = request.args.get('unit')
 
-        args = parser.parse_args()
-        value = args['value']
-        unit = args['unit'].lower()
+        query = User.query.filter(
+            User.verified == True,
+            User.disabled == False,
+            User.admin_disabled == False
+        )
+ 
+        if value is not None and unit is not None:
+            unit = unit.lower()
+            if unit not in ('hours', 'days', 'months'):
+                return dict(status='fail', message="Unit must be hours, days, or months"), 400
+
+            now = datetime.now()
+            if unit == 'hours':
+                lower_threshold = now - timedelta(hours=value)
+                upper_threshold = now - timedelta(hours=value-1)
+            elif unit == 'days':
+                lower_threshold = now - timedelta(days=value)
+                upper_threshold = now - timedelta(days=value-1)
+            else: 
+                lower_threshold = now - timedelta(days=value * 30)
+                upper_threshold = now - timedelta(days=(value-1) * 30)
+
+            query = query.filter(
+                User.last_seen <= upper_threshold,
+                User.last_seen > lower_threshold
+            )
 
-        now = datetime.now()
-        if unit == 'hours':
-            lower_threshold = now - timedelta(hours=value)
-            upper_threshold = now - timedelta(hours=value-1)
-        elif unit == 'days':
-            lower_threshold = now - timedelta(days=value)
-            upper_threshold = now - timedelta(days=value-1)
-        else:  
-            lower_threshold = now - timedelta(days=value * 30)
-            upper_threshold = now - timedelta(days=(value-1) * 30) 
+        query = query.order_by(User.last_seen.desc())
+
+        paginated = query.paginate(page=page, per_page=per_page, error_out=False)
+        users = paginated.items
+
+        pagination = {
+            'total': paginated.total,
+            'pages': paginated.pages,
+            'page': paginated.page,
+            'per_page': paginated.per_page,
+            'next': paginated.next_num,
+            'prev': paginated.prev_num
+        }
+        users_data = user_schema.dump(users)
 
-       
-        inactive_users = User.query.filter(
-            User.last_seen <= upper_threshold,
-            User.last_seen > lower_threshold,
+        return dict(
+            status='success',
+            message=f'Found {paginated.total} inactive users',
+            data=dict(pagination=pagination, users=users_data)
+        ), 200
+    
+    @admin_required
+    def post(self):
+        user_data = request.get_json()
+    
+        if not user_data or 'inactive_users' not in user_data:
+            return dict(status='fail', message='List of user UUIDs not provided'), 400
 
-            User.verified == True,  
-            User.disabled == False, 
-            User.admin_disabled == False  
-        ).all()
+        inactive_users = user_data['inactive_users']
+        
+        if not isinstance(inactive_users, list):
+            return dict(status='fail', message='Invalid format for inactive users'), 400
 
-        already_notified = set()  
-
         emails_sent = 0
         errors = []
+        now = datetime.now()
 
-        for user in inactive_users:
+        for user_uuid in inactive_users:
             try:
-                success = send_inactive_notification_to_user(
-                    email=user.email,
-                    name=user.name,
-                    app=current_app._get_current_object(),
-                    template="user/inactive_user_reminder.html",
-                    subject="Checking In: Your Crane Cloud Account",
-                    date=now.strftime("%m/%d/%Y"),
-                    is_success_template=True
-                )
-                
-                if success:
-                    emails_sent += 1
-                    already_notified.add(user.email)
+                user = User.query.get(user_uuid)
+                if not user:
+                    errors.append(f"User with UUID {user_uuid} not found")
+                    continue
+
+                if user.last_reminder_sent is None or user.last_reminder_sent < (now - timedelta(days=30)):
+                    success = send_inactive_notification_to_user(
+                        email=user.email,
+                        name=user.name,
+                        app=current_app._get_current_object(),
+                        template="user/inactive_user_reminder.html",
+                        subject="We miss you at Crane Cloud",
+                        date=now.strftime("%m/%d/%Y"),
+                        is_success_template=True
+                    )
+                    
+                    if success:
+                        emails_sent += 1
+                        user.last_reminder_sent = now
+                        db.session.add(user)
+                    else:
+                        errors.append(f"Failed to send email to {user.email}")
                 else:
-                    errors.append(f"Failed to send email to {user.email}")
+                    errors.append(f"Email reminder already sent to {user.email} within the last 30 days")
 
             except Exception as e:
-                errors.append(f"Error sending email to {user.email}: {str(e)}")
-        
+                errors.append(f"Error processing user {user_uuid}: {str(e)}")
+
+        try:
+            db.session.commit()
+        except Exception as e:
+            db.session.rollback()
+            return dict(status='fail', message=f'Database error: {str(e)}'), 500
+            
         return dict(
             status='success',
             message=f'Successfully sent {emails_sent} reminder emails',
             total_users_processed=len(inactive_users),
             errors=errors if errors else None
-        ), 200
+        ), 201 
+

app/models/user.py

@@ -40,6 +40,7 @@ class User(ModelMixin):
     verified = db.Column(db.Boolean, nullable=False, default=False)
     date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
     last_seen = db.Column(db.DateTime, default=db.func.current_timestamp())
+    last_reminder_sent = db.Column(db.DateTime, default=db.func.current_timestamp())
     projects = db.relationship('Project', backref='owner', lazy=True)
     organisation = db.Column(db.String(256), nullable=True, default="")
     other_projects = db.relationship('ProjectUser', back_populates='user')