def get_context_data(self, **kwargs):
context = super(ArticleListView, self).get_context_data(**kwargs)
context['keywords'] = settings.ARTICLE_KEYWORDS
# keywords
assigned_keyword = AssignedKeyword()
self.keywords = assigned_keyword.get_keywords_of_content_type(
self.model._meta.app_label, self.model.__name__.lower())
if self.keywords:
context['keywords'] = self.keywords
# pagination
context['objects'] = paginate(self.qs, self.request.GET.get("page", 1),
settings.ARTICLE_PER_PAGE,
settings.MAX_PAGING_LINKS)
# keyword by AssignKeyword
if 'keyword' in self.kwargs:
context['current_keyword_slug'] = self.kwargs['keyword']
# keyword by MediaType: video, audio.....
if 'type' in self.kwargs:
context['current_keyword'] = self.kwargs['type']
return context
def save_form_data(self, instance, data):
"""
The ``KeywordsWidget`` field will return data as a string of
comma separated IDs for the ``Keyword`` model - convert these
into actual ``AssignedKeyword`` instances. Also delete
``Keyword`` instances if their last related ``AssignedKeyword``
instance is being removed.
"""
from mezzanine.generic.models import AssignedKeyword, Keyword
related_manager = getattr(instance, self.name)
# Get a list of Keyword IDs being removed.
old_ids = [str(a.keyword_id) for a in related_manager.all()]
new_ids = data.split(",")
removed_ids = set(old_ids) - set(new_ids)
# Remove current AssignedKeyword instances.
related_manager.all().delete()
# Convert the data into AssignedKeyword instances.
if data:
data = [AssignedKeyword(keyword_id=i) for i in new_ids]
# Remove Keyword instances than no longer have a
# related AssignedKeyword instance.
existing = AssignedKeyword.objects.filter(keyword__id__in=removed_ids)
existing_ids = set([str(a.keyword_id) for a in existing])
unused_ids = removed_ids - existing_ids
Keyword.objects.filter(id__in=unused_ids).delete()
super(KeywordsField, self).save_form_data(instance, data)
def handle(self, *args, **options):
"""
Processes the converted data into the Mezzanine database correctly.
Attributes:
mezzanine_user: the user to put this data in against
date_format: the format the dates are in for posts and comments
"""
from mezzanine.blog.models import BlogPost
from mezzanine.core.models import CONTENT_STATUS_PUBLISHED
from mezzanine.generic.models import AssignedKeyword, Keyword
from mezzanine.generic.models import ThreadedComment
mezzanine_user = options.get("mezzanine_user")
site = Site.objects.get_current()
verbosity = int(options.get("verbosity", 1))
# Validate the Mezzanine user.
if mezzanine_user is None:
raise CommandError("No Mezzanine user has been specified")
try:
mezzanine_user = User.objects.get(username=mezzanine_user)
except User.DoesNotExist:
raise CommandError("Invalid Mezzanine user: %s" % mezzanine_user)
# Run the subclassed ``handle_import`` and save posts, tags and
# comments to the DB.
self.handle_import(options)
for post in self.posts:
if verbosity >= 1:
print "Importing post titled: %s" % post["title"]
tags = post.pop("tags")
comments = post.pop("comments")
old_url = post.pop("old_url")
post_args = post
post_args["user"] = mezzanine_user
post_args["status"] = CONTENT_STATUS_PUBLISHED
post, created = BlogPost.objects.get_or_create(**post_args)
for tag in tags:
keyword, created = Keyword.objects.get_or_create(title=tag)
post.keywords.add(AssignedKeyword(keyword=keyword))
for comment in comments:
if verbosity >= 1:
print "Importing comment by: %s" % comment["user_name"]
comment["site"] = site
post.comments.add(ThreadedComment(**comment))
if old_url is not None:
redirect, created = Redirect.objects.get_or_create(
site=site, old_path=urlparse(old_url).path)
redirect.new_path = urlparse(post.get_absolute_url()).path
redirect.save()
def save(self, *args, **kwargs):
keywords = []
self.slug = uuslug(self.title, instance=self)
if not self.keywords_string and getattr(settings, "AUTO_TAG", False):
keywords = self.title.rstrip(punctuation).split()
super(Juba, self).save(*args, **kwargs)
if keywords:
lookup = reduce(ior, [Q(title__iexact=k) for k in keywords])
for keyword in Keyword.objects.filter(lookup):
self.keywords.add(AssignedKeyword(keyword=keyword))
def save(self, *args, **kwargs):
keywords = []
if not self.keywords_string and getattr(settings, "AUTO_TAG", False):
func_name = getattr(settings, "AUTO_TAG_FUNCTION",
"drum.links.utils.auto_tag")
keywords = import_dotted_path(func_name)(self)
super(Link, self).save(*args, **kwargs)
if keywords:
lookup = reduce(ior, [Q(title__iexact=k) for k in keywords])
for keyword in Keyword.objects.filter(lookup):
self.keywords.add(AssignedKeyword(keyword=keyword), bulk=False)
def test_keywords(self):
"""
Test that the keywords_string field is correctly populated.
"""
page = RichTextPage.objects.create(title="test keywords")
keywords = set(["how", "now", "brown", "cow"])
for keyword in keywords:
keyword_id = Keyword.objects.get_or_create(title=keyword)[0].id
page.keywords.add(AssignedKeyword(keyword_id=keyword_id))
page = RichTextPage.objects.get(id=page.id)
self.assertEquals(keywords, set(page.keywords_string.split(" ")))
def save_form_data(self, instance, data):
"""
The ``KeywordsWidget`` field will return data as a string of
comma separated IDs for the ``Keyword`` model - convert these
into actual ``AssignedKeyword`` instances.
"""
from mezzanine.generic.models import AssignedKeyword
# Remove current assigned keywords.
related_manager = getattr(instance, self.name)
related_manager.all().delete()
assigned = [AssignedKeyword(keyword_id=i) for i in data.split(",")]
super(KeywordsField, self).save_form_data(instance, assigned)
def save(self, *args, **kwargs):
keywords = []
if not self.keywords_string and getattr(settings, "AUTO_TAG", False):
variations = lambda word: [word,
sub("^([^A-Za-z0-9])*|([^A-Za-z0-9]|s)*$", "", word),
sub("^([^A-Za-z0-9])*|([^A-Za-z0-9])*$", "", word)]
keywords = sum(map(variations, split("\s|/", self.title)), [])
super(Link, self).save(*args, **kwargs)
if keywords:
lookup = reduce(ior, [Q(title__iexact=k) for k in keywords])
for keyword in Keyword.objects.filter(lookup):
self.keywords.add(AssignedKeyword(keyword=keyword))
def load_page(self, item):
"""
Import content as mezzanine page
:param item: entry in json format
"""
# create widgy page
page = RawPage(title=item['title'],
gen_description=False if item['description'] else True,
description=item['description'] or '',
_meta_title=item['title'],
slug=item['slug'].strip('/') or '/',
status=CONTENT_STATUS_PUBLISHED,
site=Site.objects.get_current())
if page.slug in REAL_ESTATE_VERTICAL_SLUGS:
content_type = \
ContentType.objects.get_for_model(RealEstateVerticalLayout)
elif page.slug in {
'terms-of-use', 'legal/eula', 'legal/camera-terms-of-sale',
'legal/terms-of-service'
}:
content_type = ContentType.objects.get_for_model(
NoHeaderFooterLayout)
else:
content_type = ContentType.objects.get_for_model(WordPressLayout)
setattr(page, 'root_node', content_type)
page.save()
# add keywords
keywords = []
if item['keywords']:
keywords = [
keyword.strip() for keyword in item['keywords'].split(',')
]
for keyword in set(keywords):
keyword_obj, _ = Keyword.objects.get_or_create(title=keyword)
page.keywords.add(AssignedKeyword(keyword=keyword_obj))
# create content
page.root_node.working_copy.content.add_child(
site, UnsafeHtml, content=self.process_images(item['content']))
page = RawPage.objects.get(id=page.id)
commit = page.root_node.commit()
# approve and publish
user, _ = User.objects.get_or_create(username='******',
is_superuser=True)
commit.approve(user)
def test_keywords(self):
"""
Test that the keywords_string field is correctly populated.
"""
page = RichTextPage.objects.create(title="test keywords")
keywords = set(["how", "now", "brown", "cow"])
Keyword.objects.all().delete()
for keyword in keywords:
keyword_id = Keyword.objects.get_or_create(title=keyword)[0].id
page.keywords.add(AssignedKeyword(keyword_id=keyword_id))
page = RichTextPage.objects.get(id=page.id)
self.assertEqual(keywords, set(page.keywords_string.split()))
# Test removal.
first = Keyword.objects.all()[0]
keywords.remove(first.title)
first.delete()
page = RichTextPage.objects.get(id=page.id)
self.assertEqual(keywords, set(page.keywords_string.split()))
page.delete()
def add_meta(self, obj, tags, prompt, verbosity, old_url=None):
"""
Adds tags and a redirect for the given obj, which is a forum
post or a page.
"""
for tag in tags:
keyword = self.trunc(Keyword, prompt, title=tag)
keyword, created = Keyword.objects.get_or_create_iexact(**keyword)
obj.keywords.add(AssignedKeyword(keyword=keyword))
if created and verbosity >= 1:
print "Imported tag: %s" % keyword
if old_url is not None:
old_path = urlparse(old_url).path
if not old_path.strip("/"):
return
redirect = self.trunc(Redirect, prompt, old_path=old_path)
redirect['site'] = Site.objects.get_current()
redirect, created = Redirect.objects.get_or_create(**redirect)
redirect.new_path = obj.get_absolute_url()
redirect.save()
if created and verbosity >= 1:
print "Created redirect for: %s" % old_url
def handle(self, *args, **kwargs):
# self.cleanup()
meta_event_name = kwargs.get('meta_event')
meta_trans_all = eve_models.MetaEventTranslation.objects.all()
for meta_trans in meta_trans_all:
if meta_trans.name == meta_event_name:
break
eve_events = eve_models.Event.objects.filter(meta_event=meta_trans.id)
for eve_event in eve_events:
event_trans = eve_models.EventTranslation.objects.filter(
id=eve_event,
lang='fr'
)[0]
manifestations = eve_event.manifestations.all().order_by('happens_at')
for manifestation in manifestations:
events = ma_models.Event.objects.filter(external_id=manifestation.id)
if not events:
event = ma_models.Event(external_id=manifestation.id)
else:
event = events[0]
event.start = manifestation.happens_at
event.end = manifestation.happens_at + timedelta(
seconds=manifestation.duration
)
event.title = event_trans.name
event.user = self.default_user
locations = ma_models.EventLocation.objects.filter(
title=manifestation.location.name
)
if locations:
location = locations[0]
else:
location = ma_models.EventLocation(
title=manifestation.location.name
)
address = '\n'.join(
[
manifestation.location.address,
manifestation.location.postalcode +
' ' +
manifestation.location.city
]
)
location.address = address
location.external_id = manifestation.id
location.clean()
location.save()
event.location = location
event.save()
keyword, _ = Keyword.objects.get_or_create(
title=eve_event.event_category.name
)
event.keywords.add(AssignedKeyword(keyword=keyword), bulk=False)
eve_prices = eve_models.PriceManifestation.objects.filter(
manifestation=manifestation
)
for price in eve_prices:
event_price, c = ma_models.EventPrice.objects.get_or_create(
value=float(price.value)
)
if event:
if event_price not in event.prices.all():
event.prices.add(event_price)
event.save()
result["featured_image"] = ""
tag_list = tag_association[old_id] if tag_association.has_key(
old_id) else []
result["keywords_string"] = " ".join(tag_list)
# Make initial user the author of all blog posts
result["user"] = author
#print result
newpost = BlogPost.objects.create(**result)
newpost.categories.add(blog_cat)
print newpost
for tag in tag_list:
keyword, created = Keyword.objects.get_or_create(title=tag)
newpost.keywords.add(AssignedKeyword(keyword=keyword))
original_videos = tree.findall("object[@model='videos.video']")
for item in reversed(original_videos):
result = {}
result["title"] = item.find("field[@name='title']").text
result["content"] = item.find("field[@name='description']").text.strip()
# Get around aware datetime object requirement in Django
result["publish_date"] = item.find("field[@name='pub_date']").text
result["publish_date"] = datetime.datetime.strptime(
result["publish_date"],
"%Y-%m-%d %H:%M:%S").replace(tzinfo=get_current_timezone())
result["allow_comments"] = False
for post in BlogPost.objects.all().order_by('id'):
if post.title not in xml_items:
print '\tWARNING: blog post #%s not found in Wordpress dump' % (post.id,)
continue
xml_item = xml_items[post.title]
for xml_tag_slug in [c.get('nicename') for c in xml_item.findall('category[@domain=\'%s\']' % category_domain)]:
#print getattr(post, model_field_name).all()
if xml_tag_slug not in [c.slug for c in getattr(post, model_name.lower() + '_list')()]:
object_to_add = categories[xml_tag_slug]
# keyword_id = Keyword.objects.get_or_create(title=keyword)[0].id
# image.keywords.add(AssignedKeyword(keyword_id=keyword_id))
if not as_categories:
object_to_add = AssignedKeyword(keyword=categories[xml_tag_slug])
getattr(post, model_field_name).add(object_to_add)
#print categories[xml_tag_slug].slug
print '\tAdd %s %s to post %s' % (model_name, xml_tag_slug, post.slug)
if not self.is_dry_run():
post.save()
tag_count += 1
modified_posts[post.slug] = 1
print 'Added %d %s to %d posts.' % (tag_count, model_name, len(modified_posts.keys()))
#post.categories
#xml_items = tree.findall('.//item[title/text()=\'%s\']' % (post.title,), namespaces)
#print len(xml_items)
def reformat(self, options):
# e.g. https://digipal2.cch.kcl.ac.uk/blog/anglo-saxon-mss-online-ii-copenhagen-roy-lib-and-bav/
