def comment_delete(request):
_ = request.translate
"""
Delete an existing comment
"""
ret = {'success': False}
# check if id of comment is available
if request.POST['id'] is None:
ret['message'] = 'No comment id provided.'
return ret
# check if user has permissions to delete comments
if not isinstance(has_permission(
'moderate', request.context, request), ACLAllowed):
ret['message'] = 'Permission denied.'
return ret
# query comment
comment = Session.query(Comment).get(request.POST['id'])
if comment is None:
ret['message'] = 'Comment not found.'
return ret
Session.delete(comment)
ret['message'] = _('Comment successfully deleted.')
# if we've come this far, set success to 'True'
ret['success'] = True
return ret
def delete_all_values(request):
stack = []
nbr_activities = 0
for activity in Session.query(Activity).all():
nbr_changesets = 0
for changeset in Session.query(A_Changeset).filter(A_Changeset.fk_activity == activity.id).all():
Session.delete(changeset)
nbr_changesets += 1
nbr_tag_groups = 0
for tag_group in Session.query(A_Tag_Group).filter(A_Tag_Group.fk_activity == activity.id).all():
tag_group.fk_a_tag = None
Session.flush()
nbr_tags = 0
for tag in Session.query(A_Tag).join(A_Tag_Group, A_Tag_Group.id == A_Tag.fk_a_tag_group).join(Activity).filter(and_(A_Tag.fk_a_tag_group == tag_group.id,
A_Tag_Group.fk_activity == activity.id)).all():
Session.delete(tag)
nbr_tags += 1
Session.flush()
Session.delete(tag_group)
nbr_tag_groups += 1
Session.delete(activity)
nbr_activities += 1
try:
stack.append(str(nbr_changesets) + ' changesets deleted.')
stack.append(str(nbr_tags) + ' tags deleted.')
stack.append(str(nbr_tag_groups) + ' tag groups deleted.')
stack.append(str(nbr_activities) + ' activities deleted.')
except UnboundLocalError:
pass
return {'messagestack': stack}
def delete_sample_values(request):
# Trigger
delete_fix_data = True
stack = []
# BEGIN delete sample values ----------------------------------------------------------------------
stack.append('--- sample data ---')
inv_counter = 0
all_involvements_beneficiary = Session.query(Involvement).filter(Involvement.fk_stakeholder_role == 4).all()
for aib in all_involvements_beneficiary:
inv_counter += 1
Session.delete(aib)
if (inv_counter > 0):
stack.append(str(inv_counter) + ' involvements deleted.')
all_a_reviews = Session.query(A_Changeset_Review).filter(or_(A_Changeset_Review.comment.like('[active] Review_Comment %'), A_Changeset_Review.comment.like('[overwritten] Review_Comment %'), A_Changeset_Review.comment.like('[deleted] Review_Comment %'), A_Changeset_Review.comment.like('[overwritten] Review_Comment %'))).all()
rev_counter = 0
for aar in all_a_reviews:
rev_counter += 1
Session.delete(aar)
if (rev_counter > 0):
stack.append(str(rev_counter) + " a_changeset_reviews deleted.")
all_sh_reviews = Session.query(SH_Changeset_Review).filter(or_(SH_Changeset_Review.comment.like('[active] Review_Comment %'), SH_Changeset_Review.comment.like('[overwritten] Review_Comment %'), SH_Changeset_Review.comment.like('[deleted] Review_Comment %'), SH_Changeset_Review.comment.like('[overwritten] Review_Comment %'))).all()
rev_counter = 0
for asr in all_sh_reviews:
rev_counter += 1
Session.delete(asr)
if (rev_counter > 0):
stack.append(str(rev_counter) + " sh_changeset_reviews deleted.")
#all_activities = Session.query(Activity).join(A_Changeset).filter(or_(A_Changeset.source.like('[active] Source %'), A_Changeset.source.like('[pending] Source %'), A_Changeset.source.like('[overwritten] Source %'), A_Changeset.source.like('[deleted] Source %'), A_Changeset.source.like('[overwritten] Source %'))).all()
# Select all activities
all_activities = Session.query(Activity)
act_counter = 0
tag_counter = 0
ch_counter = 0
for aa in all_activities:
# delete tag groups
tag_groups = aa.tag_groups
tag_groups.main_tag = None
for tg in tag_groups:
tg.fk_a_tag = None
tags = tg.tags
for t in tags:
tag_counter += 1
Session.delete(t)
Session.delete(tg)
# delete changesets
changesets = aa.changesets
for ch in changesets:
ch_counter += 1
Session.delete(ch)
# delete activities
act_counter += 1
Session.delete(aa)
if (tag_counter > 0 or act_counter > 0 or ch_counter > 0):
stack.append(str(tag_counter) + " a_tags deleted.")
stack.append(str(ch_counter) + " a_changesets deleted.")
stack.append(str(act_counter) + " activities deleted.")
all_stakeholders = Session.query(Stakeholder).join(SH_Changeset).filter(or_(SH_Changeset.source.like('[active] Source %'), SH_Changeset.source.like('[pending] Source %'), SH_Changeset.source.like('[overwritten] Source %'), SH_Changeset.source.like('[deleted] Source %'), SH_Changeset.source.like('[overwritten] Source %'))).all()
sh_counter = 0
tag_counter = 0
ch_counter = 0
for alls in all_stakeholders:
# delete tag groups
tag_groups = alls.tag_groups
for tg in tag_groups:
tags = tg.tags
for t in tags:
tag_counter += 1
Session.delete(t)
Session.delete(tg)
# delete changesets
changesets = alls.changesets
for ch in changesets:
ch_counter += 1
Session.delete(ch)
# delete activities
sh_counter += 1
Session.delete(alls)
if (tag_counter > 0 or sh_counter > 0 or ch_counter > 0):
stack.append(str(tag_counter) + " sh_tags deleted.")
stack.append(str(ch_counter) + " sh_changesets deleted.")
stack.append(str(act_counter) + " stakeholders deleted.")
# END delete sample values ------------------------------------------------------------------------
# -- BEGIN delete fix data ------------------------------------------------------------------------
if (delete_fix_data):
stack.append('--- fix data ---')
# a_tags
counter = 0
all_a_keys = Session.query(A_Key).all()
for ak in all_a_keys:
Session.delete(ak)
counter += 1
if (counter > 0):
stack.append(str(counter) + " a_keys deleted.")
# a_values
counter = 0
all_a_values = Session.query(A_Value).all()
for av in all_a_values:
Session.delete(av)
counter += 1
if (counter > 0):
stack.append(str(counter) + " a_values deleted.")
# sh_tags
counter = 0
all_sh_keys = Session.query(SH_Key).all()
for shk in all_sh_keys:
Session.delete(shk)
counter += 1
if (counter > 0):
stack.append(str(counter) + " sh_keys deleted.")
# sh_values
counter = 0
all_sh_values = Session.query(SH_Value).all()
for shv in all_sh_values:
Session.delete(shv)
counter += 1
if (counter > 0):
stack.append(str(counter) + " sh_values deleted.")
# status
counter = 0
all_status = Session.query(Status).all()
for status in all_status:
Session.delete(status)
counter += 1
if (counter > 0):
stack.append(str(counter) + " status deleted.")
# stakeholder_roles
counter = 0
all_stakeholder_roles = Session.query(Stakeholder_Role).all()
for sh_role in all_stakeholder_roles:
Session.delete(sh_role)
counter += 1
if (counter > 0):
stack.append(str(counter) + " stakeholder_roles deleted.")
# groups
counter = 0
all_groups = Session.query(Group).all()
for group in all_groups:
Session.delete(group)
counter += 1
if (counter > 0):
stack.append(str(counter) + " groups deleted.")
# permissions
counter = 0
all_permissions = Session.query(Permission).all()
for perm in all_permissions:
Session.delete(perm)
counter += 1
if (counter > 0):
stack.append(str(counter) + " permissions deleted.")
# review_decisions
counter = 0
all_review_decisions = Session.query(Review_Decision).all()
for revdec in all_review_decisions:
Session.delete(revdec)
counter += 1
if (counter > 0):
stack.append(str(counter) + " review_decisions deleted.")
# languages
counter = 0
all_languages = Session.query(Language).all()
for lang in all_languages:
Session.delete(lang)
counter += 1
if (counter > 0):
stack.append(str(counter) + " languages deleted.")
# users
counter = 0
all_users = Session.query(User).all()
for user in all_users:
Session.delete(user)
counter += 1
if (counter > 0):
stack.append(str(counter) + " users deleted.")
# END delete fix data -----------------------------------------------------------------------------
if len(stack) == 0:
stack.append('Nothing was deleted.')
return {'messagestack':stack}
