示例#1
0
    def moderate(self, comment, content_object, request):
        """Need to pass Akismet test"""
        if not AKISMET_COMMENT:
            return False

        try:
            from akismet import Akismet
            from akismet import APIKeyError
        except ImportError:
            return False

        akismet = Akismet(key=AKISMET_API_KEY,
                          blog_url='%s://%s/' % (
                              PROTOCOL, Site.objects.get_current().domain))
        if akismet.verify_key():
            akismet_data = {
                'user_ip': request.META.get('REMOTE_ADDR', ''),
                'user_agent': request.META.get('HTTP_USER_AGENT', ''),
                'referrer': request.META.get('HTTP_REFERER', 'unknown'),
                'permalink': content_object.get_absolute_url(),
                'comment_type': 'comment',
                'comment_author': smart_str(comment.userinfo.get('name', '')),
                'comment_author_email': smart_str(comment.userinfo.get('email', '')),
                'comment_author_url': smart_str(comment.userinfo.get('url', '')),
            }
            is_spam = akismet.comment_check(smart_str(comment.comment),
                                            data=akismet_data,
                                            build_data=True)
            if is_spam:
                comment.save()
                user = comment.content_object.authors.all()[0]
                comment.flags.create(user=user, flag='spam')
            return is_spam
        raise APIKeyError("Your Akismet API key is invalid.")
示例#2
0
 def get_hexdigest(algorithm, salt, raw_password):
     raw_password, salt = smart_str(raw_password), smart_str(salt)
     if algorithm == 'md5':
         return md5_constructor(salt + raw_password).hexdigest()
     elif algorithm == 'sha1':
         return sha_constructor(salt + raw_password).hexdigest()
     raise ValueError('Got unknown password algorithm type in password')
示例#3
0
def _upload_file(request):
    """
    Upload file to the server.
    """
    
    from django.core.files.move import file_move_safe
    
    if request.method == 'POST':
        folder = request.POST.get('folder')
        fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("fb_upload"))
        folder = fb_uploadurl_re.sub('', folder)
        abs_path = _check_access(request, folder)
        if request.FILES:
            filedata = request.FILES['Filedata']
            filedata.name = convert_filename(filedata.name)
            _check_access(request, abs_path, filedata.name)
            # PRE UPLOAD SIGNAL
            filebrowser_pre_upload.send(sender=request, path=request.POST.get('folder'), file=filedata)
            # HANDLE UPLOAD
            uploadedfile = handle_file_upload(abs_path, filedata)
            # MOVE UPLOADED FILE
            # if file already exists
            if os.path.isfile(smart_str(os.path.join(fb_settings.MEDIA_ROOT, fb_settings.DIRECTORY, folder, filedata.name))):
                old_file = smart_str(os.path.join(abs_path, filedata.name))
                new_file = smart_str(os.path.join(abs_path, uploadedfile))
                file_move_safe(new_file, old_file)
            # POST UPLOAD SIGNAL
            filebrowser_post_upload.send(sender=request, path=request.POST.get('folder'), file=FileObject(smart_str(os.path.join(fb_settings.DIRECTORY, folder, filedata.name))))
    return HttpResponse('True')
示例#4
0
def get_option_value(optionset_admin, db_option, current_only):
    """
    Given an Option object, return its value for the current language.
    """

    name = smart_str(db_option.name)
    if not name in optionset_admin.options:
        return None

    field = optionset_admin.options[name]

    if not db_option.lang_dependant:
        return field.to_python(db_option.value) if db_option.value else ''

    value_dict = {}
    for key, value in json.loads(db_option.value).items():
        value_dict[smart_str(key)] = value

    if current_only:
        curr_lang = get_language()
        if curr_lang in value_dict:
            return field.to_python(value_dict[curr_lang]) if value_dict[curr_lang] else ''
    else:
        for key in value_dict:
            value_dict[key] = field.to_python(value_dict[key])
            return value_dict
示例#5
0
    def urlencode(self, safe=None):
        """
        Returns an encoded string of all query string arguments.

        :arg safe: Used to specify characters which do not require quoting, for
            example::

                >>> q = QueryDict('', mutable=True)
                >>> q['next'] = '/a&b/'
                >>> q.urlencode()
                'next=%2Fa%26b%2F'
                >>> q.urlencode(safe='/')
                'next=/a%26b/'

        """
        output = []
        if safe:
            encode = lambda k, v: '%s=%s' % ((quote(k, safe), quote(v, safe)))
        else:
            encode = lambda k, v: urlencode({k: v})
        for k, list_ in self.lists():
            k = smart_str(k, self.encoding)
            output.extend([encode(k, smart_str(v, self.encoding))
                           for v in list_])
        return '&'.join(output)
示例#6
0
def get_revisions(title, csv_writer, lang, textcleaner,
                  startid=None, prev_text=""):
    api_base = 'http://%s.wikipedia.org/w/api.php' % lang
    options = {}
    options.update({
        'action': 'query',
        'prop': 'revisions',
        'rvlimit': 500,
        'titles': title,
        'rvprop': 'ids|timestamp|content',
        'rvdir': 'newer',
        'format': 'json'
    })
    if startid != None:
        options.update({
            'rvstartid': startid
        })
    url = api_base + '?' + urllib.urlencode(options)
    logging.info(url)
    result = simplejson.load(urllib.urlopen(url))
    pages = result["query"]["pages"]
    for page in pages:
        revs = pages[page]["revisions"]
        for r in revs:
            text_cleaned = textcleaner.clean_all(r["*"])
            text = smart_str(_diff_text(prev_text, text_cleaned)[0])
            csv_writer.writerow([r["timestamp"], lang, smart_str(title),
                                "", text])
            prev_text = text_cleaned
    try:
        cont = result['query-continue']['revisions']['rvstartid']
        logging.info("Continue to %d", cont)
        get_revisions(title, csv_writer, lang, cont, prev_text)
    except KeyError:
        logging.info("Finished!")
示例#7
0
 def pullThread(self, msgl):
     """
     gets all messages for a thread
     """
     data= self.get(msgl)
     msgs = data.findAll("span",{"class":"username-inbox"})
     this_id=''
     
     ids,texts = [],[]
     for msg in msgs:
         this_id= msg.find("a")['href'].split("=")[1]
         txt = msg.parent.parent.findAll("div")[1].text
         if "has expressed interest in you" not in txt:
             texts.append(smart_str(txt))
             ids.append(smart_str(this_id))
     for link in data.findAll("a"):
         if "viewallmessages" in link['href'] and not data.find("span", {"class": "text-warning"}):
             newlink =  "http://www.pof.com/" + link['href']
             ids2,texts2 = self.pullThread(newlink)
             ids = ids2 + ids
             texts = texts2 + texts
             break
     if not msgs:
         return [],[]
     else:
         return ids,texts
示例#8
0
文件: api.py 项目: liujunlin/hue
 def putRow(self, cluster, tableName, row, data):
   client = self.connectCluster(cluster)
   mutations = []
   Mutation = get_thrift_type('Mutation')
   for column in data.keys():
     mutations.append(Mutation(column=smart_str(column), value=smart_str(data[column]))) # must use str for API, does thrift coerce by itself?
   return client.mutateRow(tableName, smart_str(row), mutations, None)
示例#9
0
 def convert_query(self, query, num_params):
     # kinterbasdb tries to convert the passed SQL to string.
     # But if the connection charset is NONE, ASCII or OCTETS it will fail.
     # So we convert it to string first.
     if num_params == 0:
         return smart_str(query, self.encoding)
     return smart_str(query % tuple("?" * num_params), self.encoding)
示例#10
0
    def serialize_model(self, instance):
        """
        Given a model instance or dict, serialize it to a dict..
        """
        data = {}

        fields = self.get_fields(instance)

        # serialize each required field
        for fname in fields:
            try:
                if hasattr(self, smart_str(fname)):
                    # check first for a method 'fname' on self first
                    meth = getattr(self, fname)
                    if inspect.ismethod(meth) and len(inspect.getargspec(meth)[0]) == 2:
                        obj = meth(instance)
                elif hasattr(instance, '__contains__') and fname in instance:
                    # check for a key 'fname' on the instance
                    obj = instance[fname]
                elif hasattr(instance, smart_str(fname)):
                    # finally check for an attribute 'fname' on the instance
                    obj = getattr(instance, fname)
                else:
                    continue

                key = self.serialize_key(fname)
                val = self.serialize_val(fname, obj)
                data[key] = val
            except _SkipField:
                pass

        return data
示例#11
0
文件: views.py 项目: mynicolas/hrms
def changeBusinessMan(request):
    """
    为某个实例修改businessMan
    """
    if request.method == "POST":
        if request.POST.get('change', '') == u"businessMan":
            thisUser = request.user
            if not checkPerm(thisUser, 'businessMan'):
                return HttpResponse('failed')
            thisVm = smart_str(request.POST.get('host'))
            oldValue = smart_str(request.POST.get('oldvalue', ''))
            newValue = smart_str(request.POST.get('newvalue', ''))
            vm = Vm(thisVm)
            try:
                vm.update(businessMan=newValue)
                log = LogRequest(request.user)
                logContent = '(modify businessMan) %s --> %s' %\
                    (oldValue, newValue)
                log.save(logContent)
                return HttpResponse('successful')
            except:
                return HttpResponse('failed')
        else:
            raise Http404
    else:
        raise Http404
示例#12
0
文件: admin.py 项目: mschen/wfhbtime
def export_csv_vol(modeladmin, request, queryset):
	# instead of text/html, we render the response as a text/csv file
	response = HttpResponse(mimetype='text/csv')
	response['Content-Disposition'] = 'attachement; filename="volunteer.csv"'
	writer = csv.writer(response, csv.excel)
	
	# this will ensure that the encoding is utf8 so that excel can properly open the file
	response.write(u'\ufeff'.encode('utf8'))
	
	# these are the four fields that will be exported by django (first row)
	writer.writerow([
		smart_str(u"Email"),
		smart_str(u"First Name"),
		smart_str(u"Last name"),
		smart_str(u"Start Date"),
		smart_str(u"Active")
	])
	
	# now we need to write every row that the Big C 
	for obj in queryset:
		s = time.strptime(str(obj.start_date.month) + ' ' + str(obj.start_date.day) + ' ' + str(obj.start_date.year), "%m %d %Y")
		s = time.strftime("%m/%d/%Y", s)
		writer.writerow([
			smart_str(obj.email),
			smart_str(obj.first_name),
			smart_str(obj.last_name),
			smart_str(s),
			smart_str(obj.is_active)
		])
	
	return response
示例#13
0
    def rec_list(obj):
        obj.title = smart_str("— "*obj.step) + smart_str(obj.title)
        mass_object.append(obj)
        children = Category.objects.filter(parent=obj)

        for child in children:
            rec_list(child)
示例#14
0
    def RenderContents(self,as_rows = True):
        from django.db import connection, transaction
        from django.utils.encoding import smart_str
        cursor = connection.cursor()
        cursor.execute(self.report_query)

        query_set = today_var1 = cursor.fetchall()

        self.results = query_set
        formatted_row = []
        formatted_set = []
        row_count = 0
        
        for row in query_set:
            row_count += 1
            for_index = 0
            for col in row:                
                try:
                    formatter = self.spec[for_index][2]
                    if as_rows:
                        formatted_row.append(smart_str(getattr(self, formatter)(col,self.organization)))
                    else:
                        formatted_set.append(smart_str(getattr(self, formatter)(col,self.organization)))
                    for_index += 1
                except:
                    pass
            if as_rows:
                formatted_set.append(formatted_row)
                formatted_row = []
        if as_rows:
            return formatted_set
        else:
            return formatted_set,row_count
示例#15
0
def json(request, *args, **kwargs):
    """
    The oembed endpoint, or the url to which requests for metadata are passed.
    Third parties will want to access this view with URLs for your site's
    content and be returned OEmbed metadata.
    """
    # coerce to dictionary
    params = dict(request.GET.items())
    
    callback = params.pop('callback', None)
    url = params.pop('url', None)
    
    if not url:
        return HttpResponseBadRequest('Required parameter missing: URL')
    
    try:
        provider = oembed.site.provider_for_url(url)
        if not provider.provides:
            raise OEmbedMissingEndpoint()
    except OEmbedMissingEndpoint:
        raise Http404('No provider found for %s' % url)
    
    query = dict([(smart_str(k), smart_str(v)) for k, v in params.items() if v])
    
    try:
        resource = oembed.site.embed(url, **query)
    except OEmbedException, e:
        raise Http404('Error embedding %s: %s' % (url, str(e)))
示例#16
0
 def render(self, context):
     link = '#'
     try:
         path = context['request'].META['PATH_INFO']
         view, args, kwargs = resolve(path)
         filter_value = self.filter_value.resolve(context, True)
         if filter_value:
             filter_name = smart_str(self.filter_name)
             filter_value = smart_str(filter_value)
             kwargs[filter_name] = filter_value
             # These two don't make sense
             if filter_name == 'server' and 'hostname' in kwargs:
                 del kwargs['hostname']
             elif filter_name == 'hostname' and 'server' in kwargs:
                 del kwargs['server']
             try:
                 link = reverse(view, args=args, kwargs=kwargs)
             except NoReverseMatch:
                 link = reverse(self.fallback_view, args=None,
                     kwargs={filter_name: filter_value})
             qs = context['request'].GET.urlencode()
             if qs:
                 link += "?" + qs
     except NoReverseMatch:
         rm = sys.exc_info()[1]
         raise rm
     except (Resolver404, ValueError):
         pass
     return link
示例#17
0
def print_entity_list():
  with open(ENTITYJSONFILE) as f:
    j = json.load(f)
    for i,k in enumerate(j["targets"]):
      for alias in k["alias"]:
        row = u"%s|%s|%s|%s" % (k["target_id"], k["group"], k["entity_type"], alias)
        print smart_str(row)
示例#18
0
文件: models.py 项目: hugs/django
def get_hexdigest(algorithm, salt, raw_password):
    """
    Returns a string of the hexdigest of the given plaintext password and salt
    using the given algorithm ('md5', 'sha1' or 'crypt').
    """
    raw_password, salt = smart_str(raw_password), smart_str(salt)
    if algorithm == 'crypt':
        try:
            import crypt
        except ImportError:
            raise ValueError('"crypt" password algorithm not supported in this environment')
        return crypt.crypt(raw_password, salt)
    # The rest of the supported algorithms are supported by hashlib, but
    # hashlib is only available in Python 2.5.
    try:
        import hashlib
    except ImportError:
        if algorithm == 'md5':
            import md5
            return md5.new(salt + raw_password).hexdigest()
        elif algorithm == 'sha1':
            import sha
            return sha.new(salt + raw_password).hexdigest()
    else:
        if algorithm == 'md5':
            return hashlib.md5(salt + raw_password).hexdigest()
        elif algorithm == 'sha1':
            return hashlib.sha1(salt + raw_password).hexdigest()
    raise ValueError("Got unknown password algorithm type in password.")
示例#19
0
 def render(self, context):
     try:
         source = self.src.resolve(context)
     except VariableDoesNotExist:
         return None
     if self.version_prefix:
         version_prefix = self.version_prefix
     else:
         try:
             version_prefix = self.version_prefix_var.resolve(context)
         except VariableDoesNotExist:
             return None
     try:
         source = force_unicode(source)
         version_path = get_version_path(url_to_path(source), version_prefix)
         if not os.path.isfile(smart_str(os.path.join(MEDIA_ROOT, version_path))):
             # create version
             version_path = version_generator(url_to_path(source), version_prefix)
         elif os.path.getmtime(smart_str(os.path.join(MEDIA_ROOT, url_to_path(source)))) > os.path.getmtime(smart_str(os.path.join(MEDIA_ROOT, version_path))):
             # recreate version if original image was updated
             version_path = version_generator(url_to_path(source), version_prefix, force=True)
         context[self.var_name] = FileObject(version_path)
     except:
         context[self.var_name] = ""
     return ''
示例#20
0
def fpost():
    post = MySQLdb.escape_string(smart_str(request.form['post_text']))
    user = MySQLdb.escape_string(smart_str(request.form['user']))
    lv = MySQLdb.escape_string(smart_str(request.form['lvalue']))
    la = MySQLdb.escape_string(smart_str(request.form['ladr']))
    pic = request.files['file']
    if pic:
        ur = secure_filename(pic.filename)
        if '.' not in ur:
            ur = "." + ur
        if len(get_post_all(user)) > 0:
            ur = str(get_post_all(user)[-1][0] + 1) + ur
        else:
            ur = "1" + ur
        pic.save(os.path.join(app.config['UPLOAD_FOLDER'], ur))
        ur = "pics/" + ur
    else:
        ur = "__empty__"
    if posting(user, MySQLdb.escape_string(post), ur):
        if la:
            if la[:7] != "http://":
                la = "http://" + la
            pi = int(get_post_all(user)[-1][0])
            if lv:
                put_link(pi, la, lv)
            else:
                put_link(pi, la)
        session['user'] = user
        return redirect(url_for("hom"))
    def build_message(self, contact):
        """
        Build the email as a multipart message containing
        a multipart alternative for text (plain, HTML) plus
        all the attached files.
        """
        content_html = self.build_email_content(contact)
        content_text = html2text(content_html)

        message = MIMEMultipart()

        message['Subject'] = self.build_title_content(contact)
        message['From'] = smart_str(self.newsletter.header_sender)
        message['Reply-to'] = smart_str(self.newsletter.header_reply)
        message['To'] = contact.mail_format()

        message_alt = MIMEMultipart('alternative')
        message_alt.attach(MIMEText(smart_str(content_text), 'plain', 'UTF-8'))
        message_alt.attach(MIMEText(smart_str(content_html), 'html', 'UTF-8'))
        message.attach(message_alt)

        for attachment in self.attachments:
            message.attach(attachment)

        for header, value in self.newsletter.server.custom_headers.items():
            message[header] = value

        return message
示例#22
0
def signin():
    user = MySQLdb.escape_string(smart_str(request.form['Username']))
    password = MySQLdb.escape_string(smart_str(request.form['Password']))
    if sign_in(user, password):
        posts = fget_post_all(user)
        return render_template("home.html", posts=posts, Username=user)
    return render_template("main-page.html")
示例#23
0
文件: util.py 项目: cstavr/synnefo
def put_object_headers(response, meta, restricted=False, token=None):
    response['ETag'] = meta['checksum']
    response['Content-Length'] = meta['bytes']
    response.override_serialization = True
    response['Content-Type'] = meta.get('type', 'application/octet-stream')
    response['Last-Modified'] = http_date(int(meta['modified']))
    if not restricted:
        response['X-Object-Hash'] = meta['hash']
        response['X-Object-UUID'] = meta['uuid']
        if TRANSLATE_UUIDS:
            meta['modified_by'] = \
                retrieve_displayname(token, meta['modified_by'])
        response['X-Object-Modified-By'] = smart_str(
            meta['modified_by'], strings_only=True)
        response['X-Object-Version'] = meta['version']
        response['X-Object-Version-Timestamp'] = http_date(
            int(meta['version_timestamp']))
        for k in [x for x in meta.keys() if x.startswith('X-Object-Meta-')]:
            response[smart_str(
                k, strings_only=True)] = smart_str(meta[k], strings_only=True)
        for k in (
            'Content-Encoding', 'Content-Disposition', 'X-Object-Manifest',
            'X-Object-Sharing', 'X-Object-Shared-By', 'X-Object-Allowed-To',
                'X-Object-Public'):
            if k in meta:
                response[k] = smart_str(meta[k], strings_only=True)
    else:
        for k in ('Content-Encoding', 'Content-Disposition'):
            if k in meta:
                response[k] = smart_str(meta[k], strings_only=True)
示例#24
0
def get_profile_fields(obj):
    reg = obj.user
    affiliate =  reg.profile.get_registration().wsgc_affiliate
    if not affiliate:
        affiliate =  reg.profile.get_registration().wsgc_affiliate_other
    race = [r.name for r in reg.profile.race.all()]
    fields = [
        reg.profile.salutation,
        smart_str(
            reg.first_name,
            encoding='utf-8', strings_only=False, errors='strict'
        ),
        smart_str(
            reg.profile.second_name,
            encoding='utf-8', strings_only=False, errors='strict'
        ),
        smart_str(
            reg.last_name,
            encoding='utf-8', strings_only=False, errors='strict'
        ),
        reg.email,reg.profile.email_auxiliary(),
        reg.profile.phone_primary,reg.profile.phone_mobile,
        reg.profile.address1,reg.profile.address2,reg.profile.city,
        reg.profile.state,reg.profile.postal_code,
        reg.profile.address1_current,reg.profile.address2_current,
        reg.profile.city_current,reg.profile.state_current,
        reg.profile.postal_code_current,
        reg.profile.date_of_birth,reg.profile.gender,
        ' '.join(race),reg.profile.tribe,
        reg.profile.disability,reg.profile.disability_specify,
        reg.profile.employment,reg.profile.military,reg.profile.us_citizen,
        reg.profile.registration_type, affiliate
    ]
    return fields
示例#25
0
文件: views.py 项目: amightyo/ats
def profile_sync( request ):
    profile = Profile.objects.get( user = request.user ) 
    data_encoded = urllib.urlencode( [
              ( 'first_name', smart_str( profile.first_name ) )
             ,( 'last_name', smart_str( profile.last_name ) )
             ,( 'phone', smart_str( profile.phone ) )
             ,( 'mobile', smart_str( profile.mobile ) )
             ,( 'email_1', smart_str( profile.email ) )
        ] )


    if profile.atsid: 
        url = '/'.join( [ ATS_URI, 'candidate/%s/update/' ] )
        r = urllib2.Request( url % ( profile.atsid ), data = data_encoded )
        y = urllib2.urlopen( r )
        #response = y.read()
        #y.close()
        #result = simplejson.loads( response )
    else:
        url = '/'.join( [ ATS_URI, 'candidate/new/' ] )
        r = urllib2.Request( url, data = data_encoded )
        y = urllib2.urlopen( r )
        response = y.read()
        y.close()
        result = simplejson.loads( response )
        profile.atsid = result['candidate']
        profile.save()
 
    return HttpResponseRedirect( '/jobs/' )
def download_file(file_name):
    path_to_file = EX_DIR + '\\candidateDetails\\' + file_name
    my_file = open(path_to_file, 'rb').read()
    response = HttpResponse(my_file, content_type = "text/html")
    response['Content-Disposition'] = 'attachment; filename=%s' % smart_str(file_name)
    response['X-Sendfile'] = smart_str(path_to_file)
    return response
示例#27
0
def export_xls_zip_all_classes(StudentAdmin, request, queryset):
    import openpyxl
    from django.utils.encoding import smart_str
    from openpyxl.utils import get_column_letter
    response = HttpResponse(content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')
    response['Content-Disposition'] = 'attachment; filename=journal.xlsx'
    wb = openpyxl.Workbook()
    wb.remove(wb.active)
    pos = 1

    columns = [
        (u"ID", 15),
        (u"ФИО", 20),
        (u"Класс", 20),
        (u"Оценка", 10),
        (u"Комментарий", 40),
    ]
    dv = DataValidation(type="decimal",
                        operator="between",
                        formula1=0,
                        formula2=10,
                        allow_blank=True)

    for parallel in Parallel.objects.all():
        for group in parallel.class2_set.all():
            isinstance(group, Class2)
            ws = wb.create_sheet(str(parallel) + str(group.name), pos)
            ws.protection.sheet = True
            ws.protection.password = '******'
            pos += 1
            row_num = 0
            for col_num in xrange(len(columns)):
                c = ws.cell(row=row_num + 1, column=col_num + 1)
                c.value = columns[col_num][0]

                #c.style.font.bold = True
                # set column width
                ws.column_dimensions[get_column_letter(col_num + 1)].width = columns[col_num][1]
            for student in group.student_set.all():

                row_num += 1
                row = [
                    student.pk,
                    smart_str(student.fname + " " + student.lname + ' ' + student.fathers_name),
                    smart_str(str(parallel.name) + str(group.name)),
                    smart_str(''),
                    smart_str(''),
                ]
                for col_num in xrange(len(row)):

                    c = ws.cell(row=row_num + 1, column=col_num + 1)
                    c.alignment = Alignment(wrap_text=True)
                    lock = False
                    if col_num + 1 <= 3:
                        lock = True
                    c.protection = Protection(locked=lock)
                    c.value = row[col_num]

    response.write(save_virtual_workbook(wb))
    return response
示例#28
0
文件: views.py 项目: 2013Commons/hue
def _sync_ldap_members(connection, group, ldap_info, count=0, max_count=1):
  if count >= max_count:
    return None

  # Find all users and groups of group.
  users_info = connection.find_users_of_group(ldap_info['dn'])
  groups_info = connection.find_groups_of_group(ldap_info['dn'])
  posix_members = ldap_info['posix_members']

  for user_info in users_info:
    LOG.debug("Synchronizing user %s with group %s" % (smart_str(user_info['dn']), smart_str(group.name)))
    try:
      user = ldap_access.get_ldap_user(username=user_info['username'])
      group.user_set.add(user)
    except User.DoesNotExist:
      LOG.debug("Synchronizing user %s with group %s failed. User does not exist." % (smart_str(user_info['dn']), smart_str(group.name)))

  for group_info in groups_info:
    LOG.debug("Synchronizing group %s" % smart_str(group_info['dn']))

    try:
      group = Group.objects.get(name=group_info['name'])
      _sync_ldap_members(connection, group, group_info, count+1, max_count)
    except Group.DoesNotExist:
      LOG.debug("Synchronizing group %s failed. Group does not exist." % smart_str(group.name))

  for posix_member in posix_members:
    LOG.debug("Synchronizing posix user %s with group %s" % (smart_str(posix_member), smart_str(group.name)))
    users_info = connection.find_users(posix_member, search_attr='uid', user_name_attr=desktop.conf.LDAP.USERS.USER_NAME_ATTR.get(), find_by_dn=False)
    for user_info in users_info:
      try:
        user = ldap_access.get_ldap_user(username=user_info['username'])
        group.user_set.add(user)
      except User.DoesNotExist:
        LOG.debug("Synchronizing posix user %s with group %s failed. User does not exist." % (smart_str(posix_member), smart_str(group.name)))
def get_version_path(value, version_prefix):
    """
    Construct the PATH to an Image version.
    Value has to be server-path, relative to MEDIA_ROOT.
    
    version_filename = filename + version_prefix + ext
    Returns a path relative to MEDIA_ROOT.
    """

    if os.path.isfile(smart_str(os.path.join(MEDIA_ROOT, value))):
        path, filename = os.path.split(value)
        filename, ext = os.path.splitext(filename)

        # check if this file is a version of an other file
        # to return filename_<version>.ext instead of filename_<version>_<version>.ext
        tmp = filename.split("_")
        if tmp[len(tmp) - 1] in ADMIN_VERSIONS:
            # it seems like the "original" is actually a version of an other original
            # so we strip the suffix (aka. version_perfix)
            new_filename = filename.replace("_" + tmp[len(tmp) - 1], "")
            # check if the version exists when we use the new_filename
            if os.path.isfile(smart_str(os.path.join(MEDIA_ROOT, path, new_filename + "_" + version_prefix + ext))):
                # our "original" filename seem to be filename_<version> construct
                # so we replace it with the new_filename
                filename = new_filename
                # if a VERSIONS_BASEDIR is set we need to strip it from the path
                # or we get a <VERSIONS_BASEDIR>/<VERSIONS_BASEDIR>/... construct
                if VERSIONS_BASEDIR != "":
                    path = path.replace(VERSIONS_BASEDIR + "/", "")

        version_filename = filename + "_" + version_prefix + ext
        return os.path.join(VERSIONS_BASEDIR, path, version_filename)
    else:
        return None
示例#30
0
def fun():
    user = MySQLdb.escape_string(smart_str(request.form['user']))
    unf = MySQLdb.escape_string(smart_str(request.form['unf']))
    if unfollow(user, unf):
        posts = fget_post_all(user)
        return render_template("home.html", posts=posts, Username=user)
    return render_template("main-page.html")
示例#31
0
def export_csv_customer_intercom(modeladmin, request, queryset):
    import csv
    from django.utils.encoding import smart_str
    from django.http import HttpResponse

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=for_intercom.csv'

    if not request.user.has_perm('customers.export_customer'):
        return response

    writer = csv.writer(response, csv.excel)
    response.write(u'\ufeff'.encode('utf8'))

    writer.writerow([
        smart_str(u'user_id'),
        smart_str(u'email'),
        smart_str(u'name'),
        smart_str(u'signed_up_at'),
        smart_str(u'last_login_at'),
        smart_str(u'last_order_at'),
        smart_str(u'paused'),
        smart_str(u'unsubscribed'),
        smart_str(u'has_active_order'),
        smart_str(u'address'),
        smart_str(u'postcode'),
        smart_str(u'phone'),
        smart_str(u'vouchers'),
        smart_str(u'total_spend'),
        smart_str(u'shipped_orders'),
        smart_str(u'facebook_id'),
        smart_str(u'stripe_id'),
    ])
    for obj in queryset:
        writer.writerow([
            smart_str(obj.id),
            smart_str(obj.user.email),
            smart_str(obj.get_full_name()),
            smart_str(obj.get_signed_up()),
            smart_str(obj.get_last_login()),
            smart_str(obj.get_last_order_date()),
            smart_str(obj.subscription_is_paused()),
            smart_str(obj.subscription_is_canceled()),
            smart_str(obj.has_active_order()),
            smart_str(obj.get_full_address()),
            smart_str(obj.postcode),
            smart_str(obj.phone),
            smart_str(obj.get_all_voucher_names()),
            smart_str(obj.get_total_spend()),
            smart_str(obj.get_count_orders()),
            smart_str(obj.get_facebook_id()),
            smart_str(obj.stripe_id),
        ])
    return response
示例#32
0
 def _filter_ni(reportrow, field, data):
     args = smart_str(data).strip().split(",")
     return ('"%s" not in (%s)' % (field, ",".join(["%s"] * len(args))), args)
示例#33
0
 def _filter_nc(reportrow, field, data):
     return (
         'not upper("%s") like upper(%%s)' % field,
         ["%%%s%%" % smart_str(data).strip()],
     )
示例#34
0
 def cache_key(self, name):
     return u'staticfiles:%s' % hashlib.md5(smart_str(name)).hexdigest()
示例#35
0
    def post_process(self, paths, dry_run=False, **options):
        """
        Post process the given list of files (called from collectstatic).

        Processing is actually two separate operations:

        1. renaming files to include a hash of their content for cache-busting,
           and copying those files to the target storage.
        2. adjusting files which contain references to other files so they
           refer to the cache-busting filenames.

        If either of these are performed on a file, then that file is considered
        post-processed.
        """
        # don't even dare to process the files if we're in dry run mode
        if dry_run:
            return

        # delete cache of all handled paths
        self.cache.delete_many([self.cache_key(path) for path in paths])

        # build a list of adjustable files
        matches = lambda path: matches_patterns(path, self._patterns.keys())
        adjustable_paths = [path for path in paths if matches(path)]

        # then sort the files by the directory level
        path_level = lambda name: len(name.split(os.sep))
        for name in sorted(paths.keys(), key=path_level, reverse=True):

            # use the original, local file, not the copied-but-unprocessed
            # file, which might be somewhere far away, like S3
            storage, path = paths[name]
            with storage.open(path) as original_file:

                # generate the hash with the original content, even for
                # adjustable files.
                hashed_name = self.hashed_name(name, original_file)

                # then get the original's file content..
                if hasattr(original_file, 'seek'):
                    original_file.seek(0)

                hashed_file_exists = self.exists(hashed_name)
                processed = False

                # ..to apply each replacement pattern to the content
                if name in adjustable_paths:
                    content = original_file.read()
                    converter = self.url_converter(name)
                    for patterns in self._patterns.values():
                        for pattern in patterns:
                            content = pattern.sub(converter, content)
                    if hashed_file_exists:
                        self.delete(hashed_name)
                    # then save the processed result
                    content_file = ContentFile(smart_str(content))
                    saved_name = self._save(hashed_name, content_file)
                    hashed_name = force_unicode(saved_name.replace('\\', '/'))
                    processed = True
                else:
                    # or handle the case in which neither processing nor
                    # a change to the original file happened
                    if not hashed_file_exists:
                        processed = True
                        saved_name = self._save(hashed_name, original_file)
                        hashed_name = force_unicode(
                            saved_name.replace('\\', '/'))

                # and then set the cache accordingly
                self.cache.set(self.cache_key(name), hashed_name)
                yield name, hashed_name, processed
示例#36
0
 def test_sendfile(self):
     response = real_sendfile(HttpRequest(), self._get_readme())
     self.assertTrue(response is not None)
     self.assertEqual('text/plain', response['Content-Type'])
     self.assertEqual(self._get_readme(), smart_str(response.content))
示例#37
0
 def test_xsendfile_header_containing_unicode(self):
     filepath = self.ensure_file(u'péter_là_gueule.txt')
     response = real_sendfile(HttpRequest(), filepath)
     self.assertTrue(response is not None)
     self.assertEqual(smart_str(filepath), response['X-Sendfile'])
示例#38
0
def export_csv_customer(modeladmin, request, queryset):
    import csv
    from django.utils.encoding import smart_str
    from django.http import HttpResponse

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=mymodel.csv'

    if not request.user.has_perm('customers.export_customer'):
        return response

    writer = csv.writer(response, csv.excel)
    response.write(u'\ufeff'.encode('utf8'))

    writer.writerow([
        smart_str(u"id"),
        smart_str(u"user"),
        smart_str(u"customer"),
        smart_str(u"address"),
        smart_str(u"postcode"),
        smart_str(u"phone"),
        smart_str(u"amount"),
        smart_str(u"vouchers"),
        smart_str(u"orders"),
        smart_str(u"stripe_id"),
        smart_str(u"card_details"),
    ])
    for obj in queryset:
        writer.writerow([
            smart_str(obj.id),
            smart_str(obj.user),
            smart_str(obj.get_full_name()),
            smart_str(obj.get_full_address()),
            smart_str(obj.postcode),
            smart_str(obj.phone),
            smart_str(obj.amount),
            smart_str(obj.get_all_vouchers()),
            smart_str(obj.get_count_orders()),
            smart_str(obj.stripe_id),
            smart_str(obj.card_details),
        ])
    return response
示例#39
0
def export_csv_order(modeladmin, request, queryset):
    import csv
    from django.utils.encoding import smart_str
    from django.http import HttpResponse

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=mymodel.csv'

    if not request.user.has_perm('customers.export_order'):
        return response

    writer = csv.writer(response, csv.excel)
    response.write(u'\ufeff'.encode(
        'utf8'))  # BOM (optional...Excel needs it to open UTF-8 file properly)

    writer.writerow([
        smart_str(u"id"),
        smart_str(u"status"),
        smart_str(u"creation_date"),
        smart_str(u"shipping_date"),
        smart_str(u"customer"),
        smart_str(u"coffee"),
        smart_str(u"amount"),
        smart_str(u"brew"),
        smart_str(u"package"),
        smart_str(u"different"),
        smart_str(u"recurrent"),
        smart_str(u"interval"),
        smart_str(u"voucher"),
        smart_str(u"feedback"),
    ])
    for obj in queryset:
        writer.writerow([
            smart_str(obj.id),
            smart_str(obj.status),
            smart_str(obj.date),
            smart_str(obj.shipping_date),
            smart_str(obj.customer),
            smart_str(obj.coffee),
            smart_str(obj.amount),
            smart_str(obj.brew),
            smart_str(obj.get_package_display()),
            smart_str(obj.different),
            smart_str(obj.recurrent),
            smart_str(obj.interval),
            smart_str(obj.voucher),
            smart_str(obj.get_feedback_display()),
        ])
    return response
示例#40
0
def export_csv_coffee_reviews(modeladmin, request, queryset):
    import csv
    from django.utils.encoding import smart_str
    from django.http import HttpResponse

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=coffee_reviews.csv'

    if not request.user.has_perm('customers.export_coffeereview'):
        return response

    writer = csv.writer(response, csv.excel)
    response.write(u'\ufeff'.encode('utf8'))

    writer.writerow([
        smart_str(u"id"),
        smart_str(u"created_at"),
        smart_str(u"rating"),
        smart_str(u"comment"),
        smart_str(u"coffee"),
        smart_str(u"order"),
        smart_str(u"amount"),
        smart_str(u"customer"),
        smart_str(u"stripe_id"),
    ])
    for obj in queryset:
        writer.writerow([
            smart_str(obj.id),
            smart_str(obj.created_at),
            smart_str(obj.rating),
            smart_str(obj.comment),
            smart_str(obj.order.coffee),
            smart_str(obj.order),
            smart_str(obj.order.amount),
            smart_str(obj.order.customer),
            smart_str(obj.order.customer.stripe_id),
        ])
    return response
示例#41
0
            unsubscribes += temp_list

        unsubscribes_set = set(unsubscribes)

    except mailchimp.Error, e:
        print 'MailChimp error occurred: %s - %s' % (e.__class__, e)

    customers = Customer.objects.all()
    get_started = GetStartedResponse.objects.all()
    customers_set = set([x.user.email.lower() for x in customers])
    get_started_set = set([x.email.lower() for x in get_started])
    subscribes_set = customers_set.union(get_started_set) - unsubscribes_set

    writer.writerow([
        smart_str(u"email"),
        # smart_str(u"mailchimp"),
    ])
    for email in subscribes_set:
        writer.writerow([
            smart_str(email),
            # smart_str('1'),
        ])
    # for email in unsubscribes_set:
    #     writer.writerow([
    #         smart_str(email),
    #         smart_str('0'),
    #     ])

    return response
示例#42
0
def export_csv_gearorders(modeladmin, request, queryset):
    import csv
    from django.utils.encoding import smart_str
    from django.http import HttpResponse

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=gear_orders.csv'

    if not request.user.has_perm('customers.export_gearorder'):
        return response

    writer = csv.writer(response, csv.excel)
    response.write(u'\ufeff'.encode(
        'utf8'))  # BOM (optional...Excel needs it to open UTF-8 file properly)

    writer.writerow([
        smart_str(u'id'),
        smart_str(u'status'),
        smart_str(u'creation_date'),
        smart_str(u'shipping_date'),
        smart_str(u'customer'),
        smart_str(u'gear'),
        smart_str(u'quantity'),
        smart_str(u'price'),
        smart_str(u'details'),
        smart_str(u'tracking_number'),
    ])
    for obj in queryset:
        writer.writerow([
            smart_str(obj.id),
            smart_str(obj.status),
            smart_str(obj.date),
            smart_str(obj.shipping_date),
            smart_str(obj.customer),
            smart_str(obj.gear),
            smart_str(obj.details.get('Quantity', 1)),
            smart_str(obj.price),
            smart_str(obj.details),
            smart_str(obj.tracking_number),
        ])
    return response
示例#43
0
    def handle(self, *args, **options):
        outputfile = options.get('file')

        output_text = []

        output_text.append('@@@@@'.join([
            smart_str(u"ID"),
            smart_str(u"User"),
            smart_str(u"Date"),
            smart_str(u"Date Updated"),
            smart_str(u"Name (as stated on disclaimer)"),
            smart_str(u"DOB"),
            smart_str(u"Address"),
            smart_str(u"Postcode"),
            smart_str(u"Home Phone"),
            smart_str(u"Mobile Phone"),
            smart_str(u"Emergency Contact 1: Name"),
            smart_str(u"Emergency Contact 1: Relationship"),
            smart_str(u"Emergency Contact 1: Phone"),
            smart_str(u"Emergency Contact 2: Name"),
            smart_str(u"Emergency Contact 2: Relationship"),
            smart_str(u"Emergency Contact 2: Phone"),
            smart_str(u"Medical Conditions"),
            smart_str(u"Medical Conditions Details"),
            smart_str(u"Joint Problems"),
            smart_str(u"Joint Problems Details"),
            smart_str(u"Allergies"),
            smart_str(u"Allergies Details"),
            smart_str(u"Medical Treatment Terms"),
            smart_str(u"Medical Treatment Accepted"),
            smart_str(u"Disclaimer Terms"),
            smart_str(u"Disclaimer Terms Accepted"),
            smart_str(u"Over 18 Statement"),
            smart_str(u"Over 18 Confirmed")
        ]))

        for obj in OnlineDisclaimer.objects.all():
            output_text.append('@@@@@'.join([
                smart_str(obj.pk),
                smart_str(obj.user),
                smart_str(obj.date.strftime('%Y-%m-%d %H:%M:%S:%f %z')),
                smart_str(
                    obj.date_updated.strftime('%Y-%m-%d %H:%M:%S:%f %z'
                                              ) if obj.date_updated else ''),
                smart_str(obj.name),
                smart_str(obj.dob.strftime('%Y-%m-%d')),
                smart_str(obj.address),
                smart_str(obj.postcode),
                smart_str(obj.home_phone),
                smart_str(obj.mobile_phone),
                smart_str(obj.emergency_contact1_name),
                smart_str(obj.emergency_contact1_relationship),
                smart_str(obj.emergency_contact1_phone),
                smart_str(obj.emergency_contact2_name),
                smart_str(obj.emergency_contact2_relationship),
                smart_str(obj.emergency_contact2_phone),
                smart_str('Yes' if obj.medical_conditions else 'No'),
                smart_str(obj.medical_conditions_details),
                smart_str('Yes' if obj.joint_problems else 'No'),
                smart_str(obj.joint_problems_details),
                smart_str('Yes' if obj.allergies else 'No'),
                smart_str(obj.allergies_details),
                smart_str(obj.medical_treatment_terms),
                smart_str('Yes' if obj.medical_treatment_permission else 'No'),
                smart_str(obj.disclaimer_terms),
                smart_str('Yes' if obj.terms_accepted else 'No'),
                smart_str(obj.over_18_statement),
                smart_str('Yes' if obj.age_over_18_confirmed else 'No'),
            ]))

        output_str = '&&&&&'.join(output_text)

        with open(outputfile, 'wb') as out:
            out.write(encrypt(PASSWORD, output_str))

        with open(outputfile, 'rb') as file:
            filename = os.path.split(outputfile)[1]
            try:
                msg = EmailMessage(
                    '{} disclaimer backup'.format(
                        settings.ACCOUNT_EMAIL_SUBJECT_PREFIX),
                    'Encrypted disclaimer back up file attached. '
                    '{} records.'.format(OnlineDisclaimer.objects.count()),
                    settings.DEFAULT_FROM_EMAIL,
                    to=[settings.SUPPORT_EMAIL],
                    attachments=[(filename, file.read(), 'bytes/bytes')])
                msg.send(fail_silently=False)
            except:
                pass

        self.stdout.write(
            '{} disclaimer records encrypted and written to {}'.format(
                OnlineDisclaimer.objects.count(), outputfile))

        logger.info('{} disclaimer records encrypted and backed up'.format(
            OnlineDisclaimer.objects.count()))
        ActivityLog.objects.create(
            log='{} disclaimer records encrypted and backed up'.format(
                OnlineDisclaimer.objects.count()))
示例#44
0
def export_csv_preferences(modeladmin, request, queryset):
    import csv
    from django.utils.encoding import smart_str
    from django.http import HttpResponse

    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename=mymodel.csv'

    if not request.user.has_perm('customers.export_preferences'):
        return response

    writer = csv.writer(response, csv.excel)
    response.write(u'\ufeff'.encode('utf8'))

    writer.writerow([
        smart_str(u"id"),
        smart_str(u"customer"),
        smart_str(u"coffee"),
        smart_str(u"flavor"),
        smart_str(u"brew"),
        smart_str(u"package"),
        smart_str(u"different"),
        smart_str(u"intense"),
        smart_str(u"interval"),
    ])
    for obj in queryset:
        flavors = ' | '.join([str(v) for v in obj.flavor.all()])
        writer.writerow([
            smart_str(obj.id),
            smart_str(obj.customer),
            smart_str(obj.coffee),
            smart_str(flavors),
            smart_str(obj.brew),
            smart_str(obj.package),
            smart_str(obj.different),
            smart_str(obj.intense),
            smart_str(obj.interval),
        ])
    return response
示例#45
0
 def get_menu_id(self, path):
     return hashlib.sha1(" | ".join(smart_str(p) for p in path)).hexdigest()
示例#46
0
    def foreignkey_autocomplete(self, request):
        """
        Search in the fields of the given related model and returns the
        result as a simple string to be used by the jQuery Autocomplete plugin
        """
        query = request.GET.get('q', None)
        app_label = request.GET.get('app_label', None)
        model_name = request.GET.get('model_name', None)
        search_fields = request.GET.get('search_fields', None)
        object_pk = request.GET.get('object_pk', None)

        try:
            to_string_function = self.related_string_functions[model_name]
        except KeyError:
            to_string_function = lambda x: x.__str__()

        if search_fields and app_label and model_name and (query or object_pk):

            def construct_search(field_name):
                # use different lookup methods depending on the notation
                if field_name.startswith('^'):
                    return "%s__istartswith" % field_name[1:]
                elif field_name.startswith('='):
                    return "%s__iexact" % field_name[1:]
                elif field_name.startswith('@'):
                    return "%s__search" % field_name[1:]
                else:
                    return "%s__icontains" % field_name

            model = apps.get_model(app_label, model_name)

            queryset = model._default_manager.all()
            data = ''
            if query:
                for bit in query.split():
                    or_queries = [
                        models.Q(
                            **{
                                construct_search(smart_str(field_name)):
                                smart_str(bit)
                            }) for field_name in search_fields.split(',')
                    ]
                    other_qs = QuerySet(model)
                    other_qs.query.select_related = queryset.query.select_related
                    other_qs = other_qs.filter(reduce(operator.or_,
                                                      or_queries))
                    queryset = queryset & other_qs

                additional_filter = self.get_related_filter(model, request)
                if additional_filter:
                    queryset = queryset.filter(additional_filter)

                if self.autocomplete_limit:
                    queryset = queryset[:self.autocomplete_limit]

                data = ''.join([
                    str('%s|%s\n') % (to_string_function(f), f.pk)
                    for f in queryset
                ])
            elif object_pk:
                try:
                    obj = queryset.get(pk=object_pk)
                except Exception:  # FIXME: use stricter exception checking
                    pass
                else:
                    data = to_string_function(obj)
            return HttpResponse(data, content_type='text/plain')
        return HttpResponseNotFound()
示例#47
0
 def __str__(self):
     return smart_str(self.cost_item) + " - " + smart_str(self.total)
示例#48
0
    def write_page(self, site, page, filename):
        self.out('Writing sitemap %s.' % filename, 2)
        old_page_md5 = None
        urls = []

        if conf.MOCK_SITE:
            if conf.MOCK_SITE_NAME is None:
                raise ImproperlyConfigured(
                    "STATICSITEMAPS_MOCK_SITE_NAME must not be None. Try setting to www.yoursite.com"
                )
            from django.contrib.sites.requests import RequestSite
            from django.test.client import RequestFactory
            rs = RequestSite(RequestFactory().get(
                '/', SERVER_NAME=conf.MOCK_SITE_NAME))
        try:
            if callable(site):
                if conf.MOCK_SITE:
                    urls.extend(site().get_urls(
                        page, rs, protocol=conf.MOCK_SITE_PROTOCOL))
                else:
                    urls.extend(site().get_urls(page,
                                                protocol=conf.FORCE_PROTOCOL))
            else:
                if conf.MOCK_SITE:
                    urls.extend(
                        site.get_urls(page,
                                      rs,
                                      protocol=conf.MOCK_SITE_PROTOCOL))
                else:
                    urls.extend(
                        site.get_urls(page, protocol=conf.FORCE_PROTOCOL))
        except EmptyPage:
            self.out("Page %s empty" % page)
        except PageNotAnInteger:
            self.out("No page '%s'" % page)

        lastmods = [
            lastmod for lastmod in [u.get('lastmod') for u in urls]
            if lastmod is not None
        ]
        file_lastmod = max(lastmods) if len(lastmods) > 0 else None
        path = os.path.join(self.root_dir, filename)
        template = getattr(site, 'sitemap_template', 'sitemap.xml')

        if self.storage.exists(path):
            old_page_md5 = self.read_hash(path)
            self.storage.delete(path)

        output = smart_str(loader.render_to_string(template, {'urlset': urls}))
        self._write(path, output)

        with self.storage.open(path) as sitemap_page:
            if old_page_md5 != self.get_hash(sitemap_page.read()):
                self.has_changes = True

        if conf.USE_GZIP:
            if conf.GZIP_METHOD not in [
                    'python',
                    'system',
            ]:
                raise ImproperlyConfigured(
                    "STATICSITEMAPS_GZIP_METHOD must be in ['python', 'system']"
                )

            if conf.GZIP_METHOD == 'system' and not os.path.exists(
                    conf.SYSTEM_GZIP_PATH):
                raise ImproperlyConfigured(
                    'STATICSITEMAPS_SYSTEM_GZIP_PATH does not exist')

            if conf.GZIP_METHOD == 'system' and not isinstance(
                    self.storage, FileSystemStorage):
                raise ImproperlyConfigured(
                    'system gzip method can only be used with FileSystemStorage'
                )

            if conf.GZIP_METHOD == 'system':
                # GZIP with system gzip binary
                subprocess.call([
                    conf.SYSTEM_GZIP_PATH,
                    '-f',
                    path,
                ])
            else:
                # GZIP with python gzip lib
                try:
                    gzipped_path = '%s.gz' % path
                    if self.storage.exists(gzipped_path):
                        self.storage.delete(gzipped_path)

                    self.out('Compressing...', 2)
                    buf = BytesIO()
                    with gzip.GzipFile(fileobj=buf, mode="w") as f:
                        f.write(output.encode('utf-8'))
                    self.storage.save(gzipped_path,
                                      ContentFile(buf.getvalue()))
                except OSError:
                    self.out("Compress %s file error" % path)

        return file_lastmod
示例#49
0
 def __str__(self):
     return smart_str(self.name)
示例#50
0
 def __str__(self):
     return smart_str(self.category) + " " + smart_str(self.name)
示例#51
0
 def get_size_name(self):
     if self.size:
         return smart_str(self.size.name)
     else:
         return smart_str("único")
示例#52
0
 def __str__(self):
     return smart_str(self.name) + " (" + smart_str(self.unit) + ")"
示例#53
0
 def __repr__(self):
     return smart_str(u'<%s: %s>' %
                      (self.__class__.__name__, unicode(self)))
示例#54
0
 def __str__(self):
     return smart_str(self.key)
示例#55
0
    def handle(self, *args, **options):
        print("=/= " * 20,
              "\nSitemap creation started @ %s" % (datetime.datetime.now()))
        count = -1
        if args:
            count = int(args[0]) if args[0].isdigit() else -1
        current_site = ROOT_BASE_URL
        root_url_path = 'http://%s/' % current_site
        sites = []
        today_date = datetime.date.today()
        try:
            global sitemaps
            for section, site in sitemaps.items():
                parent_xml_file = parent_xml_path + 'sitemap_' + section + '.xml'
                fd_parent = open(parent_xml_file, 'w')
                fd_parent.write('<?xml version="1.0" encoding="UTF-8"?>\n')
                fd_parent.write(
                    '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n'
                )

                fd_parent.write('<sitemap>\n')
                fd_parent.write('<loc>' + root_url_path + 'sitemap_' +
                                section + '-1.xml.gz</loc>\n')
                fd_parent.write('<lastmod>' + today_date.strftime("%Y-%m-%d") +
                                '</lastmod>\n')
                fd_parent.write('</sitemap>\n')
                if callable(site):
                    pages = site().paginator.num_pages
                else:
                    pages = site.paginator.num_pages
                sitemap_url = reverse('section_sitemap',
                                      kwargs={'section': section})
                sites.append('%s%s' % (current_site, sitemap_url))
                if pages > 1:
                    for page in range(2, pages + 1):
                        sites.append('%s%s?p=%s' %
                                     (current_site, sitemap_url, page))
                        fd_parent.write('<sitemap>\n')
                        fd_parent.write('<loc>' + root_url_path + 'sitemap_' +
                                        section + '-' + str(page) +
                                        '.xml.gz</loc>\n')
                        fd_parent.write('<lastmod>' +
                                        today_date.strftime("%Y-%m-%d") +
                                        '</lastmod>\n')
                        fd_parent.write('</sitemap>\n')

                fd_parent.write('</sitemapindex>\n')
                fd_parent.close()

            success_count = 0
            SuperSitemap.write_file = open(
                BASE_DIR + '/uploads/sitemap_log.txt', 'w')
            for each_site in sites:
                url_name = each_site.split('/')[1]
                if url_name.find('?') > 0:
                    section = url_name[url_name.find('-') +
                                       1:url_name.find('.')]
                    page = int(url_name[url_name.find('=') + 1:])
                else:
                    section = url_name[url_name.find('-') +
                                       1:url_name.find('.')]
                    page = 1
                file_name = 'sitemap_' + section + '-' + str(page) + '.xml'
                xml_file_path = parent_xml_path + file_name
                maps, urls = [], []
                maps.append(sitemaps[section])
                for site in maps:
                    if callable(site):
                        urls, success_count = site().get_urls(page, count)
                    else:
                        urls, success_count = site.get_urls(page, count)
                response = smart_str(
                    loader.render_to_string('custom_sitemap.xml',
                                            {'urlset': urls}))

                fd = open(xml_file_path, 'w')
                fd.write(response)
                fd.close()
                os.system(str('gzip -f ' + xml_file_path))

                if SuperSitemap.write_file:
                    SuperSitemap.write_file.write(
                        'XML File : %s , Success Count : %s\n' %
                        (os.path.basename(xml_file_path), success_count))

            if not SuperSitemap.write_file.closed:
                SuperSitemap.write_file.close()
        except Exception as e:
            error_stream = traceback.format_exc()
            sys.stdout.write(error_stream)
            sys.stdout.write('\nExiting with error\n' + '*' * 30 + '\n')
            sys.exit()

        sys.stdout.write('Successfully created the xml files\n\n')
示例#56
0
 def full_name(self):
     if self.flavor:
         return smart_str(self.category) + " " + smart_str(self.flavor.name)
     else:
         return smart_str(self.category)
示例#57
0
    def create_questionnaire_explanation_fields(self, questionnaire_id,
                                                language,
                                                questionnaire_lime_survey,
                                                fields,
                                                entrance_questionnaire):
        """
        :param questionnaire_id:
        :param language:
        :param questionnaire_lime_survey:
        :param fields: fields from questionnaire that are to be exported
        :param entrance_questionnaire: boolean
        :return: header, formatted according to fields
                 data_rows, formatted according to fields
                 if error, both data are []
        """
        # clear fields
        fields_cleared = [field.split("[")[0] for field in fields]

        questionnaire_explanation_fields_list = [HEADER_EXPLANATION_FIELDS]

        fields_from_questions = []

        # for each field, verify the question description
        questionnaire_title = questionnaire_lime_survey.get_survey_title(
            questionnaire_id, language)
        questionnaire_code = \
            self.get_questionnaire_code_from_id(questionnaire_id)

        # get fields description
        questionnaire_questions = questionnaire_lime_survey.list_questions_ids(
            questionnaire_id, 0)

        for question in questionnaire_questions:
            properties = questionnaire_lime_survey.get_question_properties(
                question, language)
            question_code = \
                properties['title'] if 'title' in properties else None
            if question_code and question_code in fields_cleared:
                fields_from_questions.append(question_code)
                # clean the question description that came from limesurvey
                question_description = \
                    re.sub(
                        '{.*?}', '',
                        re.sub('<.*?>', '', properties['question'])
                    ).replace('&nbsp;', '').strip()
                question_type = smart_str(properties['type'])
                question_type_description = question_types[question_type] \
                    if question_type in question_types else ''
                question_group = \
                    self.get_group_properties(
                        questionnaire_lime_survey,
                        questionnaire_id,
                        properties['gid'],
                        language
                    )
                question_order = properties['question_order']

                questionnaire_list = \
                    [smart_str(questionnaire_code),
                     smart_str(questionnaire_title)]
                question_type_list = \
                    [smart_str(question_order), question_type,
                     question_type_description]
                question_list = \
                    [smart_str(question_code),
                     smart_str(question_description)]

                scales = [""]
                # "1": "Array Dual Scale"
                if question_type == "1":
                    if isinstance(properties['attributes_lang'], dict):
                        scales = [
                            properties['attributes_lang']['dualscale_headerA']
                            if 'dualscale_headerA'
                            in properties['attributes_lang'] else "",
                            properties['attributes_lang']['dualscale_headerB']
                            if 'dualscale_headerB'
                            in properties['attributes_lang'] else ""
                        ]
                    else:
                        scales = ["", ""]

                # answers
                options_list = []

                if isinstance(properties['answeroptions'], dict):
                    options = collections.OrderedDict(
                        sorted(properties['answeroptions'].items()))
                    for option_key, option_values in options.items():
                        options_list.append([
                            smart_str(option_key),
                            smart_str(option_values['answer'])
                        ])
                else:
                    # include blank line
                    options_list = [[""] * 2]

                # sub-questions
                if isinstance(properties['subquestions'], dict):
                    sub_questions_list = [[
                        smart_str(value['title']),
                        smart_str(value['question'])
                    ] for value in properties['subquestions'].values()]
                    sub_questions_list = sorted(sub_questions_list,
                                                key=itemgetter(0))
                else:
                    # include blank line
                    sub_questions_list = [[""] * 2]

                for scale_index, scale_label in enumerate(scales):
                    scale = [scale_index + 1, scale_label] \
                        if scale_label else [""] * 2
                    for sub_question in sub_questions_list:
                        for option in options_list:

                            question_index = question_code
                            if sub_question[0]:
                                question_index += '[' + sub_question[0] + ']'
                            if scale_label:
                                question_index += \
                                    '[' + str(scale_index + 1) + ']'

                            questionnaire_explanation_fields_list.append(
                                questionnaire_list +
                                [question_group['group_name']] +
                                question_type_list + [question_index] +
                                question_list + sub_question + scale + option)

        if len(fields_cleared) != len(fields_from_questions):
            for field in fields_cleared:
                if field not in fields_from_questions:
                    description = self.get_header_description(
                        questionnaire_id, field, entrance_questionnaire)
                    question_list = [
                        smart_str(questionnaire_code),
                        smart_str(questionnaire_title), '', '',
                        smart_str(field),
                        smart_str(field),
                        smart_str(description)
                    ]
                    questionnaire_explanation_fields_list.append(question_list)

        return questionnaire_explanation_fields_list
示例#58
0
文件: views.py 项目: vkit/pyfaexample
 def post(self, request, *args, **kwargs):
     routecard = RouteCard.objects.get(pk=self.kwargs.get('pk'))
     response = HttpResponse(content_type='text/csv')
     response[
         'Content-Disposition'] = 'attachment; filename={0}-{1}.csv'.format(
             routecard.jobspec.number, routecard.number)
     writer = csv.writer(response, csv.excel)
     response.write(u'\ufeff'.encode('utf8'))
     # BOM (optional...Excel needs it to open UTF-8 file properly)
     writer.writerow([
         smart_str(u"Process"),
         smart_str(u"Machine"),
         smart_str(u"Planned Start Time"),
         smart_str(u"Planned End Time"),
         smart_str(u"Completed"),
         smart_str(u"Total Accepted"),
         smart_str(u"Delay"),
     ])
     for plan in routecard.plan_set.all():
         writer.writerow([
             smart_str(plan.process),
             smart_str(plan.machine),
             smart_str(plan.planned_on),
             smart_str(plan.end_time()),
             smart_str(plan.is_complete),
             smart_str(plan.total_accepted_quantity()),
             smart_str(plan.delay()),
         ])
     return response
示例#59
0
 def post(self, request):
     if request.is_ajax():
         try:
             if isinstance(request.body, bytes):
                 data = json.loads(request.body.decode())
             else:
                 data = json.loads(request.body)
             if data['action'] == 'create':
                 if not request.user.has_perm(
                         'common.can_add_commandssequence'):
                     raise PermissionDenied(_('403 Forbidden'))
                 obj = CommandsSequence.objects.create(
                     name=data['name'], commands=data['commands'])
                 for group in data['group']:
                     obj.group.add(ServerGroup.objects.get(name=group))
                 obj.save()
                 return JsonResponse({
                     'status':
                     True,
                     'message':
                     '%s create success!' %
                     (smart_str(data.get('name', None)))
                 })
             elif data['action'] == 'update':
                 if not request.user.has_perm(
                         'common.can_change_commandssequence'):
                     raise PermissionDenied(_('403 Forbidden'))
                 try:
                     obj = CommandsSequence.objects.get(
                         id=data.get('id', None))
                     obj.commands = data['commands']
                     [obj.group.remove(group) for group in obj.group.all()]
                     for group in data['group']:
                         obj.group.add(ServerGroup.objects.get(name=group))
                     data.pop('group')
                     obj.__dict__.update(data)
                     obj.save()
                     return JsonResponse({
                         'status':
                         True,
                         'message':
                         '%s update success!' %
                         (smart_str(data.get('name', None)))
                     })
                 except ObjectDoesNotExist:
                     return JsonResponse({
                         'status':
                         False,
                         'message':
                         'Request object not exist!'
                     })
             elif data['action'] == 'delete':
                 if not request.user.has_perm(
                         'common.can_delete_commandssequence'):
                     raise PermissionDenied(_('403 Forbidden'))
                 try:
                     obj = CommandsSequence.objects.get(
                         id=data.get('id', None))
                     taskname = obj.name
                     obj.delete()
                     return JsonResponse({
                         'status':
                         True,
                         'message':
                         'Delete task %s success!' % (taskname)
                     })
                 except ObjectDoesNotExist:
                     return JsonResponse({
                         'status':
                         False,
                         'message':
                         'Request object not exist!'
                     })
             else:
                 return JsonResponse({
                     'status': False,
                     'message': 'Illegal action.'
                 })
         except ObjectDoesNotExist:
             return JsonResponse({
                 'status':
                 False,
                 'message':
                 'Please input a valid group name!'
             })
         except IntegrityError:
             return JsonResponse({
                 'status':
                 False,
                 'message':
                 'Task name:%s already exist,Please use another name instead!'
                 % (data['name'])
             })
         except KeyError:
             return JsonResponse({
                 'status':
                 False,
                 'message':
                 "Invalid parameter,Please report it to the adminstrator!"
             })
         except Exception as e:
             print(traceback.print_exc())
             return JsonResponse({
                 'status':
                 False,
                 'message':
                 'Some error happend! Please report it to the adminstrator! Error info:%s'
                 % (smart_str(e))
             })
     else:
         pass
示例#60
0
 def _get_content(self):
     if self.has_header('Content-Encoding'):
         return ''.join(self._container)
     return smart_str(''.join(self._container), self._charset)