def avatar_and_name(speaker, mission_name, timestamp=None): if timestamp: current_speaker = speaker.current_shift(timestamp) else: current_speaker = speaker detail = """ <img src='%(MISSIONS_STATIC_URL)s%(mission_name)s/images/avatars/%(avatar)s' alt='' width='48' height='48'> <span>%(short_name)s</span> """ % { "avatar": current_speaker.avatar, "short_name": current_speaker.short_name, "mission_name": mission_name, "MISSIONS_STATIC_URL": settings.MISSIONS_STATIC_URL, } url = None if current_speaker.role == 'mission-ops': url = '%s#%s' % (reverse("people", kwargs={"role": current_speaker.role}), slugify(current_speaker.short_name)) elif current_speaker.role == 'astronaut' or current_speaker.role == 'mission-ops-title': url = '%s#%s' % (reverse("people"), slugify(current_speaker.short_name)) if url: return "<a href='%s'>%s</a>" % (url, detail) else: return detail
def test_slugify(self): self.assertEqual(slugify(' Jack & Jill like numbers 1,2,3 and 4 and' ' silly characters ?%.$!/'), 'jack-jill-like-numbers-123-and-4-and-silly-characters') self.assertEqual(slugify("Un \xe9l\xe9phant \xe0 l'or\xe9e du bois"), 'un-elephant-a-loree-du-bois')
def save(self): #Give it a passkey if necessary if not self.passkey: from core.functions import generate_passkey self.passkey = generate_passkey(25) #Geocode that shit! if not self.lat or not self.lng: self.geocode_for_point() #If it's the first save, give it an easy slug if not self.slug: self.slug = slugify("%s %s" % (self.address1, str(self.zip))) if not self.location: self.set_location() super(Property, self).save() #Now, check to make sure that the slug isn't duplicate if(Property.objects.filter(slug=self.slug).count() > 1): #Existing slug found. import random self.slug = slugify("%s-%i" % (self.slug, random.randrange(1000000,9999999))) super(Property, self).save() #Now, send the confirm email to the user if they have not received one yet. if not self.verified: from core.functions import send_email send_email(extra_context = {'name':self.email, 'property':self, 'recipeient':self.email, 'subject':"Almost! Confirm your listing."})
def project_screenshot(instance, filename): return ( "applications/screenshots/" + slugify(instance.owner.__unicode__() + "/" + ".".join(filename.split(".")[:-1])) + "." + slugify(filename.split(".")[-1]) )
def save(self, *args, **kwargs): # previous version: # from unidecode import unidecode # # if not self.slug: # self.slug = slugify(unidecode(self.title)) # # make the slug unique # orig = slugify(unidecode(self.title)) # while Post.objects.filter(slug=orig).exists(): # self.slug = '%s-' % (self.slug,) # orig = self.slug if not Post.objects.filter(slug=slugify(self.title)).exists(): # if its slug unique - save the post self.slug = slugify(self.title) super(Post, self).save(*args, **kwargs) else: # check whether it is an edit or creation created = False if self.id else True # if it's just created we have no id and no slug can be made # so get slug with id only if it's an edit and post is "not created" self.slug = "{}-{}".format(slugify(self.title), self.id) if not created else None super(Post, self).save(*args, **kwargs) # either way here we have a saved post with id, but if it wasn't "created" # it had slug and was saved with it, but if it was we must save it with # its slug now if created: self.slug = "{}-{}".format(slugify(self.title), self.id) super(Post, self).save(*args, **kwargs)
def create_discussion_via_im(request): im_address = request.POST.get("im_address", "") name = request.POST.get("name", _("Untitled")) description = request.POST.get("description", "") group = int(request.POST.get("group", 0)) user_profile = get_object_or_404(UserProfile, im_address=im_address) user = user_profile.user group = get_object_or_404(Group, pk=group) discussion = Discussion() discussion.group = group discussion.type = DiscussionType.objects.get(name=settings.DEFAULT_DISCUSSION_TYPE) discussion.name = name if is_heb(discussion.name): encoded_discussion_name = discussion.name.__repr__().encode("ascii")[2:-1] encoded_group_name = group.name.__repr__().encode("ascii")[2:-1] discussion.slug = slugify("%s_%s" % (encoded_group_name,encoded_discussion_name)) else: discussion.slug = slugify("%s_%s" % (group.name,discussion.name)) discussion.description = description discussion.created_by = user discussion.x = 0 discussion.y = 0 discussion.is_private = 'is_private' in request.POST discussion.save() discussion_details = {"id": discussion.id, "link": discussion.get_absolute_url(), "name": discussion.name} return HttpResponse(simplejson.dumps(discussion_details))
def add_discussion(request): group = Group.objects.get(id=request.POST.get('group')) group_profile = GroupProfile.objects.filter(group=group)[0] if group_profile.is_private and not group_profile.is_user_in_group(request.user): return HttpResponse("The group is private. You're not allowed to create discussion.") if request.POST: discussion_form = DiscussionForm(request.POST) if discussion_form.is_valid(): discussion = Discussion() discussion.group = group discussion.type = DiscussionType.objects.get(id=request.POST.get('type')) discussion.name = discussion_form.cleaned_data['name'] if is_heb(discussion.name): encoded_discussion_name = discussion.name.__repr__().encode("ascii")[2:-1] encoded_group_name = group.name.__repr__().encode("ascii")[2:-1] discussion.slug = slugify("%s_%s" % (encoded_group_name,encoded_discussion_name)) else: discussion.slug = slugify("%s_%s" % (group.name,discussion.name)) discussion.description = discussion_form.cleaned_data['description'] discussion.created_by = request.user discussion.x = request.POST.get('x', None) discussion.y = request.POST.get('y', None) discussion.is_private = 'is_private' in request.POST discussion.save() return HttpResponse('reload') else: return HttpResponse(discussion_form.errors.as_text(), status=400) else: return HttpResponse('Wrong usage: HTTP POST expected')
def create_relationship(self, edge): source_slug = slugify(edge.pop('source')) if not source_slug: return source = self.entity_cache[source_slug] target_slug = slugify(edge.pop('target')) if not target_slug: return target = self.entity_cache[target_slug] sources = edge.pop('sources', '') reltype_slug = edge.pop('relationtype', None) reltype = None if reltype_slug: reltype = self.get_relationshiptype(reltype_slug) edge_type = edge.pop('type', 'directed') data = {k: v for k, v in edge.items() if v} search_dict = dict( realm=self.realm, source=source, target=target, type=reltype, data=data, ) attr_dict = dict( directed=edge_type == 'directed', sources=sources, version=self.version ) rel, created = update_or_create(Relationship, search_dict, attr_dict) logger.info("Relationship %s %s", rel, STAT_VALUES[created]) self.record_relationship_stat(created) return rel
def make_rep_object(replytext,auth_id,usr): # create new twist response object new_ob = Gbobject() new_ob.title = "re-" new_ob.slug=slugify(new_ob.title) # save blank object to get auto generated id new_ob.save() # titleid contains own id + twist id titleid = "re-"+str(new_ob.id) contorg = unicode(replytext) fname=slugify(titleid)+"-"+usr new_ob.content_org=contorg.encode('utf8') ext='.org' html='.html' # write to file myfile = open(os.path.join(FILE_URL,fname+ext),'w') myfile.write(new_ob.content_org) myfile.close() # read again to remove carriage return character myfile = open(os.path.join(FILE_URL,fname+ext),'r') rfile=myfile.readlines() scontent="".join(rfile) newcontent=scontent.replace("\r","") myfile = open(os.path.join(FILE_URL,fname+ext),'w') myfile.write(newcontent) myfile = open(os.path.join(FILE_URL,fname+ext),'a') myfile.write("\n#+OPTIONS: timestamp:nil author:nil creator:nil H:3 num:nil toc:nil @:t ::t |:t ^:t -:t f:t *:t <:t") myfile.write("\n#+TITLE: ") # read myfile = open(os.path.join(FILE_URL,fname+ext),'r') stdout = os.popen("%s %s %s"%(PYSCRIPT_URL_GSTUDIO,fname+ext,FILE_URL)) output = stdout.read() data = open(os.path.join(FILE_URL,fname+html)) data1 = data.readlines() # remove header content information data2 = data1[74:] #dataa = data2[data2.index('<div id="content">\n')]='<div id=" "\n' data3 = data2[:-5] newdata="" for line in data3: newdata += line.lstrip() new_ob.content = newdata new_ob.title = "re-" new_ob.status = 2 # changed to have format like re-102486-Title_of_twist new_ob.slug = slugify(fname) new_ob.title= str(replytext[0:50]) + fname new_ob.save() new_ob.slug = new_ob.slug + "-" + str(new_ob.id) new_ob.save() # cause new_ob to be a member of Reply object type new_ob.objecttypes.add(Objecttype.objects.get(title="Reply")) new_ob.authors.add(Author.objects.get(id=auth_id)) new_ob.sites.add(Site.objects.get_current()) return new_ob
def handle(self, *args, **options): for directory in settings.COMICS_DIRS: self.stdout.write(self.style.SUCCESS("Scanning %s" % (directory,))) comics_found = self.find_all_in_dir(directory, "*.cbr", "*.cbz") new = 0 for comic in tqdm(comics_found): details = self.get_details(os.path.basename(comic)) if details['name'] is not None and details['number'] is not None: issue, created = Issue.objects.get_or_create(path=comic) if created: issue.path = comic issue.number = details['number'] issue.year = details['year'] issue.series, _ = Series.objects.get_or_create(name_slug=slugify(details['name'])) if not issue.series.name: issue.series.name_slug = slugify(details['name']) issue.series.name = details['name'] issue.series.save() issue.save() issue.get_thumbnail() # Do this now to save time later new += 1 else: self.stdout.write(self.style.ERROR("Problem processing %s" % comic)) arc_files = self.find_all_in_dir(directory, "*.arc") for arc_file in arc_files: arc, created = Arc.objects.get_or_create(name=os.path.splitext(os.path.basename(arc_file))[0]) arc.filepath = arc_file arc.save() self.stdout.write(self.style.SUCCESS("Finished (%d added)" % new))
def get_title(self): if not self.title or self.title == '' or slugify( self.title ) == u'no-data' or self.title == None: try: return slugify( self.job_set.all()[0].original_name ) except: pass return self.title
def create_categories(sheet, start_index, end_index): """ First row entry of every section will contain parent_category name. """ categories = sheet.row_values(start_index) parent_category = None parent_category_list = BlogParentCategory.objects.filter(title=categories[PARENT_CATEGORY_INDEX]) if len(parent_category_list) == 0: parent_category_string = categories[PARENT_CATEGORY_INDEX] parent_category_string = parent_category_string.replace('/', '') parent_category = BlogParentCategory(slug=slugify(parent_category_string)) parent_category.title = parent_category_string parent_category.save() else: parent_category = parent_category_list[0] sub_categories = sheet.col_values(SUB_CATEGORIES_INDEX, start_rowx=start_index, end_rowx=end_index) for sub_category in sub_categories: if sub_category == '': sub_category = parent_category.title sub_category = sub_category.replace('/','') sub_category_list = BlogCategory.objects.filter(title=sub_category) if len(sub_category_list) == 0: sub_category_obj = BlogCategory(slug=slugify(sub_category), title=sub_category) sub_category_obj.save() sub_category_obj.parent_category.add(parent_category) else: sub_category_obj = sub_category_list[0] sub_category_obj.parent_category.add(parent_category) print sub_category_obj.title, "is now listed under: ", sub_category_obj.parent_category.all(), "\n"
def autoslug_translated(sender, instance, **kwargs): """ Automatically create a unique translated slug """ qs = sender.objects.all() if instance.pk: qs = qs.exclude(pk=instance.pk) actual_lang = get_language() field_names = sender._meta.get_all_field_names() for lang_code, lang_verbose in settings.LANGUAGES: if 'slug_%s' % lang_code not in field_names: continue activate(lang_code) name = unicode(instance) if not name: continue counter = 1 slug = slugify(name) while qs.filter(**{'slug_%s' % lang_code: slug}).count(): slug = slugify(name) + unicode(counter) counter += 1 setattr(instance, 'slug_%s' % lang_code, slug) activate(actual_lang)
def funding_program_index(request): funding_programs = FundingProgram.objects.all().order_by('short_name') if request.method == 'POST': form = FundingProgramSearchForm(request.POST) if form.is_valid(): query = form.cleaned_data['text'] query = slugify(query) fps = [] for funding_program in funding_programs: if (query in slugify(funding_program.full_name)) or (query in slugify(funding_program.short_name)): fps.append(funding_program) funding_programs = fps else: form = FundingProgramSearchForm() return_dict = { 'form': form, 'funding_programs': funding_programs, 'funding_programs_length': len(funding_programs), } return render(request, "funding_programs/index.html", return_dict)
def entry(self, entry, images): old_slug = childElement(entry, 'id') new_slug = slugify(old_slug)[:50] post, created = Post.objects.get_or_create(slug=new_slug) post.slug = new_slug post.title = childElement(entry, 'title') post.tease = childElement(entry, 'description') post.publish = childDateElement(entry, 'effectiveDate') post.author = self.author body = childElement(entry, 'body') # Process inlines match = re.search(r'<img.*src=["\']([\w\.]*)["\']', body) while match: rpl = '<inline type="media.photo" id="%s" class="small_left"' % images[match.groups()[0]] body = body[:match.start()] + rpl + body[match.end():] match = re.search(r'<img.*src=["\']([\w\.]*)["\']', body) post.body = body post.save() categories = entry.getElementsByTagName('categories') if categories: for category_node in categories[0].childNodes: text = category_node.childNodes[0].nodeValue.lower() category, created = Category.objects.get_or_create(slug=slugify(text), defaults={'title': text}) post.categories.add(category) # Create a redirect Redirect.objects.get_or_create( old_path='/two-voices/%s' % old_slug, new_path=post.get_absolute_url(), site=self.site) return post
def _url(self): super(HauntedLocation, self).save() url = '%s,%s' % ( slugify(self.name),slugify(self.id) ) return url
def save(self): def slug_is_bad(self): if self.slug in [slug.values()[0] for slug in Event.objects.exclude(id=self.id).values("slug")]: return True if self.slug == "" or slug_is_bad(self): self.slug=slugify(self.short_title) if slug_is_bad(self): suffix = slugify(date(self.start_date, "Y")) if not suffix in self.slug: self.slug = self.slug + "-" + suffix print "adding suffix:", suffix, self.slug if slug_is_bad(self): suffix = slugify(date(self.start_date, "F")) if not suffix in self.slug: self.slug = self.slug + "-" + suffix print "adding suffix:", suffix, self.slug if slug_is_bad(self): suffix = slugify(date(self.start_date, "d")) if not suffix in self.slug: self.slug = self.slug + "-" + suffix print "adding suffix:", suffix, self.slug while slug_is_bad(self): self.slug=self.slug + "-x" print "adding suffix:", "-x" super(Event, self).save()
def create_profile(sender, instance, **kwargs): try: profile = Profile.objects.get(user=instance) profile.slug = slugify(instance.username) profile.save() except Profile.DoesNotExist: Profile.objects.create(slug=slugify(instance.username), user=instance)
def test_empty_bid_locked_biditem(self): """ Test that attempting to empty a bidbasket when biditem is locked fails. """ now = auction.utils.generic.get_current_time() auction_name = 'whatever auction' a,created = auction.models.Auction.objects.get_or_create(name=auction_name, slug=slugify(auction_name), start_date=now, end_date=now + datetime.timedelta(365), active=True, total_bids=0) lot_name = 'whatever' ct = ContentType.objects.get_for_model(a) lot,created = auction.models.Lot.objects.get_or_create(name=lot_name, slug=slugify(lot_name), active=True, content_type=ct, object_id=a.pk) bidbasket = auction.utils.generic.get_or_create_bidbasket(self.request) bidbasket.add_bid(lot, '42.00') a.end_date = now - datetime.timedelta(365) a.save() biditem = auction.models.BidItem.objects.get(bid_basket=bidbasket) bidbasket.empty() biditems = auction.models.BidItem.objects.filter(bid_basket=bidbasket) self.assertEqual(len(biditems), 1)
def fix_slugs(): for country in CountryBorder.objects.all(): country.slug = slugify(country.name) country.save() for state in StateBorder.objects.all(): state.slug = slugify(state.name) state.save()
def createwikinew(request): ob=System() titl=request.GET['title'] titleid=request.GET['titleid'] ob.title=titl ob.status=2 p=Systemtype.objects.get(id=14) ob.slug=slugify(titl) ob.save() ob.systemtypes.add(p) us=request.user.id ob.authors.add(request.user) ob.member_set.add(Author.objects.get(id=us)) gbid1=Gbobject.objects.get(id=titleid) sys1 = System() sys1.title = "page box of " + titl sys1.status = 2 sys1.content = "contains pages of " + titl sys1.slug = "page_box_of_" + slugify(titl) sys1.save() ob.system_set.add(sys1) ob.sites.add(Site.objects.get_current()) sys1.sites.add(Site.objects.get_current()) priorgbobject = gbid1.prior_nodes.all() posteriorgbobject = gbid1.posterior_nodes.all() t = get_template('gstudio/repriorpost.html') html = t.render(Context({'priorgbobject':priorgbobject,'posteriorgbobject':posteriorgbobject,'objectid':titleid,'optionpriorpost':"p\ riorpost"})) return HttpResponse(html)
def add_place(self, x_location): city, created = City.objects.get_or_create( city=x_location.city, state=x_location.state, slug=slugify(u'-'.join((x_location.city, x_location.state))) ) point, created = Point.objects.get_or_create( latitude=x_location.latitude, longitude=x_location.longitude, address=x_location.address, city=city, zip=x_location.zipcode, country='US' ) place, created = Place.objects.get_or_create( point=point, # prefix = '', title=x_location.title, slug=slugify(x_location.title)[:50], # nickname=models.CharField(_('nickname'), blank=True, max_length=100), # unit=models.CharField(_('unit'), blank=True, max_length=100, help_text='Suite or Apartment #'), phone=x_location.phone if x_location.phone and (not ':' in x_location.phone) else None or '', url=x_location.url or x_location.guid, # FIXME source (villagevoice) specific image_url=x_location.image_url or '' # email=models.EmailField(_('email'), blank=True), # description = models.TextField(_('description'), blank=True), # status = models.IntegerField(_('status'), choices=STATUS_CHOICES, default=1) # created = models.DateTimeField(auto_now_add=True) # modified = models.DateTimeField(auto_now=True) # place_types = models.ManyToManyField(PlaceType, blank=True) ) self.places_by_xid[x_location.id] = place
def imagen_c (request,link='',site=None): try: titulo = 'Editar Imagen' imagen_link = Imagen.objects.get(link=link,site=site) #existe if request.method == 'POST': form = Imagen_form(site,request.POST,request.FILES, instance=imagen_link) if form.is_valid(): imagen = form.save(commit=False) if not imagen.link: imagen.link = slugify(imagen.nombre) imagen.save() form.save_m2m() imagen.site.add(site) messages.add_message(request, messages.SUCCESS, 'Imagen modificada') return redirect('/imagen/%s/' %imagen.link) else: form = Imagen_form(site,instance = imagen_link) except: titulo = 'Crear Imagen' imagen_link = None if request.method == 'POST': form = Imagen_form(site,request.POST,request.FILES) if form.is_valid(): imagen = form.save(commit=False) if not imagen.link: imagen.link = slugify(imagen.nombre) imagen.save() form.save_m2m() imagen.site.add(site) messages.add_message(request, messages.SUCCESS, 'Imagen creada') return redirect('/imagen/%s/' %imagen.link) else: form = Imagen_form(site,initial={'link':link}) return render_to_response('forms.html',locals(),RequestContext(request))
def categoria_c (request,link='',site=None): try: categoria_link = Categoria.objects.get(link=link,site=site) #existe titulo = 'Editar categoria' if request.method == 'POST': form = Categoria_form(site,request.POST,request.FILES, instance=categoria_link) if form.is_valid(): categoria = form.save(commit=False) if not categoria.link: categoria.link = slugify(categoria.nombre) categoria.save() form.save_m2m() categoria.site.add(site) messages.add_message(request, messages.SUCCESS, 'Categoria modificada') return redirect('/categoria/%s/' %categoria.link) else: form = Categoria_form(site,instance = categoria_link) except: titulo = 'Crear categoria' categoria_link = None #no existe if request.method == 'POST': form = Categoria_form(site,request.POST,request.FILES) if form.is_valid(): categoria = form.save(commit=False) if not categoria.link: categoria.link = slugify(categoria.nombre) categoria.save() form.save_m2m() categoria.site.add(site) messages.add_message(request, messages.SUCCESS, 'Categoria creada') return redirect('/categoria/%s/' %categoria.link) else: form = Categoria_form(site,initial={'link':link}) return render_to_response('forms.html',locals(),RequestContext(request))
def setUp(self): country = LocationType.objects.create(name="Country", slug=slugify("country")) district = LocationType.objects.create(name="District", slug=slugify("district")) city = LocationType.objects.create(name="City", slug=slugify("city")) uganda = Location.objects.create(name="Uganda", type=country) self.abim = Location.objects.create(name="Abim", type=district, tree_parent=uganda) kampala = Location.objects.create(name="Kampala", type=city, tree_parent=self.abim) some_city = Location.objects.create(name="SomeCity", type=city, tree_parent=self.abim) self.backend = Backend.objects.create(name='something') self.survey = Survey.objects.create(name='SurveyA') self.ea = EnumerationArea.objects.create(name="EA1", survey=self.survey) self.ea_2 = EnumerationArea.objects.create(name="EA2", survey=self.survey) self.ea.locations.add(kampala) self.ea_2.locations.add(some_city) self.batch = Batch.objects.create(order=1, name='somebatch', survey=self.survey) self.batch.open_for_location(self.abim) self.investigator_1 = Interviewer.objects.create(name="investigator name_1", mobile_number="9876543210", ea=self.ea, backend=self.backend) self.household_1 = Household.objects.create(investigator=self.investigator_1, ea=self.investigator_1.ea, survey=self.survey) self.household_2 = Household.objects.create(investigator=self.investigator_1, ea=self.investigator_1.ea, survey=self.survey) self.investigator_2 = Interviewer.objects.create(name="investigator name_2", mobile_number="9876543211", ea=self.ea_2, backend=self.backend)
def articulo_c (request,link='',site=None): try: titulo = 'Editar Articulo' articulo_link = Articulo.objects.get(link=link,site=site) #existe if request.method == 'POST': form = Articulo_form(site,request.POST,request.FILES, instance=articulo_link) if form.is_valid(): articulo = form.save(commit=False) if not articulo.link: articulo.link = slugify(articulo.nombre) articulo.save() form.save_m2m() articulo.site.add(site) messages.add_message(request, messages.SUCCESS, 'Articulo modificado') return redirect('/articulo/%s/' %articulo.link) else: form = Articulo_form(site,instance = articulo_link) except: titulo = 'Crear Articulo' articulo_link = None #no existe if request.method == 'POST': form = Articulo_form(site,request.POST,request.FILES) if form.is_valid(): articulo = form.save(commit=False) if not articulo.link: articulo.link = slugify(articulo.nombre) articulo.save() form.save_m2m() articulo.site.add(site) messages.add_message(request, messages.SUCCESS, 'Articulo creado') return redirect('/articulo/%s/' %articulo.link) else: form = Articulo_form(site,initial={'link':link}) return render_to_response('forms.html', locals(),RequestContext(request))
def claim_voucher(request, human_token=None): """ /vouchers/claim/ /vouchers/claim/<human_token> """ human_token = slugify(human_token or '') voucher_name = '' is_claimed = False form = None voucher = None if request.method == 'GET' and human_token: try: voucher = Voucher.objects.get(human_token=human_token) except Voucher.DoesNotExist: raise Http404 form = get_voucher_form(voucher)() if voucher.user and voucher.user != request.user: raise Http404() elif not voucher.user: voucher.user = request.user voucher.save() voucher_name = get_voucher_form_name(voucher) messages.success(request, "The voucher %s has been assigned to you, " "fill in the form to claim your voucher!" % voucher_name) is_claimed = voucher.is_claimed() elif request.method == 'GET' and not human_token: form = TokenForm() elif request.method == 'POST': token_form = TokenForm(request.POST) if token_form.is_valid(): human_token = slugify(token_form.cleaned_data['token']) new_url = reverse('claim_voucher', args=[human_token]) return redirect(new_url) if 'submit' in request.POST and 'Send' in request.POST['submit'] and human_token: human_token = slugify(human_token) try: voucher = Voucher.objects.get(human_token=human_token, user=request.user) except Voucher.DoesNotExist: raise Http404 voucher_klass_form = get_voucher_form(voucher) voucher_name = get_voucher_form_name(voucher) form = voucher_klass_form(request.POST) is_claimed = voucher.is_claimed() if form.is_valid() and not is_claimed: try: voucher.claim_voucher(request.user, human_token, form.cleaned_data) messages.success(request, 'Voucher information has been sent!') except ValidationError as error: messages.error(request, '\n'.join(error.messages)) template = get_voucher_template(voucher) name = template.name if hasattr(template, 'name') else template.template.name return render_to_response(name, RequestContext(request, {'voucher_name': voucher_name, 'token': human_token, 'is_claimed': is_claimed, 'form': form, 'voucher': voucher}))
def get_absolute_url(self): return('nhom', (), { 'monhoc': slugify(unicode(unidecode(self.mon_hoc.ten_mon))), 'monhocid': self.mon_hoc_id, 'nhom': slugify(unicode(unidecode(self.ten_nhom))), 'nhomid': self.pk, })
def edit_entry(request, slug, template='submissions/edit.html'): entry = Entry.objects.get(slug=slug) if not entry.editable_by(request.user): return action_unavailable_response(request, case='no_edit_rights') if not request.challenge.is_open(): return action_unavailable_response(request, case='challenge_closed') if request.method == 'POST': form = EntryForm(request.POST, request.FILES, instance=entry) if form.is_valid(): entry = form.save(commit=False) entry.slug = slugify(entry.title) form.save() if entry.to_market == True: return HttpResponseRedirect(settings.MARKETPLACE_URL) else: messages.success(request, _('<strong>Game edited!</strong>')) return HttpResponseRedirect(reverse('submissions.entry_single', kwargs={'slug': slugify(entry.title)})) else: data = { 'categories': Category.objects.all(), 'form': form, 'mode': 'edit', } else: data = { 'categories': Category.objects.all(), 'form': EntryForm(instance=entry), 'mode': 'edit', } return render(request, template, data)
def export_as_csv(qs, file_name=None, fields=None): model = qs.model response = HttpResponse(mimetype='text/csv') if not file_name: file_name = slugify(model.__name__) else: file_name = slugify(file_name) response['Content-Disposition'] = 'attachment; filename=%s.csv' % file_name writer = csv.writer(response) # Write headers to CSV file if fields: headers = fields else: headers = [] for field in model._meta.fields: headers.append(field.name) # if headers[0] == 'action_checkbox': # del headers[0] writer.writerow(headers) # Write data to CSV file for obj in qs: row = [] for field in headers: val = getattr(obj, field) if callable(val): val = val() row.append(val) writer.writerow(row) # Return CSV file to browser as download return response
def save(self, *args): self.slug = slugify(self.name) super(Post, self).save(*args)
def create_demo_org(quick=False) -> Organization: with sentry_sdk.start_transaction(op="create_demo_org", name="create_demo_org", sampled=True): sentry_sdk.set_tag("quick", quick) # wrap the main org setup in transaction with transaction.atomic(): name = generate_random_name() slug = slugify(name) demo_org = DemoOrganization.create_org(name=name, slug=slug) org = demo_org.organization logger.info("create_demo_org.created_org", {"organization_slug": slug}) owner = User.objects.get(email=settings.DEMO_ORG_OWNER_EMAIL) OrganizationMember.objects.create( organization=org, user=owner, role=roles.get_top_dog().id ) team = org.team_set.create(name=org.name) python_project = Project.objects.create( name="Python", organization=org, platform="python" ) python_project.add_team(team) react_project = Project.objects.create( name="React", organization=org, platform="javascript-react" ) react_project.add_team(team) populate_org_members(org, team) # we'll be adding transactions later Project.objects.filter(organization=org).update( flags=F("flags").bitor(Project.flags.has_transactions) ) logger.info( "create_demo_org.post-transaction", extra={"organization_slug": org.slug, "quick": quick}, ) with sentry_sdk.start_span(op="handle_react_python_scenario"): try: handle_react_python_scenario(react_project, python_project, quick=quick) except Exception as e: logger.error( "create_demo_org.population_error", extra={"organization_slug": org.slug, "quick": quick, "error": str(e)}, ) # delete the organization if data population fails org.status = OrganizationStatus.PENDING_DELETION org.save() delete_organization.apply_async(kwargs={"object_id": org.id}) raise # update the org status now that it's populated demo_org.status = DemoOrgStatus.PENDING demo_org.save() logger.info( "create_demo_org.complete", extra={"organization_slug": org.slug, "quick": quick}, ) return org
def save(self, *args, **kwargs): if not self.slug: self.slug = slugify(self.title) return super().save(*args, **kwargs)
def save(self, *args): self.slug = slugify(self.name) super(Morcha, self).save(*args)
def test_has_valid_name_when_no_title_exists(self, mock_wms): mock_wms.return_value = (self.phony_url, self.parsed_wms) mock_wms.return_value[1].identification.title = "" handler = wms.WmsServiceHandler(self.phony_url) self.assertEqual(handler.name, slugify(self.phony_url)[:255])
def save(self, *args): self.slug = slugify(self.name) super(Battalion, self).save(*args)
def save(self, *args, **kwargs): self.slug = slugify(self.name) super(TaskList, self).save(*args, **kwargs)
def test_has_valid_name_when_title_exists(self, mock_wms): mock_wms.return_value = (self.phony_url, self.parsed_wms) handler = wms.WmsServiceHandler(self.phony_url) self.assertNotEqual(handler.name, slugify(self.phony_title)) self.assertEqual("a-generic-title", slugify(self.phony_title))
class Course(PhotosMixin, ToolsMixin, FilesMixin, models.Model): name = models.CharField(max_length=64) slug = property(lambda self: slugify(self.name)) active = models.BooleanField( default=True) # only used with the reshedule view _ht = "Used for the events page." short_name = models.CharField(max_length=64, null=True, blank=True, help_text=_ht) get_short_name = lambda self: self.short_name or self.name subjects = models.ManyToManyField(Subject) no_discount = models.BooleanField(default=False) @cached_property def first_room(self): return (self.courseroomtime_set.all() or [self])[0].room presentation = models.BooleanField("Evaluate Presentation", default=True) visuals = models.BooleanField("Evaluate Visuals", default=True) content = models.BooleanField("Evaluate Content", default=True) _ht = "The dashboard (/admin/) won't bug you to reschedule until after this date" reschedule_on = models.DateField(default=datetime.date.today, help_text=_ht) first_date = property(lambda self: self.active_sessions[0].first_date) last_date = property(lambda self: self.active_sessions[-1].last_date) @property def as_json(self): image = get_thumbnail(get_override(self.first_photo, 'landscape_crop'), "298x199", crop="center") out = { 'id': self.pk, 'name': self.name, 'subject_names': [s.name for s in self.subjects.all()], 'subject_ids': [s.pk for s in self.subjects.all()], 'url': self.get_absolute_url(), 'im': { 'width': image.width, 'height': image.height, 'url': image.url }, 'next_time': time.mktime(self.first_date.timetuple()) if self.active_sessions else 0, 'fee': self.fee, 'active_sessions': [s.as_json for s in self.active_sessions], 'past_session_count': len(self.archived_sessions), 'short_description': self.get_short_description(), 'requirements': self.requirements, 'no_discount': self.no_discount, } out['enrolled_status'] = "Enroll" if out[ 'active_sessions'] else "Details" return out fee = models.IntegerField(null=True, blank=True, default=0) fee_notes = models.CharField(max_length=256, null=True, blank=True) requirements = models.CharField(max_length=256, null=True, blank=True) prerequisites = models.CharField(max_length=256, null=True, blank=True) description = models.TextField(null=True, blank=True) short_description = models.TextField(null=True, blank=True) get_short_description = lambda self: self.short_description or truncatewords( striptags(self.description), 40) safety = models.BooleanField(default=False) room = models.ForeignKey(Room) def get_location_string(self): if self.first_room != self.room: s = "This class meets in the %s and then moves to the %s after a half hour lecture." return s % (self.first_room.name.lower(), self.room.name.lower()) return "This class meets in the %s." % (self.room.name.lower()) _ht = "If true, this class will not raise conflict warnings for events in the same room." no_conflict = models.BooleanField(default=False, help_text=_ht) max_students = models.IntegerField(default=16) objects = CourseManager() __unicode__ = lambda self: self.name get_absolute_url = lambda self: reverse("course:detail", args=[self.pk, self.slug]) get_admin_url = lambda self: "/admin/course/course/%s/" % self.id @cached_method def get_tools(self): criterion_ids = Criterion.objects.filter(courses=self).values_list( "id", flat=True) return Tool.objects.filter( permission__criteria__id__in=criterion_ids).distinct() @cached_property def active_sessions(self): # sessions haven't ended yet (and maybe haven't started) first_date = datetime.datetime.now() - datetime.timedelta(0.5) return list(self.sessions.filter(last_date__gte=first_date)) @property def archived_sessions(self): # opposite of active_sessions first_date = datetime.datetime.now() - datetime.timedelta(0.5) last_year = first_date - datetime.timedelta(365) sessions = self.session_set.filter(last_date__lt=first_date, last_date__gte=last_year) return list(sessions.order_by("-first_date")) sessions = lambda self: Session.objects.filter(course=self, active=True) sessions = cached_property(sessions, name="sessions") last_session = lambda self: (list(self.sessions) or [None])[-1] def save(self, *args, **kwargs): super(Course, self).save(*args, **kwargs) #this has to be repeated in the admin because of how that works subjects = self.subjects.all() for subject in subjects: if subject.parent and not (subject.parent in subjects): self.subjects.add(subject.parent) reset_classes_json("Classes reset during course save") #! inherited from section, may not be necessary def get_notes(self): notes = [] if self.requirements: notes.append(('Requirements', self.requirements)) if self.fee_notes: notes.append(('Fee Notes', self.fee_notes)) if self.safety: notes.append(( 'Safety', "This class has a 20 minute safety session before the first session." )) if self.prerequisites: notes.append(('Prerequisites', self.prerequisites)) return notes @property def list_users(self): return list(set([s.user for s in self.active_sessions])) class Meta: ordering = ("name", )
def save(self, *args, **kwargs): self.slug = slugify(self.name) self.notes_html = mistune.markdown(self.notes) super(Task, self).save(*args, **kwargs)
def save(self, *args, **kwargs): self.slug = slugify(self.title) super(Assignment, self).save(*args, **kwargs)
def save(self, *args, **kwargs): self.slug = slugify(self.name) super(Category, self).save(*args, **kwargs)
def file_upload(filename, name=None, user=None, title=None, abstract=None, license=None, category=None, keywords=None, regions=None, date=None, skip=True, overwrite=False, charset='UTF-8', is_approved=True, is_published=True, metadata_uploaded_preserve=False, metadata_upload_form=False): """Saves a layer in GeoNode asking as little information as possible. Only filename is required, user and title are optional. :return: Uploaded layer :rtype: Layer """ if keywords is None: keywords = [] if regions is None: regions = [] # Get a valid user theuser = get_valid_user(user) # Create a new upload session upload_session = UploadSession.objects.create(user=theuser) # Get all the files uploaded with the layer files = get_files(filename) # Set a default title that looks nice ... if title is None: basename = os.path.splitext(os.path.basename(filename))[0] title = basename.title().replace('_', ' ') # Create a name from the title if it is not passed. if name is None: name = slugify(title).replace('-', '_') elif not overwrite: name = slugify(name) # assert that name is slugified if license is not None: licenses = License.objects.filter( Q(name__iexact=license) | Q(abbreviation__iexact=license) | Q(url__iexact=license) | Q(description__iexact=license)) if len(licenses) == 1: license = licenses[0] else: license = None if category is not None: try: categories = TopicCategory.objects.filter( Q(identifier__iexact=category) | Q(gn_description__iexact=category)) if len(categories) == 1: category = categories[0] else: category = None except BaseException: pass # Generate a name that is not taken if overwrite is False. valid_name = get_valid_layer_name(name, overwrite) # Add them to the upload session (new file fields are created). assigned_name = None for type_name, fn in files.items(): with open(fn, 'rb') as f: upload_session.layerfile_set.create( name=type_name, file=File(f, name='%s.%s' % (assigned_name or valid_name, type_name))) # save the system assigned name for the remaining files if not assigned_name: the_file = upload_session.layerfile_set.all()[0].file.name assigned_name = os.path.splitext(os.path.basename(the_file))[0] # Get a bounding box bbox_x0, bbox_x1, bbox_y0, bbox_y1, srid = get_bbox(filename) if srid: srid_url = "http://www.spatialreference.org/ref/" + srid.replace( ':', '/').lower() + "/" # noqa # by default, if RESOURCE_PUBLISHING=True then layer.is_published # must be set to False if not overwrite: if settings.RESOURCE_PUBLISHING or settings.ADMIN_MODERATE_UPLOADS: is_approved = False is_published = False defaults = { 'upload_session': upload_session, 'title': title, 'abstract': abstract, 'owner': user, 'charset': charset, 'bbox_x0': bbox_x0, 'bbox_x1': bbox_x1, 'bbox_y0': bbox_y0, 'bbox_y1': bbox_y1, 'srid': srid, 'is_approved': is_approved, 'is_published': is_published, 'license': license, 'category': category } # set metadata if 'xml' in files: with open(files['xml']) as f: xml_file = f.read() defaults['metadata_uploaded'] = True defaults['metadata_uploaded_preserve'] = metadata_uploaded_preserve # get model properties from XML identifier, vals, regions, keywords = set_metadata(xml_file) if defaults['metadata_uploaded_preserve']: defaults['metadata_xml'] = xml_file defaults['uuid'] = identifier for key, value in vals.items(): if key == 'spatial_representation_type': value = SpatialRepresentationType(identifier=value) elif key == 'topic_category': value, created = TopicCategory.objects.get_or_create( identifier=value.lower(), defaults={ 'description': '', 'gn_description': value }) key = 'category' defaults[key] = value else: defaults[key] = value regions_resolved, regions_unresolved = resolve_regions(regions) keywords.extend(regions_unresolved) # If it is a vector file, create the layer in postgis. if is_vector(filename): defaults['storeType'] = 'dataStore' # If it is a raster file, get the resolution. if is_raster(filename): defaults['storeType'] = 'coverageStore' # Create a Django object. created = False layer = None with transaction.atomic(): try: if overwrite: try: layer = Layer.objects.get(name=valid_name) except Layer.DoesNotExist: layer = None if not layer: if not metadata_upload_form: layer, created = Layer.objects.get_or_create( name=valid_name, workspace=settings.DEFAULT_WORKSPACE, defaults=defaults) elif identifier: layer, created = Layer.objects.get_or_create( uuid=identifier, defaults=defaults) except BaseException: raise # Delete the old layers if overwrite is true # and the layer was not just created # process the layer again after that by # doing a layer.save() if not created and overwrite: # update with new information defaults['upload_session'] = upload_session defaults['title'] = defaults.get('title', None) or layer.title defaults['abstract'] = defaults.get('abstract', None) or layer.abstract defaults['bbox_x0'] = defaults.get('bbox_x0', None) or layer.bbox_x0 defaults['bbox_x1'] = defaults.get('bbox_x1', None) or layer.bbox_x1 defaults['bbox_y0'] = defaults.get('bbox_y0', None) or layer.bbox_y0 defaults['bbox_y1'] = defaults.get('bbox_y1', None) or layer.bbox_y1 defaults['is_approved'] = defaults.get( 'is_approved', is_approved) or layer.is_approved defaults['is_published'] = defaults.get( 'is_published', is_published) or layer.is_published defaults['license'] = defaults.get('license', None) or layer.license defaults['category'] = defaults.get('category', None) or layer.category try: Layer.objects.filter(id=layer.id).update(**defaults) layer.refresh_from_db() except Layer.DoesNotExist: import traceback tb = traceback.format_exc() logger.error(tb) raise # Pass the parameter overwrite to tell whether the # geoserver_post_save_signal should upload the new file or not layer.overwrite = overwrite # Blank out the store if overwrite is true. # geoserver_post_save_signal should upload the new file if needed layer.store = '' if overwrite else layer.store layer.save() if upload_session: upload_session.resource = layer upload_session.processed = True upload_session.save() # set SLD # if 'sld' in files: # sld = None # with open(files['sld']) as f: # sld = f.read() # if sld: # set_layer_style(layer, layer.alternate, sld, base_file=files['sld']) # Assign the keywords (needs to be done after saving) keywords = list(set(keywords)) if keywords: if len(keywords) > 0: if not layer.keywords: layer.keywords = keywords else: layer.keywords.add(*keywords) # Assign the regions (needs to be done after saving) regions_resolved = list(set(regions_resolved)) if regions_resolved: if len(regions_resolved) > 0: if not layer.regions: layer.regions = regions_resolved else: layer.regions.clear() layer.regions.add(*regions_resolved) # Assign and save the charset using the Layer class' object (layer) if charset != 'UTF-8': layer.charset = charset layer.save() to_update = {} if defaults.get('title', title) is not None: to_update['title'] = defaults.get('title', title) if defaults.get('abstract', abstract) is not None: to_update['abstract'] = defaults.get('abstract', abstract) if defaults.get('date', date) is not None: to_update['date'] = defaults.get( 'date', datetime.strptime(date, '%Y-%m-%d %H:%M:%S') if date else None) if defaults.get('license', license) is not None: to_update['license'] = defaults.get('license', license) if defaults.get('category', category) is not None: to_update['category'] = defaults.get('category', category) # Update ResourceBase if not to_update: pass else: try: ResourceBase.objects.filter(id=layer.resourcebase_ptr.id).update( **to_update) Layer.objects.filter(id=layer.id).update(**to_update) # Refresh from DB layer.refresh_from_db() except BaseException: import traceback tb = traceback.format_exc() logger.error(tb) return layer
def save(self, *args, **kwargs): self.slug = slugify(self.title) super(BlogPost, self).save(*args, **kwargs)