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 _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 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