def upload_pricelist(request):
    if request.user.is_staff:
        if request.method == 'POST':
            f = request.FILES['file']
            filename = request.FILES['file'].name
            name, ext = os.path.splitext(translify(filename).replace(' ', '_'))
            newname = '/uploads/' + 'purchase_doc' + ext
            oldfile = 'purchase_doc'
            for root, dirs, files in os.walk(settings.MEDIA_ROOT+'/uploads/',):
                for filename in files:
                    name, ext = os.path.splitext(translify(u'%s' % filename).replace(' ', '_'))
                    if name=='purchase_doc':
                        oldfile = '/uploads/' + filename
            try:
                os.remove(settings.MEDIA_ROOT + oldfile)
            except OSError:
                oldfile = False
            path_name = settings.MEDIA_ROOT + newname
            destination = open(path_name, 'wb+')
            for chunk in f.chunks():
                destination.write(chunk)
            destination.close()
            return http.HttpResponseRedirect('/admin/')
    else:
        return http.HttpResponse('403 Forbidden. Authentication Required!')

 def set_slug(self):
     from pytils.translit import translify
     n = ''
     if(self.first_name):
         n = n + translify(self.first_name)
     if(self.last_name):
         n = n +'-'+ translify(self.last_name)
     st = str(self.id)+'-'+n
     self.slug = st
     #import pdb; pdb.set_trace()
     self.save()

def file_upload_path(instance, filename):
    """Generates upload path
    
    Keyword arguments:
    instance -- FileField
    filename - String
    
    Returns: String
    
    """
    parts = filename.rsplit('.', 1)
    name = "%s.%s" % (slugify(translify(parts[0])), slugify(translify(parts[1])))
    return "%s/%s/%s/%s" % (strftime('%Y'), 
       strftime('%m'), strftime('%d'), name)

 def to_sms (self):
     addr_part  = remove_short_numbers (translit.translify(u"Addr:" + self.address()))
     tel_part = remove_short_numbers (translit.translify(u"Tel:" + self.phoneNo))
     order_part = remove_short_numbers (translit.translify(u'Zakaz:' + self.orderItems()))
     name_part = remove_short_numbers (translit.translify(u"Imya:" + self.name if self.name else u''))
     comment = remove_short_numbers (translit.translify (u"Komment:" + self.comment if self.comment else u''))
     zakaz = " ".join ([addr_part, tel_part, order_part])    
     if (name_part) and (len(zakaz) + len(" ")+ len(name_part))  <= 160:
         zakaz += " " + name_part
     if (comment) and (len(zakaz) + len(" ")+ len(comment))  <= 160:
         zakaz += " " + comment
     if len(zakaz) <= 160:
         return zakaz
     else:
         return u"Shlishkom dlinnyi zakaz! Smotrite na sayte ili na pochte!"

def slugify(value, limit=None, default='', lower=True, dot_allowed=False):
    value = smart_unicode(value)

    # Replace all non-allowed chars with "-" char
    # to help pytils not to crash
    if dot_allowed:
        value = RE_NOT_ENRUCHAR_DOT.sub('-', value)
    else:
        value = RE_NOT_ENRUCHAR.sub('-', value)

    # Do transliteration
    value = translify(value)

    # Replace trash with safe "-" char
    if dot_allowed:
        value = RE_NOT_ENCHAR_DOT.sub('-', value)
    else:
        value = RE_NOT_ENCHAR.sub('-', value)
    
    # Replace "-" from both side of the string
    value = value.strip('-')

    if lower:
        value = value.lower()

    # Replace sequences of dashes
    value = RE_DASH.sub('-', value)

    if limit is not None:
        value = value[:limit]

    if value != "":
        return value
    else:
        return default

def translify(text):
    """Translify russian text"""
    try:
        res = translit.translify(smart_unicode(text, encoding))
    except Exception, err:
        # because filter must die silently
        res = default_value % {'error': err, 'value': text}

def elfinder_connector(request):
    elf = elFinder.connector(settings.ELFINDER_OPTIONS)
    req = {}

    if request.method == 'GET':
        form = request.GET
    else:
        form = request.POST

    for field in elf.httpAllowedParameters:
        if field in form:
            req[field] = form.get(field)

            # Hack by Kidwind
            if field == 'targets[]' and hasattr(form, 'getlist'):
                req[field] = form.getlist(field)

    if request.FILES and request.FILES.getlist('upload[]'):
        up_files = {}
        for up in request.FILES.getlist('upload[]'):
            if up.name:
                file_name = slugify(translify(up.name))
                up_files[file_name] = up.file

        req[field] = up_files

    status, header, response = elf.run(req)

    if not response is None and status == 200:
        if 'file' in response and isinstance(response['file'], file):
            response['file'].close()

    return HttpResponse(json.dumps(response), content_type='application/json')

def slugify(value, limit=None, default='', lower=True):
    value = smart_unicode(value)

    # Replace all non russian/english chars with "-" char
    # to help pytils not to crash
    value = RE_NOT_ENRUCHAR.sub('-', value)

    # Do transliteration
    value = translify(value)

    # Replace trash with safe "-" char
    value = RE_NOT_ENCHAR.sub('-', value).strip('-')
    if lower:
        value = value.lower()

    # Replace sequences of dashes
    value = RE_DASH.sub('-', value)

    if limit is not None:
        value = value[:limit]

    if value != "":
        return value
    else:
        return default

def upload(request):
    """
    Uploads a file and send back its URL to CKEditor.

    TODO:
        Validate uploads
    """
    # Get the uploaded file from request.
    upload = request.FILES['upload']

    # Open output file in which to store upload.
    upload_filename = generate_filename(translify(upload.name))
    url = get_media_url(upload_filename)
    out = open(upload_filename, 'wb+')

    # Iterate through chunks and write to destination.
    for chunk in upload.chunks():
        out.write(chunk)
    out.close()

    # Respond with Javascript sending ckeditor upload url.
    return HttpResponse("""
    <script type='text/javascript'>
        window.parent.CKEDITOR.tools.callFunction(%s, '%s');
    </script>""" % (request.GET['CKEditorFuncNum'], url))

    def get_results(self):
        """
        Fetches the results via the form.

        Returns an empty list if there's no query to search with.
        """
        query = self.query

        if not (self.form.is_valid() and query):
            return self.form.no_query_found()

        #Replace letter ё --> е
        query = replace_special(query)

        # save the query to statistic
        if 'page' not in self.request.GET and query:
            rows = SearchLogger.objects.filter(text=query).update(counter=F('counter')+1)
            if not rows:
                SearchLogger.objects.create(text=query)
        
        translited_query = force_unicode(translify(query))
        detranslited_query = force_unicode(detranslify(query))
        
        sqs = self.searchqueryset().filter_and(SQ(content=detranslited_query) | SQ(content=translited_query) | SQ(content=query))
        
        #sqs = self.searchqueryset().auto_query(query)
        
        if self.load_all:
            sqs = sqs.load_all()
        
        return sqs

    def rename_file(self, filename):
        from pytils import translit

        filename = translit.translify(filename)
        
        filename = self.get_indexed_name(filename)
        return filename

    def slugify_func(self, content):
        try:
            from pytils.translit import translify
            content = translify(content)
        except:
            pass

        return slugify(content)

    def translit_cal(string):
        """Print transliterated formatted calendar. """

        try:
            out = string.replace('ⵛ', '-:)').replace('☩', '+').replace('⊕', '(+)')
            return translit.translify(out.decode('utf8'))
        except UnicodeDecodeError:
            return 'Transliteration is not working!'

def translify(stext):
    """Translify russian text"""
    try:
        utext = pseudo_unicode(stext, encoding, default_value)
        res = translit.translify(utext)
    except Exception, err:
        # because filter must die silently
        res = default_value % {"error": err, "value": stext}

def translit_cal(string):
    """
    :return transliterated formatted calendar.
    """
    out = string.replace(
        DICT_FORMAT['gl'], u'-:)').replace(
            DICT_FORMAT['pl'], u'+').replace(
                DICT_FORMAT['tw'], u'(+)')
    return translit.translify(out)

def _file_view(request, transformation_name, file_id=None, download=False):
    not_found_path = '%snotfound/%s'
    converting_path = '%sconverting/%s'
    if file_id:
        try:
            file = File.objects.get(id=file_id)
        except File.DoesNotExist:
            file = None
            raise Http404()

        else:
            try:
                modification = file.modifications[transformation_name]
            except File.DerivativeNotFound:
                modification = None
    else:
        file = None
        modification = None

    if modification:
        response = HttpResponse(modification.file.read(),
            content_type='application/octet-stream' if download
                else
            modification.file.content_type
        )
        response['Last-Modified'] = modification.file.upload_date
        if download:
            user_agent = request.META.get('HTTP_USER_AGENT', '').lower()
            file_name = (file.name or str(file.id)) + ('.%s' % file.extension
                                                    if file.extension else '')

            file_name = translify(file_name)
            if 0: #TODO
                file_name = iri_to_uri(file_name)

                if user_agent.find('opera') == -1:
                    pass
                if user_agent.find('msie') != -1:
                    file_name.replace('+', '%20')

            response['Content-Disposition'] = 'attachment; filename="%s";' % file_name


        return response

    if file and os.path.exists(converting_path %
                    (settings.MEDIA_ROOT, transformation_name)):
        return redirect(converting_path %
                (settings.MEDIA_URL, transformation_name))


    if os.path.exists(not_found_path %
                    (settings.MEDIA_ROOT, transformation_name)):
        return redirect(not_found_path %
                    (settings.MEDIA_URL, transformation_name))

    raise Http404()

 def translit(self, name):
     output_name = []
     for letter in name:
         try:
             out_letter = translify(letter)
         except ValueError:
             out_letter = '1'
         output_name.append(out_letter)
     output_name = ''.join(output_name)
     return output_name

def community_upload(instance, filename):
    filename = translit.translify(filename)
    new_name = md5(filename)
    path =  "uploads/communities/%(cid)d/p_%(filename)s%(ext)s" % {
            'cid': instance.id or 0,
            'filename': new_name.hexdigest(),
            'ext': os.path.splitext(filename)[-1]
        }
    print path
    return path

def handle_uploaded_file(f, filename, folder):
    name, ext = os.path.splitext(translify(filename).replace(' ', '_'))
    hashed_name=md5.md5(name+datetime.datetime.now().strftime("%Y%m%d%H%M%S")).hexdigest()
    path_name = settings.MEDIA_ROOT + '/uploads/' + folder + hashed_name + ext
    destination = open(path_name, 'wb+')

    for chunk in f.chunks():
        destination.write(chunk)
    destination.close()
    return '/media/uploads/'+ folder + hashed_name + ext

    def save(self, *args, **kwargs):
        try:
            from pytils.translit import translify
        except ImportError:
            self.slug = slugify(self.label)
        else:
            self.slug = slugify(translify(self.label))

        self.slug = self.slug.replace('-', '_')

        return super(AbstractField, self).save(*args, **kwargs)