Fix up activate/deactivate user commands

README.md

@@ -99,4 +99,16 @@ If you don't want to checkout the example quite yet, here are some hypothetical
 
     {% if current_user.has_role('admin') %}
     <a href="{{ url_for('admin.index') }}">Admin Panel</a>
-    {$ endif %}
+    {$ endif %}
+    
+## Flask-Script Commands
+
+Flask-Security comes packed with a few Flask-Script commands. They are:
+
+* `flask.ext.security.script.CreateUserCommand`
+* `flask.ext.security.script.AddRoleCommand`
+* `flask.ext.security.script.RemoveRoleCommand`
+* `flask.ext.security.script.DeactivateUserCommand`
+* `flask.ext.security.script.ActivateUserCommand`
+
+Register these on your script manager for pure convenience.

example/manage.py

@@ -8,12 +8,14 @@ sys.path.insert(0, os.getcwd())
 from example import app
 from flask.ext.script import Manager
 from flask.ext.security.script import (CreateUserCommand , AddRoleCommand,
-                                       RemoveRoleCommand)
+        RemoveRoleCommand, ActivateUserCommand, DeactivateUserCommand)
 
 manager = Manager(app.create_sqlalchemy_app())
 manager.add_command('create_user', CreateUserCommand())
 manager.add_command('add_role', AddRoleCommand())
 manager.add_command('remove_role', RemoveRoleCommand())
+manager.add_command('deactivate_user', DeactivateUserCommand())
+manager.add_command('activate_user', ActivateUserCommand())
 
 if __name__ == "__main__":
     manager.run()

flask_security/datastore/__init__.py

@@ -6,6 +6,10 @@ class UserDatastore(object):
     """Abstracted user datastore. Always extend this and implement
     missing methods"""
     
+    def _save_model(self, model, **kwargs):
+        raise NotImplementedError(
+            "User datastore does not implement _save_model method")
+    
     def _do_with_id(self, id):
         raise NotImplementedError(
             "User datastore does not implement _do_with_id method")
@@ -30,6 +34,20 @@ class UserDatastore(object):
             user.roles.remove(role)
         return user
     
+    def _do_toggle_active(self, user, active=None):
+        user = self.find_user(user)
+        if active is None:
+            user.active = not user.active
+        elif active != user.active:
+            user.active = active
+        return user
+    
+    def _do_deactive_user(self, user):
+        return self._do_toggle_active(user, False)
+    
+    def _do_active_user(self, user):
+        return self._do_toggle_active(user, True)
+    
     def _prepare_role_modify_args(self, user, role):
         if isinstance(user, security.User):
             user = user.username or user.email
@@ -92,18 +110,22 @@ class UserDatastore(object):
         if role: return role
         raise security.RoleNotFoundError()
     
-    def create_role(self, **kwargs):
-        raise NotImplementedError(
-            "User datastore does not implement create_role method")
-        
-    def create_user(self, **kwargs):
-        raise NotImplementedError(
-            "User datastore does not implement create_user method")
-        
+    def create_role(self, commit=True, **kwargs):
+        role = security.Role(**self._prepare_create_role_args(kwargs))
+        return self._save_model(role)
+    
+    def create_user(self, commit=True, **kwargs):
+        user = security.User(**self._prepare_create_user_args(kwargs))
+        return self._save_model(user)
+    
     def add_role_to_user(self, user, role):
-        raise NotImplementedError(
-            "User datastore does not implement add_role_to_user method")
-        
-    def remove_role_from_user(self, user, role):
-        raise NotImplementedError(
-            "User datastore does not implement remove_role_from_user method")
+        return self._save_model(self._do_add_role(user, role))
+    
+    def remove_role_from_user(self, user, role, commit=True):
+        return self._save_model(self._do_remove_role(user, role))
+    
+    def deactivate_user(self, user):
+        return self._save_model(self._do_deactive_user(user))
+    
+    def activate_user(self, user, commit=True):
+        return self._save_model(self._do_active_user(user))

flask_security/datastore/mongoengine.py

@@ -25,6 +25,10 @@ class MongoEngineUserDatastore(UserDatastore):
             modified_at = db.DateTimeField()
             
         return User, Role
+    
+    def _save_model(self, model):
+        model.save()
+        return model
         
     def _do_with_id(self, id):
         try: return security.User.objects.get(id=id)
@@ -36,18 +40,4 @@ class MongoEngineUserDatastore(UserDatastore):
     
     def _do_find_role(self, role):
         return security.Role.objects(name=role).first()
-    
-    def create_role(self, **kwargs):
-        role = security.Role(**self._prepare_create_role_args(kwargs))
-        role.save()
-        return role
-    
-    def create_user(self, **kwargs):
-        user = security.User(**self._prepare_create_user_args(kwargs))
-        user.save()
-        return user
-    
-    def add_role(self, user, role):
-        user = self._do_add_role(user, role)
-        user.save()
-        return user
+    

flask_security/datastore/sqlalchemy.py

@@ -49,9 +49,9 @@ class SQLAlchemyUserDatastore(UserDatastore):
             
         return User, Role
     
-    def _save_model(self, model, commit=True):
+    def _save_model(self, model):
         self.db.session.add(model)
-        if commit: self.db.session.commit()
+        self.db.session.commit()
         return model
     
     def _do_with_id(self, id):
@@ -63,20 +63,4 @@ class SQLAlchemyUserDatastore(UserDatastore):
     
     def _do_find_role(self, role):
         return security.Role.query.filter_by(name=role).first()
-    
-    def create_role(self, commit=True, **kwargs):
-        role = security.Role(**self._prepare_create_role_args(kwargs))
-        return self._save_model(role, commit)
-    
-    def create_user(self, commit=True, **kwargs):
-        user = security.User(**self._prepare_create_user_args(kwargs))
-        return self._save_model(user, commit)
-    
-    def add_role_to_user(self, user, role, commit=True):
-        user = self._do_add_role(user, role)
-        return self._save_model(user, commit)
-    
-    def remove_role_from_user(self, user, role, commit=True):
-        user = self._do_remove_role(user, role)
-        return self._save_model(user, commit)
     

flask_security/script.py

@@ -7,6 +7,7 @@ from flask.ext.security import (UserCreationError, UserNotFoundError,
 def pprint(obj):
     print json.dumps(obj, sort_keys=True, indent=4)
 
+
 class CreateUserCommand(Command):
     """Create a user"""
     
@@ -33,38 +34,45 @@ class CreateUserCommand(Command):
         kwargs['password'] = '****'
         pprint(kwargs)
 
-        
-class AddRoleCommand(Command):
-    """Add a role to a user"""
-    
+
+class _RoleCommand(Command):  
     option_list = (
         Option('-u', '--user', dest='user_identifier'),
         Option('-r', '--role', dest='role_name'),
     )
+
+
+class AddRoleCommand(_RoleCommand):
+    """Add a role to a user"""
     
     def run(self, user_identifier, role_name):
         user_datastore.add_role_to_user(user_identifier, role_name)
         print "Role '%s' added to user '%s' successfully" % (role_name, user_identifier)
-        
-class RemoveRoleCommand(Command):
+
+
+class RemoveRoleCommand(_RoleCommand):
     """Add a role to a user"""
     
-    option_list = (
-        Option('-u', '--user', dest='user_identifier'),
-        Option('-r', '--role', dest='role_name'),
-    )
-    
     def run(self, user_identifier, role_name):
         user_datastore.remove_role_from_user(user_identifier, role_name)
         print "Role '%s' removed from user '%s' successfully" % (role_name, user_identifier)
-        
-            
-class DeactiveUserCommand(Command):
-    """Deactive a user"""
-        
+
+    
+class _ToggleActiveCommand(Command):
     option_list = (
         Option('-u', '--user', dest='user_identifier'),
     )
     
+class DeactivateUserCommand(_ToggleActiveCommand):
+    """Deactive a user"""
+    
     def run(self, user_identifier):
-        user_datastore.deactive_user(user_identifier)
+        user_datastore.deactivate_user(user_identifier)
+        print "User '%s' has been deactivated" % user_identifier
+        
+class ActivateUserCommand(_ToggleActiveCommand):
+    """Deactive a user"""
+    
+    def run(self, user_identifier):
+        user_datastore.activate_user(user_identifier)
+        print "User '%s' has been activated" % user_identifier