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 __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 __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 post(self): args = group_parser.parse_args() group = Group(args["name"]) current_user.groups.append(group) db.session.add(group) db.session.commit() return group
def add_group(): """Creates a new group for the user.""" if not g.user: return redirect(url_for('login')) error = None if request.method == 'POST': if request.form['group_name']: if Group.query.filter_by( group_name=request.form['group_name']).first(): flash('Failed: Group name exists, please use another name.') return redirect(url_for('add_group')) db.session.add( Group(session['user_id'], request.form['group_name'], request.form['description'], int(time.time()))) db.session.commit() un = User.query.filter_by(user_id=session['user_id']).first() gp = Group.query.filter_by( group_name=request.form['group_name']).first() un.follows.append(gp) db.session.commit() flash('Group created!') return redirect(url_for('user_groups')) return render_template('index.html', error=error)
def test_list_group(self): # fixtures groups = [{ "name": "groupie_a", "description": "groupie_a desc" }, { "name": "groupie_b", "description": "groupie_b desc" }, { "name": "groupie_c", "description": "groupie_c desc" }] groups_orm = list() for group in groups: group_orm = Group(**group) db.session.add(group_orm) groups_orm.append(group_orm) db.session.commit() # adding returned ids from DB to the fixtures to compare them later ro response groups = list( map(lambda i: dict(groups[i], id=groups_orm[i].id), range(len(groups)))) response = self.client.get("/group", content_type="application-json") # test response status code self.assertEqual(response.status_code, 200) # test response count value self.assertEqual(response.json['count'], 3) # test response actual returned objects count self.assertEqual(len(response.json['items']), 3) # checking if each of the fixtures are included in the items (doing it this way instead of direct compare because order isn't always guaranteed) self.assertTrue( all(map(lambda group: group in response.json['items'], groups)))
def create_project(): json_data = request.get_json() if not json_data: return jsonify({"message": "No json provided"}), 400 try: data = ps.project_create_schema.load(json_data) except ValidationError as err: return jsonify({"error": err.messages}), 422 course = Course.query.get(data['course_id']) if not course: return jsonify(error="Course ID not found"), 400 if course.owner_id != current_user.id: return jsonify(error="Unauthorized to add a project to course"), 403 project = Project(name=data['name'], description=data['description'], start_date=data['start_date'], due_date=data['due_date'], course_id=data['course_id'], type=data['type']) db.session.add(project) db.session.commit() if 'group' in data['type']: for group in data['groups']: g = Group(project_id=project.id) for user in group: u = User.query.get(user['id']) g.users.append(u) db.session.add(g) db.session.commit() return jsonify(message="success", project=ps.project_schema.dump(project))
def create_group(self, subject_code, theory, seminar, name, date_valid, leader_name, phone, email, user, id=None): if id: try: gr=Group.objects.get(id=id) except: log.debug("Group isnt exist !") return None else: gr=Group() try: log.debug("Subject code: "+subject_code) subject=Subject.objects.get(activated=True, public='Y', subject_code=subject_code) except Subject.DoesNotExist: log.debug("Subject isnt exist") return None gr.subject=subject gr.user=user gr.class_theory=theory gr.class_seminar=seminar date_obj=datetime.strptime(date_valid, '%m/%d/%Y') gr.date_valid_until=date_obj gr.group_leader=leader_name gr.phone=phone gr.email=email gr.group_name=name return gr
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 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 handle_join_event(event): text = INTRO_TEXT leave_group(event.source.group_id) new_group = Group(event.source.group_id) current_app.session.add(new_group) current_app.session.commit() return TextSendMessage(text=text)
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 addGroup(): if 'email' not in session: return redirect(url_for('signin')) user = Smarketer.query.filter_by(username=session['email']).first() if user is None: return redirect(url_for('signin')) else: form = GroupForm() if request.method == 'POST': if form.validate() == False: return render_template('addGroup.html', form=form) else: totalTitle = form.groupTitle.data + " - " + form.groupID.data newGroup = Group(form.groupID.data, totalTitle) db.session.add(newGroup) db.session.commit() form.groupID.data = "" form.groupTitle.data = "" return render_template('addGroup.html', form=form, success=True) elif request.method == 'GET': return render_template('addGroup.html', form=form)
def groupAdd(): info = request.get_json() or {} group = Group(name=info["name"]) print(info["name"]) db.session.add(group) db.session.commit() return jsonify({"response": "ok"})
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 post(self): self.parser.add_argument('name', type=group_name, required=True, help='name must be at least 5 characters') self.parser.add_argument('url', type=url_validator, required=True, help='url is invalid') args = self.parser.parse_args() name = args['name'].lower() group = Group.query.filter((Group.name == name) & (Group.user_id == g.user.id)).first() if group is not None: message = 'group with {0} name exists already'.format(name) return {'message': message}, 403 group = Group.query.filter((Group.path == args['url']) & (Group.user_id == g.user.id)).first() if group is not None: message = 'group with {0} url exists already'.format(args['url']) return {'message': message}, 403 group = Group(name=name, path=args['url'], user_id=g.user.id) db.session.add(group) db.session.commit() return marshal(group, self.group_field, envelope='data'), 201
def create_class(): class_name = request.form.get('class_name') deadline = request.form.get('deadline') groups = json.loads(request.form.get('groupJSON')) class_create = Class(class_name, deadline) print(class_name, deadline, groups) db.session.add(class_create) db.session.commit() for i, g in enumerate(groups): group_password = ''.join( random.choice(string.ascii_uppercase + string.digits) for _ in range(8)) password_hash = bcrypt.generate_password_hash(group_password) group = Group(username=g['username'], password_hash=password_hash, members=g['members'], class_id=class_create.id) groups[i]['password'] = group_password db.session.add(group) db.session.commit() mailer.send_passwords(groups) response = dict() response['success'] = True response['message'] = "Successfully created class " + class_name + "!" return jsonify(response)
def register(): ''' Create admin account if it does not exist ''' from datetime import datetime exists = db.session.query( Group.id).filter_by(username='******').scalar() is not None if not exists: username = '******' password = '******' password_hash = bcrypt.generate_password_hash(password) admin = 1 group = Group(username, password_hash, admin) db.session.add(group) db.session.commit() message = "Admin account successfully created!" else: message = "Admin account exists already!" return render_template('register.html', message=message, year=datetime.now().year)
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 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 createNewGroup(username, groupName): try: examObject = Group.objects.get(exam_name=groupName) except: groupObject = Group(group_name=groupName) groupObject.save() addUserToGroup(username, groupName)
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 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 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 manage_group(): form = ManageGroupForm() if form.validate_on_submit(): if not form.manage.data: if form.group_name.data == 'Others': flash('The group name can\'t be \'Others\'') return render_template('manage_group.html', form=form) group = Group.query.filter_by( uid=current_user.id, group_name=form.group_name.data).first() if group is None: group = Group(uid=current_user.id, group_name=form.group_name.data) db.session.add(group) db.session.commit() flash('Success!') return redirect(url_for('contacts')) flash('The group exists!') else: group = Group.query.filter_by( uid=current_user.id, group_name=form.group_name.data).first() if group is not None: for friend in Friend.query.filter_by(uid=current_user.id, gid=group.id).all(): friend.gid = None db.session.add(friend) db.session.commit() db.session.delete(group) db.session.commit() flash('Success') return redirect(url_for('contacts')) flash('The group does not exist!') return render_template('manage_group.html', form=form)
def route_flow(bot_in, message_in, session_in): """Основной поток маршрутизации. """ global bot, message, session, user, group flow_list = [ 'ask_name', 'ask_password', 'ask_date', 'done', ] status_dic = { 'ask_name': ask_name, 'ask_password': ask_password, 'ask_date': ask_date, 'done': finish } bot = bot_in message = message_in session = session_in user = session.query(User).filter_by( telegramid=message.from_user.id).first() user.operation.decode_additional() if not user.operation.current_operation or user.operation.current_operation != opGroup: user.operation.current_operation = opGroup user.operation.additional_info = {} current_step = 0 else: if user.operation.operation_status in flow_list: current_step = flow_list.index(user.operation.operation_status) else: current_step = 0 group = user.operation.additional_info.get('group_id') if group: group = session.query(Group).filter(Group.id == group, Group.owner == user).first() if not group: group = Group(owner=user) session.add(group) user.operation.code_additional() session.commit() user.operation.decode_additional( ) # @Разобраться. Без этого после отмены в additional итогда что-то левое после commit образуется user.operation.additional_info['group_id'] = group.id current_step = 0 if utils.text_lower_wo_command(message) in standard.cancel_commands: cancel_all() user.operation.code_additional() return user.operation.operation_status = flow_list[current_step] while status_dic[flow_list[current_step]](): current_step += 1 user.operation.operation_status = flow_list[current_step] user.operation.code_additional()
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 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