def unlink_activity(request):
POST = request.POST
activity_id = get_from_POST_or_404(POST, 'id')
entity_id = get_from_POST_or_404(POST, 'object_id')
entities = list(
CremeEntity.objects.filter(pk__in=[activity_id, entity_id]))
if len(entities) != 2:
raise http.Http404(ugettext('One entity does not exist any more.'))
has_perm = request.user.has_perm_to_unlink_or_die
for entity in entities:
has_perm(entity)
types = (
constants.REL_SUB_PART_2_ACTIVITY,
constants.REL_SUB_ACTIVITY_SUBJECT,
constants.REL_SUB_LINKED_2_ACTIVITY,
)
for relation in Relation.objects.filter(subject_entity=entity_id,
type__in=types,
object_entity=activity_id):
relation.delete()
return http.HttpResponse()
def set_selected(request):
POST = request.POST
field_id = get_from_POST_or_404(POST, 'field_id', cast=int)
report_id = get_from_POST_or_404(POST, 'report_id', cast=int)
try:
checked = bool(int(POST.get('checked', 0)))
except ValueError:
checked = False
with atomic():
report = get_object_or_404(Report.objects.select_for_update(),
id=report_id)
request.user.has_perm_to_change_or_die(report)
rfield = get_object_or_404(Field, id=field_id)
if rfield.report_id != report.id:
raise ConflictError('This Field & this Report do not match.')
if not rfield.sub_report_id:
raise ConflictError(
'This Field has no Report, so can no be (un)selected')
report = rfield.report
if rfield.selected != checked:
if checked: # Only one Field should be selected
report.fields.exclude(pk=rfield.pk).update(selected=False)
rfield.selected = checked
rfield.save()
return HttpResponse()
def get_update_kwargs(self):
POST = self.request.POST
return {
'segment_desc_id': get_from_POST_or_404(POST, self.segment_desc_id_arg, int),
'orga_id': get_from_POST_or_404(POST, self.orga_id_arg, int),
'score': get_from_POST_or_404(POST, self.score_arg, int),
}
def test_get_from_request_or_404(self):
request = {'name': 'robert', 'age': '36'}
self.assertRaises(Http404, get_from_GET_or_404, request, 'name_') # Key error
self.assertRaises(Http404, get_from_GET_or_404, request, 'name', int) # Cast error
self.assertRaises(Http404, get_from_GET_or_404, request, 'name_', int, default='string') # Cast error
self.assertEqual('36', get_from_POST_or_404(request, 'age'))
self.assertEqual(36, get_from_POST_or_404(request, 'age', int))
self.assertEqual(1, get_from_POST_or_404(request, 'name_', int, default=1))
def post(self, request, **kwargs):
strategy = self.get_related_entity()
POST = request.POST
segment_desc_id = get_from_POST_or_404(POST, self.segment_desc_id_arg, int)
orga_id = get_from_POST_or_404(POST, self.orga_id_arg, int)
category = get_from_POST_or_404(POST, self.category_id_arg, int)
try:
strategy.set_segment_category(segment_desc_id, orga_id, category)
except Exception as e:
raise Http404(str(e)) from e
return HttpResponse()
def perform_deletion(self, request):
cell_key = get_from_POST_or_404(request.POST, self.cell_key_arg)
self.object = cfci = self.get_cfci_for_update()
desc = self.get_customform_descriptor()
groups = []
found = False
for group in self.get_groups():
cells = []
# TODO: better API for group.cells ?
for cell in getattr(group, 'cells', ()):
if cell.key != cell_key:
cells.append(cell)
else:
found = True
groups.append(
FieldGroup(name=group.name, cells=cells, layout=group.layout
) if found else group)
if not found:
raise Http404(
f'The cell with key="{cell_key}" has not been found.')
cfci.store_groups(
FieldGroupList(model=desc.model,
groups=groups,
cell_registry=desc.build_cell_registry()))
cfci.save()
def post(self, request, *args, **kwargs):
layout = get_from_POST_or_404(request.POST, self.layout_arg)
if layout not in LAYOUTS:
raise ConflictError(f'The layout "{layout}" is invalid.')
self.object = cfci = self.get_cfci_for_update()
desc = self.get_customform_descriptor()
group_id = self.get_group_id()
# groups = [
# FieldGroup(name=group.name, cells=group.cells, layout=layout)
# if i == group_id else
# group
# for i, group in enumerate(self.get_groups())
# ]
groups = [*self.get_groups()]
groups[group_id]._layout = layout
cfci.store_groups(
FieldGroupList(
model=desc.model,
groups=groups,
cell_registry=desc.build_cell_registry(),
))
cfci.save() # TODO: only if changed ?
return HttpResponse()
def resend_mails(request):
ids = get_from_POST_or_404(request.POST, 'ids').split(',')
for email in EntityEmail.objects.filter(pk__in=ids):
email.send()
return {}
def _create_failed_pcall(request):
POST = request.POST
start = _build_date_or_404(get_from_POST_or_404(POST, 'call_start'))
user = request.user
user.has_perm_to_create_or_die(Activity) # TODO: test
me, person = _get_participants(user, POST)
pcall = failed_activity_creator(
user=user,
title=_('{status} call to {person} from Creme Mobile').format(
status=_('Failed'),
person=person,
),
type_id=act_constants.ACTIVITYTYPE_PHONECALL,
sub_type_id=act_constants.ACTIVITYSUBTYPE_PHONECALL_FAILED,
status_id=act_constants.STATUS_DONE,
start=start,
end=start,
minutes=POST.get('minutes', ''),
)
_add_participants(pcall, (me, person))
return pcall, me, person
def delete(request):
root_node = get_object_or_404(RootNode, pk=get_from_POST_or_404(request.POST, 'id'))
request.user.has_perm_to_change_or_die(root_node.graph)
root_node.delete()
return HttpResponse()
def delete_instance_brick(request):
get_object_or_404(
InstanceBrickConfigItem,
pk=get_from_POST_or_404(request.POST, 'id'),
).delete()
return HttpResponse()
def delete_rtype_brick(request):
get_object_or_404(
RelationBrickItem,
pk=get_from_POST_or_404(request.POST, 'id'),
).delete()
return HttpResponse()
def post(self, request, *args, **kwargs):
target = get_from_POST_or_404(request.POST,
self.target_order_arg,
cast=int)
self.object = cfci = self.get_cfci_for_update()
desc = self.get_customform_descriptor()
group_id = self.get_group_id()
groups = [*self.get_groups()]
if target > len(groups):
raise ConflictError(f'The target "{target}" is too big.')
moved_group = groups.pop(group_id)
groups.insert(target, moved_group)
cfci.store_groups(
FieldGroupList(
model=desc.model,
groups=groups,
cell_registry=desc.build_cell_registry(),
))
cfci.save() # TODO: only if changed ?
return HttpResponse()
def get_target_order(self):
"""Returns the future order (starting at 1) of the instance we want to move."""
order = get_from_POST_or_404(self.request.POST, self.target_order_post_argument, int)
if order < 1:
raise ConflictError('Target order must be greater than or equal to 1.')
return order
def _link(request, entity_id, relation_type_id):
managed_orga = get_object_or_404(get_organisation_model(),
pk=get_from_POST_or_404(request.POST, 'id', int),
)
entity = get_object_or_404(models.CremeEntity, pk=entity_id).get_real_entity()
relation_type = get_object_or_404(models.RelationType, pk=relation_type_id)
user = request.user
# TODO: in a Relation type method() ??
if not relation_type.subject_ctypes.filter(id=entity.entity_type_id).exists():
raise Http404('Incompatible relation type for subject') # TODO: ConflictError
# TODO: in a Relation type method() ??
if not relation_type.object_ctypes.filter(id=managed_orga.entity_type_id).exists():
raise Http404('Incompatible relation type for object') # TODO: ConflictError
has_perm_or_die = user.has_perm_to_link_or_die
has_perm_or_die(entity)
has_perm_or_die(managed_orga)
models.Relation.objects.safe_get_or_create(
subject_entity=entity,
type_id=relation_type_id,
object_entity=managed_orga,
user=user,
)
return HttpResponse()
def perform_deletion(self, request):
POST = request.POST
ct_id = get_from_POST_or_404(POST, self.ct_id_arg, cast=int)
if not ct_id:
raise Http404('Default config can not be deleted')
role_id = None
superuser = False
role_str = POST.get(self.role_arg)
if role_str:
if role_str == 'superuser':
superuser = True
else:
try:
role_id = int(role_str)
except ValueError:
raise Http404(
'"role" argument must be "superuser" or an integer')
BrickDetailviewLocation.objects.filter(
content_type=ct_id,
role=role_id,
superuser=superuser,
).delete()
def post(self, request, *args, **kwargs):
get_object_or_404(
SetCredentials,
id=get_from_POST_or_404(request.POST, self.creds_id_arg),
).delete()
return HttpResponse()
def post(self, request, **kwargs):
value = utils.get_from_POST_or_404(
request.POST,
key=self.value_arg,
cast=utils.bool_from_str_extended,
)
# NB: we can still have a race condition because we do not use
# select_for_update ; but it's a state related one user & one brick,
# so it would not be a real world problem.
for _i in range(10):
state = BrickState.objects.get_for_brick_id(
brick_id=self.brick_cls.id_,
user=request.user,
)
try:
if state.set_extra_data(
key=BRICK_STATE_HIDE_DELETED_CFIELDS,
value=value,
):
state.save()
except IntegrityError:
logger.exception('Avoid a duplicate.')
continue
else:
break
return HttpResponse()
def delete_user_calendar(request):
calendar = get_object_or_404(Calendar,
pk=get_from_POST_or_404(request.POST, 'id'))
user = request.user
# TODO: factorise calendar credentials functions ?
if not calendar.is_custom or (not user.is_superuser
and calendar.user_id != user.id):
raise PermissionDenied(
ugettext('You are not allowed to delete this calendar.'))
# Attach all existing activities to the default calendar
replacement_calendar = Calendar.get_user_default_calendar(user)
if replacement_calendar == calendar:
replacement_calendar = Calendar.objects.filter(user=user)\
.exclude(id=calendar.id)\
.order_by('id')\
.first()
if replacement_calendar is None:
raise ConflictError(
ugettext('You cannot delete your last calendar.'))
for activity in calendar.activity_set.all():
activity.calendars.add(replacement_calendar)
calendar.delete()
def delete_detailview(request):
POST = request.POST
ct_id = get_from_POST_or_404(POST, 'id', int)
if not ct_id:
raise Http404('Default config can not be deleted')
role_id = None
superuser = False
role = POST.get('role')
if role:
if role == 'superuser':
superuser = True
else:
try:
role_id = int(role)
except ValueError:
raise Http404(
'"role" argument must be "superuser" or an integer')
BrickDetailviewLocation.objects.filter(
content_type=ct_id,
role=role_id,
superuser=superuser,
).delete()
return HttpResponse()
def post(self, request, *args, **kwargs):
POST = request.POST
start = get_from_POST_or_404(
POST,
key=self.start_arg,
cast=_js_timestamp_to_datetime,
)
end = get_from_POST_or_404(POST,
key=self.end_arg,
cast=_js_timestamp_to_datetime)
is_all_day = get_from_POST_or_404(
POST,
key=self.all_day_arg,
cast=bool_from_str_extended,
default='false',
)
activity = self.get_related_entity()
# Dropping a floating Activity on the Calendar fixes it.
if activity.floating_type == constants.FLOATING:
activity.floating_type = constants.NARROW
activity.start = start
activity.end = end
activity.is_all_day = is_all_day
activity.handle_all_day()
collisions = check_activity_collisions(
activity.start,
activity.end,
participants=[
r.object_entity for r in activity.get_participant_relations()
],
busy=activity.busy,
exclude_activity_id=activity.id,
)
if collisions:
raise ConflictError(
', '.join(collisions)) # TODO: improve message?
activity.save()
return HttpResponse()
def delete_home(request):
get_object_or_404(
BrickHomeLocation,
pk=get_from_POST_or_404(request.POST, 'id'),
# app_name='creme_core',
).delete()
return HttpResponse()
def delete_mypage(request):
get_object_or_404(
BrickMypageLocation,
pk=get_from_POST_or_404(request.POST, 'id'),
user=request.user,
).delete()
return HttpResponse()
def set_segment_category(request, strategy_id):
strategy = get_object_or_404(Strategy.objects.select_for_update(),
pk=strategy_id)
request.user.has_perm_to_change_or_die(strategy)
POST = request.POST
segment_desc_id = get_from_POST_or_404(POST, 'segment_desc_id', int)
orga_id = get_from_POST_or_404(POST, 'orga_id', int)
category = get_from_POST_or_404(POST, 'category', int)
try:
strategy.set_segment_category(segment_desc_id, orga_id, category)
except Exception as e:
raise Http404(str(e)) from e
return HttpResponse()
def perform_deletion(self, request):
try:
get_object_or_404(
self.model,
pk=get_from_POST_or_404(request.POST, self.id_arg),
).delete()
except ProtectedError as e:
raise ConflictError(e.args[0])
def delete_relation_type(request, graph_id):
rtype_id = get_from_POST_or_404(request.POST, 'id')
graph = get_object_or_404(Graph, pk=graph_id)
request.user.has_perm_to_change_or_die(graph)
graph.orbital_relation_types.remove(rtype_id)
return HttpResponse()
def get_email_ids(self, request):
try:
return [
int(s) for s in get_from_POST_or_404(
request.POST, self.email_ids_arg).split(',') if s.strip()
]
except ValueError as e:
raise ConflictError(str(e)) from e
def delete(request):
relation_type = get_object_or_404(RelationType, pk=get_from_POST_or_404(request.POST, 'id'))
if not relation_type.is_custom:
raise Http404("Can't delete a standard RelationType")
relation_type.delete()
return HttpResponse()
def delete(request):
sci = get_object_or_404(SearchConfigItem, id=get_from_POST_or_404(request.POST, 'id'))
if sci.is_default:
raise ConflictError('You cannot delete the default configuration')
sci.delete()
return HttpResponse()
def perform_deletion(self, request):
relation_type = get_object_or_404(
RelationType,
pk=get_from_POST_or_404(request.POST, self.id_arg),
)
if not relation_type.is_custom:
raise Http404("Can't delete a standard RelationType")
relation_type.delete()
