def user_remove(request):
    is_confirmation = 'remove_confirm' in request.session
    if is_confirmation:
        if request.method == 'POST':
            remove_user(request.user, request)
            rotate_token(request)
            logout(request)
            messages.success(
                request,
                _('Your account has been removed.')
            )
            return redirect('home')
        confirm_form = EmptyConfirmForm(request)

    elif request.method == 'POST':
        confirm_form = PasswordConfirmForm(request, request.POST)
        if confirm_form.is_valid():
            store_userid(request, remove=True)
            request.GET = {'email': request.user.email}
            return social_complete(request, 'email')
    else:
        confirm_form = PasswordConfirmForm(request)

    return render(
        request,
        'accounts/removal.html',
        {
            'confirm_form': confirm_form,
            'is_confirmation': is_confirmation,
        }
    )

    def post(self, request, **kwargs):
        component = self.get_component()
        if not request.user.has_perm('screenshot.add', component):
            raise PermissionDenied()
        self._add_form = ScreenshotForm(request.POST, request.FILES)
        if self._add_form.is_valid():
            obj = Screenshot.objects.create(
                component=component,
                user=request.user,
                **self._add_form.cleaned_data
            )
            request.user.profile.uploaded += 1
            request.user.profile.save(update_fields=['uploaded'])

            try_add_source(request, obj)
            messages.success(
                request,
                _(
                    'Screenshot has been uploaded, '
                    'you can now assign it to source strings.'
                )
            )
            return redirect(obj)
        messages.error(
            request,
            _('Failed to upload screenshot, please fix errors below.')
        )
        return self.get(request, **kwargs)

def mail_admins_contact(request, subject, message, context, sender, to):
    """Send a message to the admins, as defined by the ADMINS setting."""
    LOGGER.info(
        'contact form from %s',
        sender,
    )
    if not to and settings.ADMINS:
        to = [a[1] for a in settings.ADMINS]
    elif not settings.ADMINS:
        messages.error(
            request,
            _('Message could not be sent to administrator!')
        )
        LOGGER.error(
            'ADMINS not configured, can not send message!'
        )
        return

    mail = EmailMultiAlternatives(
        '{0}{1}'.format(settings.EMAIL_SUBJECT_PREFIX, subject % context),
        message % context,
        to=to,
        headers={'Reply-To': sender},
    )

    mail.send(fail_silently=False)

    messages.success(
        request,
        _('Message has been sent to administrator.')
    )

def add_user(request, project):
    """Add user to a project."""
    obj, form = check_user_form(request, project, True)

    if form is not None:
        try:
            user = form.cleaned_data['user']
            obj.add_user(user)
            Change.objects.create(
                project=obj,
                action=Change.ACTION_ADD_USER,
                user=request.user,
                details={'username': user.username},
            )
            messages.success(
                request, _('User has been added to this project.')
            )
        except Group.DoesNotExist:
            messages.error(
                request, _('Failed to find group to add a user!')
            )

    return redirect(
        'manage-access',
        project=obj.slug,
    )

    def save(self, request, delete_session=False):
        notify_account_activity(
            self.user,
            request,
            'password',
            password=self.user.password
        )
        # Change the password
        password = self.cleaned_data["new_password1"]
        self.user.set_password(password)
        self.user.save(update_fields=['password'])

        # Updating the password logs out all other sessions for the user
        # except the current one.
        update_session_auth_hash(request, self.user)

        # Change key for current session
        request.session.cycle_key()

        # Invalidate password reset codes
        invalidate_reset_codes(self.user)

        if delete_session:
            request.session.flush()

        messages.success(
            request,
            _('Your password has been changed.')
        )

def change_access(request, project):
    obj = get_project(request, project)

    if not request.user.has_perm('billing:project.permissions', obj):
        raise PermissionDenied()

    form = ProjectAccessForm(request.POST, instance=obj)

    if not form.is_valid():
        for error in form.errors:
            for message in form.errors[error]:
                messages.error(request, message)
    else:
        form.save()
        Change.objects.create(
            project=obj,
            action=Change.ACTION_ACCESS_EDIT,
            user=request.user,
            details={'access_control': obj.access_control},
        )
        messages.success(
            request, _('Project access control has been changed.')
        )

    return redirect(
        'manage-access',
        project=obj.slug,
    )

def delete_user(request, project):
    """Remove user from a project."""
    obj, form = check_user_form(request, project, True)

    if form is not None:
        owners = User.objects.all_admins(obj)
        user = form.cleaned_data['user']
        is_owner = owners.filter(pk=user.pk).exists()
        if is_owner and owners.count() <= 1:
            messages.error(request, _('You can not remove last owner!'))
        else:
            obj.remove_user(user)
            Change.objects.create(
                project=obj,
                action=Change.ACTION_REMOVE_USER,
                user=request.user,
                details={'username': user.username},
            )
            messages.success(
                request, _('User has been removed from this project.')
            )

    return redirect(
        'manage-access',
        project=obj.slug,
    )

def change_component(request, project, component):
    obj = get_component(request, project, component)

    if not request.user.has_perm('component.edit', obj):
        raise Http404()

    if request.method == 'POST':
        form = ComponentSettingsForm(request.POST, instance=obj)
        if form.is_valid():
            form.save()
            messages.success(request, _('Settings saved'))
            return redirect(
                'settings', project=obj.project.slug, component=obj.slug
            )
        else:
            messages.error(
                request,
                _('Invalid settings, please check the form for errors!')
            )
    else:
        form = ComponentSettingsForm(instance=obj)

    return render(
        request,
        'component-settings.html',
        {
            'project': obj.project,
            'object': obj,
            'form': form,
        }
    )

def comment(request, pk):
    """Add new comment."""
    unit = get_object_or_404(Unit, pk=pk)
    request.user.check_access(unit.translation.component.project)

    if not request.user.has_perm('comment.add', unit.translation):
        raise PermissionDenied()

    form = CommentForm(request.POST)

    if form.is_valid():
        if form.cleaned_data['scope'] == 'global':
            lang = None
        else:
            lang = unit.translation.language
        Comment.objects.add(
            unit,
            request.user,
            lang,
            form.cleaned_data['comment']
        )
        messages.success(request, _('Posted new comment'))
    else:
        messages.error(request, _('Failed to add comment!'))

    return redirect_next(request.POST.get('next'), unit)

 def post(self, request, **kwargs):
     component = self.get_component(kwargs)
     if not can_add_screenshot(request.user, component.project):
         raise PermissionDenied()
     self._add_form = ScreenshotForm(request.POST, request.FILES)
     if self._add_form.is_valid():
         obj = Screenshot.objects.create(
             component=component,
             **self._add_form.cleaned_data
         )
         try_add_source(request, obj)
         messages.success(
             request,
             _(
                 'Screenshot has been uploaded, '
                 'you can now assign it to source strings.'
             )
         )
         return redirect(obj)
     else:
         messages.error(
             request,
             _('Failed to upload screenshot, please fix errors below.')
         )
         return self.get(request, **kwargs)

def remove_source(request, pk):
    obj = get_screenshot(request, pk)

    obj.sources.remove(request.POST['source'])

    messages.success(request, _('Source has been removed.'))

    return redirect(obj)

 def form_valid(self, form):
     if not check_perm(self.request.user, 'memory.delete', self.objects):
         raise PermissionDenied()
     memory = TranslationMemory()
     memory.delete(**self.objects)
     messages.success(
         self.request, _('Entries deleted.')
     )
     return super(DeleteView, self).form_valid(form)

def new_language(request, project, component):
    obj = get_component(request, project, component)

    form_class = get_new_language_form(request, obj)
    can_add = obj.can_add_new_language(request)

    if request.method == 'POST':
        form = form_class(obj, request.POST)

        if form.is_valid():
            langs = form.cleaned_data['lang']
            kwargs = {
                'user': request.user,
                'author': request.user,
                'component': obj,
                'details': {},
            }
            for language in Language.objects.filter(code__in=langs):
                kwargs['details']['language'] = language.code
                if can_add:
                    obj.add_new_language(language, request)
                    Change.objects.create(
                        action=Change.ACTION_ADDED_LANGUAGE,
                        **kwargs
                    )
                elif obj.new_lang == 'contact':
                    Change.objects.create(
                        action=Change.ACTION_REQUESTED_LANGUAGE,
                        **kwargs
                    )
                    messages.success(
                        request,
                        _(
                            "A request for a new translation has been "
                            "sent to the project's maintainers."
                        )
                    )
            return redirect(obj)
        messages.error(
            request,
            _('Please fix errors in the form.')
        )
    else:
        form = form_class(obj)

    return render(
        request,
        'new-language.html',
        {
            'object': obj,
            'project': obj.project,
            'form': form,
            'can_add': can_add,
        }
    )

def add_user(request, project):
    """Add user to a project."""
    obj, form = check_user_form(request, project, True)

    if form is not None:
        obj.add_user(form.cleaned_data['user'])
        messages.success(
            request, _('User has been added to this project.')
        )

    return redirect(
        'manage-access',
        project=obj.slug,
    )

def unlock_component(request, project, component):
    obj = get_component(request, project, component)

    if not request.user.has_perm('component.lock', obj):
        raise PermissionDenied()

    obj.do_lock(request.user, False)

    messages.success(
        request,
        _('Component is now open for translation updates.')
    )

    return redirect_param(obj, '#repository')

def execute_locked(request, obj, message, call, *args, **kwargs):
    """Helper function to catch possible lock exception."""
    try:
        result = call(*args, **kwargs)
        # With False the call is supposed to show errors on its own
        if result is None or result:
            messages.success(request, message)
    except Timeout as error:
        messages.error(
            request,
            _('Failed to lock the repository, another operation is in progress.')
        )
        report_error(error, request)

    return redirect_param(obj, '#repository')

def remove_translation(request, project, component, lang):
    obj = get_translation(request, project, component, lang)

    if not request.user.has_perm('translation.delete', obj):
        raise PermissionDenied()

    form = DeleteForm(obj, request.POST)
    if not form.is_valid():
        show_form_errors(request, form)
        return redirect_param(obj, '#delete')

    obj.remove(request.user)
    messages.success(request, _('Translation has been removed.'))

    return redirect(obj.component)

def lock_project(request, project):
    obj = get_project(request, project)

    if not request.user.has_perm('component.lock', obj):
        raise PermissionDenied()

    for component in obj.component_set.all():
        component.do_lock(request.user)

    messages.success(
        request,
        _('All components are now locked for translation updates!')
    )

    return redirect_param(obj, '#repository')

def password(request):
    """Password change / set form."""
    do_change = False

    if request.method == 'POST':
        change_form = PasswordConfirmForm(request, request.POST)
        do_change = change_form.is_valid()
    else:
        change_form = PasswordConfirmForm(request)

    if request.method == 'POST':
        form = SetPasswordForm(request.user, request.POST)
        if form.is_valid() and do_change:

            # Clear flag forcing user to set password
            redirect_page = '#auth'
            if 'show_set_password' in request.session:
                del request.session['show_set_password']
                redirect_page = ''

            # Change the password
            user = form.save()

            # Updating the password logs out all other sessions for the user
            # except the current one.
            update_session_auth_hash(request, user)

            # Change key for current session
            request.session.cycle_key()

            messages.success(
                request,
                _('Your password has been changed.')
            )
            notify_account_activity(request.user, request, 'password')
            return redirect_profile(redirect_page)
    else:
        form = SetPasswordForm(request.user)

    return render(
        request,
        'accounts/password.html',
        {
            'title': _('Change password'),
            'change_form': change_form,
            'form': form,
        }
    )

def delete_screenshot(request, pk):
    obj = get_object_or_404(Screenshot, pk=pk)
    request.user.check_access(obj.component.project)
    if not request.user.has_perm('screenshot.delete', obj.component):
        raise PermissionDenied()

    kwargs = {
        'project': obj.component.project.slug,
        'component': obj.component.slug,
    }

    obj.delete()

    messages.success(request, _('Screenshot %s has been deleted.') % obj.name)

    return redirect('screenshots', **kwargs)