def delete_category(blog_id, category_id, confirm='N'):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
category = Category.load(category_id, blog_id=blog.id)
auth.check_category_editing_lock(blog)
tags = template_tags(blog=blog, user=user)
from core.utils import Status
if request.forms.getunicode('confirm') == user.logout_nonce:
message = 'Category {} successfully deleted'.format(category.for_log)
url = '{}/blog/{}/categories'.format(BASE_URL, blog.id)
action = 'Return to the category listing'
reparent_categories = Category.update(
parent_category=category.parent_category).where(
Category.parent_category == category)
reparent_categories.execute()
delete_category = PageCategory.delete().where(
PageCategory.category == category.id)
delete_category.execute()
category.delete_instance()
tags.status = Status(type='success',
message=message,
action=action,
url=url,
close=False)
else:
message = (
'You are about to delete category <b>{}</b> from blog <b>{}</b>.'.
format(category.for_display, blog.for_display))
yes = {
'label': 'Yes, delete this category',
'id': 'delete',
'name': 'confirm',
'value': user.logout_nonce
}
no = {
'label': 'No, return to category properties',
'url': '{}/blog/{}/category/{}'.format(BASE_URL, blog.id,
category.id)
}
tags.status = Status(message=message,
type='warning',
close=False,
yes=yes,
no=no)
tags.category = category
return report(tags, 'blog_delete_category', category)
def test_get_cates_order_by_article_count(self):
insert_amount = 10
prefix = 'testcate'
with self.app.test_request_context(), self.db.atomic():
cates = [dict(id=prefix + str(i), name=prefix + str(i))
for i in range(insert_amount)]
Category.insert_many(cates).execute()
for index, cate in enumerate(cates):
articles = [dict(id=str(index) + str(i), title='hello',
text_type='md', source_text='# hello',
category=cate['id'])
for i in range((index + 1) * 2)]
Article.insert_many(articles).execute()
resp = self.client.get(self.api_url_base + '/categories/',
query_string={'order': 'article_count',
'desc': 'true'})
self.assertResponseRestfulAndSuccess(resp)
categories = self.get_json(resp)['categories']
result_counts = [cate['article_count'] for cate in categories]
expected_counts = sorted(result_counts, reverse=True)
self.assertListEqual(result_counts, expected_counts)
def blog_create(**new_blog_data):
new_blog = Blog()
new_blog.site = new_blog_data['site'].id
new_blog.name = new_blog_data['name']
new_blog.description = new_blog_data['description']
new_blog.url = new_blog_data['url']
new_blog.path = new_blog_data['path']
new_blog.local_path = new_blog.path
new_blog.theme = new_blog_data['theme']
new_blog.save()
new_blog_default_category = Category(blog=new_blog,
title="Uncategorized",
default=True)
new_blog_default_category.save()
# template installation should be its own function
# install whatever the currently set system default templates are
user = user_from_ka(**new_blog_data)
logger.info("Blog {} created on site {} by user {}.".format(
new_blog.for_log, new_blog.site.for_log, user.for_log))
return new_blog
def test_get_articles_filter_by_nonexist_category(self):
from random import choice
insert_amount_per_cate = 30
category_amount = 3
cate_prefix = 'cate'
article_prefix = 'art'
with self.app.test_request_context(), self.db.atomic():
cates = [
dict(id=cate_prefix + str(i), name=cate_prefix + str(i))
for i in range(category_amount)
]
Category.insert_many(cates).execute()
cate_to_insert = choice(cates)['id']
articles = [
dict(id=article_prefix + str(i),
title=article_prefix,
text_type=article_prefix,
source_text=article_prefix,
category=cate_to_insert)
for i in range(insert_amount_per_cate)
]
Article.insert_many(articles).execute()
resp = self.client.get(self.api_url_base + '/articles/',
query_string={
'limit': insert_amount_per_cate,
'category': cate_to_insert + '_'
})
self.assertResponseRestful(resp)
articles = self.get_json(resp)['articles']
self.assertEqual(len(articles), 0)
def create_categories_recursive(self, categories, parent=None):
for name in categories:
category = Category(name=name, parent=parent, channel=self.channel)
category.save()
self.categories.append(category)
if isinstance(categories, dict):
subcategories = categories[name]
if subcategories:
self.create_categories_recursive(subcategories, category)
def migrate_categories():
f = open("innovonet-migration-2016-05-11/category.json", "r")
d = f.read()
f.close()
data_cats = json.loads(d)
for row in data_cats['RECORDS']:
data_obj = Category(name=row['name'])
data_obj.save()
def create_category():
"""``POST`` |API_URL_BASE|/category/:category_id
Create a category.
:param id: **JSON Param**, required
:param name: **JSON Param**, required
Response JSON:
.. code-block:: javascript
// success
{
$errors: null,
category: {
id: string,
name: string,
article_count: integer
}
}
// failed
{
$errors: {
id: 'this id is invalid.',
name: 'this name is invalid.',
id: 'this id is duplicated.'
}
}
Permission: ``CREATE_CATEGORY``
"""
json = request.get_json()
name = json.get('name', '').strip()
if not name:
return {'name': '请输入有效的分类名'}
id = json.get('id', '')
if not re_match(app_config['CATEGORY_ID_PATTERN'], id):
return {'id': app_config['CATEGORY_ID_DESCRIPTION']}
if Category.select().where(Category.id == id).count() == 1:
return {'id': '该分类ID %s 已存在' % id}
if Category.select().where(Category.name == name).count() == 1:
return {'name': '该分类名 %s 已存在' % name}
new_category = Category.create(id=id, name=name)
signals.event_emitted.send(current_app._get_current_object(),
type='Category: Create',
description='category(%s) has been create.' %
new_category.id)
return None, {'category': new_category.to_dict()}
def migrate_categories():
f = open("innovonet-migration-2016-05-11/category.json", "r")
d = f.read()
f.close()
data_cats = json.loads(d)
for row in data_cats['RECORDS']:
data_obj = Category(name=row['name'])
data_obj.save()
def _create_category(wealth, name, type, parent=None):
category = Category(
wealth=wealth,
name=name,
parent=parent,
total_balance=0,
balance=0,
type=type)
category.save()
return category
def test_get_channels_categories_is_up(self, client, initial_data):
channel = initial_data['channel']
categories = ['Books', 'National Literature', 'Science Fiction']
Category.create_channel_categories(channel=channel,
categories=categories)
url = reverse('core:category_list',
kwargs={'channel': initial_data['channel'].pk})
response = client.get(url)
assert response.status_code == 200
def setUp(self):
"""Define the test variables."""
self.channel_name = "test"
self.category_name = 'Games'
self.subcategories_names = ['XBOX One', 'XBOX 360', 'Playstation 4']
self.channel = Channel(name=self.channel_name)
self.category = Category(name=self.category_name)
self.subcategories = [
Category(name=category_name)
for category_name in self.subcategories_names
]
def new_category(blog_id):
from core.models import db
with db.atomic() as txn:
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_editor(user, blog)
category_list = [n for n in blog.categories]
category = Category(id=0,
title='',
blog=blog)
top_level_category = Category(
id=None,
title='[Top-level category]',
parent=None
)
category_list.insert(0, top_level_category)
tags = template_tags(
blog=blog,
user=user)
if request.method == "POST":
with db.atomic() as txn:
category_title = request.forms.getunicode('category_title')
try:
parent_category = int(request.forms.getunicode('category_parent'))
except ValueError:
parent_category = None
with db.atomic() as txn:
category = Category(blog=blog,
title=category_title,
parent_category=parent_category
)
category.save()
redirect('{}/blog/{}/category/{}'.format(
BASE_URL, blog.id, category.id))
tpl = template('edit/category',
category=category,
category_list=category_list,
menu=generate_menu('blog_new_category', category),
search_context=(search_contexts['sites'], None),
**tags.__dict__)
return tpl
def test_models_catagory(self):
slug = get_unique_slug(Category, "Test title")
self.assertEqual(slug, "test-title")
category_obj = Category(title="Test title")
category_obj.save()
self.assertEqual(category_obj.slug, "test-title")
self.assertEqual(str(category_obj), "Test title")
slug = get_unique_slug(Category, "Test title")
self.assertEqual(slug, "test-title-1")
def create(self, validated_data):
# {'name': 'new category 4'}
# name='new category 4'
category = Category(**validated_data)
category.save()
return category
def add_category(cls, request):
if request.method == 'POST':
form = CategoryForm(request.POST)
if form.is_valid():
name = request.POST['name']
new_category = Category(name=name)
new_category.save()
return HttpResponseRedirect("/manager/kategorie/")
else:
form = CategoryForm()
return render_to_response('backpanel_new_category.html',
{'form': form},
context_instance=RequestContext(request))
def add_category(cls, request):
if request.method == 'POST':
form = CategoryForm(request.POST)
if form.is_valid():
name = request.POST['name']
new_category = Category(name=name)
new_category.save()
return HttpResponseRedirect("/manager/kategorie/")
else:
form = CategoryForm()
return render_to_response('backpanel_new_category.html',
{'form': form},
context_instance=RequestContext(request))
def make_category(request):
if request.method == 'POST':
form = CategoryCreateForm(request.POST)
if form.is_valid():
new_category = Category()
new_category.name = form.cleaned_data['category']
new_category.save()
return redirect(to='staff')
else:
form = CategoryCreateForm()
return render(request, 'core/make_category.html', {
'form' : form,
})
class ModelTestCase(TestCase):
"""Test suite for the channel and category models."""
def setUp(self):
"""Define the test variables."""
self.channel_name = "test"
self.category_name = 'Games'
self.subcategories_names = ['XBOX One', 'XBOX 360', 'Playstation 4']
self.channel = Channel(name=self.channel_name)
self.category = Category(name=self.category_name)
self.subcategories = [
Category(name=category_name)
for category_name in self.subcategories_names
]
def test_model_can_create_a_channel(self):
"""Test the channel model can create a channel."""
old_count = Channel.objects.count()
self.channel.save()
new_count = Channel.objects.count()
self.assertNotEqual(old_count, new_count)
def test_model_can_create_categories(self):
"""Test the category model can create a category."""
self.channel.save()
self.category.channel = self.channel
self.category.save()
old_count = Category.objects.count()
for category in self.subcategories:
category.parent = self.category
category.channel = self.channel
category.save()
new_count = Category.objects.count()
self.assertNotEqual(old_count, new_count)
def test_model_can_overwrite_a_channel_categories(self):
"""Test the category model can create a category."""
self.channel.save()
self.category.channel = self.channel
self.category.save()
old_count = Category.objects.count()
for category in self.subcategories:
category.parent = self.category
category.channel = self.channel
category.save()
new_count = Category.objects.count()
self.assertNotEqual(old_count, new_count)
old_count = new_count
Category.objects.filter(channel=self.channel).delete()
new_count = Category.objects.count()
self.assertNotEqual(old_count, new_count)
def test_get_cates(self):
insert_amount = 30
prefix = 'testcate'
with self.app.test_request_context(), self.db.atomic():
cates = [dict(id=prefix + str(i), name=prefix + str(i))
for i in range(insert_amount)]
Category.insert_many(cates).execute()
resp = self.client.get(self.api_url_base + '/categories/')
self.assertResponseRestfulAndSuccess(resp)
categories = self.get_json(resp)['categories']
self.assertEqual(len(categories), insert_amount)
nums = [int(cate['name'][len(prefix):]) for cate in categories]
self.assertListEqual(nums, list(range(insert_amount)))
def save(self):
parent = self.cleaned_data['parent']
if parent == 'inc' or parent == 'exp':
parent = None
category = Category(
wealth=self.wealth,
type=self.category_type,
parent=parent,
name=self.cleaned_data['text'],
description=self.cleaned_data['description'],
balance=0,
total_balance=0)
category.save()
return category
def handle(self, channel_name, categories_filename, *args, **options):
if not isfile(categories_filename):
raise CommandError('The specified filename does not exist.')
try:
channel = Channel.objects.get(name=channel_name)
self.stdout.write('Overwriting channel %s...' % channel_name)
Category.objects.filter(channel=channel).delete()
except Channel.DoesNotExist:
self.stdout.write('Creating channel %s...' % channel_name)
channel = Channel(name=channel_name)
channel.save()
categories_paths = []
created_categories = []
with open(categories_filename, 'rt', encoding='utf8') as inp:
# TODO Check the parent category is in the db if its not found in created_categories
# (may happen if the file is not sorted)
for line in inp:
category_path = line.strip().replace('\n', '')
if category_path != '':
categories_paths.append(category_path)
last_slash_pos = category_path.rfind('/')
parent = None
parent_path = ''
parent_name = ''
if last_slash_pos != -1:
parent_path = category_path[:last_slash_pos].strip()
parent_last_slash_pos = parent_path.rfind('/')
parent_name = parent_path[parent_last_slash_pos +
1:].strip()
for created_category in reversed(created_categories):
if created_category.name == parent_name:
parent = created_category
break
if not parent:
self.stderr.write(
'Could not find the parent of category %s (check the file is sorted).'
% category_path)
category_name = category_path[last_slash_pos + 1:].strip()
self.stdout.write('Creating category %s...' %
category_path)
category = Category(name=category_name,
channel=channel,
parent=parent)
category.save()
created_categories.append(category)
n_categories = len(created_categories)
self.stdout.write('Channel %s was imported with %i categories.' %
(channel_name, n_categories))
def __init__(self, request, *args, **kwargs):
super(SystemObject, self).__init__(request, *args, **kwargs)
self.urls.add = 'core.view.categoryadmin.add_item'
self.urls.edit = 'core.view.categoryadmin.edit_item'
self.urls.show_items = 'core.view.categoryadmin.show_items'
self.manager = AdminManager()
self.manager.fetchOptions = {
'site': self.portal.activeSite.id,
'active': self.requester.rData['selectedactivity'],
'activesite': self.requester.rData['activesite']
}
self.manager.model = Category()
self.manager.modelLanguage = CategoryLanguage()
self.manager.form_class = AdmItemForm().__class__
self.manager.language_form_class = AdmItemLanguageForm().__class__
self.manager.order = 'parent'
self.manager.debugger.filename = 'categoryadmin.py'
self.manager.moduleName = '__adm_Categories__'
self.data.update(
{'filter_activity': reverse('core.view.categoryadmin.show_items')})
toppanel = {}
self.data.update({'toppanel': toppanel})
self.data.update({
'savebutton': 1,
'saveaddbutton': 1,
'copybutton': 1,
'addbutton': 1
})
self.requester.rData['selectedmenu'] = -1
def get_a_category(id):
"""``GET`` |API_URL_BASE|/category/:category_id
Get a category.
Response JSON:
.. code-block:: javascript
// success
{
$errors: null,
category: {
id: string,
name: string,
article_count: integer
]
}
Permission: ``READ_CATEGORY``
"""
try:
category = Category.get(Category.id == id)
except Category.DoesNotExist:
return {'id': '该分类不存在'}
return None, {'category': category.to_dict()}
def handle(self, *args, **options):
Category.objects.all().delete()
url = settings.LIB_CATEGORIES_URL
result = requests.get(url)
html = result.text
soup = BeautifulSoup(html, 'lxml')
ul_genre_list = soup.find('ul', class_='genre-list')
categories = [h2.text for h2 in ul_genre_list.find_all('h2')]
sublist = [
tag.text.strip()
for tag in ul_genre_list.find_all('ul', class_='genre-sublist')
]
subcategories = list(
map(lambda categories: categories.split('\n'), sublist))
category_dict = dict(zip(categories, subcategories))
for category in enumerate(category_dict, 1):
cat_model = Category.objects.create(id=category[0],
name=category[1])
for subcategory in category_dict[category[1]]:
Category(name=subcategory, parent=cat_model).save()
def new_impress_service(request):
context = {'categories': Category.create_choices_category()}
if request.method == 'GET':
form = ServiceForm()
context.update({'form': form})
return render(request, 'dashboard_admin/new_impress_service.html',
context)
else:
form = ServiceForm(request.POST, request.FILES)
context.update({'form': form})
if form.is_valid():
category_id = int(request.POST.get('category'))
category = Category.objects.get(id=category_id)
service = ServiceImpress()
service.description = form.cleaned_data['description']
service.image = form.cleaned_data['image']
service.category = category
service.value = Service.change_for_decimal(
form.cleaned_data['value'])
service.value_creation_art = \
Service.change_for_decimal(form.cleaned_data['value_creation_art'])
service.deadline = form.cleaned_data['deadline']
service.save()
messages.success(request, 'Novo serviço criado com sucesso!')
return HttpResponseRedirect(
reverse('dashboard_admin:all_services'))
else:
messages.error(request, form.errors)
return render(request, 'dashboard_admin/new_impress_service.html',
context)
def validate_category(self, value):
""" Validate Category is available """
value = re_strip(str(value))
category = Category.choicefield_filter(value)
if category.exists():
return category.first()
raise serializers.ValidationError(
"Sorry, that category does not exist!")
def test_item(self):
category = Category(name='Test', module='marketplace')
item = Item(user=self.user,
title='foo',
category=category,
price=10.00)
serializer = SearchSerializer(item, context={'auth_user': self.user})
self.assertEqual(serializer.data['label'], 'foo')
self.assertEqual(serializer.data['data']['price'], '10.00')
def setUp(self):
self.profile = Profile(username='******', spent_time=133)
self.profile.save()
category1 = Category(name="Категория1",
profile=self.profile,
spent_time=63)
category1.save()
category2 = Category(name="Категория2",
profile=self.profile,
spent_time=70)
category2.save()
def test_delete_non_empty_cate(self):
with self.app.test_request_context():
cate = Category.create(id='testcate', name='testcate')
Article.create(id='testart', title='testart',
text_type='md', source_text='# hello',
category=cate)
resp = self.client.delete(self.api_url_base + '/category/' + cate.id)
self.assertResponseRestful(resp)
self.assertResponseErrorInField(resp, 'not_empty')
def test_modify_cate_using_illegal_name(self):
with self.app.test_request_context():
cate = Category.create(id='testcate', name='testcate')
payload_json = {'name': ''}
resp = self.client.patch(self.api_url_base + '/category/' + cate.id,
content_type='application/json',
data=json_dumps(payload_json))
self.assertResponseRestful(resp)
self.assertResponseErrorInField(resp, 'name')
def handle(self, *args, **options):
channel, _ = Channel.objects.get_or_create(name=options['channel'])
Category.objects.filter(channel=channel).delete()
with open(options['file']) as categories_file:
categories_reader = csv.reader(categories_file)
next(categories_reader)
for row in categories_reader:
count = Category.create_channel_categories(channel, row[0].split(' / '))
self.stdout.write('Processed {} Categories'.format(count))
self.stdout.write(self.style.SUCCESS('Categories imported!'))
def category_create(request):
if request.method == "POST":
form = CategoryForm(request.user, request.POST)
if form.is_valid():
name = form.cleaned_data["name"]
Category(name=name, user=request.user).save()
messages.success(request, "Entry sucessfully saved.")
return redirect("core:category_management")
else:
form = CategoryForm(request.user)
return render(request, "core/category_create.html", {"form": form})
def edit_service(request, service_id):
try:
service = ServiceImpress.objects.get(id=service_id)
except:
service = Service.objects.get(id=service_id)
infos_categories = Category.get_names_and_id()
current_category = service.category
context = {
'service': service,
'infos_categories': infos_categories,
'current_category': service.category.id
}
if request.method == 'GET':
data = {
'description': service.description,
'image': service.image.url,
'value': service.value,
}
if service.__class__.__name__ == 'ServiceImpress':
data['value_creation_art'] = service.value_creation_art
form = ServiceForm(initial=data)
context.update({'form': form})
else:
form = ServiceForm(request.POST, request.FILES)
if form.is_valid():
category = Category.objects.get(
id=int(request.POST.get('category')))
service.description = form.cleaned_data['description']
if form.cleaned_data['image']:
service.image = form.cleaned_data['image']
service.category = category
service.value = Service.change_for_decimal(
form.cleaned_data['value'])
if service.__class__.__name__ == 'ServiceImpress':
service.value_creation_art = \
Service.change_for_decimal(form.cleaned_data['value_creation_art'])
service.save()
context.update({'form': form})
context.update({'current_category': service.category.id})
messages.success(request, 'Serviço editado com sucesso!')
else:
# print(form.errors)
messages.warning(request,
'Não foi possível realizar essa operação')
return render(request, 'dashboard_admin/edit_service.html', context)
def test_delete_cate(self):
self.login_as_su()
with self.app.test_request_context():
cate = Category.create(id='testcate', name='testcate')
resp = self.client.delete(self.api_url_base + '/category/' + cate.id)
self.assertResponseRestfulAndSuccess(resp)
resp = self.get_category(cate.id)
self.assertResponseRestful(resp)
self.assertResponseErrorInField(resp, 'id')
def test_command_delete(self, mock_get_products):
"""
Test for the command : python manage.py database --delete
"""
mock_get_products.return_value = Mock()
mock_get_products.return_value.json.return_value = mock_api_return
# Register a category for the test.
cat = Category(name='test_category')
cat.save()
# Register a product for the test.
Product(name='prod_name',
code='1',
nutrition_grade='a',
image_nutrition_url='image_nutrition_url',
image_small_product_url='image_small_product_url',
image_full_product_url='image_full_product_url',
url='url',
category=cat).save()
category_count_before_del = Category.objects.all().count()
product_count_before_del = Product.objects.all().count()
out = StringIO()
call_command('database', '--delete', stdout=out)
category_count_after_del = Category.objects.all().count()
product_count_after_del = Product.objects.all().count()
# Before delete
self.assertEqual(category_count_before_del, 1)
self.assertEqual(product_count_before_del, 1)
# After delete
self.assertEqual(category_count_after_del, 0)
self.assertEqual(product_count_after_del, 0)
self.assertIn('1 products and 1 categories deleted', out.getvalue())
def category_context(fileinfo, original_page, tag_context, date_counter):
if fileinfo is None:
category_context = PageCategory.select(PageCategory.category).where(
PageCategory.page == original_page)
else:
category_context = PageCategory.select(PageCategory.category).where(
PageCategory.category == Category.select().where(Category.id == fileinfo.category).get())
page_constraint = PageCategory.select(PageCategory.page).where(PageCategory.category << category_context)
tag_context_next = tag_context.select().where(Page.id << page_constraint)
return tag_context_next, date_counter
def blog_pages_in_category(blog_id, category_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_editor(user, blog)
errormsg = auth.check_category_editing_lock(blog, True)
from core.models import Category
category = Category.load(category_id, blog_id=blog.id)
return listing(request, category, category.pages,
'blog', 'blog_pages_in_category',
user=user,
errormsg=errormsg,
search_ui='blog_pages_in_category',
search_context=blog_pages_in_category_search_results,
tags_data={'blog':blog}
)
def blog_import (blog_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_publisher(user, blog)
reason = auth.check_template_lock(blog, True)
tags = template_tags(blog=blog,
user=user)
import os, settings
import_path = os.path.join(
settings.APPLICATION_PATH,
"data",
"import.json")
tags.status = reason
if request.method == "POST":
from core.models import db
tpl = ''
with db.atomic() as txn:
import json
from core.utils import string_to_date
import_path = request.forms.getunicode('import_path')
with open(import_path, 'r', encoding='utf8') as f:
json_data = json.load(f)
from core.models import page_status, MediaAssociation, Category
from core.error import PageNotChanged
from core.libs.peewee import InterfaceError
from core.cms import media_filetypes
format_str = "<b>{}</b> / (<i>{}</i>)"
# TODO: go in chunks of 50 or something?
# allow graceful disconnection?
for n in json_data:
q = []
n_id = n['id']
q.append("Checking {}".format(n_id))
changed = False
found = False
match = Page.kv_get('legacy_id', n_id)
if match.count() > 0:
if match[0].object_ref.blog == blog:
found = True
q.append(match[0].key + "/" + match[0].value + " / Exists: " + format_str.format(n['title'], n_id))
existing_entry = Page.load(match[0].objectid)
update = existing_entry.kv_get('update').count()
# raise Exception(update)
q.append('{} / {}'.format(string_to_date(n['modified_date']).replace(tzinfo=None), existing_entry.modified_date
))
if string_to_date(n['modified_date']).replace(tzinfo=None) <= existing_entry.modified_date and update == 0:
q.append('Existing page {} not changed.'.format(existing_entry.id))
else:
changed = True
q.append('Updating data for existing page {}.'.format(existing_entry.id))
existing_entry.title = n['title']
existing_entry.text = n['text']
existing_entry.basename = n['basename']
existing_entry.excerpt = n['excerpt']
existing_entry.created_date = string_to_date(n['created_date']).replace(tzinfo=None)
existing_entry.modified_date = string_to_date(n['modified_date']).replace(tzinfo=None)
existing_entry.publication_date = string_to_date(n['publication_date']).replace(tzinfo=None)
try:
existing_entry.save(user, False, False, 'New revision from import')
except PageNotChanged:
pass
except InterfaceError:
raise Exception("Error saving {}. Check the JSON to make sure it's valid.".format(n_id))
for media in existing_entry.media:
media.kv_del()
existing_entry.clear_categories()
existing_entry.clear_kvs()
existing_entry.clear_tags()
existing_entry.clear_media()
entry = existing_entry
if found is False:
q.append("Creating: " + format_str.format(n['title'], n_id))
changed = True
new_entry = Page(
title=n['title'],
text=n['text'],
basename=n['basename'],
excerpt=n['excerpt'],
user=user,
blog=blog,
created_date=string_to_date(n['created_date']),
publication_date=string_to_date(n['publication_date']),
modified_date=string_to_date(n['modified_date']),
)
new_entry.modified_date = new_entry.publication_date
if n['status'] in ('Publish', 'Published', 'Live'):
new_entry.status = page_status.published
new_entry.save(user)
entry = new_entry
q.append("New ID: {}".format(entry.id))
# Everything from here on out is
if changed:
# Register a legacy ID for the page
entry.kv_set("legacy_id", n["id"])
entry.kv_set("legacy_user", n["user_id"])
# Category assignments
categories = n['categories']
if categories == []:
saved_page_category = PageCategory.create(
page=entry,
category=blog.default_category,
primary=True).save()
else:
primary = True
for category in categories:
cat_exists = False
category_id = category['id']
existing_category = Category.kv_get('legacy_id', category_id)
if existing_category.count() > 0:
if existing_category[0].object_ref.blog == blog:
cat_exists = True
if cat_exists is False:
q.append('Created new category {}/{}'.format(
category_id, category['name']
))
new_category = Category.create(
blog=blog,
title=category['name'],
parent_category=getattr(category, 'parent', None)
)
new_category.save()
new_category.kv_set('legacy_id',
category_id
)
else:
new_category = Category.load(existing_category[0].objectid)
q.append('Added to existing category {}/{}'.format(
new_category.id, category['name']
))
saved_page_category = PageCategory.create(
page=entry,
category=new_category,
primary=primary
).save()
primary = False
# Check to make sure a default category exists for the whole blog.
# If not, assign one based on the lowest ID.
# This can always be reassigned later.
# Register tags
tags_added, tags_existing, _ = Tag.add_or_create(
n['tags'], page=entry)
q.append('Tags added: {}'.format(','.join(n.tag for n in tags_added)))
q.append('Tags existing: {}'.format(','.join(n.tag for n in tags_existing)))
# Register KVs
kvs = n['kvs']
for key in kvs:
if key != "":
value = kvs[key]
entry.kv_set(key, value)
q.append('KV: {}:{}'.format(key, value))
# Register media
media = n['media']
for m in media:
if 'path' not in m:
continue
path = os.path.split(m['path'])
try:
new_media = Media.get(Media.url == m['url'])
except:
new_media = Media(
filename=path[1],
path=m['path'],
url=m['url'],
type=media_filetypes.image,
created_date=string_to_date(m['created_date']),
modified_date=string_to_date(m['modified_date']),
friendly_name=m['friendly_name'],
user=user,
blog=blog,
site=blog.site
)
# TODO: RBF
try:
new_media.save()
except Exception:
continue
media_association = MediaAssociation(
media=new_media,
page=entry)
media_association.save()
# Save legacy ID to KV on media
if 'id' in m:
new_media.kv_set('legacy_id', m['id'])
q.append('IMG: {}'.format(new_media.url))
# add tags for media
q.append('Tags: {}'.format(m['tags']))
new_tags = Tag.add_or_create(m['tags'], media=new_media)
kvs = m['kvs']
for key in kvs:
value = kvs[key]
new_media.kv_set(key, value)
q.append('KV: {}:{}'.format(key, value))
fileinfo.build_pages_fileinfos((entry,))
fileinfo.build_archives_fileinfos((entry,))
tpl += ('<p>'.join(q)) + '<hr/>'
return tpl
# TODO:
# Import or create categories as needed
# Categories in export will need to have parent-child data
# categories should have legacy identifiers where possible too
# Import image files, assign those legacy KV identifiers
# Modify URLs for imported images in posts
# Make importing of image assets optional
else:
tpl = template('ui/ui_blog_import',
menu=generate_menu('blog_import', blog),
# search_context=(search_context['blog'], blog),
import_path=import_path,
**tags.__dict__)
return tpl
def test_create_categories_from_list(self, initial_data):
channel = initial_data['channel']
categories = ['Books', 'National Literature', 'Science Fiction']
created = Category.create_channel_categories(channel=channel,
categories=categories)
assert created == len(categories)
def edit_category(blog_id, category_id):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
category = Category.load(category_id, blog_id=blog.id)
auth.check_category_editing_lock(blog)
category_list = [n for n in blog.categories]
top_level_category = Category(
id=None,
title='[Top-level category]',
parent=None
)
category_list.insert(0, top_level_category)
tags = template_tags(
blog=blog,
user=user)
from core.utils import Status
status = []
if request.method == "POST":
new_category_title = request.forms.getunicode('category_title')
old_category_title = category.title
if new_category_title != old_category_title:
category.title = new_category_title
category.save()
status.append(
['Category <b>{}</b> was renamed to <b>{}</b>.',
[old_category_title, new_category_title]])
old_parent_category = category.parent_category
try:
new_parent_category = int(request.forms.getunicode('category_parent'))
except ValueError:
new_parent_category = None
new_basename = request.forms.getunicode('category_basename')
if category.basename != new_basename:
category.basename = new_basename
category.save()
status.append(['Category basename was changed.',
[]])
if old_parent_category != new_parent_category:
category.parent_category = new_parent_category
category.save()
if new_parent_category is not None:
new_category = Category.load(
category_id=new_parent_category,
blog=blog)
else:
new_category = top_level_category
status.append(['Category <b>{}</b> was reparented to <b>{}</b>.',
[category.title, new_category.for_log]])
if request.forms.getunicode('default') == "Y":
clear_default_categories = Category.update(
default=False).where(
Category.blog == blog,
Category.default == True)
clear_default_categories.execute()
category.default = True
category.save()
status.append(['Category <b>{}</b> was set to default for blog <b>{}</b>.',
[category.title, blog.for_log]])
if len(status) > 0:
message = ''
vals = []
for n in status:
message += n[0]
for m in n[1]:
vals.append(m)
vals.append('{}/blog/{}/purge'.format(BASE_URL, blog.id))
tags.status = Status(type='success',
message=message + '<br/><a href="{}">Purge and republish this blog</a> to make these changes take effect.',
vals=vals)
# from core.ui_kv import kv_ui
from core.ui import kv
kv_ui_data = kv.ui(category.kv_list())
from core.ui import sidebar
tags.sidebar = sidebar.render_sidebar(
panel_set='edit_category',
# status_badge=status_badge,
kv_object='Category',
kv_objectid=category.id,
kv_ui=kv_ui_data)
tpl = template('edit/category',
category=category,
category_list=category_list,
menu=generate_menu('blog_edit_category', category),
search_context=(search_contexts['sites'], None),
**tags.__dict__)
return tpl
def delete_category(blog_id, category_id, confirm='N'):
user = auth.is_logged_in(request)
blog = Blog.load(blog_id)
permission = auth.is_blog_admin(user, blog)
category = Category.load(category_id, blog_id=blog.id)
auth.check_category_editing_lock(blog)
tags = template_tags(
blog=blog,
user=user)
from core.utils import Status
if request.forms.getunicode('confirm') == user.logout_nonce:
message = 'Category {} successfully deleted'.format(
category.for_log)
url = '{}/blog/{}/categories'.format(BASE_URL, blog.id)
action = 'Return to the category listing'
reparent_categories = Category.update(
parent_category=category.parent_category).where(
Category.parent_category == category)
reparent_categories.execute()
delete_category = PageCategory.delete().where(
PageCategory.category == category.id)
delete_category.execute()
category.delete_instance()
tags.status = Status(
type='success',
message=message,
action=action,
url=url,
close=False)
else:
message = ('You are about to delete category <b>{}</b> from blog <b>{}</b>.'.format(
category.for_display,
blog.for_display))
yes = {
'label':'Yes, delete this category',
'id':'delete',
'name':'confirm',
'value':user.logout_nonce}
no = {
'label':'No, return to category properties',
'url':'{}/blog/{}/category/{}'.format(
BASE_URL, blog.id, category.id)
}
tags.status = Status(
message=message,
type='warning',
close=False,
yes=yes,
no=no
)
tags.category = category
return report(tags, 'blog_delete_category', category)
def test_expense_model(self):
c1 = Category(name='food')
c2 = Category(name='doctor')
c3 = Category(name='entertainment')
c4 = Category(name='ride')
c1.save()
c2.save()
c3.save()
c4.save()
u1 = User(username='******', email='*****@*****.**', first_name='soonmo', last_name='kwon')
u1.save()
u2 = User(username='******', email='*****@*****.**', first_name='soonuck', last_name='kwon')
u2.save()
item1 = Item(dollar_amount=100.00, team_member=u1, category=c2, activity_date=(date(year=2013, month=7, day=23)))
item1.save()
item2 = Item(dollar_amount=52.25, team_member=u2, category=c3, activity_date=(date(year=2013, month=7, day=22)))
item2.save()
def get_or_create_category(each_deal_data_dict, categories_dict, shortcut=False):
'''
* 'shortcut' option is for simply retreiving the category object.
'''
category_slug = each_deal_data_dict['category_slug']
category_name = each_deal_data_dict['category_name']
if category_slug == 'retail-services':
category_slug = 'shopping-services'
category_name = 'Shopping & Services'
if not category_slug:
return None # In case where Sqoot doesn't show any category for a given deal
try:
category_model = Category.objects.get(code=category_slug, ref_id_source='sqoot')
except Category.DoesNotExist:
category_model = Category(ref_id_source='sqoot', code=category_slug, name=category_name)
category_model.save()
if shortcut:
return category_model
parent_slug = categories_dict[category_slug]
if parent_slug:
try:
parent_category = Category.objects.get(code=parent_slug, ref_id_source='sqoot')
category_model.parent = parent_category
except Category.DoesNotExist:
parent_category = Category(ref_id_source='sqoot', code=parent_slug)
parent_category.save()
category_model.parent = parent_category
else:
category_model.parent = None
# In case it was already created as another category's parent (hence save outside try-except)
category_model.name = category_name
category_model.save()
return category_model
def save_page(page, user, blog=None):
'''
Saves edits to a page in the CMS.
Note that this function does _not_ perform permission checking. In other words, it doesn't
verify if the user described in the `user` parameter does in fact have permissions to
edit the page in question.
:param page:
Page object whose data is to be saved. If this is None, then it is assumed that we are
creating a new page.
:param user:
The user object associated with the save action for this page. If this is a newly-created page,
the page's user will be set to this.
:param blog:
The blog object under which the page will be created, if this is a newly-created page.
'''
getunicode = request.forms.getunicode
# invalidate_cache()
save_action = int(request.forms.get('save'))
original_page_status = page_status.unpublished
new_basename = getunicode('basename')
if page is None:
# CREATE NEW PAGE ENTRY
page = Page()
page.user = user.id
page.blog = blog.id
page.basename = create_basename(getunicode('page_title'),
page.blog)
original_page_basename = page.basename
time_now = datetime.datetime.utcnow()
page.publication_date = time_now
page.created_date = time_now
else:
# UPDATE EXISTING ENTRY
# Queue neighbor actions for page BEFORE modification
if page.status == page_status.published:
if not (save_action & save_action_list.UNPUBLISH_PAGE):
queue_page_actions((page.next_page, page.previous_page),no_neighbors=True, no_archive=True)
queue_page_archive_actions(page)
original_page_status = page.status
original_page_basename = page.basename
page.modified_date = datetime.datetime.utcnow()
change_basename = False
if new_basename is not None:
if new_basename == "":
change_basename = True
new_basename = create_basename(getunicode('page_title'),
page.blog)
if new_basename != original_page_basename:
change_basename = True
new_publication_date = datetime.datetime.strptime(
request.forms.get('publication_date'), DATE_FORMAT)
if change_basename:
page.basename = create_basename(new_basename, page.blog)
page.publication_date = page._date_to_utc(page.blog.timezone, new_publication_date).replace(tzinfo=None)
page.title = getunicode('page_title')
page.text = getunicode('page_text')
page.status = page_status.modes[int(request.forms.get('publication_status'))]
page.tag_text = getunicode('page_tag_text')
page.excerpt = getunicode('page_excerpt')
change_note = getunicode('change_note')
msg = []
# UNPUBLISH
if (
(save_action & save_action_list.UNPUBLISH_PAGE and page.status == page_status.published) or # unpublished a published page
(original_page_status == page_status.published and page.status == page_status.unpublished) # set a published page to draft
):
unpublish_page(page)
msg.append("Page <b>{}</b> unpublished successfully.")
# SET UNPUBLISHED TO PUBLISHED
elif original_page_status == page_status.unpublished and (save_action & save_action_list.UPDATE_LIVE_PAGE):
page.status = page_status.published
msg.append("Set to publish.")
# SAVE DRAFT
if (save_action & save_action_list.SAVE_TO_DRAFT):
try:
save_result = page.save(user, False, False, change_note)
except PageNotChanged:
save_result = (None, None)
msg.append("Page <b>{}</b> saved successfully.")
# Assign categories for page
categories = []
for n in request.forms.allitems():
if n[0][:8] == 'cat-sel-':
try:
category_id = int(n[0][8:])
except ValueError:
category_id = None
else:
categories.append(category_id)
if not categories:
categories.append(blog.default_category.id)
msg.append(" Default category auto-assigned for page.")
page_categories = []
primary = None
for n in page.categories:
if n.category.id not in categories:
delete_category = PageCategory.delete().where(
PageCategory.id == n.id)
delete_category.execute()
else:
page_categories.append(n.category.id)
if n.primary is True:
primary = n
for n in categories:
if n not in page_categories:
new_page_category = PageCategory.create(
page=page,
category=Category.load(n, blog_id=page.blog.id),
primary=False)
if primary is None:
n = page.categories[0]
n.primary = True
n.save()
delete_page_fileinfo(page)
build_archives_fileinfos((page,))
build_pages_fileinfos((page,))
# UPDATE TAGS
if getunicode('tag_text') is not None:
import json
tag_text = json.loads(getunicode('tag_text'))
add_tags_to_page(tag_text, page)
delete_orphaned_tags(page.blog)
# QUEUE CHANGES FOR PUBLICATION (if any)
if ((save_action & save_action_list.UPDATE_LIVE_PAGE)
and (page.status == page_status.published)):
queue_ssi_actions(page.blog)
queue_page_actions((page,))
queue_index_actions(page.blog)
msg.append(" Live page updated.")
# DETECT ANY PAGE CHANGES
if (
(save_action & (save_action_list.SAVE_TO_DRAFT + save_action_list.UPDATE_LIVE_PAGE))
and (save_result[1]) is None):
msg.append(" (Page unchanged.)")
# RETURN REPORT
tags = template_tags(page=page, user=user)
status = Status(
type='success',
message=' / '.join(msg),
vals=(page.for_log,)
)
tags.status = status
tags._save_action = save_action
tags._save_action_list = save_action_list
return tags
