def groups(self, start=None, end=None, limit=25):
     from server.models.permission import Permission
     db = core.connect()
     if not start:
         start = [self.id]
     if not end:
         end = [self.id, {}]
     results = Permission.readable_by_user_and_created(db, limit=limit)
     return Permission.joinData(core.objects(results[start:end]))

    def inviteUser(self, aUser, otherUser):
        from server.models.permission import Permission
        from server.models.message import Message

        Permission.create(aUser.id, self.id, otherUser.id, 0)
        json = {
            "fromId": aUser.id,
            "toId": otherUser.id,
            "title": "%s invited you to join the group %s!" % (aUser.userName, self.longName),
            "text": "%s invited you to join the group %s!" % (aUser.userName, self.longName),
            "meta": "invite",
            "content": {"type": "group", "_id": self.id},
        }
        Message.create(**json)

 def setPrivilege(self, aUser, level):
     from server.models.permission import Permission
     thePermission = Permission.readByUserAndGroup(aUser.id, self.id)
     if thePermission and level > 0:
         db = core.connect()
         thePermission.level = level
         thePermission.store(db)

 def join(self, aUser):
     from server.models.permission import Permission
     thePermission = Permission.readByUserAndGroup(aUser.id, self.id)
     if thePermission and thePermission.level == 0:
         db = core.connect()
         thePermission.level = 2
         thePermission.store(db)

 def delete(self):
     from server.models.permission import Permission
     server = core.sharedServer()
     # delete the metadata
     db = core.connect()
     del db[self.id]
     # delete the group database
     del server[Group.db(self.id)]
     # delete all permissions
     [perm.delete() for perm in core.objects(Permission.by_group(core.connect(), key=self.id))]

    def create(cls, groupJson):
        from server.models.permission import Permission
        from server.models.ssuser import SSUser

        userId = groupJson["createdBy"]

        # create the group metadata
        newGroup = Group(**utils.clean(groupJson))
        newGroup.source.server = core.serverName()
        newGroup.source.database = Group.db(newGroup.id)
        # save the group metadata to the master db
        newGroup.store(core.connect())
        # create the root permission for this group
        Permission.create(userId, newGroup.id, userId, level=4)
        # create the group db
        server = core.sharedServer()
        server.create(Group.db(newGroup.id))
        # copy the group metadata to the db
        newGroup.copyTo(Group.db(newGroup.id))
        return newGroup

 def testPublishToGroup(self):
     json = shiftJson()
     json["createdBy"] = self.fakemary.id
     newShift = Shift.create(json)
     json = groupJson()
     json["createdBy"] = self.fakemary.id
     newGroup = Group.create(json)
     # make sure fakemary owns the group
     newPerm = Permission.readByUserAndGroup(self.fakemary.id, newGroup.id)
     self.assertTrue(newPerm.level == 4)
     # create read permission for fakejohn
     newPerm = Permission.create("shiftspace", newGroup.id, self.fakejohn.id, level=1)
     fakejohn = SSUser.read(self.fakejohn.id)
     self.assertTrue(Group.db(newGroup.id) in fakejohn.readable())
     publishData = {
         "dbs": [Group.db(newGroup.id)]
         }
     newShift.publish(publishData)
     # should exists in shiftspace/shared
     db = core.connect("shiftspace/shared")
     theShift = Shift.load(db, newShift.id)
     self.assertEqual(theShift.summary, newShift.summary)
     newGroup.delete()

 def testPublishToGroupAndUser(self):
     json = shiftJson()
     json["createdBy"] = self.fakemary.id
     newShift = Shift.create(json)
     json = groupJson()
     json["createdBy"] = self.fakemary.id
     newGroup = Group.create(json)
     newPerm = Permission.create("shiftspace", newGroup.id, self.fakejohn.id, level=1)
     publishData = {
         "dbs": [Group.db(newGroup.id), SSUser.db(self.fakebob.id)]
         }
     newShift.publish(publishData)
     # should exist in subscriber's feed
     db = core.connect("shiftspace/shared")
     theShift = Shift.load(db, newShift.id)
     self.assertEqual(theShift.summary, newShift.summary)
     newGroup.delete()
     # should exist in shiftspace/shared
     # TODO: inbox if user is peer - David 11/18/09
     theShift = Shift.load(core.connect("shiftspace/shared"), newShift.id)
     self.assertEqual(theShift.summary, newShift.summary)

    def members(self):
        from server.models.permission import Permission

        db = core.connect()
        return core.fetch(core.connect(), keys=[row.value for row in Permission.all_members(db, key=self.id).rows])

 def adminable(self):
     from server.models.permission import Permission
     return Permission.adminable(self.id)

 def writeable(self):
     from server.models.permission import Permission
     return Permission.writeable(self.id)

 def readable(self):
     from server.models.permission import Permission
     return Permission.readable(self.id)

 def isMemberOf(self, aGroup):
     from server.models.permission import Permission
     thePermission = Permission.readByUserAndGroup(self.id, aGroup.id)
     return thePermission and Permission.level > 0

 def canJoin(self, group):
     from server.models.permission import Permission
     perm = Permission.readByUserAndGroup(self.id, group.id)
     return (perm and perm.level == 0)

    def adminCount(self):
        from server.models.permission import Permission

        db = core.connect()
        return core.value(Permission.admin_count(db, key=self.id))

    def admins(self):
        from server.models.permission import Permission

        db = core.connect()
        return [row.value for row in Permission.admins(db, key=self.id).rows]

 def setPrivilege(self, aUser, level):
     thePermission = Permission.readByUserAndGroup(aUser.id, self.id)
     if thePermission and level > 0:
         db = core.connect()
         thePermission.level = level
         thePermission.store(db)