def add_user_to_registered_group(sender, **kwargs):
    """
    Add any user created on the system to the `registered` group.

    This signal must be called by the post_save signal from the User class.
    This signal also creates a public profile for the user if it does not exist.
    """
    if 'created' in kwargs and kwargs['created'] is True:

        user = kwargs['instance']

        # Add user to registered group
        group, created = Group.objects.get_or_create(name='registered')
        user.groups.add(group)

        sid = transaction.savepoint()

        # Create Public Profile
        try:
            profile, created = Profile.objects.get_or_create(user=user)
            profile.save()
            transaction.savepoint_commit(sid)
        except:
            logger.debug("User profile not created.")
            transaction.savepoint_rollback(sid)

    transaction.commit()

def search(request):
    query_string = prepare_solr_query_string(request.GET.get('q', ""))
    search_terms = query_string.split()
    index_query = SearchQuerySet().models(Project)
    spelling_suggestion = None

    if not FULLTEXT:
        try:
            results = index_query.auto_query(query_string)
            count = results.count()
        except TypeError:
            count = 0
    else:
        try:
            qfilter = fulltext_project_search_filter(query_string)
            results = index_query.filter(qfilter)
            spelling_suggestion = results.spelling_suggestion(query_string)
            count = results.count()
        except TypeError:
            results = []
            count = 0

    logger.debug("Searched for %s. Found %s results." % (query_string, count))
    return render_to_response("search.html",
        {'query': query_string,
         'terms': search_terms,
         'results': results,
         'spelling_suggestion': spelling_suggestion},
          context_instance = RequestContext(request))

def post_resource_save_handler(sender, instance, created, user, **kwargs):
    if settings.ENABLE_NOTICES:
        resource = instance
        project = resource.project
        users = [
            watch.user
            for watch in notification.ObservedItem.objects.filter(
                content_type__model="project", object_id=project.id, signal="project_changed"
            ).select_related("user")
        ]
        for user in users:
            try:
                notification.ObservedItem.objects.get_for(resource.project, user, "project_changed")
                if created:
                    for signal in resource_signals:
                        try:
                            notification.ObservedItem.objects.get_for(resource, user, signal)
                        except notification.ObservedItem.DoesNotExist:
                            notification.observe(resource, user, signal, signal)
                    nt = "project_resource_added"
                else:
                    nt = "project_resource_changed"
                project = resource.project
                _notify_resourcewatchers(project, resource, nt)
            except notification.ObservedItem.DoesNotExist, e:
                logger.debug("Watches: %s" % unicode(e))

def msgfmt_check(po_contents, ispot=False, with_exceptions=True):
    """
    Run a `msgfmt -c` on the file contents.

    Raise a FileCheckError in case the stderror has errors/warnings or
    the command execution returns Error.
    """
    try:
        if ispot:
            command = "msgfmt -o /dev/null --check-format --check-domain -"
        else:
            command = "msgfmt -o /dev/null -c -"
        status, stdout, stderr = run_command(
            command, _input=po_contents, with_extended_output=True, with_exceptions=with_exceptions
        )
        # Not sure why msgfmt sends its output to stderr instead of stdout
        # if 'warning:' in stderr or 'too many errors, aborting' in stderr:
        if "too many errors, aborting" in stderr:
            raise CommandError(command, status, stderr)
    except CommandError:
        logger.debug("pofile: The 'msgfmt -c' check failed.")
        raise FileCheckError, ugettext(
            "Your file failed a correctness check "
            "(msgfmt -c). Please run this command on "
            "your system to see the errors."
        )

def handle_exception_mailing(request, exception):
    """Handle an exception if in production mode."""
    exc_info = sys.exc_info()
    subject, message = exception_email(request, exc_info)
    if not settings.DEBUG:
        logger.debug('Sending handled exception to admins.')
        mail_admins(('%s - %s') % (subject, exception.message), message,
            fail_silently=True)

def priority_creation(**kwargs):
    """Create the default priority on Resource creation."""
    if 'created' in kwargs and kwargs['created'] is True:
        resource = kwargs['instance']
        if resource:
            ResourcePriority.objects.create(resource=resource)
            logger.debug("Resource %s: New ResourcePriority created." % (
                         resource.name))

 def delete(self, *args, **kwargs):
     """
     Delete file from filesystem even if object has not been saved yet.
     """
     try:
         os.remove(self.get_storage_path())
     except OSError, e:
         if self.id:
             logger.debug("Error deleting StorageFile: %s" % str(e))

 def _get_stats(self, request, pslug, rslug, lang_code):
     try:
         resource = Resource.objects.get(project__slug=pslug, slug=rslug)
     except Resource.DoesNotExist, e:
         logger.debug(
             "Resource %s.%s requested, but it does not exist" % (pslug, rslug),
             exc_info=True
         )
         return rc.NOT_FOUND

 def combine_strings(source_entities, language):
     source_entities = list(source_entities)
     result = old_get_strings(source_entities, language)
     for entity in source_entities:
         if not result.get(entity, None):
             trans = handler._get_translation(entity, source_language, 5)
             if trans:
                 logger.debug(trans.string)
                 result[entity] = trans.string
     return result

def _notify_resourcewatchers(project, resource, signal):
    """
    Notify watchers of a resource add/change
    """
    context = {"project": project, "resource": resource}
    logger.debug("addon-watches: Sending notification for '%s'" % resource)
    if signal == "project_resource_added":
        observed_instance = project
    else:
        observed_instance = resource
    txnotification.send_observation_notices_for(observed_instance, signal=signal, extra_context=context)

 def delete(self, request, uuid=None, api_version=1):
     """
     Deletes file by storage UUID
     """
     if request.user.is_anonymous():
         return rc.FORBIDDEN
     try:
         StorageFile.objects.get(uuid=uuid, user=request.user).delete()
     except StorageFile.DoesNotExist:
         return rc.NOT_FOUND
     logger.debug("Deleted file %s" % uuid)
     return rc.DELETED

def _notify_translationwatchers(resource, language):
    """
    Notify the watchers for a specific TranslationWatch
    """
    context = {"project": resource.project, "resource": resource, "language": language}

    twatch = TranslationWatch.objects.get_or_create(resource=resource, language=language)[0]

    logger.debug("addon-watches: Sending notification for '%s'" % twatch)
    txnotification.send_observation_notices_for(
        twatch, signal="project_resource_translation_changed", extra_context=context
    )

def update_template_cache(template_name, fragment_names, key_vars, context):
    """Update the template cache with the new data.

    The caches will be invalidated in the order given.
    """
    logger.debug("Invalidating %s in %s" % (fragment_names, template_name))
    t = get_template(template_name)
    nodes = t.nodelist.get_nodes_by_type(CacheNode)
    for f_name in fragment_names:
        for node in nodes:
            if f_name == node.fragment_name:
                set_fragment_content(node, key_vars, context)
                break

    def test_pseudo_file_api_calls(self):
        """Test Pseudo translation requests through the API."""
        source_language = self.project.resources.all()[0].source_language
        for i18n_type, v in FORMATS.items():
            resource_slug = 'resource_%s' % i18n_type.lower()
            resource_url = reverse('apiv2_resources', kwargs={
                    'project_slug': self.project.slug})

            # Creating resource using the API
            f = open(v['file'])
            res = self.client['maintainer'].post(
                resource_url,
                data={
                    'slug': resource_slug,
                    'name': resource_slug,
                    'i18n_type': i18n_type,
                    'attachment': f},
                )
            f.close()

            logger.debug('-----------------------')
            logger.debug(i18n_type)
            logger.debug(settings.I18N_METHODS[i18n_type]['mimetype'])
            logger.debug(res.content)
            logger.debug('-----------------------')

            # Pseudo file API URL
            url = reverse('apiv2_pseudo_content', args=[self.project.slug,
                resource_slug])

            for pseudo_type in settings.PSEUDO_TYPES:
                # Get resource file using a specific pseudo type
                resp = self.client['registered'].get(url, data={'pseudo_type':pseudo_type})

                # Get response and check encoding
                resp_content = eval(resp.content)['content']
                if type(resp_content) != unicode:
                    try:
                        resp_content = resp_content.decode('utf-8')
                    except UnicodeDecodeError:
                        resp_content = resp_content.decode('iso-8859-1')

                #FIXME: We have a bug related to spaces being escaped in
                # .properties files. This can be dropped after fixing it.
                if i18n_type == 'PROPERTIES' and \
                    pseudo_type in ['PLANGUAGE', 'UNICODE']:
                    resp_content = resp_content.replace('\\ ', ' ')

                # Assert expected value in the generated file
                for message in v['pseudo_messages'][pseudo_type]:
                    self.assertTrue(message in resp_content)

    def create(self):
        """
        Creates a new translation from file.

        Returns:
            A dict with information for the translation.

        Raises:
            BadRequestError: There was a problem with the request.
            NoContentError: There was no file in the request.
        """
        if not self.request.FILES:
            raise NoContentError("No file has been uploaded.")

        submitted_file = self.request.FILES.values()[0]
        name = str(submitted_file.name)
        size = submitted_file.size

        try:
            file_ = tempfile.NamedTemporaryFile(
                mode='wb',
                suffix=name[name.rfind('.'):],
                delete=False
            )
            for chunk in submitted_file.chunks():
                file_.write(chunk)
            file_.close()

            parser = registry.appropriate_handler(
                self.resource,
                language=self.language,
                filename=name
            )
            parser.bind_file(file_.name)
            if parser is None:
                raise BadRequestError("Unknown file type")
            if size == 0:
                raise BadRequestError("Empty file")

            try:
                parser.is_content_valid()
                logger.debug("Uploaded file %s" % file_.name)
            except (FileCheckError, ParseError), e:
                raise BadRequestError("Error uploading file: %s" % e)
            except Exception, e:
                logger.error(unicode(e), exc_info=True)
                raise BadRequestError("A strange error happened.")

def _notify_all_on_source_change(resource, context):
    """
    Send notifications to everyone involved with a resource.

    Args:
        resource: The updated resource.
    """
    signal_name = 'project_resource_translation_changed'
    msg = "addon-watches: Sending notification for '%s'"
    TWatch = get_model('watches', 'TranslationWatch')

    for l in resource.available_languages:
        twatch = TWatch.objects.get_or_create(resource=resource, language=l)[0]
        logger.debug(msg % twatch)
        txnotification.send_observation_notices_for(
            twatch, signal=signal_name, extra_context=context
        )

def get_from_app(request, project_slug, txapp_slug):
    """Get a template string from a tx app."""
    txapp = get_object_or_404(TxApp, slug=txapp_slug)
    project = get_object_or_404(Project, slug=project_slug)

    root_path = _root_namespace(request.path, txapp)
    requested_path = _remove_namespace_from_path(root_path, request.path)
    if not txapp.access_is_allowed(request.user, project, requested_path):
        return HttpResponseForbidden()
    logger.debug(
        "Path requested from tx app %s is %s" % (txapp_slug, requested_path)
    )

    url = '/'.join([txapp.url, project_slug, requested_path])
    try:
        res = _forward_to_app(url, request.method, dict(request.POST.items()))
    except RemoteTxAppError, e:
        return error_contacting_app(request, url, txapp, e)

    def test_pseudo_file_api_calls(self):
        """Test Pseudo translation requests through the API."""
        source_language = self.project.resources.all()[0].source_language
        for i18n_type, v in FORMATS.items():
            resource_slug = "resource_%s" % i18n_type.lower()
            resource_url = reverse("apiv2_resources", kwargs={"project_slug": self.project.slug})

            # Creating resource using the API
            f = open(v["file"])
            res = self.client["maintainer"].post(
                resource_url,
                data={"slug": resource_slug, "name": resource_slug, "i18n_type": i18n_type, "attachment": f},
            )
            f.close()

            logger.debug("-----------------------")
            logger.debug(i18n_type)
            logger.debug(settings.I18N_METHODS[i18n_type]["mimetype"])
            logger.debug(res.content)
            logger.debug("-----------------------")

            # Pseudo file API URL
            url = reverse("apiv2_pseudo_content", args=[self.project.slug, resource_slug])

            for pseudo_type in settings.PSEUDO_TYPES:
                # Get resource file using a specific pseudo type
                resp = self.client["registered"].get(url, data={"pseudo_type": pseudo_type})

                # Get response and check encoding
                resp_content = eval(resp.content)["content"]
                if type(resp_content) != unicode:
                    try:
                        resp_content = resp_content.decode("utf-8")
                    except UnicodeDecodeError:
                        resp_content = resp_content.decode("iso-8859-1")

                # FIXME: We have a bug related to spaces being escaped in
                # .properties files. This can be dropped after fixing it.
                if i18n_type == "PROPERTIES" and pseudo_type in ["PLANGUAGE", "UNICODE"]:
                    resp_content = resp_content.replace("\\ ", " ")

                # Assert expected value in the generated file
                for message in v["pseudo_messages"][pseudo_type]:
                    self.assertTrue(message in resp_content)

def check_and_notify_string_freeze_breakage(sender, **kwargs):
    """
    Handler to notify people about string freeze breakage of releases.

    This happens whenever a resource source file changes in the string freeze
    period.
    """
    resource = kwargs.pop('resource')
    language = kwargs.pop('language')

    # Check it only for source languages
    if kwargs.pop('is_source'):
        logger.debug("release: Checking string freeze breakage.")
        # FIXME: Get timestamp from RLStats last_update field, but it depends
        # on some changes on formats/core.py. At this point the RLStats object
        # wasn't created yet.
        timestamp = datetime.datetime.now()
        project = resource.project.outsource or resource.project
        releases = Release.objects.filter(resources=resource, project=project,
            stringfreeze_date__lte=timestamp, develfreeze_date__gte=timestamp)
        for release in releases:
            logger.debug("release: Sending notifications about string "
                "freeze breakage for '%s'" % release)
            project = release.project.outsource or release.project

            # User list with project maintainers and team coordinators of the
            # given release PLUS maintainers of the project that the RLStats
            # object belongs to PLUS
            users = User.objects.filter(
                Q(projects_maintaining=resource.project) |
                Q(projects_maintaining=project) |
                Q(team_coordinators__project=project)).distinct()

            # Notification
            context = {'project': release.project, 'release': release,
                'resource': resource}
            if release.project != project:
                context.update({'parent_project': project})

            nt = "project_release_stringfreeze_breakage"
            #TODO: Add support for actionlog without a user author.
            #action_logging(None, [project, release], nt, context=context)
            if settings.ENABLE_NOTICES:
                notification.send(users, nt, context)

def invalidate_cache(sender, instance, created=True, **kwargs):
    """
    Invalidate caching on places related to the lock icon in the stats table
    row.
    """
    if created:
        logger.debug("lock-addon: Invalidating cache: %s" % instance)

        invalidate_template_cache('resource_details_lang',
            instance.rlstats.resource.project.slug,
            instance.rlstats.resource.slug,
            instance.rlstats.language.code)

        invalidate_template_cache('resource_details',
            instance.rlstats.resource.project.slug,
            instance.rlstats.resource.slug)

        team = Team.objects.get_or_none(instance.rlstats.resource.project,
            instance.rlstats.language.code)
        if team:
            invalidate_template_cache('team_details', team.id,
                instance.rlstats.resource.id)