def grp_drop():
grpid = json.loads(request.args['grpid'])
try:
Group.delete(grpid)
return jsonify(groups=Group.get_all())
except Exception as ex:
return jsonify(error=str(ex))
def start_story(message, user, group):
match = regex_dotall(r'^start (?P<code>.+)', message.text.lower())
if not match:
logging.info("No start code provided")
return Result(response_type=INFO, messages=[START_INSTRUCTIONS], user=user, group=group)
code = match.groupdict().get('code')
story_code = StoryCode.build_key(code).get()
if not story_code:
logging.info("Couldn't find story for code: %s", code)
return Result(response_type=INFO, messages=[STORY_NOT_FOUND], user=user, group=group)
if story_code.used:
logging.info("Story code already used: %s", code)
return Result(response_type=INFO, messages=[CODE_ALREADY_USED], user=user, group=group)
story_code.use()
start_clue = Clue.get_by_id('{}:START'.format(story_code.story_uid))
if not start_clue:
raise ValueError('Story {} has no clue named "START"'.format(story_code.story_uid))
group_code = Group.gen_uid()
group = Group.from_uid(group_code, clue_uid=start_clue.uid, story_uid=story_code.story_uid, user_keys=[user.key], activation_code=story_code.word_string)
return Result(
response_type=INFO,
messages=[INTRO_INSTRUCTIONS, start_clue],
user=user,
group=group,
)
def grp_add():
values = json.loads(request.form['params'])
try:
grpid = Group.add(values)
return jsonify(grpid=grpid, groups=Group.get_all())
except Exception as ex:
return jsonify(error=str(ex))
def get(self, group_id):
template_params={}
user = None
if self.request.cookies.get('our_token'): #the cookie that should contain the access token!
user = User.checkToken(self.request.cookies.get('our_token'))
if not user:
html = template.render("web/templates/index.html", {})
self.response.write(html)
return
#newlinks
linkslist=Link.getAllLinksPerUser(user)
newurls = []
template_params = {}
if linkslist:
for link in linkslist:
url = link.url_link
des = link.description
fromlink=link.from_link
if fromlink is not None:
urlandlink =[url,des,fromlink]
newurls.append(urlandlink)
template_params['newurls'] = newurls
#newlinks
template_params['useremail'] = user.email
grouplist= Group.getAllGroups(user)
groups= []
if grouplist:
for group in grouplist:
group_name= group['group_name']
groupid=group['id']
one=[group_name,groupid]
groups.append(one)
template_params['groupss']= groups
group = Group.get_by_id(int(group_id))
if group is None:
return
if group.admin != user.key and user.key not in group.members:
template_params['no_access'] = True
html = template.render('web/templates/mygroups.html', template_params)
self.response.write(html)
return
else:
template_params['group_name'] = group.group_name
template_params['group_id'] = group_id
linksInGroup=group.getLinks()
links= []
for link in linksInGroup:
link_user_name= link['email']
link_description= link['description']
link_url_link= link['url_link']
link_date= link['time_of_enter_the_link']
one=[link_user_name,link_description,link_url_link,link_date]
links.append(one)
links.reverse()
template_params['links']= links
html = template.render('web/templates/mygroupschat.html', template_params)
self.response.write(html)
def grp_update():
values = json.loads(request.form['params'])
grpid = values['id']
try:
Group.update(values)
return jsonify(grpid=grpid, groups=Group.get_all())
except Exception as ex:
return jsonify(error=str(ex))
def post(self):
form = GroupForm(self.request.arguments)
if form.validate():
group = Group(**form.data)
user_id = self.get_current_user_id()
user = User.get(user_id)
user.groups.append(group)
group.save()
self.redirect(self.reverse_url('group', group.id))
else:
self.redirect(self.reverse_url('groups')) # Todo エラーメッセージを渡す
def create_test_group_needing_approval(**kwargs):
user = kwargs['user']
group = Group()
group.active = True
group.title = "Grupo"
group.description = "Description"
group.needs_approval_to_join = True
group.admins.append(user)
group.subscriptions.append(user)
db.session.add(group)
db.session.commit()
approve_subscription_of_user(user,group)
return group
def get(self):
template_params={}
user = None
if self.request.cookies.get('our_token'): #the cookie that should contain the access token!
user = User.checkToken(self.request.cookies.get('our_token'))
if not user:
html = template.render("web/templates/index.html", {})
self.response.write(html)
return
#newlinks
linkslist=Link.getAllLinksPerUser(user)
newurls = []
template_params = {}
if linkslist:
for link in linkslist:
url = link.url_link
des = link.description
fromlink=link.from_link
if fromlink is not None:
urlandlink =[url,des,fromlink]
newurls.append(urlandlink)
template_params['newurls'] = newurls
#newlinks
template_params['useremail'] = user.email
grouplist= Group.getAllGroups(user)
groups= []
if grouplist:
for group in grouplist:
group_name= group['group_name']
groupid=group['id']
one=[group_name,groupid]
groups.append(one)
template_params['groupss']= groups
html = template.render("web/templates/mygroups.html", template_params)
self.response.write(html)
def grp_members():
grpid = json.loads(request.args['grpid'])
try:
data = Group.get_members(grpid)
return jsonify(members=data)
except Exception as ex:
return jsonify(error=str(ex))
def get(self):
group = Group.get_by_id(int(self.request.get('group_id')))
user = None
if self.request.cookies.get('our_token'): #the cookie that should contain the access token!
user = User.checkToken(self.request.cookies.get('our_token'))
if not user or group.admin != user.key:
self.error(403)
self.response.write('access denied')
return
new_user_email = self.request.get('member_email')
logging.info("Email {}".format(new_user_email))
new_user = User.query(User.email == new_user_email).get()
if not new_user:
self.error(404)
self.response.write('User with email {} not found'.format(new_user_email))
return
group.members.append(new_user.key)
group.put()
members = group.getMembers()
time.sleep(0.5)
self.response.write(json.dumps({"status": "OK", "members": members}))
def _test_group_survey_percolation(self):
# see surveys in a group's list of active_surveys
survey_id = Survey().create_generic_item(creator_id=None, item_id=self.generic_group_id, item_type='Group')
self.generic_group_data = Group().get_item(self.generic_user_id)
active_surveys = self.generic_group_data.get('active_surveys', [])
message = "expected survey_id {0} in group {1} active_surveys".format(survey_id, self.generic_group_id)
self.assertIn(survey_id, active_surveys, message)
def post(self, group_id):
user_id = self.get_argument('user_id', '')
user = User.get(user_id)
group = Group.get(group_id)
user.groups.append(group)
user.save()
self.redirect(self.reverse_url('member_addition', group_id))
def group_join(group_id):
user = get_user()
group = Group.get(group_id)
if group.get_is_join(user.id):
group.join_user(user.id, False)
else:
group.join_user(user.id, True)
return redirect(url_for('group_show',group_id = group_id))
def post(self, group_id):
form = RoomForm(self.request.arguments)
if form.validate():
room = Room(**form.data)
group = Group.get(group_id)
group.rooms.append(room)
group.save()
self.redirect(self.reverse_url('rooms', group_id))
def groups():
if request.method == 'GET':
data = Group.get_all()
return render_template(
'groups.html',
title='Groups',
groups=data
)
def post(self, group_id):
form = GroupForm(self.request.arguments)
if form.validate():
group = Group.get(group_id)
group.update(**form.data)
group.save()
self.redirect(self.reverse_url('group', group_id))
else:
self.redirect(self.reverse_url('group', group_id))
def group_create():
if request.method == 'POST':
name = request.form['grp_name']
intro = request.form['grp_intro']
id = Group.create(name, intro, get_user().id)
if not id:
return header_render('group_create.html')
return redirect(url_for('group_show',group_id = id))
else:
return header_render('group_create.html')
def blog_create(group_id):
group = Group.get(group_id)
if request.method == 'POST':
title = request.form['blog_title']
content = request.form['blog_content']
id = Blog.create(title, content, get_user().id, group_id)
if not id:
return header_render('blog_create.html', group = group)
return redirect(url_for('blog_show',blog_id = id))
else:
return header_render('blog_create.html', group = group)
def group_show(group_id):
group = Group.get(group_id)
if group:
creator = doubanusers.User(id=group.creator_id)
blog_list = Blog.get_all_by_group(group_id)
is_join = group.get_is_join(get_user().id)
member_list = group.get_members()
return header_render('group_show.html',group=group, creator = creator,
blog_list = blog_list, is_join = is_join, member_list = member_list)
else:
abort(404)
def get(self):
template_params={}
group_name=self.request.get('group_name')
members= json.loads(self.request.get('members'))
user = None
if self.request.cookies.get('our_token'): #the cookie that should contain the access token!
user = User.checkToken(self.request.cookies.get('our_token'))
if not user:
self.error(403)
self.response.write('No user')
self.response.write(html)
return
group= Group()
group.group_name=group_name
group.admin= user.key
for newM in members:
usermem= User.checkIfUesr(newM)
group.members.append(usermem.key)
group.put()
self.response.set_cookie('our_token', str(user.key.id()))
self.response.write(json.dumps({'status':'OK'}))
return
def create_group_request_impl(args):
new_group = Group()
try:
admin = user_from_token(args['token'])
new_group.title = args['title']
new_group.description = args['description']
new_group.admins.append(admin)
new_group.subscriptions.append(admin)
new_group.needs_approval_to_join = bool(args['needs_approval'])
db.session.add(new_group)
db.session.commit()
approve_subscription_of_user(admin, new_group)
#add rules
if args.has_key('rules') and args['rules'] is not None:
for rule_dict in args['rules']:
new_rule = Rule(rule_dict['property'], int(rule_dict['operand']), rule_dict['value'], rule_dict['value_type'], new_group)
new_rule.name = rule_dict['name']
db.session.add(new_rule)
new_group.rules.append(new_rule)
db.session.commit()
user_can_join_group(admin, new_group)
#invite users
if args.has_key('invited_user_ids') and args['invited_user_ids'] is not None:
for invite_user_id in args['invited_user_ids']:
args = {'token': admin.user_token.token, 'group_id': new_group.id, 'user_id': int(invite_user_id)}
invite_request_impl(args)
db.session.commit()
return Response(True, "Group Created", GroupSchema().dumps(new_group).data).output()
except Exception as exception:
new_group.active = False
return Response(False, str(exception), None).output()
def wrapper():
if not current_user.is_authenticated:
return error(10111, 'require login')
args = func.__name__.split('_')
mod, action = args[0], args[1]
group_id = User.get(current_user.get_id()).group_id
if not group_id:
return error(10112, 'user cannot find group id')
auth_value = Group.get(group_id).__getattribute__(mod)
# print "auth_value=", auth_value
index = action_arr.index(action)
index = len(action_arr) - index - 1
if not (auth_value >> index & 1):
return error(10113, 'cannot access this action')
return func()
def csv_import():
if request.method == 'GET':
return render_template(
'contacts/csv_import.html',
title='Contact Import'
)
data = json.loads(request.form['params'])
dao = Dao(stateful=True)
# precincts = Precinct.get_by_jwp(dao)
groups = Group.get_all_by_code(dao)
memberships = []
next_id = dao.get_max_id('contacts', 'id')
for rec in data:
rec['precinct_id'] = None
next_id += 1
# if rec['jurisdiction'] and rec['ward'] and rec['precinct']:
# jwp = '%s:%s:%s' % (
# rec['jurisdiction'].upper(),
# rec['ward'].zfill(2),
# rec['precinct'].zfill(3)
# )
# rec['precinct_id'] = precincts[jwp]['id']
if rec['groups']:
for code in rec['groups'].split('/'):
if code in groups:
memberships.append({
'group_id': groups[code]['id'],
'contact_id': next_id,
'role': '',
'comment': ''
})
try:
con_dao.add_many(data)
GroupMember.add_many(memberships)
return jsonify(msg='Successful!')
except Exception as ex:
return jsonify(error=str(ex))
finally:
dao.close()
def join_group(message, user, group):
""" Join group by code """
match = regex_match(r'^join (?P<group_uid>.+)', message.text.lower())
if not match:
logging.info("No group code provided")
return Result(response_type=INFO, messages=[JOIN_GROUP_INSTRUCTIONS], user=user, group=group)
group_uid = match.groupdict().get('group_uid')
if user.group_uid == group_uid:
logging.info("Already in group for group_uid: %s", group_uid)
return Result(response_type=INFO, messages=[ALREADY_IN_GROUP], user=user, group=group)
if not group_uid:
logging.info("Need to specify a group_uid")
return Result(response_type=INFO, messages=[NO_GROUP_FOUND], user=user, group=None)
group = Group.get_by_id(group_uid)
if not group:
logging.info("Couldn't find group for group_uid: %s", group_uid)
return Result(response_type=INFO, messages=[NO_GROUP_FOUND], user=user, group=None)
group.user_keys.append(user.key)
user.group_uid = group.uid
clue = group.clue
return Result(response_type=JOINED, messages=[JOINED_GROUP, clue], user=user, group=group)
def get(self):
user = None
if self.request.cookies.get('our_token'): #the cookie that should contain the access token!
user = User.checkToken(self.request.cookies.get('our_token'))
if not user:
self.error(403)
self.response.write('No user')
self.response.write(html)
return
group_to_remove= Group.get_by_id(int(self.request.get('groupid')))
if group_to_remove is None:
return
if group_to_remove.admin == user.key:
group_to_remove.remove_group()
else:
group_to_remove.removeUserFromTheGroup(user)
time.sleep(0.5)
self.response.set_cookie('our_token', str(user.key.id()))
self.response.write(json.dumps({'status':'OK'}))
return
def test_subscribe_unsubscribe_user(self):
# create a survey and subscribe a user to a group
survey_id = Survey().create_generic_item(creator_id=None, item_id=self.generic_group_id, item_type='Group')
Group().subscribe_user(self.generic_user_id, self.generic_group_id)
self.generic_user_data = User().get_item(self.generic_user_id)
self.generic_group_data = Group().get_item(self.generic_group_id)
subscribers = self.generic_group_data.get('subscribers', [])
subscribed_groups = self.generic_user_data.get('subscribed_groups', [])
user_unanswered_surveys = self.generic_user_data.get('unanswered_surveys', [])
message1 = "expected group id {0} in user {1} subscribed_groups".format(self.generic_group_id, self.generic_user_id)
message2 = "expected user id {0} in group {1} subscribers".format(self.generic_user_id, self.generic_group_id)
message3 = "expected survey_id {0} in user {1} unanswered_surveys".format(survey_id, self.generic_user_id)
self.assertIn(self.generic_group_id, subscribed_groups, message1)
self.assertIn(self.generic_user_id, subscribers, message2)
self.assertIn(survey_id, user_unanswered_surveys, message3)
# create a new survey after the user has subscribed and see it percolate to the user
survey_id2 = Survey().create_generic_item(creator_id=None, item_id=self.generic_group_id, item_type='Group')
message4 = "expected survey_id {0} in user {1} unanswered_surveys".format(survey_id2, self.generic_user_id)
self.generic_user_data = User().get_item(self.generic_user_id)
user_unanswered_surveys = self.generic_user_data.get('unanswered_surveys', [])
self.assertIn(survey_id2, user_unanswered_surveys, message4)
pass
def get(self):
user = None
if self.request.cookies.get('our_token'): #the cookie that should contain the access token!
user = User.checkToken(self.request.cookies.get('our_token'))
if not user:
self.error(403)
self.response.write('No user - access denied')
return
group = Group()
group.title = self.request.get('title')
group.admin = user.key
group.put()
time.sleep(0.5)
groups = Group.getAllGroups(user)
self.response.write(json.dumps({"status": "OK", "groups": groups}))
import sys
sys.path.append('../../porper')
import os
region = os.environ.get('AWS_DEFAULT_REGION')
import boto3
dynamodb = boto3.resource('dynamodb', region_name=region)
from models.group import Group
group = Group(dynamodb)
params = {'name': 'public'}
group.create(params)
params = {'id': '1234', 'name': 'new'}
group.create(params)
params = {'id': 'abcd', 'name': 'old'}
group.create(params)
params = {'id': '1234'}
group.find(params)
params = {'ids': ['1234', 'tt']}
group.find(params)
params = {}
group.find(params)
class TestGroupSubscribe(BaseAsyncTest):
generic_user_id = ""
generic_user_data = {}
generic_group_id = ""
generic_user_data = {}
def setUpClass():
logging.disable(logging.CRITICAL)
TestGroupSubscribe.generic_user_id = User().create_generic_item()
TestGroupSubscribe.generic_user_data = User().get_item(TestGroupSubscribe.generic_user_id)
TestGroupSubscribe.generic_group_id = Group().create_generic_item()
TestGroupSubscribe.generic_group_data = Group().get_item(TestGroupSubscribe.generic_group_id)
return
def test_api_group(self):
with mock.patch.object(BaseHandler, 'get_current_user') as m:
m.return_value = User().get_item(self.generic_user_id)
bodya = urllib.parse.urlencode({})
bodyb = urllib.parse.urlencode({'groupname': self.generic_group_id})
bodyc = urllib.parse.urlencode({'groupname': str(time.time())})
bodyd = urllib.parse.urlencode({'groupname': 'not unique'})
response0 = self.fetch('/api/groups', body=bodya, method="POST")
response1 = self.fetch('/api/groups', body=bodyb, method="POST")
response2 = self.fetch('/api/groups', body=bodyc, method="POST")
response3 = self.fetch('/api/groups', method="GET")
self.assertEqual(response0.code, 400)
self.assertEqual(response1.code, 400)
self.assertEqual(response2.code, 200, str(response2.error))
self.assertEqual(response3.code, 200, str(response3.error))
def test_api_subscribe(self):
with mock.patch.object(BaseHandler, 'get_current_user') as m:
m.return_value = User().get_item(self.generic_user_id)
bodya = tornado.escape.json_encode({'action': 'sub'})
bodyb = tornado.escape.json_encode({'action': 'sub', 'id': self.generic_group_id})
bodyc = tornado.escape.json_encode({'action': 'sub', 'id': 'xxx'})
bodyd = tornado.escape.json_encode({'action': 'unsub', 'id': 'xxx'})
bodye = tornado.escape.json_encode({'action': 'unsub', 'id': self.generic_group_id})
response0 = self.fetch('/api/subscribe', body=bodya, method="POST")
response1 = self.fetch('/api/subscribe', body=bodyc, method="POST")
response2 = self.fetch('/api/subscribe', body=bodyb, method="POST")
response3 = self.fetch('/api/subscribe', body=bodyb, method="POST")
response4 = self.fetch('/api/subscribe', body=bodyd, method="POST")
response5 = self.fetch('/api/subscribe', body=bodye, method="POST")
response6 = self.fetch('/api/subscribe', body=bodye, method="POST")
self.assertEqual(response0.code, 400)
self.assertTrue('id cannot be null' in str(response0.error))
self.assertEqual(response1.code, 400)
self.assertTrue('group_id xxx does not correspond' in str(response1.error))
self.assertEqual(response2.code, 200)
self.assertEqual(response3.code, 400)
self.assertTrue('user is already subscribed to this group' in str(response3.error))
self.assertEqual(response4.code, 400)
self.assertTrue('group_id xxx does not correspond' in str(response4.error))
self.assertEqual(response5.code, 200)
self.assertEqual(response6.code, 400)
self.assertTrue('user is not yet subscribed to this group' in str(response6.error))
def _test_group_survey_percolation(self):
# see surveys in a group's list of active_surveys
survey_id = Survey().create_generic_item(creator_id=None, item_id=self.generic_group_id, item_type='Group')
self.generic_group_data = Group().get_item(self.generic_user_id)
active_surveys = self.generic_group_data.get('active_surveys', [])
message = "expected survey_id {0} in group {1} active_surveys".format(survey_id, self.generic_group_id)
self.assertIn(survey_id, active_surveys, message)
def test_subscribe_unsubscribe_user(self):
# create a survey and subscribe a user to a group
survey_id = Survey().create_generic_item(creator_id=None, item_id=self.generic_group_id, item_type='Group')
Group().subscribe_user(self.generic_user_id, self.generic_group_id)
self.generic_user_data = User().get_item(self.generic_user_id)
self.generic_group_data = Group().get_item(self.generic_group_id)
subscribers = self.generic_group_data.get('subscribers', [])
subscribed_groups = self.generic_user_data.get('subscribed_groups', [])
user_unanswered_surveys = self.generic_user_data.get('unanswered_surveys', [])
message1 = "expected group id {0} in user {1} subscribed_groups".format(self.generic_group_id, self.generic_user_id)
message2 = "expected user id {0} in group {1} subscribers".format(self.generic_user_id, self.generic_group_id)
message3 = "expected survey_id {0} in user {1} unanswered_surveys".format(survey_id, self.generic_user_id)
self.assertIn(self.generic_group_id, subscribed_groups, message1)
self.assertIn(self.generic_user_id, subscribers, message2)
self.assertIn(survey_id, user_unanswered_surveys, message3)
# create a new survey after the user has subscribed and see it percolate to the user
survey_id2 = Survey().create_generic_item(creator_id=None, item_id=self.generic_group_id, item_type='Group')
message4 = "expected survey_id {0} in user {1} unanswered_surveys".format(survey_id2, self.generic_user_id)
self.generic_user_data = User().get_item(self.generic_user_id)
user_unanswered_surveys = self.generic_user_data.get('unanswered_surveys', [])
self.assertIn(survey_id2, user_unanswered_surveys, message4)
pass
def tearDownClass():
logging.disable(logging.NOTSET)
# Drop the database
Group().delete_item(TestGroupSubscribe.generic_group_id)
User().delete_item(TestGroupSubscribe.generic_user_id)
import pymysql.cursors
from models.group import Group
# Connect to the database
connection = pymysql.connect(
host='localhost',
# port=8889,
user='******',
password='',
db='test',
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
try:
with connection.cursor() as cursor:
# Read a single record
sql = "SELECT group_name, group_header, group_footer, group_id FROM `group_list`"
cursor.execute(sql)
result = cursor.fetchall()
groups = []
for g in result:
groups.append(
Group(name=g['group_name'],
header=g["group_header"],
footer=g["group_footer"]))
print(groups)
connection.commit()
finally:
connection.close()
def all(gid):
u = current_user()
g = Group.get_one_by(group_id=gid)
print(g)
list = Tag.getAll(None, g)
return (list)
def group(request):
return Group(**request.param)
def group_modify(name, header, footer):
return Group(name_group=name, header=header, footer=footer)
def convert(group):
return Group(id=str(group.id), name=group.name,
header=group.header, footer=group.footer)
def new_group(name, header, footer):
return Group(name_group=name, header=header, footer=footer)
def non_empty_group_list(db, app):
if len(db.get_group_list()) == 0:
app.group.create(Group(name_group="testfortheemptyness"))
return db.get_group_list()
def all(gid):
u=current_user()
g = Group.get_one_by(group_id=gid)
list = Note.getAll(None, g)
return (list)
def createGroup(self,groupName):
group = Group(groupName)
group.createGroup()
self.joinGroup(groupName)
opts, args = getopt.getopt(sys.argv[1:], "n:f:", ["number of groups", "file"])
except:
getopt.usage()
sys.exit(2)
n = 5
f = "data/groups.json"
for o, a in opts:
if o == "-n":
n = int(a)
elif o == "-f":
f = a
def random_string(prefix, max_length):
sym = string.ascii_letters + string.digits + " "*20
#The following string generates random string, replaces duplicated spaces with only one and deletes space in the end
return re.sub('\s+', ' ', (prefix + "".join([random.choice(sym)
for i in range(random.randrange(max_length))]).rstrip()))
testdata = [Group(name="", header="", footer="")] + [
Group(name=random_string("name", 10), header=random_string("head", 15), footer=random_string("foot", 15))
for i in range(n)
]
data_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", f)
with open(data_file, "w") as f_out:
jsonpickle.set_encoder_options("json", indent=2)
f_out.write(jsonpickle.encode(testdata))
def make_group(codename):
#codename = random.choice(codenames)
group = Group.get_or_create(db.session, id=codename)
return group
from models.group import Group
testdata = [
Group(name_group="Name1", header="Header1", footer="Footer1"),
Group(name_group="Name2", header="Header2", footer="Footer2")
]
def __init__(self):
self.groups = [Group('Group {}'.format(i)) for i in range(5)]
self.users = []
self.user_group_map = {}
[chr(l) for l in range(0x0400, 0x04FF) if chr(l).isprintable()])
cyr_symbol_ru_uk = ''.join(
[chr(l) for l in range(0x0410, 0x0457) if chr(l).isprintable()])
def random_string(maxlen):
length = random.randrange(maxlen)
symbols = string.ascii_letters + string.digits + " " * 10 + string.punctuation + cyr_symbol_ru_uk
return ''.join([random.choice(symbols) for _ in range(length)])
file_name = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"group_data.json")
with open(file_name, encoding='utf-8') as f:
test_groups = [Group(**data) for data in json.load(f)]
test_groups += [
Group(name=random_string(14),
header=random_string(20),
footer=random_string(50)) for _ in range(3)
]
# names = ['', 'hgvjhsdfcs', "123"]
# headers = ['', 'hgvjhsdfcs', "123"]
# footers = ['', 'hgvjhsdfcs', "123"]
#
# test_groups = [
# Group(name=name, header=header, footer=footer)
# for name in names
# for header in headers
def get(self):
template_params = {}
user = None
if self.request.cookies.get('session'):
user = User.checkToken(self.request.cookies.get('session'))
if not user:
self.redirect('/')
return
group = None
template_params['userEmail'] = user.email
group_id = None
group_id = int(self.request.cookies.get('group_id_cookie'))
groupsLists = List.getAllListsNameOfTheUser(group_id, user.email)
if groupsLists:
template_params['groupLists'] = groupsLists
list_id = int(self.request.cookies.get('list_id_cookie'))
if list_id:
list = List.getListByID(list_id)
if list:
users = List.getAllListUsersByID(list_id)
template_params['listUsers'] = users
template_params['listName'] = list.ListName
template_params['listAdmin'] = list.ListAdmin
if (list.ListAdmin == user.email):
template_params['isListAdmin'] = user.email
else:
template_params['isNotListAdmin'] = user.email
# Retrieving all the groups names for showing on left side.
groupsNames = Group.getAllGroupsNames(user.email)
if groupsNames:
template_params['userGroups'] = groupsNames
template_params['group_id'] = group_id
#delete user from a list
deleteUser = self.request.get('deleteUser')
if deleteUser:
List.deleteUserFromList(deleteUser, list_id)
#add user to a list
addUser = self.request.get('addUser')
permit = self.request.get('permit')
if addUser:
userToAdd = List.checkIfUserInList(addUser)
if userToAdd == True:
self.response.write('userExist')
return
else:
#need to implement
self.response.write('userNotExist')
# changing a list name
newListName = self.request.get('newListName')
if newListName:
List.changeListName(list_id, newListName)
# check if asked to delete group
confirmDeletion = self.request.get('confirmDeletion')
if confirmDeletion:
List.deleteList(list_id, group_id)
self.response.delete_cookie('list_id')
time.sleep(0.3)
self.response.write('statusDeleted')
html = template.render("web/templates/listDetails.html",
template_params)
self.response.write(html)
def index(gid):
u = current_user()
g = Group.get_one_by(group_id=gid)
print(g)
return render_template("g_index.html", user=u, group=g)
questions_map = {}
def zeroPad(value):
return "0" + str(value) if value < 10 else str(value)
for i in range(0, len(postes)):
question_code = "Q{numeral}".format(numeral=zeroPad(i + 1))
question_name = "Qui voulez-vous au poste de {poste}?".format(
poste=postes[i])
attributes = [
Attribute("max_answers", "3"),
Attribute("max_subquestions", "3"),
Attribute("min_answers", "0")
]
group = Group(id=i, name=postes[i])
question = Question(id=i,
code=question_code,
gid=group.gid,
title=question_name,
attributes=attributes)
groups.append(group)
questions.append(question)
questions_map[postes[i]] = question
for candidat in fc.values:
for POSTE in POSTES_VISES:
poste = candidat[colonnes[POSTE]]
if isinstance(poste, str):
nom = candidat[colonnes[NOM_USUEL]]
from models.group import Group testdata = [Group(name="Name_1", header="Header_1", footer="Footer_1")]
def random_string(maxlen):
length = random.randrange(1, maxlen)
symbols = cyr_symbol + string.ascii_letters + string.digits + string.punctuation + " " * 10
result = ""
for i in range(length):
result += random.choice(symbols)
return result
print(random_string(255))
file_name = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"groups.json")
with open(file_name, encoding='utf8') as f:
groups_list = [Group(**data) for data in json.load(f)]
# groups_list = []
# for data in group_data:
# g = Group(name=data["name"], header=data["header"], footer=data["footer"])
# groups_list.append(g)
# print(groups_list)
# print(groups_list)
groups_list += [
Group(name=random_string(20),
header=random_string(50),
footer=random_string(150)) for _ in range(5)
]
def get_model(self):
return Group(id=self.id,
name=self.name,
header=self.header,
footer=self.footer)
def all(gid):
g = Group.get_one_by(group_id=gid)
t_list = Todo.getAll(None, g)
return (t_list)
def group_list_mine():
user = get_user()
group_list = Group.get_user_groups(user.id)
return header_render('group_list.html',title="我的小组",group_list=group_list)
def create_group() -> Group:
person1 = Person(first_name="Jan", last_name="Kowalski")
person2 = Person(first_name="Anna", last_name="Nowak")
player1 = Player(person=person1, username="******", password="******")
player2 = Player(person=person2, username="******", password="******")
return Group(name="group", players=[player1, player2])
def group_list_hot():
group_list = Group.get_hot_groups()
return header_render('group_list.html',title="热门小组",group_list=group_list)
def create_data():
#create some users
facebook_id = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(10))
rafael = User()
rafael.name = 'Rafael Goncalves'
rafael.facebook_id = facebook_id
rafael.birthday = date.today()
rafael.friends = 299
rafael.gender = 'male'
rafael.nickname = 'rafael'
rafael.email = '*****@*****.**'
db.session.add(rafael)
token = Token(rafael.id)
db.session.commit()
facebook_id2 = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(10))
bola = User()
bola.name = 'Bola Domingues'
bola.facebook_id = facebook_id2
bola.birthday = date.today()
bola.friends = 532
bola.gender = 'male'
bola.nickname = 'bola'
bola.email = '*****@*****.**'
db.session.add(bola)
token = Token(bola.id)
db.session.commit()
facebook_id3 = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(10))
bolovo = User()
bolovo.name = 'Doutor Bolovo'
bolovo.facebook_id = facebook_id3
bolovo.birthday = date.today()
bolovo.friends = 23
bolovo.gender = 'male'
bolovo.nickname = 'bolovo'
bolovo.email = '*****@*****.**'
db.session.add(bolovo)
token = Token(bolovo.id)
db.session.commit()
#create some groups
share_t = Group()
share_t.active = True
share_t.title = "Share Your Thoughts"
share_t.description = "Grupo copiado do facebook chamado share-your-thoughts"
share_t.admins.append(bola)
share_t.subscriptions.append(bola)
share_t.subscriptions.append(bolovo)
share_t.subscriptions.append(rafael)
db.session.add(share_t)
db.session.commit()
shammu = Group()
shammu.active = True
shammu.title = "Salvem as Baleias!"
shammu.description = "Grupo dedicado ao salvamento de baleias e o fechamentos de parques de entretenimento que usam animais em cativeiro para estrelar em suas atracoes"
shammu.admins.append(bola)
shammu.subscriptions.append(bolovo)
shammu.subscriptions.append(bola)
db.session.add(shammu)
db.session.commit()
share_c = Group()
share_c.active = True
share_c.title = "Share Your Career"
share_c.description = "Grupo dedicado ao compartilhamento de informacoes sobre estagios, empregos e carreiras em geral"
share_c.admins.append(bolovo)
share_c.subscriptions.append(bolovo)
share_c.subscriptions.append(rafael)
share_c.subscriptions.append(bola)
db.session.add(share_c)
db.session.commit()
#create some posts to share_t
share_t_post1 = Post('E possivel a contratacao de anoes para animar festar de criancas acima de 11 anos?', 0)
share_t_post1.group_id = bola.id
share_t_post1.user_id = share_t.id
db.session.add(share_t_post1)
db.session.commit()
share_t_post2 = Post('Algo para fazer esse fds??? Geoconda ta com nada me disseram migas!', 0)
share_t_post2.group_id = bolovo.id
share_t_post2.user_id = share_t.id
db.session.add(share_t_post2)
db.session.commit()
#create some posts to share_t
share_c_post1 = Post('[PUC][FACULDADE] Puc ou mackenzie!!!??', 0)
share_c_post1.group_id = bolovo.id
share_c_post1.user_id = share_c.id
db.session.add(share_c_post1)
db.session.commit()
share_c_post2 = Post('[EMPREGO][ENTREVISTA] Como e fazer uma entrevista no JPMorgan gente?', 0)
share_c_post2.group_id = bolovo.id
share_c_post2.user_id = share_c.id
db.session.add(share_c_post2)
db.session.commit()
#create some posts to shammu
shammu_post1 = Post('O seaworld realmente acabou ou o boato vem do cu do desentendido?', 0)
shammu_post1.group_id = bola.id
shammu_post1.user_id = shammu.id
db.session.add(shammu_post1)
db.session.commit()
#create comments
share_t_post1_comment = Comment('Obvio que sim querido, anoes sao para todos!')
share_t_post1_comment.user_id = bolovo.id
share_t_post1_comment.post_id = share_t_post1.id
db.session.add(share_t_post1_comment)
db.session.commit()
#create rules
only_woman = Rule('gender', RuleOperands.OPERAND_EQUAL, 'female', 'str', shammu)
shammu.rules.append(only_woman)
db.session.add(only_woman)
db.session.commit()
#create rules
only_male = Rule('gender', RuleOperands.OPERAND_EQUAL, 'male', 'str', shammu)
share_c.rules.append(only_male)
db.session.add(only_male)
db.session.commit()
def leaveGroup(self, groupName):
group_id = Group.getGroupId(groupName)
sql = "DELETE FROM `user-groups` WHERE `user_id` = %s AND `group_id` = %s "
User.cursor.execute(sql, (self.id,group_id))
from db_api.addressbook_orm import AddressbookORM
from models.group import Group
config = {
"host": "localhost",
"port": 8889,
"user": "******",
"password": "******",
"db": "test"
}
db = AddressbookORM(**config)
try:
l = db.get_contacts_in_group(Group(id='612'))
for c in l:
print(c)
print(len(l))
finally:
pass
def getAvailGroups(self):
groups = Group.selectAllgr()
mygroups = self.getMyGroups()
return [x for x in groups if x not in mygroups]
from models.user import User
from models.suggestion import Suggestion
from models.favorite import Favorite
from models.message import Message
from models.statistic import Statistic
from models.statistic import track_activity
from models.revision import Revision
if __name__ == "__main__":
Category.create_table(fail_silently=True)
Bot.create_table(fail_silently=True)
Country.create_table(fail_silently=True)
Channel.create_table(fail_silently=True)
User.create_table(fail_silently=True)
Suggestion.create_table(fail_silently=True)
Group.create_table(fail_silently=True)
Notifications.create_table(fail_silently=True)
Keyword.create_table(fail_silently=True)
Favorite.create_table(fail_silently=True)
APIAccess.create_table(fail_silently=True)
APIAccess.insert({
'user':
User.get(User.username == 'Josxa'),
'token':
'5f25218eb541b992b926c2e831d9e611853158e9bd69af56a760b717922029a9',
}).execute()
# Country.insert_many([
# {'name': 'Italy', 'emoji': '🇮🇹'},
# {'name': 'Brazil', 'emoji': '🇧🇷'},
def joinGroup(self,groupName):
group_id = Group.getGroupId(groupName)
sql = "INSERT INTO `user-groups` SET `user_id` = %s ,`group_id` = %s "
User.cursor.execute(sql, (self.id,group_id))
