Example #1
0
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
Example #2
0
    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')
Example #3
0
	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."})
Example #4
0
def project_screenshot(instance, filename):
    return (
        "applications/screenshots/"
        + slugify(instance.owner.__unicode__() + "/" + ".".join(filename.split(".")[:-1]))
        + "."
        + slugify(filename.split(".")[-1])
    )
Example #5
0
 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)
Example #6
0
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))
Example #7
0
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')
Example #8
0
    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
Example #9
0
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
Example #10
0
 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))
Example #11
0
 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
Example #12
0
	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"
Example #13
0
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)
Example #14
0
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)
Example #15
0
    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
Example #16
0
    def _url(self):
        super(HauntedLocation, self).save()

        url = '%s,%s' % (
             slugify(self.name),slugify(self.id)
        )
        return url
Example #17
0
    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()
Example #18
0
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)
Example #19
0
    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)
Example #20
0
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()
Example #21
0
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)
Example #22
0
 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
Example #23
0
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))
Example #24
0
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)
Example #26
0
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))
Example #27
0
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}))
Example #28
0
 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,
     })
Example #29
0
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)
Example #30
0
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)
Example #32
0
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
Example #33
0
 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)
Example #35
0
 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)
Example #37
0
 def save(self, *args, **kwargs):
     self.slug = slugify(self.name)
     super(TaskList, self).save(*args, **kwargs)
Example #38
0
 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))
Example #39
0
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", )
Example #40
0
 def save(self, *args, **kwargs):
     self.slug = slugify(self.name)
     self.notes_html = mistune.markdown(self.notes)
     super(Task, self).save(*args, **kwargs)
Example #41
0
 def save(self, *args, **kwargs):
     self.slug = slugify(self.title)
     super(Assignment, self).save(*args, **kwargs)
Example #42
0
 def save(self, *args, **kwargs):
     self.slug = slugify(self.name)
     super(Category, self).save(*args, **kwargs)
Example #43
0
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
Example #44
0
 def save(self, *args, **kwargs):
     self.slug = slugify(self.title)
     super(BlogPost, self).save(*args, **kwargs)