def group_edit_view(request): """returns current group information for editing and then collects all information that has been added by the user whether new or existing and edits the existing entries. """ username = request.authenticated_userid group = Group.lookup_by_attribute(name=request.matchdict['group_name'])[0] criteria = Criteria.lookup_by_attribute(group=group)[0] if request.method == 'POST': criteria = Criteria.edit(location=request.params.getall('location'), taste=request.params.getall('taste'), diet=request.params.getall('diet'), cost=request.params.getall('cost'), age=request.params.getall('age'), id=criteria.id) group = Group.edit(name=request.params.get('name'), description=request.params.get('description'), id=group.id) return HTTPFound(request.route_url('group_detail', group_name=group.name)) profile = {} profile['criteria'] = criteria profile['group'] = group profile['username'] = username return profile
def addressbook_add_group(): group_name = request.form.get('group_name', None) data = {} subst = {'group': group_name} if not group_name: dict_return(data, WARNING, u"Veuillez saisir un nom de groupe", message_html=u"Veuillez saisir un nom de" u"<strong> groupe</strong>.") return json.dumps(data) try: group = Group(name=group_name) group.save() dict_return(data, SUCCESS, u"%(group)s a été ajouté avec succès." % subst, message_html=u"<strong>%(group)s</strong> " u"a été ajouté avec succès." % subst) except sqlite3.IntegrityError: dict_return(data, INFO, u"%(group)s existe déjà." % subst, message_html=u"<strong>%(group)s</strong> existe déjà." % subst) except Exception as e: subst.update({'err': e.message}) dict_return(data, ERROR, u"Impossible d'enregistrer le groupe %(group)s : %(err)r" % subst, message_html=u"Impossible d'enregistrer le groupe " u"<strong>%(group)s</strong><br />" u"<em>%(err)r</em>" % subst) return json.dumps(data)
def create_group(payload): body = request.get_json() print(body) new_group_name = body['group_name'] new_area = body['area'] try: group = Group( group_name=new_group_name, area=new_area ) print(group) group.insert() groups = list(map(Group.format, Group.query.order_by(Group.group_name).all())) '''current_questions = paginate_questions(request, selection)''' return jsonify({ 'success': True, 'walkers': groups }) except Exception as e: print(e) abort(422)
def register_group(): """ "POST": crear un grupo y devolver su información """ # crear una variable y asignarle diccionario con datos para crear grupo data_group = request.json if data_group is None: return jsonify({"resultado": "no envió datos para crear el grupo..."}), 400 # verificar que el diccionario tenga group_name if ("group_name" not in data_group): return jsonify({"resultado": "revise las propiedades de su solicitud"}), 400 # validar que campos no vengan vacíos if (data_group["group_name"] == ""): return jsonify({"resultado": "revise los valores de su solicitud"}), 400 # crear una variable y asignarle el nuevo group con los datos validados new_group = Group(group_name=data_group["group_name"]) # agregar a la sesión de base de datos (sqlalchemy) y hacer commit de la transacción db.session.add(new_group) try: db.session.commit() print(new_group) # devolvemos el nuevo contact serializado y 201_CREATED return jsonify(new_group.serialize()), 201 except Exception as error: db.session.rollback() print(f"{error.args} {type(error)}") # devolvemos "hay un error..." return jsonify({"resultado": f"{error.args}"}), 500
def createGroup(request): ''' USAGE: create a civi Group responsible for creating and managing civi content. Please validate file uploads as valid images on the frontend. File Uploads: profile (optional) cover (optional) Text POST: title description :returns: (200, ok, group_id) (500, error) ''' pi = request.FILES.get('profile', False) ci = request.FILES.get('cover', False) title = request.POST.get(title, '') data = { "owner": Account.objects.get(user=request.user), "title": title, "description": request.POST.get('description',''), "profile_image": writeImage('profile', pi, title), "cover_image": writeImage('cover', ci, title) } try: group = Group(**data) group.save() account.groups.add(group) return JsonResponse({'result':group.id}) except Exception as e: return HttpResponseServerError(reason=e)
def populate_with_defaults(): '''Create user admin and grant him all permission If the admin user already exists the function will simply return ''' logging.getLogger(__name__).debug("Populating with default users") if not User.select().where(User.name == 'admin').exists(): admin = User.create(name='admin', password='******') admins = Group.create(name='admins') starCap = Capability.create(domain='.+', action=(Action.CREATE | Action.READ | Action.UPDATE | Action.DELETE)) admins.capabilities.add(starCap) admin.groups.add(admins) admin.save() if not User.select().where(User.name == 'anonymous').exists(): anon = User.create(name='anonymous', password='') anons = Group.create(name='anonymous') readCap = Capability.create(domain=Capability.simToReg('/volumes/*'), action=Action.READ) anons.capabilities.add(readCap) anon.groups.add(anons) anon.save()
def groupmember(group_addfriend): # add addfriend info = group_addfriend.split(",") cur_friend = Friend_control() group_id = info[0] addfriend = info[1] cur_group = Group() if addfriend == "None": print("ignore") else: cur_friend.check_relation(current_user.user_email, addfriend) f_count = len(cur_friend.friend_count(current_user.user_email)) user_info_global["f_count"] = f_count mems = cur_group.show_member(current_user.user_email, group_id) # print(mems) # group,addfriend=group_addfriend ''' mems=[ { 'ID':'001', 'name':'a', 'isfriend':'0' } ] ''' return render_template('groupmember.html', mems=mems, group=group_id, user_info_global=user_info_global)
def screen_init(self): self.set_os_params() pygame.init() pygame.display.gl_set_attribute(pygame.GL_DEPTH_SIZE, 24) flags = pygame.DOUBLEBUF | pygame.HWSURFACE | pygame.OPENGL | pygame.NOFRAME try: pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS, 1) self.surf = pygame.display.set_mode(self.window_size, flags) except: pygame.display.gl_set_attribute(pygame.GL_MULTISAMPLEBUFFERS, 0) self.surf = pygame.display.set_mode(self.window_size, flags) glEnable(GL_BLEND) glDepthFunc(GL_LESS) glEnable(GL_DEPTH_TEST) glEnable(GL_TEXTURE_2D) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glClearColor(*self.background) glClearDepth(1.0) glDepthMask(GL_TRUE) self.renderer = self._get_renderer() #this effectively determines the modelview matrix self.world = Group(self.models) self.world.init() #up vector is always (0,0,1), why would I ever need to roll the camera?! self.set_eye((0, -self.screen_dist, 0), (0, 0))
def run(self): db.drop_all() db.create_all() db.session.add(Group('Diggers', 'Preschool')) db.session.add(Group('Discoverers', 'Year R-2')) db.session.add(Group('Explorers', 'Years 3-6')) db.session.commit()
def group(call): if not is_person(call.message.chat): return try: user = User.get(telegram_id=call.message.chat.id) if user not in User.select(User).join(Links).join(Group).where(Group.group_name == 'Admins'): raise Exception("Unauthorized user") except Exception: bot.send_message(text=get_unauthorized_user_start_message(), chat_id=call.message.chat.id) return group_to_add_to = Group.get(id=int(call.data.split('_')[1])) user_to_be_entered_to_group = User.get(id=int(call.data.split('_')[2])) Links.get_or_create(user=user_to_be_entered_to_group, group=group_to_add_to) if user_to_be_entered_to_group in User.select(User).join(Links).join(Group).where( Group.group_name == 'Unauthorized'): temp_link = Links.get(user=user_to_be_entered_to_group, group=Group.get(group_name='Unauthorized')) temp_link.delete_instance() logger.info( f'{user.first_name} {user.last_name} added user {user_to_be_entered_to_group.first_name} {user_to_be_entered_to_group.last_name} to group {group_to_add_to.group_name}') bot.send_message(chat_id=user_to_be_entered_to_group.telegram_id, text=f'Вы авторизованы и добавлены в группу {group_to_add_to.group_name}', reply_markup=get_start_keyboard(user)) bot.send_message(chat_id=user_to_be_entered_to_group.telegram_id, text='Список доступных Вам функций', reply_markup=get_main_inline_keyboard(user_to_be_entered_to_group)) bot.edit_message_text(message_id=call.message.message_id, chat_id=call.message.chat.id, text=user_info(user_to_be_entered_to_group), reply_markup=keyboard_to_chose_users_groups(user_to_be_entered_to_group))
def group_list(context): group = Group.query(Group.user == users.get_current_user()).order( Group.name) if context.get('is_admin'): group = Group.query().order(Group.name) groups = group.fetch() return groups
def group(call): if not is_person(call.message.chat): return try: user = User.get(telegram_id=call.message.chat.id) if user not in User.select(User).join(Links).join(Group).where(Group.group_name == 'Admins'): raise Exception("Unauthorized user") except Exception: bot.send_message(text=get_unauthorized_user_start_message(), chat_id=call.message.chat.id) return group_to_remove_from = Group.get(id=int(call.data.split('_')[1])) user_to_be_removed_from_group = User.get(id=int(call.data.split('_')[2])) Links.get(user=user_to_be_removed_from_group, group=group_to_remove_from).delete_instance() logger.info( f'{user.first_name} {user.last_name} removed user {user_to_be_removed_from_group.first_name} {user_to_be_removed_from_group.last_name} from group {group_to_remove_from.group_name}') bot.send_message(chat_id=user_to_be_removed_from_group.telegram_id, text=f'Вы удалены из группы {group_to_remove_from.group_name}', reply_markup=get_start_keyboard(user)) bot.send_message(chat_id=user_to_be_removed_from_group.telegram_id, text='Список доступных Вам функций', reply_markup=get_main_inline_keyboard(user_to_be_removed_from_group)) if Group.select(Group).join(Links).join(User).where(User.id == user_to_be_removed_from_group.id).count() == 0: Links.get_or_create(user=user_to_be_removed_from_group, group=Group.get(group_name='Unauthorized')) bot.send_message(chat_id=user_to_be_removed_from_group.telegram_id, text='Вы были удалены из всех групп. Получите авторизацию у администратора, чтобы продолжить пользоваться этим ботом!', reply_markup=None) bot.edit_message_text(message_id=call.message.message_id, chat_id=call.message.chat.id, text=user_info(user_to_be_removed_from_group), reply_markup=keyboard_to_chose_users_groups(user_to_be_removed_from_group))
def _get_group(self, group_id=None, group_name=None): if group_id is not None: return Group.query(ndb.AND(Group.unique_id == group_id)).get() else: return Group.query( ndb.AND(Group.name == group_name, Group.user == self.user_key)).get()
def __init__(self, **kwargs): ''' Constructor for Box Parameters ---------- kwargs: optional keyword arguments All passed to parent constructor Returns ------- Box instance ''' bcolor = (181/256., 116/256., 96/256., 1) sidelen = 16 linerad=.1 self.vert_box = Group([ Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(-sidelen/2, -sidelen/2, -sidelen/2), Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(sidelen/2, -sidelen/2, -sidelen/2), Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(sidelen/2, sidelen/2, -sidelen/2), Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(-sidelen/2, sidelen/2, -sidelen/2)]) self.hor_box = Group([ Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(-sidelen/2, -sidelen/2, -sidelen/2), Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(sidelen/2, -sidelen/2, -sidelen/2), Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(sidelen/2, sidelen/2, -sidelen/2), Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(-sidelen/2, sidelen/2, -sidelen/2)]) self.depth_box = Group([ Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(-sidelen/2, -sidelen/2, -sidelen/2), Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(sidelen/2, -sidelen/2, -sidelen/2), Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(sidelen/2, sidelen/2, -sidelen/2), Cylinder(radius=linerad, height=sidelen, color=bcolor).translate(-sidelen/2, sidelen/2, -sidelen/2)]) self.hor_box.xfm.rotate = Quaternion.rotate_vecs((0,0,1), (1,0,0)) self.depth_box.xfm.rotate = Quaternion.rotate_vecs((0,0,1), (0,1,0)) self.box = Group([self.hor_box, self.depth_box, self.vert_box]) super(Box, self).__init__([self.box], **kwargs)
def create(self): """Handles the POST data for creating a group. Form Variables: name: the name of the new group public: true if the group should be joinable by the public """ if auth.logged_in(): name = self.request.get('name') public = self.request.get('public') == 'public' owner = auth.current_user() if Group.exists(name): Messages.add('A group with that name already exists') return self.redirect('/groups/signup') Group(name=name, public=public, owner=owner, members=[owner]).put() return self.redirect('/groups') else: Messages.add('You must be logged in to create a group') return self.redirect('/groups/signup')
def search(): if request.method == 'POST': if g.search_form.validate_on_submit(): n = unicode(g.search_form.select.data) text = unicode(g.search_form.text.data) if n == 'group': if text.isdigit(): return render_template('search_result.html', type=n, data=Group.get_group_by_number_like(int(text)), count=Specialty.count() + 1) elif text.isalpha(): return render_template('search_result.html', type=n, data=Group.get_by_specialty_like(text), count=Specialty.count() + 1) else: if text.find(' ') != -1: arr = text.split(' ') if arr[0].isdigit(): return render_template('search_result.html', type=n, data=Group.get_by_number_and_specialty(arr[0], arr[1]), count=Specialty.count() + 1) else: return render_template('search_result.html', type=n, data=Group.get_by_number_and_specialty(arr[1], arr[0]), count=Specialty.count() + 1) elif n == 'lecturer': if text.isalpha(): return render_template('search_result.html', type=n, data=Lecturer.get_by_name(text)) elif n == 'subject': if text.isalnum(): return render_template('search_result.html', type=n, data=Subject.get_by_substring(text), text=text) return redirect(url_for('index')) return redirect(url_for('group_timetable', group_number=427, week=get_week()))
def test_parse_group(self): response = ''' {"response":[{"gid":1,"name":"ВКонтакте API","screen_name":"apiclub","is_closed":0, "is_admin":1,"type":"group","photo":"http://cs400.vkontakte.ru/g00001/e_5ba03323.jpg", "photo_medium":"http://cs400.vkontakte.ru/g00001/d_7bfe2183.jpg", "photo_big":"http://cs400.vkontakte.ru/g00001/a_9a5cd502.jpg"}, {"gid":45,"name":"›››› ФМЛ 239 ››››","screen_name":"fml239","is_closed":1,"is_admin":0,"type":"group", "photo":"http://cs39.vkontakte.ru/g00045/c_5a38eec.jpg", "photo_medium":"http://cs39.vkontakte.ru/g00045/b_5a38eec.jpg", "photo_big":"http://cs39.vkontakte.ru/g00045/a_5a38eec.jpg"}]} ''' instance = Group() instance.parse(json.loads(response)['response'][0]) instance.save() self.assertEqual(instance.remote_id, 1) self.assertEqual(instance.name, u'ВКонтакте API') self.assertEqual(instance.screen_name, 'apiclub') self.assertEqual(instance.is_closed, False) self.assertEqual(instance.is_admin, True) self.assertEqual(instance.type, 'group') self.assertEqual(instance.photo, 'http://cs400.vkontakte.ru/g00001/e_5ba03323.jpg') self.assertEqual(instance.photo_medium, 'http://cs400.vkontakte.ru/g00001/d_7bfe2183.jpg') self.assertEqual(instance.photo_big, 'http://cs400.vkontakte.ru/g00001/a_9a5cd502.jpg')
def createNewGroup(username, groupName): try: examObject = Group.objects.get(exam_name=groupName) except: groupObject = Group(group_name=groupName) groupObject.save() addUserToGroup(username, groupName)
def add_groups(l_input): #TODO add for rm group db_groups = get_all_group() l_name_groups = [g.url for g in db_groups] ## add group for group in l_input: if group['url'] not in l_name_groups: db_group = Group() db_group.name = group['name'] if group['name'] else None db_group.url = group['url'] session.add(db_group) status = True try: session.commit() logger.info('Commited.') except exc.SQLAlchemyError as e: session.rollback() logger.error('Database rollback.{}'.format(e)) status = False finally: #session.close() logger.info('Database close') return status
def store_seller_post(store_id): """ store 添加商店人员 """ db = g._imdb developer_id = session['user']['id'] form = request.form name = form.get('name', '') password = form.get('password', '') number = form.get('number', '') if not name or not password or not store_id: return INVALID_PARAM() if not number: number = None password = md5.new(password).hexdigest() group_id = Store.get_store_gid(db, store_id) db.begin() seller_id = Seller.add_seller(db, name, password, store_id, group_id, number) Group.add_group_member(db, group_id, seller_id) db.commit() content = "%d,%d"%(group_id, seller_id) publish_message(g.im_rds, "group_member_add", content) return redirect(url_for('.store_seller', store_id=store_id))
def create_group(req): """ :param req: the received HTTP request :return: an HTTP response: - redirect to group view if request method is POST - redirect to the user's page who sent the request otherwise """ user = req.user if req.method == 'POST': form = GroupForm(req.POST, req.FILES) if form.is_valid(): cleaned_data = form.cleaned_data name = cleaned_data['name'] description = cleaned_data['description'] profile_pic = req.FILES['profile_pic'] group = Group(name=name, description=description, profile_pic=profile_pic, admin=user.student) group.save() members = cleaned_data['members'] if members.count() > 0: group.members.add(user.student, *members) else: group.members.add(user.student) return redirect('group_view', group_id=group.id) return redirect('student_view', student_username=user.username)
def addGConfig(request): if request.method == 'POST': try: name = request.POST.get('name', '') interval = request.POST.get('interval', '60s') type = request.POST.get('type', '60s') check = request.POST.get('check', '') match = request.POST.get('match', '') uri = request.POST.get('uri', '') if uri.strip() == '': uri = '/metrics' pc = Group.objects.filter(name=name) if len(pc) > 0: return HttpResponse(json.dumps(u'目标' + name + u'已存在')) flag = createGroup(name) if flag is False: return HttpResponse(json.dumps(u'添加失败,组目录创建失败!')) pc = Group(name=name, scrape_interval=interval, scheme=type, insecure_skip_verify=check, metrics_path=uri, match=match) pc.save() return HttpResponse(json.dumps(u'添加成功')) except Exception, e: print e return HttpResponse(json.dumps(u'添加失败'))
def store_seller_post(store_id): """ store 添加商店人员 """ db = g._imdb developer_id = session['user']['id'] form = request.form name = form.get('name', '') password = form.get('password', '') number = form.get('number', '') if not name or not password or not store_id: return INVALID_PARAM() if not number: number = None password = md5.new(password).hexdigest() group_id = Store.get_store_gid(db, store_id) db.begin() seller_id = Seller.add_seller(db, name, password, store_id, group_id, number) Group.add_group_member(db, group_id, seller_id) db.commit() content = "%d,%d" % (group_id, seller_id) publish_message(g.im_rds, "group_member_add", content) return redirect(url_for('.store_seller', store_id=store_id))
def delete(self, key): if auth.user_is_admin(): Group.get(key).delete() else: Messages.add('Only an administrator may delete groups. This ' + 'incident has been logged.') return self.redirect('/groups')
def handle_post(self, user): new_group = Group(parent=user_utils.get_parent_key(user), groupName=self.request.get("name"), groupDescription=self.request.get("description"), members=[user_utils.get_account_info(user).key]) new_group.put() self.redirect("/group?group_key=" + new_group.key.urlsafe())
def post(self, key): group = self.getGroup(key) if group is None: group = Group() group.name = self.request.get('group[name]') group.password = self.request.get('group[password]') try: slots = int(self.request.get('group[slots]')) if slots <= 0: raise ValueError('Below zero') group.slots = slots except ValueError as e: raise ValidationError( errors={ 'group[slots]': 'Must be an integer number above zero' }) project_key = self.request.get('group[project]') project = Project.get(project_key) if project_key != '' else None group.setProject(project) group.put() error_code = 1 if key == 'new' else 2 self.redirect('/admin/groups/{}'.format(group.key()), {'error': error_code})
def __init__(self, link_radii=arm_radius, joint_radii=arm_radius, link_lengths=[15,15,5,5], joint_colors=arm_color, link_colors=arm_color, base_loc=np.array([2., 0., -15]), **kwargs): ''' Instantiate the graphics and the virtual arm for a kinematic chain ''' num_joints = 2 self.num_joints = 2 self.link_radii = make_list(link_radii, num_joints) self.joint_radii = make_list(joint_radii, num_joints) self.link_lengths = make_list(link_lengths, num_joints) self.joint_colors = make_list(joint_colors, num_joints) self.link_colors = make_list(link_colors, num_joints) self.curr_vecs = np.zeros([num_joints, 3]) #rows go from proximal to distal links # set initial vecs to correct orientations (arm starts out vertical) self.curr_vecs[0,2] = self.link_lengths[0] self.curr_vecs[1:,0] = self.link_lengths[1:] # Create links self.links = [] for i in range(self.num_joints): joint = Sphere(radius=self.joint_radii[i], color=self.joint_colors[i]) # The most distal link gets a tapered cylinder (for purely stylistic reasons) if i < self.num_joints - 1: link = Cylinder(radius=self.link_radii[i], height=self.link_lengths[i], color=self.link_colors[i]) else: link = Cone(radius1=self.link_radii[-1], radius2=self.link_radii[-1]/2, height=self.link_lengths[-1], color=self.link_colors[-1]) link_i = Group((link, joint)) self.links.append(link_i) link_offsets = [0] + self.link_lengths[:-1] self.link_groups = [None]*self.num_joints for i in range(self.num_joints)[::-1]: if i == self.num_joints-1: self.link_groups[i] = self.links[i] else: self.link_groups[i] = Group([self.links[i], self.link_groups[i+1]]) self.link_groups[i].translate(0, 0, link_offsets[i]) # Call the parent constructor super(RobotArmGen3D, self).__init__([self.link_groups[0]], **kwargs) # Instantiate the kinematic chain object if self.num_joints == 2: self.kin_chain = robot_arms.PlanarXZKinematicChain(link_lengths) self.kin_chain.joint_limits = [(-pi,pi), (-pi,0)] else: self.kin_chain = robot_arms.PlanarXZKinematicChain(link_lengths) # TODO the code below is (obviously) specific to a 4-joint chain self.kin_chain.joint_limits = [(-pi,pi), (-pi,0), (-pi/2,pi/2), (-pi/2, 10*pi/180)] self.base_loc = base_loc self.translate(*self.base_loc, reset=True)
def choose_group(users): group = Group() for user in users: group.users.add(user) group.save() return group
def delete(self, key): """Deletes a group.""" if auth.user_is_admin(): Group.get(key).delete() else: Messages.add('Only an administrator may delete groups. This ' + 'incident has been logged.') return self.redirect('/groups')
def admin_group(): form = GroupForm() form.group_specialty.choices = [(h.id, h.long_form) for h in Specialty.get_all()] if form.validate_on_submit(): Group.add(form.group_number.data, form.group_course.data, form.group_specialty.data) flash(u'Спеціальність успішно додано') return redirect_back('admin_group') return render_template('admin_group.html', data=Group.get_all(), form=form)
def get_group(self, title): db.connect() try: g = Group.get(Group.title == title) except Group.DoesNotExist: g = Group.create(title = title) db.close() return g
def create_group(): form = {k: request.form[k].strip() for k in request.form} group = Group(name=form['name'], owner_id=int(current_user.id), info=('' if 'info' not in form else form['info'])) db.session.add(group) db.session.commit() print('group created') return Validity(True, group.get_info_map()).get_resp()
def create_or_read_group(group_id=None): from models import Group if group_id == None and request.method == 'GET': return Group.get_groups() elif group_id == None: group_name = request.json['group_name'] return Group.create_group(group_name) else: return Group.get_group(group_id)
def group(request): dbsession = DBSession() name = clean_matchdict_value(request, 'group') group = Group() group.name = name group.timestamp = get_timestamp() dbsession.add(group) transaction.commit() return {'status': 'success'}
def insert(self, group_name): existing_group = self._get_group(group_name=group_name) if existing_group: return existing_group group = Group() group.user = self.user_key group.name = group_name group.put() return group
def group(name): """ New or existing group """ try: group = Group.objects.get(name__exact=name) except: group = Group(name=name) group.save() return group
def handle_post(self, google_user): if self.request.get("group-key"): group_key = ndb.Key(urlsafe=self.request.get("group-key")) group = group_key.get() group.name = self.request.get("name") group.put() else: user = User.get_by_user(google_user) Group.insert_group(user=user, name=self.request.get("name")) self.redirect(self.request.referer)
def test_session_to_group(self): m = Mentor(name='Snoke') g1 = Group(name='Solo') g2 = Group(name='Generals') s1 = Student(name='Ray') s2 = Student(name='Kylo') s3 = Student(name='Hux') db.session.add(m) db.session.add(g1) db.session.add(g2) db.session.add(s1) db.session.add(s2) db.session.add(s3) db.session.commit() sesh1 = Session() g1.add_session(sesh1) db.session.add(sesh1) db.session.commit() g1.add_student(s1) g1.add_student(s2) g2.add_student(s3) assert g1.has_session(sesh1) assert sesh1.group_id == g1.id
def upload_opml_file(request): if request.method == 'POST': form = UploadOpmlFileForm(request.POST, request.FILES) if form.is_valid(): #opml_file = request.FILES['file'].read() #tree = ET.parse(opml_file) #root = tree.getroot() #for outline in root.iter('outline'): # source = Source(user=request.user, xml_url=outline.get('xmlUrl')) # source.save() Source.objects.all().delete() Group.objects.all().delete() group = None for event, elem in ET.iterparse(request.FILES['file']): #import pdb; pdb.set_trace() if elem.tag == 'body': outlines = list(elem) for outline in outlines: if 'xmlUrl' not in outline.attrib: group = Group(user=request.user, name=outline.attrib['title']) group.save() children = list(outline) for child in children: source = Source() source.text = child.attrib['text'] source.title = child.attrib['title'] source.feed_type = child.attrib['type'] source.xml_url = child.attrib['xmlUrl'] source.html_url = child.attrib['htmlUrl'] source.save() user_source = UserSource(user=request.user, source=source, group=group) user_source.save() elif 'xmlUrl' in outline.attrib: print outline.attrib source = Source() source.text = outline.attrib['text'] source.title = outline.attrib['title'] source.feed_type = outline.attrib['type'] source.xml_url = outline.attrib['xmlUrl'] source.html_url = outline.attrib['htmlUrl'] source.save() user_source = UserSource(user=request.user, source=source) user_source.save() return HttpResponseRedirect( reverse('entries') ) else: form = UploadOpmlFileForm() return render_to_response('feeds/upload_opml.html', {'form': form}, context_instance=RequestContext(request))
def address_book(item_type): """Add a person or group to the address book.""" data = json.loads(request.data) address_book = AddressBook.query.first() if not address_book: address_book = AddressBook() address_book.save() if item_type == "person": person_obj = Person(**data) try: person_obj.save() address_book.person_list.append(person_obj) except MissingValueException as e: return jsonify({ "saved": False, "type": "person", "data": data, "message": "Missing {}".format(e) }) except Exception as e: raise e elif item_type == "group": data['persons'] = [Person.query.get(x) for x in data['persons']] try: group_obj = Group(**data) group_obj.save() address_book.group_list.append(group_obj) except MissingValueException as e: return jsonify({ "saved": False, "type": "person", "message": "Missing {}".format(e) }) except BadValueException as e: return jsonify({ "saved": False, "type": "person", "message": "One of the Ids provided is not in Database" }) except Exception as e: raise e else: return jsonify( {"message": "The url has to be address_book/[person|group]"}), 404 address_book.save() return jsonify({ "message": "saved {} to Address Book".format(item_type), "data": json.loads(dumps(address_book.wrap())) })
def test_model_User_profile_change_default_group(self): username = "******" user = DjangoUser(username=username) user.save() profile = user.profile group = Group(name='testgroupname') group.save() profile.default_group = group profile.save() profile = User.objects.get(user=user) self.assertEquals(profile.default_group, group)
def _addStickTopic(self, webPage): """ 访问小组首页,添加置顶贴 """ #pdb.set_trace() group = Group(self.group_id) group.parse(webPage) self.group_info = group self.save_thread.putTask(self._saveGroupHandler, group)
def save_new_group(request): if request.method == 'POST': form = GroupForm(request.POST) if form.is_valid(): group = Group() group.name = form.cleaned_data['name'] group.max_loan_days = form.cleaned_data['max_loan_days'] group.save() return HttpResponseRedirect('/webconf/couchauth/')
def popup(self, pos): row = self.selectionModel().selection().indexes()[0].row() if row < 1: return menu = QMenu() delaction = menu.addAction("Supprimer") action = menu.exec_(self.mapToGlobal(pos)) if action == delaction: Group.get(Group.name == self.item(row).text()).delete_instance() self.refresh_()
def groups(request): if request.method == "GET": groups = Group.objects.all() return HttpResponse(format_groups(groups), mimetype="application/json") elif request.method == "POST": group = Group() data = json.loads(request.raw_post_data) if len(data["name"]) > 0: group.name = data["name"] group.save() return HttpResponse(format_groups([group]), mimetype="application/json") raise "Got Error?"
def group(request, id): c = {} group_info = get_group(request.session['token'], id) c['group_info'] = group_info c['member_map'] = {member[u'user_id']: member[u'nickname'] for member in group_info[u'members']} request.session['member_map'] = c['member_map'] if cache.get('group-%s' % id) and settings.CACHE_ENABLED: c['group'] = cache.get('group-%s' % id) return render(request, 'group.html', c) if request.GET.get('ajaxLoad', '0') == '0' and settings.CACHE_ENABLED: return render(request, 'group-loader.html', c) get_attachment = lambda x: x[0].get('url', None) if len(x) else None try: group = Group.objects.get(id=id) msgs = list(Message.objects.filter(group=group).order_by('created')) if msgs: after_id = msgs[-1].id if not str(after_id).isdigit(): after_id = 0 elif str(after_id) != str(group_info[u'messages'][u'last_message_id']): msgs += [Message( id=msg[u'id'], created=datetime.fromtimestamp(float(msg[u'created_at'])), author=msg[u'user_id'] if msg[u'user_id'] != 'system' else 0, text=msg[u'text'], img=get_attachment(msg[u'attachments']), likes=msg[u'favorited_by'], n_likes=len(msg[u'favorited_by']) ) for msg in msg_concurrent(request.session['token'], id, after_id=after_id, n_workers=(int(group_info[u'messages'][u'count'])/10 + 1))] group.analysis = analysis(request, msgs, group_info) except Group.DoesNotExist: msgs = [Message( id=msg[u'id'], created=datetime.fromtimestamp(float(msg[u'created_at'])), author=msg[u'user_id'] if msg[u'user_id'] != 'system' else 0, text=msg[u'text'], img=get_attachment(msg[u'attachments']), likes=msg[u'favorited_by'], n_likes=len(msg[u'favorited_by']) ) for msg in msg_concurrent(request.session['token'], id, n_workers=(int(group_info[u'messages'][u'count'])/10 + 1))] group = Group(id=id, analysis=analysis(request, msgs, group_info)) def save_msg(m): m.group = group m.save() map(lambda m: save_msg(m), msgs) if settings.CACHE_ENABLED: cache.set('group-%s' % id, group, 180) group.save() c['group'] = group return render(request, 'group.html', c)
def send_image(): """ send image/photo to given telegram user """ username = request.args.get("username", "") to_id = request.args.get("to", "") photo_file = request.files.get("photo", "") photo = request.form.get("photo", "") if not username: msg = "username missing" raise Error(msg) if not to_id: msg = "to id missing" raise Error(msg) if not any([photo_file, photo]): msg = "photo can not be blank" raise Error(msg) user_obj = User() user = user_obj.get(username=username) if not user: msg = "you dont have permisson to send notification" raise Error(msg) to = user_obj.get(username=to_id) if not to: group_obj = Group() to = group_obj.get(group_name=to_id) if not to: msg = "invalid to id" raise Error(msg) else: if photo: send_photo(my_bot, user["uid"], to["gid"], photo) else: out = BytesIO() out.write(photo_file.stream.read()) out.seek(0) send_photo(my_bot, user["uid"], to["gid"], out) return jsonify({"ok": 1}) if photo: send_photo(my_bot, user["uid"], to["uid"], photo) else: out = BytesIO() out.write(photo_file.stream.read()) out.seek(0) send_photo(my_bot, user["uid"], to["uid"], out) return jsonify({"ok": 1})
def post_group(jwt): group = request.get_json() name = group['name'] player_name = group['player_name'] try: group = Group(name=name, player_name=player_name) group.insert() except: abort(422) return jsonify({ 'success': True, 'group': group.full() })
def post(self): # get group name from request group_name = self.get_argument("groupName", "") response = {} if group_name: # create group group = Group(name=group_name) group.store() url = '//{0}{1}'.format(self.request.host, "/chat/{0}".format(group.key)) response = {"key": group.key, "url": url} return self.write(response)
def create(self, params): group_name = params['group_name'] try: self.db.session.query(Group).filter(Group.name == group_name).one() return self.get(warning="Group name already exists") except NoResultFound, e: group = Group() group.name = group_name sha1 = hashlib.sha1() sha1.update(group.name) group.hash_name = sha1.hexdigest()[0:10] self.db.session.add(group) self.db.session.commit() return redirect(url_for('scoreboard', hash_name=group.hash_name))
def _get_group(self, group_id=None, group_name=None): if group_id is not None: return Group.query( ndb.AND( Group.unique_id == group_id ) ).get() else: return Group.query( ndb.AND( Group.name == group_name, Group.user == self.user_key ) ).get()
def test_model_Group_basic(self): """Test Group model""" name = 'testgroup' obj = Group(name=name) obj.save() self.assertIsNone(obj.parent) self.assertIsNone(obj.details) self.assertQuerysetEqual(obj.child_set.all(), []) self.assertEqual(obj.get_absolute_url(), '/contacts/group/view/{}'.format(obj.id)) self.assertEqual(obj.get_root(), obj) self.assertEqual(obj.get_tree_path(), [obj]) self.assertIsNone(obj.get_contact()) self.assertFalse(obj.has_contact()) self.assertEqual(obj.get_fullname(), name) self.assertEqual(obj.get_perspective(), Perspective.objects.all()[0])
def post(self, *args, **kwargs): groupname = kwargs['groupname'] query = Group.query(Group.name == groupname) groups = query.fetch() if len(groups) == 1: thisGroup = groups[0] else: thisGroup = None user = self.user print(user) if user: memberships = GroupMembership.query(GroupMembership.userKey == user.key, GroupMembership.groupKey == thisGroup.key).fetch() if len(memberships) == 1: membership = memberships[0] print(membership) else: self.display_message('You can only post if you\'re a member') return if user: print(self.request.get('message')) newMessage = Message(parent=thisGroup.key, userKey=user.key, text=self.request.get('message')) newMessage.put() self.redirect('/{groupname}/show'.format(groupname = groupname))
def check_group(self, *args, **kwargs): logging.info('check_group') if not 'groupname' in kwargs: logging.error('No groupname although expected') self.display_message('No groupname provided.') groupName = kwargs['groupname'] print(groupName) query = Group.query(Group.name == groupName) groups = query.fetch() if len(groups) == 1: thisGroup = groups[0] else: thisGroup = None if not thisGroup: logging.error('Group "{groupname}" not found'.format(groupname = groupName)) self.redirect(self.uri_for('home'), abort=True) self.group = thisGroup if handler: return handler(self, *args, **kwargs) return handler
def add_store(): db = g._imdb developer_id = g.developer_id appid = KEFU_APPID name = request.form['name'] if request.form.has_key('name') else None if not name: return INVALID_PARAM() mode = default_mode db.begin() if mode == MODE_BROADCAST: gid = Group.create_group(db, appid, 0, name, False) else: gid = 0 store_id = Store.create_store(db, name, gid, mode, developer_id) db.commit() #将名称存储redis,用于后台推送 Store.set_store_name(g.im_rds, store_id, name) if gid: content = "%d,%d,%d"%(gid, appid, 0) publish_message(g.im_rds, "group_create", content) obj = {"store_id":store_id} return make_response(200, obj)