def seed_groups():
user1 = User.query.get(1)
user2 = User.query.get(2)
user3 = User.query.get(3)
group1 = Group(name="Gryffindor")
db.session.add(group1)
group2 = Group(name="Ravenclaw")
db.session.add(group2)
group3 = Group(name="Hufflepuff")
db.session.add(group3)
group4 = Group(name="Slytherin")
db.session.add(group4)
user1.groups.append(group1)
user1.groups.append(group2)
user1.groups.append(group3)
user2.groups.append(group1)
user2.groups.append(group2)
user2.groups.append(group3)
user3.groups.append(group1)
user3.groups.append(group2)
user3.groups.append(group3)
db.session.commit()
def post():
params = {'name': FieldString(requirement=True)}
try:
json_data = parse_req(params)
# Check valid params
validate(instance=json_data, schema=schema_group)
name = json_data.get('name', None)
except Exception as ex:
return send_error(message="Parameters error:" + str(ex))
row = Group.query.filter_by(name=name).first()
if row is not None:
return send_error(message='The group name has existed!')
create_date = get_datetime_now_s()
_id = str(uuid.uuid1())
new_group = Group(id=_id, name=name, create_date=create_date)
try:
db.session.add(new_group)
db.session.commit()
except Exception as ex:
return send_error(message=str(ex))
data = {'name': name}
return send_result(data=data, message="Create the group successfully!")
def register():
# if current_user.is_authenticated:
# return redirect(url_for('group', groupname=session['groupname']))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data.lower(),
email=form.email.data,
usertype=form.usertype.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
# auto-generate group when a new elderly user registered
if form.usertype.data == "elderly":
group = Group(groupname="Group-" + form.username.data.lower(),
elder=form.username.data,
admin=form.username.data)
db.session.add(group)
# let the registered elderly join his own gorup
myuser = User.query.filter(
User.username == form.username.data).first()
mygroup = Group.query.filter(
Group.admin == form.username.data).first()
myuser.join_group(mygroup)
db.session.commit()
flash('Welcome new user, please login now!', 'success')
return redirect(url_for('auth.login'))
return render_template('register.html', title='Register', form=form)
def add_group_form(form):
"""
Create a new Group table
:param form:
:return: if the group can be added, return the id of the group, else return False
"""
name = form.name.data
if Group.from_name(name) is not None:
flash("Ce groupe existe déjà", "danger")
return False
is_private = (form.is_private.data == 'private')
password = form.password.data
if not password and is_private:
flash("Vous devez mettre un mot de passe pour un groupe privé",
"danger")
return False
elif len(password) > 10:
flash("Veuillez rentrer un mot de passe de moins de 10 caractères",
"warning")
return False
db.session.add(
Group(name=name,
is_private=is_private,
password=password,
manager_id=current_user.id))
group_id = Group.from_name(name).id
db.session.add(Participate(group_id=group_id, member_id=current_user.id))
db.session.commit()
return group_id
def moderation():
if current_user.role == 'admin':
groups = Group.query.all()
admins = User.query.filter_by(role='admin').all()
current_time = {}
create_moderator_form = CreateModerForm()
for group in groups:
current_time[group.name] = datetime.now() + timedelta(hours=int(group.time_zone)) - timedelta(hours=int(Config.SERVER_TIME_ZONE))
if create_moderator_form.validate_on_submit():
if create_moderator_form.submit.data and create_moderator_form.validate():
for group in create_moderator_form.group.data:
gr = Group.query.get(group.id)
us = User.query.get(create_moderator_form.user.data.id)
gr.moderators.append(us)
db.session.commit()
return redirect(request.referrer)
create_group_form = CreateGroupForm()
if create_group_form.validate_on_submit():
if create_group_form.submit.data and create_group_form.validate():
group = Group()
group.name = create_group_form.name.data
db.session.add(group)
db.session.commit()
return redirect(request.referrer)
return render_template('admin/moderation.html', groups=groups, create_group_form=create_group_form,
create_moderator_form=create_moderator_form, current_time=current_time)
else:
return redirect(url_for('main.index'))
def create_groups():
req = request.get_json()
g_name = req['groupname']
has = Group.query.filter_by(group_name=g_name).first()
if has:
return jsonify({'status': 400})
group = Group(group_name=g_name, manager_id=current_user.id)
db.session.add(group)
db.session.commit()
g_id = Group.query.filter_by(group_name=g_name).first()
datas = req['data']
for data in datas:
vh = GroupValidHeaders(group_id=g_id.id,
header_name=data['header'],
data_type=data['type'])
db.session.add(vh)
db.session.commit()
db.engine.execute(
text(
f"UPDATE `user` SET group_id = {g_id.id} where id={current_user.id}"
))
return jsonify({'status': 200})
def save_similar_groups_into_database(filename='tmp/groups.csv'):
"""
Saves the group data from a .csv file into the database.
:param filename: – a string name of .csv file with group information
"""
with open(filename, 'r') as f:
reader = csv.reader(f)
groups = list(reader)
# An array of groups to save into the database
group_instances = []
# Fill the list of groups
for group in tqdm(groups[1:]):
name = group[0]
common = group[1]
gid = group[2]
group_instance = Group(gid=gid)
group_instance.name = name
group_instance.common_users = common
group_instances.append(group_instance)
# Add all into the database
db.session.add_all(group_instances)
db.session.commit()
def mutate(self, info, data, id_from_token):
a_level = GroupAccessEnum(data.access_level)
role = RoleEnum(data.admin_role)
new_group = Group(title=data.title,
about=data.about,
access_level=a_level,
date_creation=datetime.utcnow(),
date=data.date,
admin_id=id_from_token)
try:
db.add(new_group)
commit_with_check(db)
except:
db.rollback()
db.refresh(new_group)
try:
db.add(
GroupUser(group_id=new_group.id,
user_id=id_from_token,
role_in_group=role))
commit_with_check(db)
except:
db.rollback()
return AddGroup(ok=True,
message="Group has been added!",
ID=new_group.id)
def test_user_post_group(self):
u = User()
g = Group()
p = Post()
u.my_group = g
p.author = g
self.assertTrue(p.author.owner[0])
def groups():
if request.method == "POST":
name = request.args['name']
donated = float(request.args['donated'])
if name:
group = Group(name=name)
group.donated = donated
group.save()
response = jsonify({
'id': group.id,
'name': group.name,
'donated': group.donated
})
response.status_code = 201
return response
else:
groups = Group.get_all()
ret_list = []
for group in groups:
json_elm = {
'id': group.id,
'name': group.name,
'donated': group.donated
}
ret_list.append(json_elm)
response = jsonify(ret_list)
response.status_code = 200
return response
def add_group():
if not current_user.is_authenticated or current_user.role != 'admin':
return redirect(url_for('login'))
form1 = AddGroup(prefix="form1")
if form1.validate_on_submit() and form1.submit.data:
old_group = Group.query.filter(Group.name == form1.name.data).first()
if old_group is not None:
flash('Group already exists')
return redirect(url_for('add_group'))
group = Group(name=form1.name.data)
db.session.add(group)
db.session.commit()
flash('Group is added')
return redirect(url_for('add_group'))
db_group_list = Group.query.all()
group_list = [(i.group_id, i.name) for i in db_group_list]
form2 = DeleteGroup(prefix="form2")
form2.groups.choices = group_list
if form2.validate_on_submit() or form2.submit.data:
group = Group.query.filter(Group.group_id == form2.groups.data) \
.all()[0]
for st in group.students:
us = User.query.filter(User.id == st.std_id).first()
db.session.delete(us)
db.session.delete(group)
db.session.commit()
flash('Group is deleted')
return redirect(url_for('add_group'))
return render_template('add_group.html', form1=form1, form2=form2)
def team_match_storage(self, data):
for d in data:
group = Group.query.filter_by(name=d["group_name"]).first()
if group is None:
group = Group(name=d["group_name"])
db.session.add(group)
v1 = Team.query.filter_by(name=d["v1"]).first()
if v1 is None:
v1 = Team(name=d["v1"], group=group)
v1_pinyin = TeamPinYin(name=pinyin.get(d["v1"],
format="strip"),
team=v1)
db.session.add(v1)
db.session.add(v1_pinyin)
v2 = Team.query.filter_by(name=d["v2"]).first()
if v2 is None:
v2 = Team(name=d["v2"], group=group)
v2_pinyin = TeamPinYin(name=pinyin.get(d["v2"],
format="strip"),
team=v2)
db.session.add(v2)
db.session.add(v2_pinyin)
db.session.commit()
duel = Duel(team_er=v1,
team_ed=v2,
t1_score=d["vs"][0],
t2_score=d["vs"][2],
datetime=d["datetime"],
area=d["area"],
group_cls=d["group_cls"])
db.session.add(duel)
db.session.commit()
print("保存%s小组赛成功..." % d["group_name"])
def create_group(user_id):
print(f"{user_id} making post request to /group")
post_data = request.get_json()
group_name = post_data['group_name']
print(group_name)
#TODO: there is no need for group to have unique name
group = Group.query.filter_by(name=group_name).first()
if group:
return make_response(
jsonify({
"success": False,
"message": "group already exists. Try a different name"
})), 409
# TODO: add the member in a transaction
group = Group(name=group_name)
db.session.add(group)
db.session.commit()
group = group.query.filter_by(name=group_name).first()
member = Member(user_id, group.id, False)
db.session.add(member)
db.session.commit()
return make_response(
jsonify({
"success": True,
"message": "group created successfully"
})), 200
def test_mass_delete(self):
from app.models import Group
g1 = Group(name="g1", project_id=self.project1._id)
g1.save()
h1 = Host(fqdn="host1", group_id=g1._id)
h1.save()
h2 = Host(fqdn="host2", group_id=g1._id)
h2.save()
h3 = Host(fqdn="host3", group_id=g1._id)
h3.save()
h4 = Host(fqdn="host4", group_id=g1._id)
h4.save()
r = self.post_json("/api/v1/hosts/mass_delete",
{"host_ids": [str(h2._id), str(h3._id)]})
self.assertEqual(200, r.status_code)
data = json.loads(r.data)
self.assertIn("data", data)
hosts_data = data["data"]
self.assertIn("hosts", hosts_data)
hosts_data = hosts_data["hosts"]
self.assertIs(list, type(hosts_data))
self.assertEqual(2, len(hosts_data))
deleted_hosts = Host.find({"_id": {"$in": [h2._id, h3._id]}})
self.assertEqual(0, deleted_hosts.count())
g1 = Group.find_one({"_id": g1._id})
self.assertItemsEqual([h1._id, h4._id], g1.host_ids)
def create_obj():
first_group = Group(id=0, title="No Group")
db.session.add(first_group)
first_edu = Educator(id=0, title="No Educator")
db.session.add(first_edu)
db.session.commit()
def setUp(self):
super().setUp()
with self.app.app_context():
role = Role.query.filter_by(name='admin').first()
user = User.query.filter_by(id=self.std_user.id).first()
grp = Group(name='tempGroup', roles=[role], users=[user])
db.session.add(grp)
db.session.commit()
def test_get_groups(self):
group = Group(group_name="swvl")
db.session.add(group)
db.session.commit()
response = self.client.get("group")
data = json.loads(response.data)
return self.assertEquals(data.get("count"), 1)
def get_or_insert_group(platform, group_id, group_name):
while True:
group = get_group(group_id, platform)
if not group: # 不存在，就新建
group = Group(platform=platform, group_id=group_id, group_name=group_name)
db.session.add(group)
db.session.commit()
else:
return group
def create_group():
form = CreateGroupForm()
if form.validate_on_submit():
group = Group(name=form.name.data, creator_id=current_user.id)
db.session.add(group)
db.session.commit()
flash('Your group has been created')
return redirect(url_for('users.all_groups'))
return render_template('create_group.html', form=form)
def test_add_to_group(self):
"""Tests if users can be added to groups"""
user = self.create_test_user()
group = Group(code='1234', active=True)
db.session.add(group)
db.session.commit()
user.add_to_group(group)
assert group in user.groups_of_student()
assert user in group.students.all()
def new_group():
"""Create a new group."""
form = NewGroupForm()
if form.validate_on_submit():
group = Group(name=form.name.data, users=form.users.data)
db.session.add(group)
db.session.commit()
flash('Group {} successfully created'.format(group.name),
'form-success')
return render_template('admin/new_group.html', form=form)
def add_group(user, name):
if Group.query.filter_by(name=name).filter(
Group.users.any(id=user.id)).first():
return
group = Group(name=name)
set_class_code(group)
add_user(group, user)
db.session.add(group)
db.session.commit()
return group
def test_2_add_groups(self):
print('\n------ add groups ----------')
names = ['math', 'english', 'history']
groups = []
for name in names:
group = Group(name=name)
groups.append(group)
db.session.add(group)
db.session.commit()
print(Group.query.all())
def post():
form = GroupForm() # need to create a form
if form.validate_on_submit():
new_group = Group()
new_group.leader_id = request.json["leader_id"]
form.populate_obj(new_group)
db.session.add(new_group)
db.session.commit()
return new_group.to_dict()
return "Bad Data"
def groups():
form = GroupForm()
if form.validate_on_submit():
group = Group(name=form.name.data)
db.session.add(group)
db.session.commit()
flash('Your group is now live!')
return redirect(url_for('groups'))
groups = Group.query.all()
return render_template('groups.html', groups=groups, form=form)
def addGroup(name):
"""Add group to database.
args:
name: string
"""
group = Group()
group.name = name
group.members.append(current_user)
db.session.add(group)
db.session.commit()
return group.id
def process_group(self, group_id, count):
posts = self.get_group_posts(group_id, count)
duplicate = Group.query.filter_by(item_id=group_id).first()
if not duplicate:
group = Group(item_id=group_id)
db.session.add(group)
db.session.commit()
current_group = Group.query.filter_by(item_id=group_id).first()
for post in posts:
self.like(post['id'], current_group)
def add_group():
form = AddGroupForm()
if form.validate_on_submit():
gid = form.gid.data
group = Group(gid)
group.user_id = g.user.id
db.session.add(group)
db.session.commit()
run_watching()
return redirect(url_for('index'))
def createGroup():
form = GroupForm()
if form.validate_on_submit():
group = Group(name=form.name.data)
current_user.groups.append(group)
db.session.add(group)
db.session.commit()
flash('Congratulations, you have now created a new group!')
return redirect(url_for('index'))
return render_template('create_group.html', form=form)
def add_group():
if request.method == 'POST':
form = request.form
name = form.get('name')
group_id = form.get('group_id')
if group_id:
group = Group.query.get(group_id)
if group:
db.session.delete(group)
db.session.commit()
if name:
if group_id:
group = Group(group_id=group_id, name=name)
else:
group = Group(name=name)
db.session.add(group)
db.session.commit()
return redirect('/group')
return "of the jedi"
