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 group(name):
"""
New or existing group
"""
try:
group = Group.objects.get(name__exact=name)
except:
group = Group(name=name)
group.save()
return group
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 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)
