def process_group_form(group=None):
"""
Validate and process submitted group form.
:param group:
:return:
"""
if request.method == 'GET':
# construct new form
if group:
# edit form
obj = dict(name=group.name,
owners=[u.name for u in group.owners],
packages=[p.name for p in group.packages])
form = forms.GroupForm(**obj)
else:
# creation form
form = forms.GroupForm(owners=[g.user.name])
return render_template('edit-group.html', group=group, form=form)
form = forms.GroupForm()
# check permissions
if group and not group.editable:
flash_nak("You don't have permission to edit this group")
return redirect(
url_for('group_detail', name=group.name,
namespace=group.namespace))
# check form validity
if not form.validate_or_flash():
return render_template('edit-group.html', group=group, form=form)
# existing group being edited or None - to be sent into template
existing_group = group
if not group:
group = PackageGroup(namespace=g.user.name)
db.add(group)
group.name = form.name.data
try:
db.flush()
except IntegrityError:
db.rollback()
flash_nak("Group already exists")
return render_template('edit-group.html',
group=existing_group,
form=form)
try:
data.set_group_content(session, group, form.packages.data)
data.set_group_maintainers(session, group, form.owners.data)
except data.PackagesDontExist as e:
db.rollback()
flash_nak(str(e))
return render_template('edit-group.html',
group=existing_group,
form=form)
db.commit()
flash_ack("Group created" if not existing_group else "Group modified")
return redirect(
url_for('group_detail', name=group.name, namespace=group.namespace))
def prepare_package(self):
pkg = self.prepare_basic_data()[0]
groups = PackageGroup(name='c'), PackageGroup(name='xml')
for group in groups:
self.s.add(group)
self.s.flush()
self.s.add(
PackageGroupRelation(group_id=group.id, package_id=pkg.id))
self.s.commit()
return pkg
def process_group_form(group=None):
if request.method == 'GET':
if group:
obj = dict(name=group.name,
owners=[u.name for u in group.owners],
packages=[p.name for p in group.packages])
form = GroupForm(**obj)
else:
form = GroupForm(owners=[g.user.name])
return render_template('edit-group.html', group=group, form=form)
form = GroupForm()
# check permissions
if group and not group.editable:
flash("You don't have permission to edit this group")
return redirect(
url_for('group_detail', name=group.name,
namespace=group.namespace))
# check form validity
if not form.validate_or_flash():
return render_template('edit-group.html', group=group, form=form)
names = set(form.packages.data)
users = [
get_or_create(db, User, name=name) for name in set(form.owners.data)
]
db.commit()
user_ids = [u.id for u in users]
packages = db.query(Package).filter(Package.name.in_(names))
found_names = {p.name for p in packages}
if len(found_names) != len(names):
flash("Packages don't exist: " + ', '.join(names - found_names))
return render_template('edit-group.html', group=group, form=form)
created = not group
if created:
group = PackageGroup(namespace=g.user.name)
db.add(group)
group.name = form.name.data
try:
db.flush()
except IntegrityError:
db.rollback()
flash("Group already exists")
return render_template('edit-group.html', group=group, form=form)
if not created:
db.query(PackageGroupRelation)\
.filter_by(group_id=group.id).delete()
db.query(GroupACL)\
.filter_by(group_id=group.id).delete()
rels = [dict(group_id=group.id, package_name=name) for name in found_names]
acls = [dict(group_id=group.id, user_id=user_id) for user_id in user_ids]
db.execute(PackageGroupRelation.__table__.insert(), rels)
db.execute(GroupACL.__table__.insert(), acls)
db.commit()
flash("Group created" if created else "Group modified")
return redirect(
url_for('group_detail', name=group.name, namespace=group.namespace))
def execute(self, session, name, content_from_file, append):
ns, name = PackageGroup.parse_name(name)
group = session.db.query(PackageGroup)\
.filter_by(name=name, namespace=ns or None).first()
if group:
sys.exit("Group already exists")
group = PackageGroup(name=name, namespace=ns)
session.db.add(group)
session.db.flush()
session.log_user_action("Group {} created".format(group.full_name))
self.set_group_content(session, group, content_from_file, append)
def process_group_form(group=None):
"""
Validate and process submitted group form.
:param group:
:return:
"""
if request.method == 'GET':
# construct new form
if group:
# edit form
obj = dict(name=group.name, owners=[u.name for u in group.owners],
packages=[p.name for p in group.packages])
form = forms.GroupForm(**obj)
else:
# creation form
form = forms.GroupForm(owners=[g.user.name])
return render_template('edit-group.html', group=group, form=form)
form = forms.GroupForm()
# check permissions
if group and not group.editable:
flash_nak("You don't have permission to edit this group")
return redirect(url_for('group_detail', name=group.name,
namespace=group.namespace))
# check form validity
if not form.validate_or_flash():
return render_template('edit-group.html', group=group, form=form)
# existing group being edited or None - to be sent into template
existing_group = group
if not group:
group = PackageGroup(namespace=g.user.name)
db.add(group)
group.name = form.name.data
try:
db.flush()
except IntegrityError:
db.rollback()
flash_nak("Group already exists")
return render_template('edit-group.html', group=existing_group, form=form)
try:
data.set_group_content(session, group, form.packages.data)
data.set_group_maintainers(session, group, form.owners.data)
except data.PackagesDontExist as e:
db.rollback()
flash_nak(str(e))
return render_template('edit-group.html', group=existing_group, form=form)
db.commit()
flash_ack("Group created" if not existing_group else "Group modified")
return redirect(url_for('group_detail', name=group.name,
namespace=group.namespace))
def process_group_form(group=None):
if request.method == 'GET':
if group:
obj = dict(name=group.name, owners=[u.name for u in group.owners],
packages=[p.name for p in group.packages])
form = GroupForm(**obj)
else:
form = GroupForm(owners=[g.user.name])
return render_template('edit-group.html', group=group, form=form)
form = GroupForm()
# check permissions
if group and not group.editable:
flash("You don't have permission to edit this group")
return redirect(url_for('group_detail', name=group.name,
namespace=group.namespace))
# check form validity
if not form.validate_or_flash():
return render_template('edit-group.html', group=group, form=form)
names = set(form.packages.data)
users = [get_or_create(db, User, name=name) for name in set(form.owners.data)]
db.commit()
user_ids = [u.id for u in users]
packages = db.query(Package).filter(Package.name.in_(names))
found_names = {p.name for p in packages}
if len(found_names) != len(names):
flash("Packages don't exist: " + ', '.join(names - found_names))
return render_template('edit-group.html', group=group, form=form)
created = not group
if created:
group = PackageGroup(namespace=g.user.name)
db.add(group)
group.name = form.name.data
try:
db.flush()
except IntegrityError:
db.rollback()
flash("Group already exists")
return render_template('edit-group.html', group=group, form=form)
if not created:
db.query(PackageGroupRelation)\
.filter_by(group_id=group.id).delete()
db.query(GroupACL)\
.filter_by(group_id=group.id).delete()
rels = [dict(group_id=group.id, package_name=name) for name in found_names]
acls = [dict(group_id=group.id, user_id=user_id) for user_id in user_ids]
db.execute(PackageGroupRelation.__table__.insert(), rels)
db.execute(GroupACL.__table__.insert(), acls)
db.commit()
flash("Group created" if created else "Group modified")
return redirect(url_for('group_detail', name=group.name,
namespace=group.namespace))
def execute(self, session, group, pkgs, maintainer):
namespace, name = PackageGroup.parse_name(group)
if (session.db.query(PackageGroup).filter_by(namespace=namespace,
name=name).count()):
sys.exit("Group already exists")
group_obj = PackageGroup(name=name, namespace=namespace)
session.db.add(group_obj)
session.db.flush()
session.log_user_action("Group {} created".format(group.full_name))
try:
data.set_group_content(session, group, pkgs)
data.set_group_maintainers(session, group, maintainer)
except data.PackagesDontExist as e:
sys.exit(str(e))
def test_set_group_contents_nonexistent(self):
group = PackageGroup(name='foo')
self.prepare_packages('bar')
self.db.add(group)
self.db.flush()
with self.assertRaises(data.PackagesDontExist) as exc:
data.set_group_content(self.session, group, ['bar', 'a1', 'a2'])
self.assertCountEqual({'a1', 'a2'}, exc.exception.packages)
def execute(self, backend, name, content_from_file, append):
ns, name = parse_group_name(name)
group = backend.db.query(PackageGroup)\
.filter_by(name=name, namespace=ns or None).first()
if group:
sys.exit("Group already exists")
group = PackageGroup(name=name, namespace=ns)
backend.db.add(group)
backend.db.flush()
self.set_group_content(backend, group, content_from_file, append)
backend.db.commit()
def add_group(self, group, pkgs):
group_obj = self.db.query(PackageGroup)\
.filter_by(name=group).first()
if not group_obj:
group_obj = PackageGroup(name=group)
self.db.add(group_obj)
self.db.flush()
for pkg in pkgs:
rel = PackageGroupRelation(group_id=group_obj.id,
package_id=pkg.id)
self.db.add(rel)
def execute(self, session, name, content_from_file, append):
ns, name = PackageGroup.parse_name(name)
group = session.db.query(PackageGroup)\
.filter_by(name=name, namespace=ns or None).first()
if group:
sys.exit("Group already exists")
group = PackageGroup(name=name, namespace=ns)
session.db.add(group)
session.db.flush()
session.log_user_action("Group {} created".format(group.full_name))
self.set_group_content(session, group, content_from_file, append)
def execute(self, session, current_name, new_name, new_namespace,
make_global, content_from_file, append):
ns, name = PackageGroup.parse_name(current_name)
group = session.db.query(PackageGroup)\
.filter_by(name=name, namespace=ns or None).first()
if not group:
sys.exit("Group {} not found".format(current_name))
if new_name:
group.name = new_name
if new_namespace:
group.namespace = new_namespace
if make_global:
group.namespace = None
self.set_group_content(session, group, content_from_file, append)
def execute(self, session, current_name, new_name, new_namespace,
make_global, content_from_file, append):
ns, name = PackageGroup.parse_name(current_name)
group = session.db.query(PackageGroup)\
.filter_by(name=name, namespace=ns or None).first()
if not group:
sys.exit("Group {} not found".format(current_name))
if new_name:
group.name = new_name
if new_namespace:
group.namespace = new_namespace
if make_global:
group.namespace = None
self.set_group_content(session, group, content_from_file, append)
def execute(self, session, group, pkgs, maintainer):
namespace, name = PackageGroup.parse_name(group)
if (session.db.query(PackageGroup)
.filter_by(namespace=namespace, name=name)
.count()):
sys.exit("Group already exists")
group_obj = PackageGroup(name=name, namespace=namespace)
session.db.add(group_obj)
session.db.flush()
session.log_user_action("Group {} created".format(group.full_name))
try:
data.set_group_content(session, group, pkgs)
data.set_group_maintainers(session, group, maintainer)
except data.PackagesDontExist as e:
sys.exit(str(e))
def prepare_group(self,
name,
content=(),
namespace=None,
owners=('john.doe', )):
users = [self.prepare_user(name=username) for username in owners]
packages = self.prepare_packages(*content)
group = PackageGroup(name=name, namespace=namespace)
self.db.add(group)
self.db.commit()
self.db.execute(PackageGroupRelation.__table__.insert(), [
dict(group_id=group.id, base_id=package.base_id)
for package in packages
])
self.db.execute(
GroupACL.__table__.insert(),
[dict(group_id=group.id, user_id=user.id) for user in users])
self.db.commit()
return group
def test_append_group_content(self):
group = PackageGroup(name='foo')
self.db.add(group)
self.db.flush()
bar, a1, a2, a3 = self.prepare_packages('bar', 'a1', 'a2', 'a3', 'a4')[:4]
rel = PackageGroupRelation(group_id=group.id, base_id=bar.base_id)
self.db.add(rel)
self.db.commit()
content = ['a1', 'a2', 'a3']
data.set_group_content(self.session, group, content, append=True)
self.assertCountEqual([bar.base_id, a1.base_id, a2.base_id, a3.base_id],
self.db.query(PackageGroupRelation.base_id)
.filter_by(group_id=group.id).all_flat())
self.assert_action_log(
"Group foo modified: package a1 added",
"Group foo modified: package a2 added",
"Group foo modified: package a3 added",
)
def add_packages():
"""
Mark multiple packages as tracked. Optionally add them to a group.
"""
form = forms.AddPackagesForm()
if request.method == 'POST':
if not form.validate_or_flash():
return render_template("add-packages.html", form=form)
names = set(form.packages.data)
try:
collection = [
c for c in g.collections if c.name == form.collection.data
][0]
except IndexError:
abort(404)
try:
added = data.track_packages(session, collection, names)
except data.PackagesDontExist as e:
db.rollback()
flash_nak(str(e))
# frontend doesn't have Koji access, so it needs to rely on backend's polling
flash_nak(
dedent("""
If a package has been just created, it is possible that it
hasn't been propagated to our database yet. In that case,
please, try again later.
"""))
return render_template("add-packages.html", form=form)
if form.group.data:
namespace, name = PackageGroup.parse_name(form.group.data)
group = db.query(PackageGroup)\
.filter_by(namespace=namespace, name=name)\
.first_or_404()
if not group.editable:
abort(400)
data.set_group_content(session, group, names, append=True)
flash_ack("Packages added: {}".format(','.join(p.name for p in added)))
db.commit()
return redirect(request.form.get('next') or url_for('frontpage'))
return render_template("add-packages.html", form=form)
def test_delete_group_content(self):
group = PackageGroup(name='foo')
self.db.add(group)
self.db.flush()
bar, a1, = self.prepare_packages('bar', 'a1', 'a2', 'a3')[:2]
rel = PackageGroupRelation(group_id=group.id, base_id=bar.base_id)
self.db.add(rel)
self.db.commit()
rel = PackageGroupRelation(group_id=group.id, base_id=a1.base_id)
self.db.add(rel)
self.db.commit()
content = ['a1']
data.set_group_content(self.session, group, content, delete=True)
self.assertCountEqual([bar.base_id],
self.db.query(
PackageGroupRelation.base_id).filter_by(
group_id=group.id).all_flat())
self.assert_action_log("Group foo modified: package a1 removed")
def add_packages():
"""
Mark multiple packages as tracked. Optionally add them to a group.
"""
form = forms.AddPackagesForm()
if request.method == 'POST':
if not form.validate_or_flash():
return render_template("add-packages.html", form=form)
names = set(form.packages.data)
try:
collection = [c for c in g.collections
if c.name == form.collection.data][0]
except IndexError:
abort(404)
try:
added = data.track_packages(session, collection, names)
except data.PackagesDontExist as e:
db.rollback()
flash_nak(str(e))
# frontend doesn't have Koji access, so it needs to rely on backend's polling
flash_nak(dedent("""
If a package has been just created, it is possible that it
hasn't been propagated to our database yet. In that case,
please, try again later.
"""))
return render_template("add-packages.html", form=form)
if form.group.data:
namespace, name = PackageGroup.parse_name(form.group.data)
group = db.query(PackageGroup)\
.filter_by(namespace=namespace, name=name)\
.first_or_404()
if not group.editable:
abort(400)
data.set_group_content(session, group, names, append=True)
flash_ack("Packages added: {}".format(','.join(p.name for p in added)))
db.commit()
return redirect(request.form.get('next') or url_for('frontpage'))
return render_template("add-packages.html", form=form)
def test_group_name_parse(self):
self.assertEqual((None, 'foo'), PackageGroup.parse_name('foo'))
self.assertEqual(('ns', 'bar'), PackageGroup.parse_name('ns/bar'))
