def test_non_alnumeric_string(self):
'''
Test a series of strings with
non-alphanumeric characters excluding dashes.
'''
text1 = Tag.normalize_text('__init__(*args, **kwargs):')
text2 = Tag.normalize_text('# This is a comment')
text3 = Tag.normalize_text('Hello!')
text4 = Tag.normalize_text('4^2')
text5 = Tag.normalize_text('Total is $2.99')
text6 = Tag.normalize_text('tag_name_')
text7 = Tag.normalize_text('. . .')
text8 = Link.normalize_key('(')
text9 = Link.normalize_key(')')
self.assertEqual(text1, None)
self.assertEqual(text2, None)
self.assertEqual(text3, None)
self.assertEqual(text4, None)
self.assertEqual(text5, None)
self.assertEqual(text6, None)
self.assertEqual(text7, None)
self.assertEqual(text8, None)
self.assertEqual(text9, None)
def mutate(self, info, url, description):
link = Link(url=url, description=description)
link.save()
return CreateLink(id=link.id,
url=link.url,
description=link.description)
def test_entity_description(self):
link_to_school = Link(
destination_content_type=ContentType.objects.get_for_model(
self.school
),
destination_object_id=self.school.id,
)
self.assertEquals(link_to_school.text(), self.school.name)
# home_page = create_page("title", "arkestra.html", "en", menu_title=None, slug=None, apphook=None, redirect=None, meta_description="Description")
#
#
# self.assertEquals(link_to_school.description(), "Description")
link_to_building = Link(
destination_content_type = ContentType.objects.get_for_model(self.main_building),
destination_object_id = self.main_building.id,
)
self.assertEquals(link_to_building.text(), self.main_building.identifier())
self.assertEquals(link_to_building.description(), u"St Mary's Street, Cardiff")
"""
def clone(request):
user = request.user.get_profile()
if request.method == "POST":
form = project_forms.CloneProjectForm(request.POST)
if form.is_valid():
base_project = form.cleaned_data["project"]
project = Project(
name=base_project.name,
category=base_project.category,
other=base_project.other,
other_description=base_project.other_description,
short_description=base_project.short_description,
long_description=base_project.long_description,
clone_of=base_project,
)
project.save()
act = Activity(actor=user, verb=verbs["post"], scope_object=project, target_object=project)
act.save()
participation = Participation(project=project, user=user, organizing=True)
participation.save()
new_rel, created = Relationship.objects.get_or_create(source=user, target_project=project)
new_rel.deleted = False
new_rel.save()
detailed_description = Page(
title=_("Full Description"),
slug="full-description",
content=base_project.detailed_description.content,
listed=False,
author_id=user.id,
project_id=project.id,
)
detailed_description.save()
project.detailed_description_id = detailed_description.id
base_sign_up = base_project.sign_up.get()
sign_up = Signup(
public=base_sign_up.public,
between_participants=base_sign_up.between_participants,
author_id=user.id,
project_id=project.id,
)
sign_up.save()
project.save()
tasks = Page.objects.filter(project=base_project, listed=True, deleted=False).order_by("index")
for task in tasks:
new_task = Page(title=task.title, content=task.content, author=user, project=project)
new_task.save()
links = Link.objects.filter(project=base_project).order_by("index")
for link in links:
new_link = Link(name=link.name, url=link.url, user=user, project=project)
new_link.save()
project.create()
messages.success(request, _("The %s has been cloned.") % project.kind.lower())
return http.HttpResponseRedirect(reverse("projects_show", kwargs={"slug": project.slug}))
else:
messages.error(request, _("There was a problem cloning the study group, course, ..."))
else:
form = project_forms.CloneProjectForm()
return render_to_response(
"projects/project_clone.html", {"form": form, "clone_tab": True}, context_instance=RequestContext(request)
)
def import_from_old_site(request):
user = request.user.get_profile()
if request.method == 'POST':
form = project_forms.ImportProjectForm(request.POST)
if form.is_valid():
course = form.cleaned_data['course']
#CS - too much logic in view
project = Project(name=course['name'], kind=course['kind'],
short_description=course['short_description'],
long_description=course['long_description'],
imported_from=course['slug'])
project.save()
act = Activity(actor=user,
verb=verbs['post'],
scope_object=project,
target_object=project)
act.save()
participation = Participation(project=project, user=user,
organizing=True)
participation.save()
new_rel, created = Relationship.objects.get_or_create(source=user,
target_project=project)
new_rel.deleted = False
new_rel.save()
if course['detailed_description']:
detailed_description_content = course['detailed_description']
else:
detailed_description_content = render_to_string(
"projects/detailed_description_initial_content.html",
{'project': project})
detailed_description = Page(title=_('Full Description'),
slug='full-description', content=detailed_description_content,
listed=False, author_id=user.id, project_id=project.id)
detailed_description.save()
project.detailed_description_id = detailed_description.id
sign_up = Signup(between_participants=course['sign_up'],
author_id=user.id, project_id=project.id)
sign_up.save()
project.save()
for title, content in course['tasks']:
new_task = Page(title=title, content=content, author=user,
project=project)
new_task.save()
for name, url in course['links']:
new_link = Link(name=name, url=url, user=user, project=project)
new_link.save()
project.create()
messages.success(request,
_('The %s has been imported.') % project.kind.lower())
return http.HttpResponseRedirect(reverse('projects_show', kwargs={
'slug': project.slug,
}))
else:
msg = _("Problem importing the study group, course, ...")
messages.error(request, msg)
else:
form = project_forms.ImportProjectForm()
return render_to_response('projects/project_import.html', {
'form': form, 'import_tab': True},
context_instance=RequestContext(request))
def clone(request):
user = request.user.get_profile()
if request.method == 'POST':
form = project_forms.CloneProjectForm(request.POST)
if form.is_valid():
base_project = form.cleaned_data['project']
project = Project(name=base_project.name, kind=base_project.kind,
short_description=base_project.short_description,
long_description=base_project.long_description,
clone_of=base_project)
project.save()
act = Activity(actor=user,
verb=verbs['post'],
scope_object=project,
target_object=project)
act.save()
participation = Participation(project=project, user=user,
organizing=True)
participation.save()
new_rel, created = Relationship.objects.get_or_create(source=user,
target_project=project)
new_rel.deleted = False
new_rel.save()
detailed_description = Page(title=_('Full Description'),
slug='full-description',
content=base_project.detailed_description.content,
listed=False, author_id=user.id, project_id=project.id)
detailed_description.save()
project.detailed_description_id = detailed_description.id
sign_up = Page(title=_('Sign-Up'), slug='sign-up',
content=base_project.sign_up.content, listed=False,
editable=False, author_id=user.id, project_id=project.id)
sign_up.save()
project.sign_up_id = sign_up.id
project.save()
tasks = Page.objects.filter(project=base_project, listed=True,
deleted=False).order_by('index')
for task in tasks:
new_task = Page(title=task.title, content=task.content,
author=user, project=project)
new_task.save()
links = Link.objects.filter(project=base_project).order_by('index')
for link in links:
new_link = Link(name=link.name, url=link.url, user=user,
project=project)
new_link.save()
project.create()
messages.success(request,
_('The %s has been cloned.') % project.kind.lower())
return http.HttpResponseRedirect(reverse('projects_show', kwargs={
'slug': project.slug,
}))
else:
messages.error(request,
_("There was a problem cloning the study group, course, ..."))
else:
form = project_forms.CloneProjectForm()
return render_to_response('projects/project_clone.html', {
'form': form, 'clone_tab': True,
}, context_instance=RequestContext(request))
def import_from_old_site(request):
user = request.user.get_profile()
if request.method == 'POST':
form = project_forms.ImportProjectForm(request.POST)
if form.is_valid():
course = form.cleaned_data['course']
#CS - too much logic in view
project = Project(name=course['name'], kind=course['kind'],
short_description=course['short_description'],
long_description=course['long_description'],
imported_from=course['slug'])
project.save()
act = Activity(actor=user,
verb=verbs['post'],
scope_object=project,
target_object=project)
act.save()
participation = Participation(project=project, user=user,
organizing=True)
participation.save()
new_rel, created = Relationship.objects.get_or_create(source=user,
target_project=project)
new_rel.deleted = False
new_rel.save()
if course['detailed_description']:
detailed_description_content = course['detailed_description']
else:
detailed_description_content = render_to_string(
"projects/detailed_description_initial_content.html",
{'project': project})
detailed_description = Page(title=_('Full Description'),
slug='full-description', content=detailed_description_content,
listed=False, author_id=user.id, project_id=project.id)
detailed_description.save()
project.detailed_description_id = detailed_description.id
sign_up = Signup(between_participants=course['sign_up'],
author_id=user.id, project_id=project.id)
sign_up.save()
project.save()
for title, content in course['tasks']:
new_task = Page(title=title, content=content, author=user,
project=project)
new_task.save()
for name, url in course['links']:
new_link = Link(name=name, url=url, user=user, project=project)
new_link.save()
project.create()
messages.success(request,
_('The %s has been imported.') % project.kind.lower())
return http.HttpResponseRedirect(reverse('projects_show', kwargs={
'slug': project.slug,
}))
else:
msg = _("Problem importing the study group, course, ...")
messages.error(request, msg)
else:
form = project_forms.ImportProjectForm()
return render_to_response('projects/project_import.html', {
'form': form, 'import_tab': True},
context_instance=RequestContext(request))
def add_link(self, url, description, tags):
l = Link(url=url,pub_date=timezone.now())
l.save()
linkId = l.id
for tag in tags:
t = Tag(value=tag,link=l)
t.save()
def import_from_old_site(request):
user = request.user.get_profile()
if request.method == "POST":
form = project_forms.ImportProjectForm(request.POST)
if form.is_valid():
course = form.cleaned_data["course"]
project = Project(
name=course["name"],
kind=course["kind"],
short_description=course["short_description"],
long_description=course["long_description"],
imported_from=course["slug"],
)
project.save()
act = Activity(actor=user, verb=verbs["post"], scope_object=project, target_object=project)
act.save()
participation = Participation(project=project, user=user, organizing=True)
participation.save()
new_rel, created = Relationship.objects.get_or_create(source=user, target_project=project)
new_rel.deleted = False
new_rel.save()
if course["detailed_description"]:
detailed_description_content = course["detailed_description"]
else:
detailed_description_content = render_to_string(
"projects/detailed_description_initial_content.html", {}
)
detailed_description = Page(
title=_("Full Description"),
slug="full-description",
content=detailed_description_content,
listed=False,
author_id=user.id,
project_id=project.id,
)
detailed_description.save()
project.detailed_description_id = detailed_description.id
sign_up = Signup(between_participants=course["sign_up"], author_id=user.id, project_id=project.id)
sign_up.save()
project.save()
for title, content in course["tasks"]:
new_task = Page(title=title, content=content, author=user, project=project)
new_task.save()
for name, url in course["links"]:
new_link = Link(name=name, url=url, user=user, project=project)
new_link.save()
project.create()
messages.success(request, _("The %s has been imported.") % project.kind.lower())
return http.HttpResponseRedirect(reverse("projects_show", kwargs={"slug": project.slug}))
else:
msg = _("Problem importing the study group, course, ...")
messages.error(request, msg)
else:
form = project_forms.ImportProjectForm()
return render_to_response(
"projects/project_import.html", {"form": form, "import_tab": True}, context_instance=RequestContext(request)
)
def mutate_and_get_payload(root, info, **input):
user = info.context.user or None
link = Link(url=input.get('url'),
description=input.get('description'),
posted_by=user)
link.save()
return RelayCreateLink(link=link)
class ModelTestCase(TestCase):
def setUp(self):
self.link_title = 'Книжный парад'
self.link = Link(name=self.link_title)
def test_model_created_link(self):
old_count = Link.objects.count()
self.link.save()
new_count = Link.objects.count()
self.assertNotEqual(old_count, new_count)
def mutate(self, info, url, description):
user = get_user(info) or None
link = Link(url=url, description=description, posted_by=user)
## save the date
link.save()
return CreateLink(id=link.id,
url=link.url,
description=link.description,
posted_by=link.posted_by)
def mutate(self, info, url, description):
user = info.context.user or None
link = Link(url=url, description=description, posted_by=user)
link.save()
return CreateLink(id=link.id,
url=link.url,
description=link.description,
posted_by=link.posted_by)
def test_spaces_inbetween_string(self):
'''
Test strings with multiple
whitespaces in between words.
'''
text1 = Link.normalize_key('the sky is blue')
text2 = Link.normalize_key('my age is 25')
self.assertEqual(text1, None)
self.assertEqual(text2, None)
def mutate_and_get_payload(self, info, **input):
user = info.context.user or None
logger.info('12345 上山打老虎')
link = Link(
url=input.get('url'),
description=input.get('description'),
posted_by=user,
)
link.save()
return RelayCreateLink(link=link)
def mutate(self, info, url, description):
# will fail if there is no logged in user
posted_by = get_user(info)
link = Link(url=url, description=description, posted_by=posted_by)
link.save()
return CreateLink(
id=link.id,
url=link.url,
description=link.description,
posted_by=link.posted_by,
)
def test_multiple_whitespace_string(self):
'''
Test normalize_key method with
strings with 2 whitespaces and
10 whitespaces.
'''
text1 = Link.normalize_key(' ')
text2 = Link.normalize_key(' ')
self.assertEqual(text1, None)
self.assertEqual(text2, None)
def test_link_encode(self):
tests = [
(1, 'MQ=='),
(100, 'MTAw'),
(10000, 'MTAwMDA='),
(1000000, 'MTAwMDAwMA=='),
]
for test in tests:
l = Link(id=test[0], url='http://example.com')
key = l.encode()
self.assertEqual(key, test[1])
def test_uppercase_string(self):
'''
Test strings with uppercase characters.
'''
text1 = Link.normalize_key('Hello')
text2 = Link.normalize_key('HellO')
text3 = Link.normalize_key('HELLO')
self.assertEqual(text1, 'Hello')
self.assertEqual(text2, 'HellO')
self.assertEqual(text3, 'HELLO')
def POST(self, link_id=None):
if link_id:
link = Link.get_by_id(int(link_id))
else:
link = Link()
max_sort_link = Link.all().order('-sort').get()
if max_sort_link:
# max_sort_category = max_sort_category.pop()
max_sort = max_sort_link.sort
if not max_sort:
max_sort = 1
else:
max_sort = 0
link.sort = max_sort + 1
inp = web.input()
link.name = inp.name
url = inp.get('url')
if not url.startswith(('http://', 'https://')):
url = 'http://' + url
link.url = url
link.save()
clear_cache()
return web.seeother('/admin/links')
def edit(self: T, field: str, value: str, *args, **kwargs):
"""Change field by given value."""
assert field in ["name", "feed", "link"]
if field == "name":
self.name = value
elif field == "feed":
self.feed = Link.get_or_create(value)
elif field == "link":
link = Link.get_or_create(value)
if self.links.filter(pk=link.pk).exists():
self.links.remove(link)
else:
self.links.add(link)
self.save()
def from_dict(cls: Type[T], data: Dict) -> Tuple[T, bool]:
"""Create from dict.
Returns True if was crated, i. e. was not found in the DB.
"""
defaults: Dict = {}
if "series" in data and data["series"]:
defaults["series"] = Series.from_dict(data["series"])[0]
if "volume" in data and data["volume"]:
defaults["volume"] = data["volume"]
book, created = Book.objects.get_or_create(title=data["title"],
defaults=defaults)
if "authors" in data and data["authors"]:
for i in data["authors"]:
book.authors.add(Person.from_dict(i)[0])
if "genres" in data and data["genres"]:
for i in data["genres"]:
book.genres.add(Genre.from_dict(i)[0])
if "links" in data and data["links"]:
for i in data["links"]:
book.links.add(Link.from_dict(i)[0])
return book, created
def edit(self: T, field: str, value: Union[str, float], *args, **kwargs):
"""Change field by given value."""
assert field in [
"title", "author", "series", "volume", "genre", "link"
]
if field == "title":
self.title = value
elif field == "author" and isinstance(value, str):
author = Person.get_or_create(value)
if self.authors.filter(pk=author.pk).exists():
self.authors.remove(author)
else:
self.authors.add(author)
elif field == "series" and isinstance(value, str):
self.series = Series.get_or_create(value)
elif field == "volume":
self.volume = value
elif field == "genre" and isinstance(value, str):
genre = Genre.get_or_create(value)
if self.genres.filter(pk=genre.pk).exists():
self.genres.remove(genre)
else:
self.genres.add(genre)
elif field == "link" and isinstance(value, str):
link = Link.get_or_create(value)
if self.links.filter(pk=link.pk).exists():
self.links.remove(link)
else:
self.links.add(link)
self.save(*args, **kwargs)
def test_right_whitespace_string(self):
'''
Test a string with whitespaces to right.
'''
text = Link.normalize_key('key ')
self.assertEqual(text, None)
def test_get(self):
link, created = Link.from_dict({"url": "https://example.com"})
self.assertTrue(created)
self.assertIsNotNone(link.id)
link2 = Link.get("https://example.com")
self.assertIsNotNone(link2)
self.assertEquals(link, link2)
link2 = Link.get("example")
self.assertIsNotNone(link2)
self.assertEquals(link, link2)
link2 = Link.get(str(link.id))
self.assertIsNotNone(link2)
self.assertEquals(link, link2)
def create_or_update_single_bill(self, proposal, pdf_link, link_file):
if not(proposal['date']) or CUTOFF_DATE and proposal['date'] < CUTOFF_DATE:
return
law_name = proposal['law']
(law, created) = Law.objects.get_or_create(title=law_name)
if created:
law.save()
if law.merged_into:
law = law.merged_into
title = u''
if proposal['correction']:
title += proposal['correction']
if proposal['comment']:
title += ' ' + proposal['comment']
if len(title)<=1:
title = u'חוק חדש'
(gp,created) = GovProposal.objects.get_or_create(booklet_number=proposal['booklet'], knesset_id=18,
source_url=proposal['link'],
title=title, law=law, date=proposal['date'])
if created:
gp.save()
logger.debug("created GovProposal id = %d" % gp.id)
bill_params = dict(law=law, title=title, stage='3', stage_date=proposal['date'])
similar_bills = Bill.objects.filter(**bill_params).order_by('id')
if len(similar_bills) >= 1:
b = similar_bills[0]
if len(similar_bills) > 1:
logger.debug("multiple bills detected")
for bill in similar_bills:
if bill.id == b.id:
logger.debug("bill being used now - %d" % bill.id)
else:
logger.debug("bill with same fields - %d" % bill.id)
else:
b = Bill(**bill_params)
b.save()
gp.bill = b
gp.save()
if link_file.link is None:
link = Link(title=pdf_link, url=pdf_link,
content_type=ContentType.objects.get_for_model(gp),
object_pk=str(gp.id))
link.save()
link_file.link = link
link_file.save()
logger.debug("check updated %s" % b.get_absolute_url())
def form_valid(self, form):
new_homework=Homework(
entered_by=self.request.user,
entered_on=datetime.today(),
)
new_homework.save()
new_details=form.save(commit=False)
new_details.deleted=False
new_details.hwk=new_homework
if self.request.user.has_perm('classlists.is_kksastaff'):
#creating multiple copies of the same hwk details record, one for each class
for k in form.cleaned_data['klass']:
new_details.pk=None
new_details.klass=k
new_details.save()
if form.cleaned_data['link']:
new_link=Link(
link=form.cleaned_data['link'],
description=form.cleaned_data['link_description'],
homework=new_homework,
subject=new_details.subject,
)
new_link.save()
for k in form.cleaned_data['klass']:
new_link.klass.add(k)
if form.cleaned_data['attached_file']:
new_document=Document(
attached_file=form.cleaned_data['attached_file'],
filename=form.cleaned_data['attached_file'].name,
description=form.cleaned_data['document_description'],
homework=new_homework,
subject=new_details.subject,
)
new_document.save()
for k in form.cleaned_data['klass']:
new_document.klass.add(k)
else:
new_details.klass=Klass.objects.get(klass_name=self.kwargs['class_url'])
new_details.save()
return HttpResponseRedirect(reverse('homework_view', args=(self.kwargs['class_url'],),))
def from_dict(cls: Type[T], data: Dict) -> Tuple[T, bool]:
"""Create from dict.
Returns True if was crated, i. e. was not found in the DB.
"""
defaults: Dict = {}
if "feed" in data and data["feed"]:
defaults["feed"] = Link.from_dict(data["feed"])[0]
magazine, created = cls.objects.get_or_create(
name=data["name"], defaults=defaults
)
if "links" in data and data["links"]:
for i in data["links"]:
magazine.links.add(Link.from_dict(i)[0])
return magazine, created
def mutate(root, input, context, info):
user = get_user(context) or None
link = Link(
url=input.get('url'),
description=input.get('description'),
posted_by=user,
)
link.save()
return CreateLink(
id=link.id,
url=link.url,
description=link.description,
posted_by=link.posted_by,
)
def test_delete(self):
link, created = Link.from_dict({"url": "https://example.com"})
self.assertTrue(created)
self.assertIsNotNone(link.id)
deleted = link.delete()
self.assertIsNone(link.id)
self.assertEquals((1, {"links.Link": 1}), deleted)
def test_empty_string(self):
'''
Test normalize_key method with
empty string.
'''
text = Link.normalize_key('')
self.assertEqual(text, None)
def test_one_whitespace_string(self):
'''
Test normalize_key method with
one whitespace.
'''
text = Link.normalize_key(' ')
self.assertEqual(text, None)
def GET(self, link_id=None):
if link_id:
link = Link.get_by_id(int(link_id))
link.delete()
clear_cache()
return web.seeother('/admin/links')
def test_entity_description(self):
link_to_school = Link(
destination_content_type=ContentType.objects.get_for_model(
self.school
),
destination_object_id=self.school.id,
)
self.assertEquals(link_to_school.__unicode__(), self.school.name)
link_to_building = Link(
destination_content_type = ContentType.objects.get_for_model(self.main_building),
destination_object_id = self.main_building.id,
)
self.assertEquals(
link_to_building.__unicode__(),
self.main_building.__unicode__()
)
self.assertEquals(
link_to_building.summary(),
u"St Mary's Street, Cardiff"
)
"""
class LinkDataSerializer(Serializer):
link = ForeignKeyField(slug_field='url',
queryset=lambda: Link.all(),
many=False)
class Meta:
model = LinkData
fields = ('id', 'link', 'created')
read_only_fields = ('created', )
def GET(self, link_id=None):
link = None
if link_id:
link = Link.get_by_id(int(link_id))
title = u'修改友情链接'
else:
title = u'新增友情链接'
return render('admin/link.html',link=link,title=title)
def test_from_to_dict(self):
magazine, created = Magazine.objects.get_or_create(name="Cool")
self.assertTrue(created)
self.assertIsNotNone(magazine.id)
self.assertEquals(
{
"name": "Cool",
"feed": None,
"links": None,
},
magazine.to_dict(),
)
self.assertEquals((magazine, False),
Magazine.from_dict(magazine.to_dict()))
self.assertEquals((magazine, False),
Magazine.from_dict({"name": "Cool"}))
feed, created = Link.from_dict({"url": "https://example.com/feed"})
self.assertTrue(created)
self.assertIsNotNone(feed.id)
link, created = Link.from_dict({"url": "https://example.com"})
self.assertTrue(created)
self.assertIsNotNone(link.id)
magazine, created = Magazine.objects.get_or_create(name="Example",
feed=feed)
magazine.links.add(link)
self.assertTrue(created)
self.assertIsNotNone(magazine.id)
self.assertEquals(
{
"name": "Example",
"feed": {
"url": "https://example.com/feed"
},
"links": [{
"url": "https://example.com"
}],
},
magazine.to_dict(),
)
self.assertEquals((magazine, False),
Magazine.from_dict(magazine.to_dict()))
def from_dict(cls: Type[T], data: Dict, book: Book) -> Tuple[T, bool]:
"""Create from dict.
Returns True if was crated, i. e. was not found in the DB.
"""
defaults: Dict = {}
if "alternate_title" in data and data["alternate_title"]:
defaults["alternate_title"] = data["alternate_title"]
if "isbn" in data and data["isbn"]:
defaults["isbn"] = data["isbn"]
if "publishing_date" in data and data["publishing_date"]:
defaults["publishing_date"] = datetime.datetime.strptime(
data["publishing_date"], "%Y-%m-%d").date()
if "publisher" in data and data["publisher"]:
defaults["publisher"] = Publisher.from_dict(data["publisher"])[0]
if "binding" in data and data["binding"]:
defaults["binding"] = Binding.from_dict(data["binding"])[0]
if "bibtex" in data and data["bibtex"]:
defaults["bibtex"] = data["bibtex"]
edition, created = cls.objects.get_or_create(
book=book,
alternate_title=data["alternate_title"]
if "alternate_title" in data else None,
isbn=data["isbn"] if "isbn" in data else None,
publishing_date=data["publishing_date"]
if "publishing_date" in data else None,
defaults=defaults,
)
if "cover_image" in data and data["cover_image"]:
edition.cover_image.save(
os.path.basename(data["cover_image"]),
DJFile(open(data["cover_image"], "rb")),
)
if "languages" in data and data["languages"]:
for i in data["languages"]:
edition.languages.add(Language.from_dict(i)[0])
if "links" in data and data["links"]:
for i in data["links"]:
edition.links.add(Link.from_dict(i)[0])
if "persons" in data and data["persons"]:
for i in data["persons"]:
edition.persons.add(Person.from_dict(i)[0])
if "acquisitions" in data and data["acquisitions"]:
for i in data["acquisitions"]:
Acquisition.from_dict(i, edition)
if "files" in data and data["files"]:
for i in data["files"]:
File.from_dict(i, edition)
if "reads" in data and data["reads"]:
for i in data["reads"]:
Read.from_dict(i, edition)
edition.save()
return edition, created
def edit(self: T, field: str, value: str, *args, **kwargs):
"""Change field by given value."""
assert field in [
"alternate_title",
"alternate-title",
"binding",
"cover",
"isbn",
"person",
"publishing_date",
"publishing-date",
"publisher",
"language",
"link",
"file",
]
if field == "alternate_title" or field == "alternate-title":
self.alternate_title = value
elif field == "binding":
self.binding = Binding.get_or_create(value)
elif field == "cover":
self.cover_image.save(os.path.basename(str(value)),
DJFile(open(str(value), "rb")))
elif field == "isbn":
self.isbn = value
elif field == "person":
person = Person.get_or_create(value)
if self.persons.filter(pk=person.pk).exists():
self.persons.remove(person)
else:
self.persons.add(person)
elif field == "publishing_date" or field == "publishing-date":
self.publishing_date = value
elif field == "publisher":
self.publisher = Publisher.get_or_create(value)
elif field == "language":
language = Language.get_or_create(value)
if self.languages.filter(pk=language.pk).exists():
self.languages.remove(language)
else:
self.languages.add(language)
elif field == "link":
link = Link.get_or_create(value)
if self.links.filter(pk=link.pk).exists():
self.links.remove(link)
else:
self.links.add(link)
elif field == "file":
file, created = File.from_dict({"path": value})
if self.files.filter(pk=file.pk).exists():
self.files.remove(file)
file.delete()
else:
self.files.add(file)
self.save(*args, **kwargs)
def test_link_decode(self):
tests = [
('MTIzNDU2Nzg5', '123456789'),
('OTk5', '999'),
('MTIyMzMzNDQ0NDU1NTU1', '122333444455555'),
]
for test in tests:
pk = Link.decode(test[0])
self.assertEqual(pk, test[1])
def POST(self):
data = web.data()
sorted_data = json.loads(data)
for link_id, sort in sorted_data.iteritems():
link_id = Link.get_by_id(int(link_id))
link_id.sort = sort
link_id.save()
clear_cache()
return json.dumps({'status': 'ok'})
def add_link(self, channel, nick, host, msg):
"""adds link to database"""
if not host.startswith('~muse'):
urls = regex.findall(msg)
if urls:
for url in [u for u in urls if 'notune' not in u]:
url = url_processing(url)
try:
tree = lxml.html.parse(url)
title = title_processing(tree.xpath('//title/text()')[0])
self.msg(channel, title)
except:
title = ''
link = Link(nick=nick,
host=host,
channel=channel,
added=datetime.datetime.now(),
link=url,
context=msg,
title=title)
try: link.save()
except: pass
def __init__(self, user=None, profile=None, notification=None, you=None):
if user:
self.user_id = user.id
self.username = user.username
self.email = user.email
self.first_name = user.first_name
self.last_name = user.last_name
if profile:
self.profile_id = profile.id
self.is_stage_name = profile.is_stage_name
self.stage_first_name = profile.stage_first_name
self.stage_last_name = profile.stage_last_name
self.title = profile.title
self.height = profile.height
self.weight = profile.weight
self.birth_day = profile.birth_day
self.hair_color = profile.hair_color
self.eye_color = profile.eye_color
self.race = profile.race
self.personal_add1 = profile.personal_add1
self.personal_add2 = profile.personal_add2
self.personal_city = profile.personal_city
self.personal_state = profile.personal_state
self.personal_zip = profile.personal_zip
self.personal_mobile = profile.personal_mobile
self.personal_office = profile.personal_office
self.personal_email = profile.personal_email
self.is_agency_contact = profile.is_agency_contact
self.agency = profile.agency
self.agency_name = profile.agency_name
self.agency_mobile = profile.agency_mobile
self.agency_email = profile.agency_email
self.agency_office_num = profile.agency_office_num
self.agency_add1 = profile.agency_add1
self.agency_add2 = profile.agency_add2
self.agency_city = profile.agency_city
self.agency_state = profile.agency_state
self.agency_zip = profile.agency_zip
self.resume_categories = profile.resume_categories
self.thumbnail = profile.thumbnail
if notification:
self.notifications_count = notification.notifications_count
self.links_count = notification.links_count
else:
self.notifications_count = 0
self.links_count = 0
if you:
self.link_status = Link.link_status(user, you)
else:
self.link_status = "U"
def site_context(request):
site=get_site()
additional_context={'site': site,
'user':get_current_profile(),
'admin':users.is_current_user_admin(),
'logout':users.create_logout_url(reverse('account-signout')),
'links':Link.all().filter('status =','approved').fetch(20)
}
#additional_context['logo']=get_serving_url(str(site.original_logo.key()), 512)
return additional_context
def body(self):
content = memcache.get('widget_links')
if not content:
links = Link.all().order('sort')
content = []
write = content.append
write('<ul>')
for link in links:
write('<li><a href="%s" target="_blank">%s</a></li>' %
(link.url, link.name))
write('</ul>')
content = '\n'.join(content)
memcache.set('widget_links', content)
return content
def send_message(request):
"""
Sends a message to a linked user.
Allowed HTTP methods are:\n
1. POST to send\n
Accepts following hash:\n
. {\n
"to": [user_id],\n
"title": [message_title],\n
"message": [the_message]\n
}\n
Returns:\n
. Newly created message
Status:\n
1. 200 on success
2. 400 if some error occurs
3. 401 if un-authorized
4. 404 if user not found
Notes:\n
1. Require user's token to be sent in the header as:\n
Authorization: Token [token]\n
"""
me = request.user
to_id = request.DATA.get("to")
title = request.DATA.get("title")
msg = request.DATA.get("message")
to = User.objects.filter(id=to_id).first()
if to:
if Link.is_already_link(me, to):
message = Message()
message.from_user = me
message.to_user = to
message.title = title
message.message = msg
message.save()
create_notification("MSG", message.id, me, to, message=msg)
serializer = PlainMessageSerializer(message.plain())
return Response(serializer.data)
return Response({
"status": HTTP_400_BAD_REQUEST,
"message": "Cannot send message to a non-link"
}, status=HTTP_400_BAD_REQUEST)
return Response({
"status": HTTP_404_NOT_FOUND,
"message": "User not found"
}, status=HTTP_404_NOT_FOUND)
def create_or_update_single_bill(self, data, pdf_link, link_file, gp=None):
"""
data - a dict of data for this gov proposal
pdf_link - the source url from which the bill is taken
link_file - a cached version of the pdf
gp - an existing GovProposal objects. if this is given, it will be
updated, instead of creating a new object
"""
if not(data['date']) or CUTOFF_DATE and data['date'] < CUTOFF_DATE:
return
law_name = data['law']
(law, created) = Law.objects.get_or_create(title=law_name)
if created:
law.save()
if law.merged_into:
law = law.merged_into
title = u''
if data['correction']:
title += data['correction']
if data['comment']:
title += ' ' + data['comment']
if len(title) <= 1:
title = u'חוק חדש'
if data['date'] > Knesset.objects.current_knesset().start_date:
k_id = 19
else:
k_id = 18
if gp is None: # create new GovProposal, or look for an identical one
(gp, created) = GovProposal.objects.get_or_create(
booklet_number=data['booklet'],
source_url=data['link'],
title=title,
law=law,
date=data['date'], defaults={'knesset_id': k_id})
if created:
gp.save()
logger.debug("created GovProposal id = %d" % gp.id)
# look for similar bills
bill_params = dict(law=law, title=title, stage='3',
stage_date=data['date'])
similar_bills = Bill.objects.filter(**bill_params).order_by('id')
if len(similar_bills) >= 1:
b = similar_bills[0]
if len(similar_bills) > 1:
logger.debug("multiple bills detected")
for bill in similar_bills:
if bill.id == b.id:
logger.debug("bill being used now: %d" % bill.id)
else:
logger.debug("bill with same fields: %d" % bill.id)
else: # create a bill
b = Bill(**bill_params)
b.save()
# see if the found bill is already linked to a gov proposal
try:
bill_gp_id = b.gov_proposal.id
except GovProposal.DoesNotExist:
bill_gp_id = None
if (bill_gp_id is None) or (gp.id == b.gov_proposal.id):
# b is not linked to gp, or linked to the current gp
gp.bill = b
gp.save()
else:
logger.debug("processing gp %d - matching bill (%d) already has gp"
" (%d)" % (gp.id, b.id, b.gov_proposal.id))
else: # update a given GovProposal
gp.booklet_number = data['booklet']
gp.knesset_id = k_id
gp.source_url = data['link']
gp.title = title
gp.law = law
gp.date = data['date']
gp.save()
gp.bill.title = title
gp.bill.law = law
gp.bill.save()
b = gp.bill
if (link_file is not None) and (link_file.link is None):
link = Link(title=pdf_link, url=pdf_link,
content_type=ContentType.objects.get_for_model(gp),
object_pk=str(gp.id))
link.save()
link_file.link = link
link_file.save()
logger.debug("check updated %s" % b.get_absolute_url())
def update_db_from_files(self):
logger.debug("Update DB From Files")
try:
laws = [] # of lists: [name,name_for_search,explanation,link]
f = gzip.open(os.path.join(DATA_ROOT, 'laws.tsv.gz'))
content = f.read().split('\n')
for line in content:
law = line.split('\t')
if len(law) == 3:
name_for_search = self.get_search_string(law[0])
law.insert(1, name_for_search)
laws.append(law)
f.close()
parties = dict() # key: party-name; value: Party
members = dict() # key: member-name; value: Member
votes = dict() # key: id; value: Vote
memberships = dict() # key: (member.id,party.id)
current_max_src_id = Vote.objects.aggregate(Max('src_id'))['src_id__max']
if current_max_src_id == None: # the db contains no votes, meaning its empty
current_max_src_id = 0
logger.debug("processing votes data")
f = gzip.open(os.path.join(DATA_ROOT, 'votes.tsv.gz'))
content = f.read().split('\n')
for line in content:
if len(line) <= 1:
continue
(vote_id, vote_src_url, vote_label, vote_meeting_num, vote_num, vote_time_string, _, _, _,
_) = line.split('\t')
# if vote_id < current_max_src_id: # skip votes already parsed.
# continue
vote_time_string = vote_time_string.replace(' ', ' ')
for i in self.heb_months:
if i in vote_time_string:
month = self.heb_months.index(i) + 1
day = re.search("""(\d\d?)""", vote_time_string).group(1)
year = re.search("""(\d\d\d\d)""", vote_time_string).group(1)
vote_hm = datetime.datetime.strptime(vote_time_string.split(' ')[-1], "%H:%M")
vote_date = datetime.date(int(year), int(month), int(day))
vote_time = datetime.datetime(int(year), int(month), int(day), vote_hm.hour, vote_hm.minute)
vote_label_for_search = self.get_search_string(vote_label)
# if vote_date < datetime.date(2009, 02, 24): # vote before 18th knesset
# continue
try:
v = Vote.objects.get(src_id=vote_id)
created = False
except:
v = Vote(title=vote_label, time_string=vote_time_string, importance=1, src_id=vote_id,
time=vote_time)
try:
vote_meeting_num = int(vote_meeting_num)
v.meeting_number = vote_meeting_num
except:
pass
try:
vote_num = int(vote_num)
v.vote_number = vote_num
except:
pass
v.src_url = vote_src_url
for law in laws:
(_, law_name_for_search, law_exp, law_link) = law
if vote_label_for_search.find(law_name_for_search) >= 0:
v.summary = law_exp
v.full_text_url = law_link
v.save()
if v.full_text_url != None:
l = Link(title=u'מסמך הצעת החוק באתר הכנסת', url=v.full_text_url,
content_type=ContentType.objects.get_for_model(v), object_pk=str(v.id))
l.save()
votes[int(vote_id)] = v
f.close()
logger.debug("processing member votes data")
f = gzip.open(os.path.join(DATA_ROOT, 'results.tsv.gz'))
content = f.read().split('\n')
for line in content:
if len(line) < 2:
continue
s = line.split('\t') # (id,voter,party,vote)
vote_id = int(s[0])
voter = s[1]
voter_party = s[2]
# transform party names to canonical form
if voter_party in CANONICAL_PARTY_ALIASES:
voter_party = CANONICAL_PARTY_ALIASES[voter_party]
vote = s[3]
try:
v = votes[vote_id]
except KeyError: # this vote was skipped in this read, also skip voteactions and members
continue
vote_date = v.time.date()
# create/get the party appearing in this vote
if voter_party in parties:
party = parties[voter_party]
created = False
else:
party, created = Party.objects.get_or_create(name=voter_party)
parties[voter_party] = party
# if created: # this is magic needed because of unicode chars. if you don't do this, the object p will have gibrish as its name.
# only when it comes back from the db it has valid unicode chars.
# use this vote's time to update the party's start date and end date
if (party.start_date is None) or (party.start_date > vote_date):
party.start_date = vote_date
if (party.end_date is None) or (party.end_date < vote_date):
party.end_date = vote_date
if created: # save on first time, so it would have an id, be able to link, etc. all other updates are saved in the end
party.save()
# create/get the member voting
if voter in members:
member = members[voter]
created = False
else:
try:
member = Member.objects.get(name=voter)
except: # if there are several people with same age,
member = Member.objects.filter(name=voter).order_by('-date_of_birth')[
0] # choose the younger. TODO: fix this
members[voter] = member
# use this vote's date to update the member's dates.
if (member.start_date is None) or (member.start_date > vote_date):
member.start_date = vote_date
if (member.end_date is None) or (member.end_date < vote_date):
member.end_date = vote_date
# if created: # save on first time, so it would have an id, be able to link, etc. all other updates are saved in the end
# m.save()
# create/get the membership (connection between member and party)
if ((member.id, party.id) in memberships):
ms = memberships[(member.id, party.id)]
created = False
else:
ms, created = Membership.objects.get_or_create(member=member, party=party)
memberships[(member.id, party.id)] = ms
# if created: # again, unicode magic
# ms = Membership.objects.get(member=m,party=p)
# again, update the dates on the membership
if (ms.start_date is None) or (ms.start_date > vote_date):
ms.start_date = vote_date
if (ms.end_date is None) or (ms.end_date < vote_date):
ms.end_date = vote_date
if created: # save on first time, so it would have an id, be able to link, etc. all other updates are saved in the end
ms.save()
# add the current member's vote
va, created = VoteAction.objects.get_or_create(vote=v, member=member, type=vote,
party=member.current_party)
if created:
va.save()
logger.debug("done")
logger.debug(
"saving data: %d parties, %d members, %d memberships " % (len(parties), len(members), len(memberships)))
for party in parties:
parties[party].save()
for member in members:
members[member].save()
for ms in memberships:
memberships[ms].save()
logger.debug("done")
f.close()
except Exception:
logger.exception('Update db from file exception')
def get_notifications(user_id):
user = User.objects.get(id=user_id)
notification = NotificationSummary()
notification.notifications_count = Notification.unseen_notifications_count(user)
notification.links_count = Link.links_count(user)
return notification
def test_link_decode_pads_keys(self):
key = 'xx'
pk = Link.decode(key)
self.assertEqual(pk, '\xc7')
def get_pk_from_key(self, key):
try:
pk = int(Link.decode(str(key)))
except ValueError:
pk = None
return pk
casting_user.set_password("p@$$w0rd")
casting_user.save()
# Create my_user.
my_user = MyUser(user=casting_user, type='C', activation_key='')
my_user.save()
# Create user's casting profile.
casting_profile = CastingProfile(user=casting_user, my_user=my_user)
casting_profile.save()
# Make the user, admin member of their respective organization.
member = OrganizationMember(organization=org, initiator=casting_user, user=casting_user, role='ADM', is_accepted=True, is_rejected=False)
member.save()
# Make the casting user, an attendee of the "SETC" event.
attendee = EventAttendee(event=event, organization=org, attendee=casting_user, is_accepted=True, is_rejected=False)
attendee.save()
# Link casting user to Matthew.
link = Link(from_user=matthew_user, to_user=casting_user, optional_message="", is_accepted=True, is_rejected=False)
link.save()
print "Casting Users - DONE"
i = 0
def GET(self):
links = Link.all().order('sort')
return render('admin/links.html', links=links)
def clone(request):
user = request.user.get_profile()
if 'school' in request.GET:
try:
school = School.objects.get(slug=request.GET['school'])
except School.DoesNotExist:
return http.HttpResponseRedirect(reverse('projects_clone'))
else:
school = None
if request.method == 'POST':
form = project_forms.CloneProjectForm(school, request.POST)
if form.is_valid():
base_project = form.cleaned_data['project']
project = Project(name=base_project.name,
short_description=base_project.short_description,
long_description=base_project.long_description,
school=base_project.school, clone_of=base_project)
project.save()
act = Activity(actor=user,
verb='http://activitystrea.ms/schema/1.0/post',
project=project,
target_project=project)
act.save()
participation = Participation(project=project, user=user, organizing=True)
participation.save()
new_rel = Relationship(source=user, target_project=project)
try:
new_rel.save()
except IntegrityError:
pass
detailed_description = Page(title=_('Full Description'), slug='full-description',
content=base_project.detailed_description.content, listed=False,
author_id=user.id, project_id=project.id)
detailed_description.save()
project.detailed_description_id = detailed_description.id
sign_up = Page(title=_('Sign-Up'), slug='sign-up',
content=base_project.sign_up.content, listed=False, editable=False,
author_id=user.id, project_id=project.id)
sign_up.save()
project.sign_up_id = sign_up.id
project.save()
tasks = Page.objects.filter(project=base_project, listed=True,
deleted=False).order_by('index')
for task in tasks:
new_task = Page(title=task.title, content=task.content, author=user,
project=project)
new_task.save()
links = Link.objects.filter(project=base_project).order_by('index')
for link in links:
new_link = Link(name=link.name, url=link.url, user=user, project=project)
new_link.save()
messages.success(request, _('The study group has been cloned.'))
return http.HttpResponseRedirect(reverse('projects_show', kwargs={
'slug': project.slug,
}))
else:
messages.error(request,
_("There was a problem cloning the study group."))
else:
form = project_forms.CloneProjectForm(school)
return render_to_response('projects/project_clone.html', {
'form': form, 'clone_tab': True, 'school': school,
}, context_instance=RequestContext(request))
def event_queue(request):
def save_details(event):
data=request.POST
event.title=data['title']
event.link=data['link'] or None
event.cost=data['cost'] or None
tz=request.site.tz
event.start=tz.localize(parser.parse(data['start']))
event.end=tz.localize(parser.parse(data['end']))
if request.POST.has_key('tags'):
event.tags=[t.strip() for t in request.POST.get("tags","").lower().split(',')]
event.put()
timezone=pytz.timezone(request.site.timezone)
pending_events=request.site.event_set.filter('status = ', 'submitted')
today=utc.localize(datetime.utcnow()).astimezone(timezone).date()
pending_events_future=pending_events.filter('local_start >=', today).order('local_start').fetch(50)
if request.method == 'POST' and request.POST.has_key('button'):
profile=get_current_profile()
if request.POST['button'] == 'Reject' and (profile.userlevel == 10):
event_results=request.site.event_set.filter(' __key__ =', db.Key(request.POST['event_key']) )
event=event_results.get()
event.status="rejected-%s" % request.POST.get('rejection-reason','unspecified')
event.put()
messages.add_message(request, messages.INFO,'Rejected! Feels good, right?')
if request.POST['button'] == 'Save':
event_results=request.site.event_set.filter(' __key__ =', db.Key(request.POST['event_key']) )
event=event_results.get()
if profile.userlevel == 10:
save_details(event)
messages.add_message(request, messages.INFO,'%s saved' % event.title)
if request.POST['button'] == 'Approve':
event_results= request.site.event_set.filter(' __key__ =', db.Key(request.POST['event_key']) )
event=event_results.get()
if profile.userlevel == 10:
event.status='approved'
event.approved_by=profile
event.approved_on=datetime.now()
save_details(event)
messages.add_message(request, messages.INFO,'%s approved' % event.title)
if request.POST['button'] == 'Back to queue':
event_results= request.site.event_set.filter(' __key__ =', db.Key(request.POST['event_key']) )
event=event_results.get()
if profile.userlevel == 10:
event.status='submitted'
event.approved_by=None
event.approved_on=None
save_details(event)
messages.add_message(request, messages.INFO,'%s sent back' % event.title)
request.site.expire_assets()
if request.POST.has_key('return'):return HttpResponseRedirect(request.POST['return'])
pending_events=request.site.event_set.filter('status = ', 'submitted')
has_pending_sources=submitted_icals=ICalendarSource.all().filter('status =', 'submitted').get()
has_pending_links=Link.all().filter('status =','submitted').get()
return render_to_response('events/queue.html', locals(), context_instance=RequestContext(request))
def update_members_from_file(self):
logger.debug('update_members_from_file')
f = gzip.open(os.path.join(DATA_ROOT, 'members.tsv.gz'))
content = f.read().split('\n')
for line in content:
if len(line) <= 1:
continue
(member_id, name, img_url, phone, fax, website, email,
family_status, number_of_children, date_of_birth,
year_of_birth, place_of_birth, date_of_death,
year_of_aliyah, k18, k19, _) = line.split('\t')
if email != '':
email = email.split(':')[1]
try:
if date_of_birth.find(',') >= 0:
date_of_birth = date_of_birth.split(',')[1].strip(' ')
date_of_birth = datetime.datetime.strptime(date_of_birth, "%d/%m/%Y")
except:
date_of_birth = None
try:
if date_of_birth.find(',') >= 0:
date_of_death = date_of_birth.split(',')[1].strip(' ')
date_of_death = datetime.datetime.strptime(date_of_death, "%d/%m/%Y")
except:
date_of_death = None
try:
year_of_birth = int(year_of_birth)
except:
year_of_birth = None
try:
year_of_aliyah = int(year_of_aliyah)
except:
year_of_aliyah = None
try:
number_of_children = int(number_of_children)
except:
number_of_children = None
try:
m = Member.objects.get(id=member_id)
m.phone = phone
m.fax = fax
m.email = email
m.family_status = family_status
m.number_of_children = number_of_children
m.date_of_death = date_of_death
m.save()
logger.debug('updated member %d' % m.id)
except Member.DoesNotExist: # member_id not found. create new
m = Member(id=member_id, name=name, img_url=img_url, phone=phone, fax=fax, website=None, email=email,
family_status=family_status,
number_of_children=number_of_children, date_of_birth=date_of_birth,
place_of_birth=place_of_birth,
date_of_death=date_of_death, year_of_aliyah=year_of_aliyah)
m.save()
m = Member.objects.get(pk=member_id) # make sure we are are
# working on the db object. e.g m.id is a number.
logger.debug('created member %d' % m.id)
if len(website) > 0:
l = Link(title='אתר האינטרנט של %s' % name, url=website,
content_type=ContentType.objects.get_for_model(m), object_pk=str(m.id))
l.save()
if k19: # KNESSET 19 specific
parties = Party.objects.filter(knesset_id=19).values_list('name', 'id')
k19 = k19.decode(ENCODING)
for k, v in parties:
if k in k19:
m.current_party_id = int(v)
logger.debug('member %s, k19 %s, party %s'
% (m.name,
k19,
k))
m.save()
if m.current_party is None:
logger.debug('member %s, k19 %s not found' %
(m.name,
k19))
def import_from_old_site(request):
user = request.user.get_profile()
if 'school' in request.GET:
try:
school = School.objects.get(slug=request.GET['school'])
except School.DoesNotExist:
return http.HttpResponseRedirect(reverse('projects_clone'))
else:
school = None
if request.method == 'POST':
form = project_forms.ImportProjectForm(school, request.POST)
if form.is_valid():
course = form.cleaned_data['course']
project = Project(name=course['name'],
short_description= course['short_description'],
long_description=course['long_description'],
school=course['school'], imported_from=course['slug'])
project.save()
act = Activity(actor=user,
verb='http://activitystrea.ms/schema/1.0/post',
project=project,
target_project=project)
act.save()
participation = Participation(project=project, user=user, organizing=True)
participation.save()
new_rel = Relationship(source=user, target_project=project)
try:
new_rel.save()
except IntegrityError:
pass
if course['detailed_description']:
detailed_description_content = course['detailed_description']
else:
detailed_description_content = render_to_string(
"projects/detailed_description_initial_content.html",
{})
detailed_description = Page(title=_('Full Description'), slug='full-description',
content=detailed_description_content, listed=False,
author_id=user.id, project_id=project.id)
detailed_description.save()
project.detailed_description_id = detailed_description.id
sign_up_content = render_to_string("projects/sign_up_initial_content.html",
{})
sign_up = Page(title=_('Sign-Up'), slug='sign-up',
content=sign_up_content, listed=False, editable=False,
author_id=user.id, project_id=project.id)
sign_up.save()
project.sign_up_id = sign_up.id
project.save()
for title, content in course['tasks']:
new_task = Page(title=title, content=content, author=user,
project=project)
new_task.save()
for name, url in course['links']:
new_link = Link(name=name, url=url, user=user, project=project)
new_link.save()
messages.success(request, _('The study group has been imported.'))
return http.HttpResponseRedirect(reverse('projects_show', kwargs={
'slug': project.slug,
}))
else:
messages.error(request,
_("There was a problem importing the study group."))
else:
form = project_forms.ImportProjectForm(school)
return render_to_response('projects/project_import.html', {
'form': form, 'import_tab': True, 'school': school,
}, context_instance=RequestContext(request))
