def add_membership(request, group): current_user = LyfeUser.objects.get(pk=request.user.username) newMembership = Membership(user_id=current_user, group_id_id=group, accepted=False) newMembership.save() return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def add_member(asso, form): if not form.is_valid(): return member = form.cleaned_data['membre'] membership = Membership(asso=asso, member=member, role=MemberRole.SIMPLE._value_) membership.save() Dashboard.msg = member.username + " a bien été ajouté à l'association."
def servers_admins_entries(request, page): superusers = [] for superuser in User.objects.filter(is_superuser=True, is_steam=True): m = Membership() m.user = superuser m.is_superuser = True superusers.append(m) memberships = Membership.objects.all() return renderer(request, 'components/admins/servers/admins/entry.pug', memberships, page, extra=superusers)
def add_group(request): current_user = LyfeUser.objects.get(pk=request.user.username) GroupForm = modelform_factory(Group, fields=('name', 'description', 'logo')) newGroup = GroupForm(request.POST, request.FILES) if newGroup.is_valid(): group = newGroup.save(commit=False) group.creator_id = current_user group.save() defaultMembership = Membership(group_id=group, user_id=current_user) defaultMembership.save() return HttpResponseRedirect(reverse('core.views.dashboard'))
def list(request, validated={}, *args, **kwargs): if request.method == 'GET': roles = Role.objects.filter(name__icontains=validated['match']).values( 'id', 'name', 'server') limit = validated['limit'] offset = validated['offset'] roles = roles[offset:] if limit < 0 else roles[offset:limit] return [g for g in roles] else: users = [] for user in validated['members']: for u in User.objects.filter(id=user): users.append(u) role = Role(name=validated['name']) if validated['flags'] is not None: flags = validated['flags'] permission = ServerPermission().convert(conv=flags) else: permission = ServerPermission() permission.save() role.flags = permission role.immunity = validated['immunity'] if validated['server'] is not None: role.server = Server.objects.get(id=validated['server']) if validated['usetime'] is not None: role.usetime = datetime.timedelta(seconds=validated['usetime']) role.save() for u in users: m = Membership(user=u, role=role) m.save() # role.user_set.set(users) # role.save() return 'passed'
def handle(self, *args, **options): data = requests.get('https://onmyoji.rapospectre.com/s/file/scene_datiangou.json', verify=False).content json_data = json.loads(data) num = 0 for item in json_data: scene = Scene(name=item.get('scene_name')) scene.save() for itm in item.get('team_list'): team = Team(name=itm.get('name'), index=itm.get('index'), belong=scene) team.save() for mitm in itm.get('monsters'): hs = Hellspawn.objects.get(name=mitm.get('name')) Membership(hellspawn=hs, count=mitm.get('count'), team=team).save()
def boompanel(self): self.conn.query("""SELECT * FROM bp_players""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) users = {} for raw in result: query = User.objects.filter(username=raw['steamid']) if not query: user = User.objects.create_user(username=raw['steamid']) user.is_active = False user.is_steam = True populate(user) else: user = query[0] user.save() users[raw["id"]] = user self.conn.query("""SELECT * FROM bp_servers""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) servers = {} for raw in result: server, _ = Server.objects.get_or_create(ip=raw['ip'], port=raw['port']) server.password = raw['rcon_pw'] server.name = raw['name'] servers[raw['id']] = server try: conn = RCONBase(server, timeout=3) conn.connect() conn.authenticate(timeout=3) conn.close() except (valve.rcon.RCONTimeoutError, valve.rcon.RCONAuthenticationError, ConnectionError, TimeoutError, socket.timeout) as e: print("Warning: Could not connect to server {}:{} ({})".format( raw['ip'], raw['port'], e)) continue server.save() self.conn.query("""SELECT * FROM bp_admin_groups""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) roles = {} for raw in result: role, _ = Role.objects.get_or_create(name=raw['name']) role.immunity = raw['immunity'] role.flags = ServerPermission().convert(raw['flags']) role.usetime = None if raw['usetime'] == 0 else raw['usetime'] role.save() roles[raw['id']] = role self.conn.query("""SELECT * FROM bp_admins""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) admins = {} for raw in result: m = Membership() m.role = roles[raw['sid']] m.user = roles[raw['pid']] m.save() admins[raw['aid']] = m self.conn.query("""SELECT * FROM bp_mutegag""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) for raw in result: if raw['aid'] not in users or raw['pid'] not in users or raw[ 'sid'] not in servers: continue m = Punishment() m.user = users[raw["pid"]] m.server = servers[raw[ 'sid']] if raw['sid'] != 0 and raw['sid'] in servers else None m.created_by = users[raw['aid']] m.created_at = timezone.make_aware( datetime.datetime.fromtimestamp(raw['time'])) m.reason = raw['reason'][:255] m.length = datetime.timedelta(seconds=raw['length'] * 60) if raw['length'] > 0 else None m.is_muted = True if raw['type'] == 1 else False m.is_gagged = True if raw['type'] == 2 else False m.resolved = False if raw['time'] + raw['length'] < self.now.timestamp( ) and raw['length'] > 0: m.resolved = True if raw['unbanned'] == 1: m.resolved = True m.save() self.conn.query("""SELECT * FROM bp_bans""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) for raw in result: if raw['aid'] not in users or raw['pid'] not in users or raw[ 'sid'] not in servers: continue b = Punishment() b.is_banned = True b.user = users[raw["pid"]] b.server = servers[raw[ 'sid']] if raw['sid'] != 0 and raw['sid'] in servers else None b.created_by = users[raw['aid']] m.created_at = timezone.make_aware( datetime.datetime.fromtimestamp(raw['time'])) b.reason = raw['reason'][:255] b.length = datetime.timedelta( seconds=raw['length']) if raw['length'] > 0 else None b.resolved = False if raw['time'] + raw['length'] < self.now.timestamp( ) and raw['length'] > 0: b.resolved = True if raw['unbanned'] == 1: b.resolved = True b.save() return True
def sourcemod(self): self.conn.query("""SELECT * FROM sm_groups""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) roles = {} for raw in result: flags = ServerPermission().convert(raw['flags']) flags.save() role = Role.objects.get_or_create(name=raw['name'], default={ 'flags': flags, 'immunity': raw['immunity_level'] }) role.name = raw['name'] role.flags = flags role.immunity = raw['immunity_level'] role.save() roles[raw['id']] = role self.conn.query("""SELECT * FROM sm_admins""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) generated = {} for raw in result: try: steamid = SteamID.from_text(raw['identity']).as_64() except: print("Could not add admin {}".format(raw['name'])) continue query = User.objects.filter(username=steamid) if not query: user = User.objects.create_user(username=steamid) user.is_active = False user.is_steam = True populate(user) else: user = query[0] user.namespace = raw['user'] user.save() self.conn.query("""SELECT * FROM sm_admins_groups WHERE admin_id = {}""".format(raw['id'])) r = self.conn.store_result() groups = r.fetch_row(maxrows=0, how=1) if not groups and raw['flags']: if raw['flags'] in generated: role = generated[raw['flags']] else: role = Role() role.name = raw['flags'] role.flags = ServerPermission().convert(raw['flags']) role.flags.save() role.immunity = 0 role.save() generated[raw['flags']] = role m = Membership() m.user = user m.role = role m.save() elif groups: for group in groups: role = roles[group["group_id"]] m = Membership() m.user = user m.role = role m.save() return True
def sourceban(self): superuser = User.objects.filter(is_superuser=True) superuser = superuser[0] if superuser else None # get servers self.conn.query("""SELECT * FROM sb_servers""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) servers = {} for raw in result: if raw['enabled'] != 1: continue server, _ = Server.objects.get_or_create(ip=raw['ip'], port=raw['port']) server.password = raw['rcon'] server.name = "{}:{}".format(raw['ip'], raw['port']) server.save() try: conn = RCONBase(server, timeout=3) conn.connect() conn.authenticate(timeout=3) conn.close() servers[raw['sid']] = server except (valve.rcon.RCONTimeoutError, valve.rcon.RCONAuthenticationError, ConnectionError, TimeoutError, socket.timeout) as e: server.delete() print("Warning: Could not connect to server {}:{} ({})".format( raw['ip'], raw['port'], e)) continue # get groups self.conn.query("""SELECT * FROM sb_srvgroups""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) for raw in result: flags = ServerPermission().convert(raw['flags']) flags.save() role, _ = Role.objects.get_or_create(name=raw['name'], defaults={ 'flags': flags, 'immunity': raw['immunity'] }) role.immunity = raw['immunity'] role.flags = flags role.save() # get admins self.conn.query("""SELECT * FROM sb_admins""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) users = {0: User.objects.filter(is_superuser=True)[0]} generated = {} for raw in result: try: steamid = SteamID.from_text(raw['authid']).as_64() except: print("Could not add admin {}".format(raw['user'])) continue query = User.objects.filter(username=steamid) if not query: user = User.objects.create_user(username=steamid) user.is_active = False user.is_steam = True populate(user) else: user = query[0] user.namespace = raw['user'] user.save() if not raw['srv_group'] and raw['srv_flags']: m = Membership() m.user = user if raw['srv_flags'] in generated: m.role = generated[raw['srv_flags']] else: m.role = Role() m.role.immunity = 0 m.role.name = raw['srv_flags'] m.role.flags = ServerPermission().convert(raw['srv_flags']) m.role.flags.save() m.role.save() m.save() generated[raw['srv_flags']] = m.role elif raw['srv_group']: m = Membership() m.role = Role.objects.get(name=raw['srv_group']) m.user = user m.save() users[raw['aid']] = user # get bans self.conn.query("""SELECT * FROM sb_bans""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) for raw in result: try: steamid = SteamID.from_text(raw['authid']).as_64() except: print("Could not add ban of user {}".format(raw['name'])) continue query = User.objects.filter(username=steamid) if not query: user = User.objects.create_user(username=steamid) user.is_active = False user.is_steam = True populate(user) else: user = query[0] b = Punishment() b.is_banned = True b.user = user if raw['sid'] in servers: b.server = servers[raw['sid']] if raw['sid'] != 0 else None else: b.server = None if raw['aid'] in users: b.created_by = users[raw['aid']] elif superuser: b.created_by = superuser else: continue m.created_at = timezone.make_aware( datetime.datetime.fromtimestamp(raw['created'])) b.reason = raw['reason'][:255] b.length = datetime.timedelta( seconds=raw['length'] ) if raw['length'] > 0 and raw['length'] < 31540000 else None b.resolved = False if raw['created'] + raw['length'] < self.now.timestamp( ) and raw['length'] > 0: b.resolved = True if raw['RemovedOn']: b.resolved = True b.save() # get comms self.conn.query("""SELECT * FROM sb_comms""") r = self.conn.store_result() result = r.fetch_row(maxrows=0, how=1) for raw in result: try: steamid = SteamID.from_text(raw['authid']).as_64() except: print("Could not add mutegag of user {}".format(raw['name'])) continue query = User.objects.filter(username=steamid) if not query: user = User.objects.create_user(username=steamid) user.is_active = False user.is_steam = True populate(user) else: user = query[0] m = Punishment() m.user = user if raw['sid'] in servers: m.server = servers[raw['sid']] if raw['sid'] != 0 else None else: m.server = None if raw['aid'] in users: m.created_by = users[raw['aid']] elif superuser: m.created_by = superuser else: continue m.created_at = timezone.make_aware( datetime.datetime.fromtimestamp(raw['created'])) m.reason = raw['reason'][:255] m.length = datetime.timedelta( seconds=raw['length'] ) if raw['length'] > 0 and raw['length'] < 31540000 else None m.is_muted = True if raw['type'] == 1 else False m.is_gagged = True if raw['type'] == 2 else False m.resolved = False if raw['created'] + raw['length'] < self.now.timestamp( ) and raw['length'] > 0: m.resolved = True if raw['RemovedOn']: m.resolved = True m.save() return True
def perform_create(self, serializer): ws = serializer.save() Membership.objects.filter(user=self.request.user).update(is_default=False) Membership(workspace=ws, user=self.request.user, role=Membership.OWNER, is_default=True).save()
def populate_membership(self, member_idx): ''' member의 가변필드인 membership 테이블에 폼의 내용을 업데이트함. ''' camp_idx = Camp.get_idx(self.camp) membership_fields = form_config.MEMBERSHIP_FIELDS[self.camp] for membership_field in membership_fields: if membership_field == 'route': for route in getattr(self, membership_field).data: r_membership = Membership() r_membership.camp_idx = camp_idx r_membership.member_idx = member_idx r_membership.key = 'route' r_membership.value = route db.session.add(r_membership) else: if getattr(self, membership_field).data not in [None, '', 'none']: membership = Membership() membership.camp_idx = camp_idx membership.member_idx = member_idx membership.key = membership_field membership.value = getattr(self, membership_field).data db.session.add(membership) if self.camp != 'ga': if self.training.data not in [None, '', 'None']: for training in self.training.data: t_membership = Membership() t_membership.camp_idx = camp_idx t_membership.member_idx = member_idx t_membership.key = 'training' t_membership.value = training db.session.add(t_membership) db.session.commit()
def populate_membership(self, member_idx): ''' member의 가변필드인 membership 테이블에 폼의 내용을 업데이트함. ''' camp_idx = Camp.get_idx(self.camp) membership_fields = form_config.MEMBERSHIP_FIELDS[self.camp] for membership_field in membership_fields: if membership_field == 'route': for route in getattr(self, membership_field).data: r_membership = Membership() r_membership.camp_idx = camp_idx r_membership.member_idx = member_idx r_membership.key = 'route' r_membership.value = route db.session.add(r_membership) else: if getattr(self, membership_field).data not in [None, '', 'none']: membership = Membership() membership.camp_idx = camp_idx membership.member_idx = member_idx membership.key = membership_field membership.value = getattr(self, membership_field).data db.session.add(membership) if self.camp != 'ga': if self.training.data not in [None, '', 'None']: for training in self.training.data: t_membership = Membership() t_membership.camp_idx = camp_idx t_membership.member_idx = member_idx t_membership.key = 'training' t_membership.value = training db.session.add(t_membership) db.session.commit()
def detailed(request, u=None, s=None, validated={}, *args, **kwargs): if request.method == 'GET': if u is not None: try: user = User.objects.get(id=u) except Exception as e: return 'not existent user queried - {}'.format(e), 403 if s is not None: user = User.objects.get(username=s) try: pass except Exception as e: return 'not existent steamid provided - {}'.format(e), 403 output = {'id': user.id, 'ip': user.ip, 'username': user.namespace if user.is_steam else user.username, 'steamid': int(user.username) if user.is_steam else None, 'avatar': user.avatar, 'profile': user.profile, 'permissions': [a.content_type.app_label + '.' + a.codename for a in user.user_permissions.all()], 'groups': [str(a) for a in user.groups.all()], 'roles': [], 'is_internal': user.is_active, 'country': None if user.country is None else user.country.code } memberships = user.membership_set.filter(user=user) if validated['server'] is not None: server = Server.objects.get(id=validated['server']) memberships.filter(Q(role__server=server) | Q(role__server=None)) memberships = memberships.order_by('-role__immunity') if user.is_superuser: # fake root role output['roles'].append({'name': settings.ROOT, 'server': None, 'flags': 'ABCDEFGHIJKLNMNOPQRSTUVXYZ'.lower(), 'immunity': 100, 'usetime': None, 'timeleft': None }) for mem in memberships: usetime = None if mem.role.usetime is None else mem.role.usetime timeleft = None if usetime is not None: timeleft = (mem.created_at + usetime) - timezone.now() usetime = usetime.total_seconds() if timeleft < 0: mem.delete() continue output['roles'].append({'name': mem.role.name, 'server': None if not mem.role.server else mem.role.server.id, 'flags': mem.role.flags.convert().lower(), 'immunity': mem.role.immunity, 'usetime': usetime, 'timeleft': timeleft }) return output elif request.method == 'POST': if u is not None: try: user = User.objects.get(id=u) except Exception as e: return 'not existent user queried - {}'.format(e), 403 if s is not None: try: user = User.objects.get(username=s) except Exception as e: if validated['force']: user = User.objects.create_user(username=str(s)) user.save() steam_populate(user) else: return 'not existent steamid provided - {}'.format(e), 403 if validated['role'] is not None: group = Role.objects.get(id=validated['role']) if validated['promotion']: m = Membership() m.user = user m.role = group m.save() else: m = Membership.objects.get(user=user, role=group) m.delete() if validated['group'] is not None: group = Group.objects.get(id=validated['group']) if validated['promotion']: user.groups.add(group) else: user.groups.remove(group) if validated['roles']: Membership.objects.filter(user=user).delete() for role in validated['roles']: group = Role.objects.get(id=role) m = Membership() m.user = user m.role = group m.save() if validated['groups']: groups = Group.objects.filter(id__in=validated['groups']) user.groups.set(groups) user.is_active = True if validated['permissions'] is not None: base = Permission.objects.all()\ .annotate(encoded=F('content_type__model') + '.' + F('codename'))\ .filter(encoded__in=request.user.get_all_permissions())\ .order_by('content_type__model') exceptions = [] perms = [] for perm in validated['permissions']: perm = perm.split('.') p = base.filter(content_type__model=perm[0], codename=perm[1]) if not p: exceptions.append('.'.join(perm)) perms.extend(p) if exceptions: return {'info': 'You are trying to assign permissions that either do not exist or are out of your scope.', 'affects': exceptions}, 403 user.user_permissions.set(perms) user.save() return ':+1:' elif request.method == 'DELETE': if u: try: user = User.objects.get(id=u) except Exception as e: return 'not existent user queried - {}'.format(e), 403 if s: try: user = User.objects.get(username=s) except Exception as e: return 'not existent steamid provided - {}'.format(e), 403 if validated['purge']: if user.is_superuser: return 'superuser cannot be removed', 403 if request.user == user: return 'you cannot disable yourself', 403 user.delete() return 'CASCADE DELETE', 200 elif validated['reset']: if not user.is_active: return 'user not using panel', 403 if user.is_superuser: return 'superuser cannot be deactivated', 403 if request.user == user: return 'you cannot disable yourself', 403 user.is_active = False user.is_staff = False user.is_superuser = False user.user_permissions.clear() user.groups.clear() else: if validated['role']: m = Membership.objects.get(user=user, role=validated['role']) m.delete() for role in validated['roles']: m = Membership.objects.get(user=user, role=role) m.delete() for group in validated['groups']: user.groups.remove(Group.objects.get(id=group)) if user.groups.count() == 0: user.is_active = False user.save()