Esempio n. 1
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()
Esempio n. 2
0
    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)
Esempio n. 3
0
    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)
Esempio n. 4
0
 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
Esempio n. 5
0
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)
Esempio n. 6
0
    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)))
Esempio n. 7
0
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))
Esempio n. 8
0
 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
Esempio n. 10
0
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)
Esempio n. 11
0
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)
Esempio n. 12
0
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)
Esempio n. 13
0
    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))
Esempio n. 14
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)
Esempio n. 15
0
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"})
Esempio n. 16
0
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)
Esempio n. 17
0
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'添加失败'))
Esempio n. 18
0
    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
Esempio n. 19
0
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)
Esempio n. 20
0
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)
Esempio n. 21
0
 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())
Esempio n. 22
0
    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')
Esempio n. 23
0
def createNewGroup(username, groupName):
    try:
        examObject = Group.objects.get(exam_name=groupName)
    except:
        groupObject = Group(group_name=groupName)
        groupObject.save()
        addUserToGroup(username, groupName)
Esempio n. 24
0
    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)
Esempio n. 25
0
    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})
Esempio n. 26
0
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
Esempio n. 27
0
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)
Esempio n. 28
0
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()
Esempio n. 29
0
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()
Esempio n. 30
0
    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