Пример #1
0
 def test_create_outgoing(self):
     """Create an outgoing record."""
     Category.create(category_id='001', description='Testing Stock')
     Project.create(project_id='001', project_description="Testing")
     Role.create(role_name='Admin')
     User.create(first_name='Jay', second_name='Palm', phone='9783978223', role='Admin', username='******',
                 password='******', email='*****@*****.**')
     create_stock('001', 'Testing stock', 1, '001', 9.99)
     create_outgoing_stock(stock='001', project_id='001', date="2015-07-22", quantity='7', username='******')
     OutgoingStock.get(OutgoingStock.stock == '001').delete_instance()
     Stock.get(Stock.category == '001').delete_instance()
     User.get(User.username == 'JayPalm').delete_instance()
     Role.get(Role.role_name == 'Admin').delete_instance()
     Project.get(Project.project_id == '001').delete_instance()
     Category.get(Category.category_id == '001').delete_instance()
Пример #2
0
def respond_role_menu(call, user):
    role = Role.get(Role.role_name == call.data)
    prev_value = RoleSelectionTracker.get(
        RoleSelectionTracker.user == user,
        RoleSelectionTracker.role == role).checked

    new_value = not prev_value
    RoleSelectionTracker.update(checked=new_value).where(
        RoleSelectionTracker.user == user,
        RoleSelectionTracker.role == role).execute()

    if new_value:
        answer_callback(f"نقش {role.role_name} اضافه شد.", call.id)
    else:
        answer_callback(f"نقش {role.role_name} حذف شد.", call.id)

    # update role team keyboard
    if role.team == "مافیا":
        message_id = Tracker.get(Tracker.id == user.id).mafia_message_id
    else:
        message_id = Tracker.get(Tracker.id == user.id).citizen_message_id

    # edit reply keyboard with new values
    edit_message_reply_markup(
        create_role_selection_menu(user, role.team),
        chat_id=user.id,
        message_id=message_id,
    )

    # send the new list of roles to every player
    players = get_players(user, include_god=True)
    num_players = len(players) - 1
    for player in players:
        send_current_roles(player, num_players, edit=True)
Пример #3
0
def host_send_roles(message, user):
    players = get_players(user)
    roles = get_selected_roles(user)

    if len(players) > len(roles):
        send_message(user.id, ":cross_mark: "
                     f"تعداد بازیکن‌ها بیشتر از نقش‌هاست.")
        return
    if len(players) < len(roles):
        send_message(user.id, ":cross_mark: "
                     f"تعداد بازیکن‌ها کمتر از نقش‌هاست.")
        return

    # shuffle players and send their roles.
    players_id = [player.user.id for player in players]
    random.shuffle(roles)

    for role_name, player_id in zip(roles, players_id):
        role_db = Role.get(Role.role_name == role_name)
        text = f":bust_in_silhouette: نقش شما: <b>{role_name}</b>\n"
        text += f":high_voltage: تیم: <b>{role_db.team}</b>\n\n"
        text += ":page_facing_up: <b>شرح نقش:</b>\n"
        text += role_db.description
        send_message(player_id, text)
        Game.update(mafia_role=role_name).where(Game.id == player_id).execute()

    # get updated players (mafia_role is updated now)
    players = get_players(user)

    # send roles to GOD
    send_message(user.id, get_players_roles(players))
Пример #4
0
 def delete(self, id):
     role = Role.get(id)
     if role:
         role.delete()
         return '', 204
     else:
         abort(404, error='Role not exist.')
Пример #5
0
 def wrapper(*args, **kwargs):
     if app.current_user is not None:
         r = Role.get(Role.role == role)
         if app.current_user.role.level >= r.level:
             return func(*args, **kwargs)
         app.flash(u'У Вас недостатньо прав для перегляду')
         redirect()
     app.flash(u'Увійдіть, щоб переглянути дану сторінку')
     redirect('/login?back=' + request.path)
Пример #6
0
async def remove_role(message):
    splitmsg = message.content.split()
    rolename = ' '.join(splitmsg[1:])
    role = discord.utils.get(message.server.roles, name=rolename)
    try:
        r = Role.get(Role.rid == role.id)
        r.assignable = False
        r.save()
    except Role.DoesNotExist as e:
        return

    await reply(f"The {rolename} role is now assignable", message)
Пример #7
0
async def remove_leader_role(message):
    splitmsg = message.content.split()
    rolename = ' '.join(splitmsg[1:])
    role = discord.utils.get(message.server.roles, name=rolename)
    try:
        r = Role.get(Role.rid == role.id)
        r.leaderboard = False
        r.save()
    except Role.DoesNotExist as e:
        return

    await reply(
        f"The {rolename} role will no longer given as a leaderboard reward",
        message)
Пример #8
0
async def iamnot(message):
    splitmsg = message.content.split()
    rolename = ' '.join(splitmsg[1:])
    role = None
    for ro in message.server.roles:
        if ro.name.lower() == rolename.lower():
            role = ro
    try:
        r = Role.get(Role.rid == role.id)
        if r.assignable:
            await client.remove_roles(message.author, role)
    except Role.DoesNotExist as e:
        return

    await reply(f"I have removed the {rolename} role from you", message)
Пример #9
0
    def check(action: int, resource: Resource):
        """
        Function to check the user access for a particular action on resource
        :return: bool
        """
        logged_in_user = User.get(
            filters={'username': UserLogin.check_session().username})[0]

        user_roles = Role.get(filters={'id': logged_in_user.roles})

        policies = []
        for role in user_roles:
            policies.extend(role.policies)

        user_policies = Policy.get(filters={'id': policies})

        resource_policies = [
            policy for policy in user_policies
            if policy.resource == '*' or policy.resource == resource
        ]

        # check for the denied policy
        denied_policy = next(
            (policy
             for policy in resource_policies if policy.effect == 'deny' and (
                 policy.action == '*' or policy.action == action)), None)

        if denied_policy:
            return False

        # check for an allowed policy
        allowed_policy = next(
            (policy
             for policy in resource_policies if policy.effect == 'allow' and (
                 policy.action == '*' or policy.action == action)), None)

        if allowed_policy:
            return True

        return False
Пример #10
0
async def on_message(message):
    lmsg = None
    smsg = None
    if not message.author.bot:
        if message.content.startswith('cb.'):
            fields = message.content.split()
            cmd = fields[0].split('.')[1]
            await bot.call(cmd, message)
            return
    async with lock:
        if not message.author.bot:
            server, created = Server.get_or_create(sid=message.server.id)
            user, created = User.get_or_create(uid=message.author.id)
            local, created = LocalLevel.get_or_create(user=user, server=server)

            level, exp = await levelup(server.level, server.experience)
            try:
                if level > server.level:
                    # Yay, the server leveled up
                    if server.announce_channel:
                        channel = client.get_channel(
                            f'{server.announce_channel}')
                        smsg = await client.send_message(
                            channel,
                            f"{party} {message.server.name} is now level"
                            f" {level}! {party}")
            except Exception as e:
                pass

            server.level = level
            server.experience = exp
            server.save()

            level, exp = await levelup(user.level, user.experience)

            user.level = level
            user.experience = exp
            user.save()

            level, exp = await levelup(local.level, local.experience)
            try:
                if level > local.level:
                    # User leveled up on the server
                    leaders = LocalLevel.select().where(
                        LocalLevel.server == server).order_by(
                            LocalLevel.level.desc(),
                            LocalLevel.experience.desc()).limit(1)

                    if f"{leaders[0].user.uid}" == message.author.id:
                        leaderboard_roles = Role.select().where(
                            (Role.server == server)
                            & (Role.leaderboard == True)).order_by(
                                Role.awardlevel.desc())

                        leader_role = discord.utils.get(
                            message.server.roles,
                            id=f'{leaderboard_roles[0].rid}')
                        for member in message.server.members:
                            item = next((i for i in member.roles
                                         if i.id == f"{leader_role.id}"), None)
                            if item:
                                await client.remove_roles(member, leader_role)
                        await client.add_roles(message.author, leader_role)
                    try:
                        try:
                            role = Role.get((Role.server == server)
                                            & (Role.awardlevel == level))
                        except Role.DoesNotExist as e:
                            role = None
                        if role:
                            r = discord.utils.get(message.server.roles,
                                                  id=f'{role.rid}')
                            try:
                                logger.info(f"Adding role {r.name} to "
                                            f"{message.author.name}")
                                await client.add_roles(message.author, r)
                            except AttributeError as e:
                                logger.exception("Could not add role")
                    except Role.DoesNotExist as e:
                        logger.exception("Count not find level up reward")
            except Exception as e:
                logger.exception("Could not process level up")

            local.level = level
            local.experience = exp
            local.save()

    await asyncio.sleep(10)
    if lmsg:
        await client.delete_message(lmsg)
    if smsg:
        await client.delete_message(smsg)
Пример #11
0
    view_role_acls = ACL.filter(object_id=view.guid)
    acl_roles.role_rights = defaultdict(int)
    for role_acl in view_role_acls:
        acl_roles.role_rights[role_acl.subject_id] += 1
    acl_roles.render()

    acl_table.objects = [acl_views, acl_roles]
    #role_rights

else:
    if type == 'role':

        if len(acl_table.objects) > 2:
            acl_table.objects = acl_table.objects[:-1]

        role = Role.get(guid=object_id)
        acl_table.objects[-1].selected_id = role.guid
        acl_table.objects[-1].render()
        selected_view = View.get(guid=acl_table.objects[0].selected_id)

        acl_rights = ACLRightTemplateCollection()
        acl_rights.objects = selected_view.rights
        acl_rights.selected_id = [
            acl.right_id for acl in acl_list.values() if
            acl.object_id == selected_view.guid and acl.subject_id == role.guid
        ]
        acl_rights.view_rights = [
            acl.right_id for acl in selected_view.acl_list(role)
        ]
        acl_rights.render()
Пример #12
0
from models import Role, Right

object_id = request.arguments.get('object_id', '')
type = request.arguments.get('type', 'role')  # or 'right'
command = request.arguments.get('command', 'update')

object_instance = Role.get(guid=object_id) if type == 'role' else Right.get(guid=object_id)

if object_instance:
	disabled = '2' if command == 'delete' else '0'

	form = self.dialog_update.form_update

	form.title.value = object_instance.name
	form.title.mode = disabled
	form.description.value = object_instance.description
	form.description.mode = disabled
	form.command.value = command
	form.object_id.value = object_instance.guid
	form.workspace_id.value = object_instance.workspace_id

	self.dialog_update.form_update.btn_update.label = command.title()
	form.btn_update.action( "setClass", [ 'btn btn-danger' if command == 'delete' else 'btn btn-success' ] )
	self.dialog_update.title = '{} {}'.format(type.title(), command.title())
	self.dialog_update.show = '1'
Пример #13
0
def add_role_test():
    u = User.from_object(session['user'])
    role = User_Role.create(
        role=Role.get(Role.role == AuthRoleType.ADMIN.value), user=u)
    return redirect(url_for('auth.login'))
Пример #14
0
 def get(self, id):
     role = Role.get(id)
     if role:
         return {'data': role.to_dict()}
     else:
         abort(404, error='Role not exist.')