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
