def _get_nfzm_article(self, url, date, issue): medium = Medium.objects.get(pk=951) article = Article() article.medium = medium article.issue = issue article.url = url article.publication_date = date r = requests.get(url, cookies={'PHPSESSID': 'l19dgbf6ticijmo9ka9osvufk0'}) content = bs4.BeautifulSoup(r.content) article.title = content.title.string.split('-')[-1].strip() article.content = content.find('section', {'id' : 'articleContent'}).text author = content.find('span', {'class' : 'author'}).find_all('em') if author[1].text.find(u'南方周末记者') != -1: author, created = Journalist.objects.get_or_create(medium=medium, name=author[2].text.strip()) if not created: article.author = author elif author[1].text.find(u'南方周末特约撰稿') != -1: article.author_name = author[2].text.strip() elif author[1].text.find(u'南方周末编辑部') != -1: article.author_name = u'南方周末编辑部' print article.author or article.author_name return article
def _get_whb_article(self, url, date,issue, page): medium = Medium.objects.get(pk=1399) soup = bs4.BeautifulSoup(requests.get(url).content) for title in soup.find('div', {'id' : 'BT'}).find_all('a'): article_page_url = urljoin(url, title.get('href')) r = requests.get(article_page_url) if r.status_code == 404: continue article_page = bs4.BeautifulSoup( r.content) if Article.objects.filter(medium=medium).filter(url=article_page_url).count(): article = Article.objects.filter(medium=medium).get(url=article_page_url) else: article = Article() article.medium = medium article.url = article_page_url article.publication_date = date article.page = page.text.strip() article.issue = issue print article_page_url title = article_page.title.text.strip().replace(u'文汇报 - ', '') article.title = title article.content = article_page.find('div', {'id' : 'articleText'}).text.strip().replace(u' ', '\n ') article.save()
def make_test_article(self): article = Article() article.title = 'Article on something.' article.lead_text_trevor = put_text_in_trevor('abc') article.main_text_trevor = put_text_in_trevor('abc') article.author = self.user return article
def home(request,article_id=None): article_obj=None if article_id: article_obj = Article.objects.get(id = article_id) user=User.objects.get(id = request.session['id']) if request.method == 'POST': form=ArticleForm(request.POST) if form.is_valid(): title = form.cleaned_data['title'] content = form.cleaned_data['content'] if article_id: article_obj.title = title article_obj.content = content article_obj.modified_at = datetime.datetime.now() article_obj.save() else: insert_db=Article(title = form.cleaned_data['title'], content = form.cleaned_data['content'], created_by=request.session['username'], ) insert_db.save() return HttpResponseRedirect('/') else: if article_id: if (user.is_superuser or (article_obj.created_by == request.session['username'])): form=ArticleForm(initial = {'title': article_obj.title,'content' : article_obj.content}) else: return HttpResponseRedirect('/') else: form = ArticleForm() context_variables = RequestContext(request) return render_to_response('article_index.html',locals(),context_variables)
def _get_zgqnb_article(self, url, date, page_name): print url medium = Medium.objects.get(pk=1836) urls = bs4.BeautifulSoup(requests.get(url).content).find('div', {'id' : 'titleList'}).find_all('a') for a in urls: article_url = urljoin(url, a.get('href')) soup = bs4.BeautifulSoup(requests.get(article_url).content) title = soup.find('h1').text print title article = Article() article.medium = medium article.title = title article.url = article_url article.publication_date = date article.page = page_name p_list = [] for p in soup.find('div', {'id' : 'ozoom'}).find_all('p'): p_list.append(p.text) content = '\n'.join(p_list) article.content = content if Article.objects.filter(medium=medium).filter(url=article_url).count(): article = Article.objects.filter(medium=medium).get(url=article_url) article.content = content article.save()
def fetch_articles(): articles = list() if not DEBUG: sql = """ SELECT p.ID, p.post_title, u.display_name as author, p.post_date_gmt FROM `wp_posts` p, `wp_users` u WHERE p.post_author = u.ID AND p.post_type = 'post' AND p.post_status = 'publish' ORDER BY p.post_date_gmt DESC """ else: sql = """ select a.id, a.subject, b.first_name, a.update_date_time from articles_article a, auth_user b where a.author_id = b.id order by a.create_date_time desc limit 10 """ connection = get_connection() cursor = connection.cursor() cursor.execute(sql) for row in cursor.fetchall(): article = Article() article.id = row[0] article.subject = row[1] article.create_date_time = row[3] articles.append(article) connection.close() return articles
class ArticleTest(TestCase): def setUp(self): # create the objects needed self.client = Client() self.article = Article() self.user = User(username='******') self.user.set_password('google') self.user.is_active = True self.user.save() def tearDown(self): self.client = None self.article = None self.user = None def test_save(self): self.article.headline = 'Unit Testing' self.article.summary = 'Unit Testing' # required fields self.article.creator = self.user self.article.creator_username = self.user.username self.article.owner = self.user self.article.owner_username = self.user.username self.article.status = True self.article.status_detail = 'active' self.article.enclosure_length = 0 self.article.timezone = 'America/Chicago' self.article.save() self.assertEquals(type(self.article.id), long)
def add_new(request): # get information from POST method if request.method == 'POST': title = request.POST['title'] story = request.POST['story'] # if author is anonymous try: is_anonymous = request.POST['anonymous'] author = 'Аноним' except: author = request.POST['author'] # if user don't enter any of the required fields if title == '' or story == '' or author == '': msg = 'Пожалуйста, заполните все поля.' return render(request, 'articles/addnew.html', {'msg': msg}) else: # save new story to database a = Article(article_title=title, article_text=story, article_author=author) a.save() link = 'http://the-trembling.info/articles/administration/list/{0}/'.format(a.id) mail_body = story + '\n-----------------------------------------\n' + 'Автор: ' + author + '\n' + link send_mail(title, mail_body, '*****@*****.**', ['*****@*****.**'], fail_silently=False) return HttpResponseRedirect(reverse('articles:index')) else: return render(request, 'articles/addnew.html')
def test_new_to_review_mails(self): author = testing.create_user() reviewer_a = testing.create_user(perms=['content.review']) testing.create_user(perms=['content.review']) # There are two reviewers, both should receive an email about the new # article added by Alice. article = Article.create_for_testing(author) send_new_to_review_mails(article) self.assertEqual(len(mail.outbox), 2) # Only one email should be sent when an approver adds a new article - # only the other one can review it. article = Article.create_for_testing(reviewer_a) send_new_to_review_mails(article) self.assertEqual(len(mail.outbox), 3) # https://github.com/ppiet/piosenka/issues/8 # Set the first reviewers's email to empty - they should now be skipped, # but the other reviewer should be notified. reviewer_a.email = '' reviewer_a.save() article = Article.create_for_testing(author) send_new_to_review_mails(article) self.assertEqual(len(mail.outbox), 4)
def create_article(request): """ Création d'un article Il faut être connecté et avoir les bons droits """ user = request.user if request.method == 'POST': form = CreateArticleForm(request.POST) if form.is_valid(): title = form.cleaned_data['title'] intro = form.cleaned_data['intro'] content = form.cleaned_data['content'] # sauvegarde de l'article article = Article(title=title, intro=intro, content=content, author=user) article.save() # on redirige vers l'article créé return redirect("get_article", slug=article.slug) else: form = CreateArticleForm() return render(request, "articles/create_article.html", locals())
def test_create_article(self): """ Tests that an article can be created """ article = Article(name='name',header='header') article.save() self.assertEqual(article.creation_date.date(), article.last_updated_date.date())
def create_articles(self, emails): """Attempts to post new articles based on parsed email messages""" created = [] site = Site.objects.get_current() ack = self.config.get("acknowledge", False) autopost = self.config.get("autopost", False) # make sure we have a valid default markup markup = self.config.get("markup", MARKUP_HTML) if markup not in (MARKUP_HTML, MARKUP_MARKDOWN, MARKUP_REST, MARKUP_TEXTILE): markup = MARKUP_HTML for num, email in emails.iteritems(): name, sender = parseaddr(email["From"]) try: author = User.objects.get(email=sender, is_active=True) except User.DoesNotExist: # unauthorized sender self.log("Not processing message from unauthorized sender.", 0) continue # get the attributes for the article title = email.get("Subject", "--- article from email ---") content = self.get_email_content(email) try: # try to grab the timestamp from the email message publish_date = datetime.fromtimestamp(time.mktime(parsedate(email["Date"]))) except StandardError, err: self.log( "An error occurred when I tried to convert the email's timestamp into a datetime object: %s" % (err,) ) publish_date = datetime.now() # post the article article = Article( author=author, title=title, content=content, markup=markup, publish_date=publish_date, is_active=autopost, ) try: article.save() self.log("Article created.") except StandardError, err: # log it and move on to the next message self.log("Error creating article: %s" % (err,), 0) continue
def test_article_can_count_links_in_its_body(self): a = G(Article, raw_content='this article has two links http://devcharm.com and https://127.0.0.1:8000') self.assertEqual(a.count_own_links(), 2) # This should work for 0 links too a.raw_content = 'No links here' self.assertEqual(a.count_own_links(), 0) # And we should also be able to use the static method directly: self.assertEqual(Article.count_links('this article has one link http://devcharm.com'), 1) # Duplicate links should not be counted twice self.assertEqual(Article.count_links('this article has one link http://devcharm.com http://devcharm.com'), 1)
def add_article(request): if request.POST['title'] and request.POST['text']: a = Article(title=request.POST['title'], article_text=request.POST['text'], date_change=timezone.now()) a.save() return HttpResponseRedirect(reverse('index')) else: return render(request, 'articles/article.html', { 'new': True, 'error_message': "Поля не должны быть пустыми", })
def handle(self, *args, **options): #self.stdout.write(*args) with open(*args, encoding='utf-8') as data_file: json_data = json.loads(data_file.read()) for record in json_data: result = Article( title=record['fields']['title'], text=record['fields']['text'], published_at=record['fields']['published_at'], image=record['fields']['image'], ) result.save()
def setUp(self): # création d'un admin admin = User.objects.create_user('admin', password='******') admin.is_staff = True admin.save() self.admin = admin # création d'un utilisateur sans droit reader = User.objects.create_user('reader', password='******') reader.save() self.reader = reader # création d'un utilisateur ayant des droits writer = User.objects.create_user('writer', password='******') writer.has_perm('articles.add_article') writer.save() self.writer = writer # création de plusieurs articles a1 = Article(title="titre 1", content="content 1", author=writer, views=1) a1.save() a2 = Article(title="titre 2", content="content 2", author=admin, likes=1) a2.save()
def Bibtex_parser(file,collection_name): # Generate bibtex parser and import the uploaded file parser = bibtex.Parser() bib_data = parser.parse_file(file) items = bib_data.entries.keys() # Check to is if this is already a collection try: # If already exists, make current col = Collection.objects.get(name=collection_name) except: # If is doesn't exist, start a new one col = Collection(name=collection_name) col.save() for item in items: a = bib_data.entries[item].fields['author'].replace('{','').replace('}','') try: j = bib_data.entries[item].fields['journal'].replace('{','').replace('}','') except: j = "N/A" try: v = int(bib_data.entries[item].fields['volume']) except: v = 0 try: p = bib_data.entries[item].fields['pages'] except: p = "N/A" try: y = int(bib_data.entries[item].fields['year']) except: y = 0 t = bib_data.entries[item].fields['title'].replace('{','').replace('}','').capitalize() # put all the information together # Check to see if this article has been put in this collection before try: # This article exists in this collection already, so do nothing Article.objects.get(title=t,collection=col) except: # A new article for this collection, put it in ref = Article(author_list=a,journal=j,volume=v,pages=p,year=y,title=t,collection=col) ref.save() del ref
def db_put(link): html_doc = urllib2.urlopen(link).read() soup = BeautifulSoup(html_doc, "html.parser") new_article = Article(title=tcparser.get_title(soup), \ website=tcparser.get_site_name(soup), \ url=link, \ authors=tcparser.get_author(soup), \ twitter=tcparser.get_twitter(soup), \ date=tcparser.get_date(soup), \ content=tcparser.get_contents(soup), \ image=tcparser.get_image(soup)) new_article.save()
def save_article(request): title = request.POST.get('title', None) cover_image = request.FILES.get('cover-image', None) if cover_image: save_path = os.path.join(settings.MEDIA_ROOT, '', cover_image.name) path = default_storage.save(save_path, cover_image) cover_image = cover_image.name member_name = request.POST.get('member-name', None) member_title = request.POST.get('member-title', None) attribute = request.POST.get('attribute', None) region = request.POST.get('region', None) category = request.POST.get('category', None) creation_date = request.POST.get('creation_date', datetime.now().replace(microsecond=0)) if creation_date == '': creation_date = datetime.now().replace(microsecond=0) content = request.POST.get('content', None) free_link_1_anchor = request.POST.get('free-link-1-anchor', None) free_link_1_url = request.POST.get('free-link-1-url', None) free_link_2_anchor = request.POST.get('free-link-2-anchor', None) free_link_2_url = request.POST.get('free-link-2-url', None) free_link_3_anchor = request.POST.get('free-link-3-anchor', None) free_link_3_url = request.POST.get('free-link-3-url', None) free_links = {} if free_link_1_anchor and free_link_1_url: free_links[free_link_1_anchor] = free_link_1_url if free_link_2_anchor and free_link_2_url: free_links[free_link_2_anchor] = free_link_2_url if free_link_3_anchor and free_link_3_url: free_links[free_link_3_anchor] = free_link_3_url user = request.user brand = Brand.objects.filter(user=user).first() article = Article(title=title, brand=brand, cover_image=cover_image, member_name=member_name, member_title=member_title, attribute=attribute, region=region, category=category, creation_date=creation_date, content=content, free_links=free_links) article.save() return redirect('brand_admin_dashboard')
def handle(self, *args, **options): if options['json_path']: with open(os.path.join(settings.BASE_DIR, options['json_path'][0]), 'r') as json_file: articles = json.load(json_file) for article in articles: art = Article( article['pk'], article['fields']['title'], article['fields']['text'], article['fields']['published_at'], article['fields']['image'], ) art.save()
def migrate_posts(self, author): from articles.models import Article timezone = get_current_timezone() for item in self.items: if item["type"] in ("page", "post"): print " migrating page : " + item["title"] a = Article( title=item["title"] + "(PAGE)", content=item["content"], author=author, publish_date=make_aware(datetime.datetime.strptime(item["date"], "%Y-%m-%d %H:%M:%S"), timezone), ) a.save() print " ...done"
def deserialize_news_data(data): # list of articles articles = [] # get count of articles article_count = len(data['articles']) i = 0 # iterate through each article and save object to database while i < article_count: source_name = data['articles'][i]['source']['name'] author = data['articles'][i]['author'] # Handles null author values from News API if author is None: author = source_name title = data['articles'][i]['title'] description = data['articles'][i]['description'] image_url = data['articles'][i]['urlToImage'] url = data['articles'][i]['url'] published_at_str = str(data['articles'][i]['publishedAt']) try: published_at = datetime.datetime.strptime(published_at_str, '%Y-%m-%dT%H:%M:%SZ') except ValueError: published_at = datetime.datetime.now() category = get_category_name(source_name) # only add article if url doesn't exist in DB if not Article.objects.filter(url=url).exists(): article = Article(source_name=source_name, author=author, title=title, description=description, image_url=image_url, url=url, published_at=published_at, category=category) article.save() articles.append(article) i = i + 1 return articles
def addArticle(request): article = Article() article.title = request.POST.get('title', '') article.abstract = request.POST.get('abstract', '') article.category_id = request.POST.get('categorie'); article.content = request.POST.get('content', '') article.author = User.objects.get(id=request.user.id) try: article.save() return HttpResponseRedirect('/articles/read') except: return HttpResponseRedirect('/')
def articles(request, page_name=None): c = get_common_context(request) if page_name is None: c['title'] = u'Статьи' items = Article.objects.all() paginator = Paginator(items, PAGINATION_COUNT) page = int(request.GET.get('page', '1')) try: items = paginator.page(page) except PageNotAnInteger: page = 1 items = paginator.page(page) except EmptyPage: page = paginator.num_pages items = paginator.page(page) c['page'] = page c['page_range'] = paginator.page_range if len(c['page_range']) > 1: c['need_pagination'] = True c['items'] = items return render_to_response('articles.html', c, context_instance=RequestContext(request)) else: b = Article.get_by_slug(page_name) c['title'] = b.name c['p'] = b return render_to_response('page.html', c, context_instance=RequestContext(request))
def post(self, request: Request, article_id: str) -> HttpResponse: """Create an `ArticleVersion`. :param request: class: `Request` :param article_id: str :return: class: `HttpResponse` """ if not article_id or not Article.id_is_valid(article_id): return Response({'error': 'Please provide a valid article id'}, status=status.HTTP_400_BAD_REQUEST) run_id = self.get_run_id(request) with transaction.atomic(): article, created = Article.objects.get_or_create(id=article_id) with message_publisher('article.version.post', run_id=run_id): article_version = ArticleVersion.objects.create(version=article.next_version, article=article) for content_item in request.data.get('content-list', []): Content.objects.create(article_version=article_version, **content_item) if settings.AIRFLOW_ACTIVE: start_article_dag(run_id=run_id, article_id=article_id, article_version=article_version.version, article_version_id=article_version.id) return Response(status=status.HTTP_201_CREATED, headers=self.response_headers(request))
def article_page(request, art_slug): c = get_common_context(request) try: c['a'] = Article.get_by_slug(art_slug) return render_to_response('article.html', c, context_instance=RequestContext(request)) except: raise Http404()
def handle(self, *args, **options): URL = "https://cloud.nousdigital.net/s/rNPWPNWKwK7kZcS/download" r = requests.get(url=URL) items_data = r.json() for item in items_data["items"]: if not Article.objects.filter(title=item["title"]): try: title, description, image_url = item["title"], item[ "description"], item["imageUrl"] #valid_image = is_url_image(image_url) article_object = Article(title=title, description=description, image_url=image_url) article_object.save() except: pass
def create_article(): user = current_identity if user.is_not_author() and user.is_not_admin(): pass title = request.json.get('title') description = request.json.get('description') body = request.json.get('body') tags_input = request.json.get('tags') categories_input = request.json.get('categories') tags = [] categories = [] for category in categories_input: categories.append( get_or_create(db.session, Category, {'description': category.get('description', None)}, name=category['name'])[0]) for tag in tags_input: tags.append(get_or_create(db.session, Tag, {'description': tag.get('description')}, name=tag['name'])[0]) user_id = user.id article = Article(title=title, description=description, body=body, user_id=user_id, tags=tags, categories=categories) db.session.add(article) db.session.commit() response = {'full_messages': ['Article created successfully']} response.update(ArticleDetailsSerializer(article).data) return jsonify(response)
def get_data(data_type='article', category='new'): if data_type == 'article' and category not in ['new', 'page']: logging.error( "Category must be 'new' or 'page' (for front page articles)") return [] hn = httplib.HTTPConnection('api.ihackernews.com') # get the endpoint for the api query path = category if data_type == 'article' else 'newcomments' hn.request('GET', '/' + path) r1 = hn.getresponse() if r1.status == 200: try: text = r1.read() data_dict = json.loads(text) except Exception, e: logging.error('Failed to parse Json response: %s', e) return [] # get the list of either comments or articles based on data_type if data_type == 'article': if category == 'new': # only need the first 5 articles - will improve the sort time later (this list is already sorted) data_dict['items'] = data_dict['items'][:5] data_list = [Article(**i) for i in data_dict['items']] else: data_list = [ArtComment(**i) for i in data_dict['comments'][:5]] if data_type != 'article' or category == 'new': # list is already sorted return (True, data_list[:5]) else: # need to sort to find the newest front page articles return (True, sorted(data_list)[:5])
def run_dayily_schedule(crollers): count = 0 for croller in crollers: croller = croller() for title, url, preface, img_url in croller.feed(): if Article.objects.filter(url=url).exists(): continue article = Article(title=title, url=url, preface=preface, img_url=img_url) print(vars(article)) article.save() count += 1 time.sleep(10) print('{0} articles registered.'.format(count))
def handle(self, *args, **options): Tag.objects.bulk_create([Tag(tag=t[0], slug=t[1]) for t in tags], ignore_conflicts=True) names = generate_username(int(options["num_users"])) User = get_user_model() users = [ User.objects.create_user(username=n, password=self.password) for n in names ] print(users) gen = DocumentGenerator() gen.init_word_cache(5000) gen.init_sentence_cache(5000) for user in users: user = User.objects.get(username=user.username) user.profile.bio = gen.sentence() user.profile.save() articles = Article.objects.bulk_create([ Article( slug=make_slug(gen.sentence()), title=gen.sentence(), description=gen.sentence(), body=gen.paragraph(), author=user.profile, ) # Make sure every user has at least 1 article for _ in range(random.randrange(1, self.article_upper_bound)) ]) print(articles) # Make sure every article has 1 tag, could add more later for article in articles: article.tags.add(Tag.objects.get(slug=random.choice(tags)[1])) self.stdout.write(self.style.SUCCESS(f"Created {len(users)} users"))
def insert(**overrides): article_data = make_article(**overrides) article = Article(**article_data) db_session.add(article) db_session.commit() return article
def get_rt_media_showable_data(media_id): from articles.models import Article from statistics.models import (RealTimeMedia, DailyMedia, RealTimeArticle) from articles.consts import STATUS_PUBLISHED, STATUS_OFFLINE, STATUS_ADMIN_OFFLINE site_url = media_utils.gen_site_url(media_id) articles = Article.objects(media_id=str(media_id), status__in=[STATUS_PUBLISHED, STATUS_OFFLINE, STATUS_ADMIN_OFFLINE]).only('language', 'online_seq_id') articles = sorted((article for article in articles if article.online_seq_id), key=lambda x: x.language) rt_read_count = 0 for lang, _articles in groupby(articles, lambda x: x.language): online_seq_ids = [article.online_seq_id for article in _articles] with context_managers.switch_db(RealTimeArticle, 'statistics') as RealTimeArticle: rt_stats = RealTimeArticle.objects(online_seq_id__in=online_seq_ids, lang=lang).only('read_count') rt_read_count += sum([normalize_count(stat.read_count) for stat in rt_stats]) with context_managers.switch_db(RealTimeMedia, 'statistics') as RealTimeMedia: rt_medias = RealTimeMedia.objects(site_url=site_url) rt_follow_count = sum([normalize_count(rt_media.follow_count if rt_media else 0) \ for rt_media in rt_medias]) with context_managers.switch_db(DailyMedia, 'statistics') as DailyMedia: media_stats = DailyMedia.objects(site_url=site_url) follow_count = sum([normalize_count(stat.mp_fans_count) for stat in media_stats if stat.mp_fans_count]) read_count = sum([normalize_count(stat.uclick_count) for stat in media_stats if stat.uclick_count]) follow_count += rt_follow_count read_count += rt_read_count return follow_count, read_count
def editar_article(request, id_article): EditForm = modelform_factory(Article, fields=('nom', 'consola', 'esconsola', 'preu', 'PEGI', 'stock', 'companyia', 'imatge', 'coleccionista', 'detalls', 'video', 'esaccesori')) unEdit = Article() #comprovem que existeix l'oferta_disc if id_article: unEdit = get_object_or_404(Article, pk=id_article) if request.method == 'POST': form = EditForm(request.POST, request.FILES, instance=unEdit) if form.is_valid(): form.save() messages.info(request, "article canviat correctament") return redirect("usuaris:menu_usuari") else: form = EditForm(instance=unEdit) for f in form.fields: form.fields[f].widget.attrs['class'] = 'formulari' form.fields['nom'].widget.attrs['placeholder'] = "Nom" form.fields['consola'].widget.attrs['placeholder'] = "Consola" form.fields['companyia'].widget.attrs['placeholder'] = "companyia" form.fields['detalls'].widget.attrs['placeholder'] = "detalls" form.fields['preu'].widget.attrs['placeholder'] = "Preu" return render(request, 'articles/editar_article.html', {'form': form})
def test_item_approved_mail(self): author = testing.create_user() reviewer = testing.create_user(perms=['content.review']) self.assertEqual(len(mail.outbox), 0) article = Article.create_for_testing(author) send_item_approved_mail(article, reviewer) self.assertEqual(len(mail.outbox), 1)
def test_post_add_tags(self, base_article: Article): url = reverse('articles:id', kwargs={'id': base_article.pk}) tags = base_article.get_tags() + ['some_new_tag1', 'some_new_tag2'] response = self.client.post(url, data={'tags': tags}, format='json') updated = Article.objects.get(pk=base_article.pk) assert response.status_code == status.HTTP_200_OK t = updated.get_tags() assert t == tags
def new(request, site): active_site = Site.objects.get(id=site) article = Article( thumbnail=None, hide_thumbnail=False, published=False, pub_date=None, created_by=request.user, site=active_site) article.save() variant = Variant(page=None, article=article, name='default', segment=None, priority=1, owner=request.user) variant.save() version = Version(variant=variant, version=1, owner=request.user, active=True, ads=False) version.save() version.publishers.add(request.user) create_template(request.POST['template'], version, request.POST['title']) return redirect('admin.sites.articles.views.edit', active_site.id, version.id)
def to_review(request): to_review = [] to_review.extend(Article.items_reviewable_by(request.user)) to_review.extend(ArtistNote.items_reviewable_by(request.user)) to_review.extend(Post.items_reviewable_by(request.user)) to_review.extend(Song.items_reviewable_by(request.user)) to_review.extend(SongNote.items_reviewable_by(request.user)) return {'to_review': to_review}
def _get_rmrb_article(self, content): medium = Medium.objects.get(pk=1081) article = Article() article.medium = medium article.title = content.find('h1').text.strip() for author_name in content.find_all('div', {'class' : 'summary'})[0].find_all('a'): try: author = Journalist.objects.get(medium=medium, name=author_name.text.strip()) except: pass else: article.author = author break for li in content.find_all('div', {'class' : 'summary'})[-1].find_all('li'): if li.text.find(u'报纸日期') != -1: p = re.compile('(\d+)-(\d+)-(\d+)') publication_date = p.search(li.text).group() if li.text.find(u'版名') != -1: page = li.text.replace('\n','').replace(u'【版名】', '').replace(' ', '') else: page = '头版' article.issue = self._get_issue_from_date(publication_date, 'rmrb') article.page = page article.publication_date = datetime.datetime.strptime(publication_date, '%Y-%m-%d') article, created = Article.objects.get_or_create(medium=article.medium, title=article.title, issue=article.issue, publication_date=article.publication_date) print article.title return article
def update_article(request,articleid=0): typeid = request.POST.get('typeid', '') title = request.POST.get('title', '') u_text = request.POST.get('u_text', '') if articleid==0: a = Article(title=title, typeid=typeid, authorname=request.user.username) a.save() a_addon = AddonArticle(aid=a.aid, content=u_text, authorip=request.META['REMOTE_ADDR']) a_addon.save() sort_img(a.aid) return render_to_response('edit-article.html', {'form': EditForm(), 'page_title': u'添加新文章', 'result_aid':a.aid, 'aid':articleid},context_instance=RequestContext(request,processors=[custom_proc]))#articleid是0时,表示添加新文章 else: a = get_object_or_404(Article, aid=articleid) if request.user.username==a.authorname or in_editor_group(request.user): a.title = title a.typeid = typeid #a.is_verified = None a_addon = AddonArticle.objects.get(aid=articleid) a_addon.content = u_text c=a_addon.content a.save() a_addon.save() sort_img(a.aid) else: return show_article(request,articleid,{'no_perm':True}) return show_article(request,a.aid,{'has_edited':True})
def update_article(request,articleid=0): typeid = request.POST.get('typeid', '') title = request.POST.get('title', '') u_text = request.POST.get('u_text', '') #assert False if articleid==0: a = Article(title=title, typeid=typeid, authorname=request.user.username) a.save() a_addon = AddonArticle(aid_id=a.aid, content=u_text, authorip=request.META['REMOTE_ADDR']) a_addon.save() else: a = get_object_or_404(Article, aid=articleid) if request.user.username==a.authorname or in_editor_group(request.user): a.title = title a.typeid = typeid a_addon = AddonArticle.objects.get(aid_id=articleid) a_addon.content = u_text c=a_addon.content a.save() a_addon.save() #assert False else: return show_article(request,articleid,no_perm=True) return show_article(request,a.aid,edited=True)
def setUp(self): # create the objects needed self.client = Client() self.article = Article() self.user = User(username='******') self.user.set_password('google') self.user.is_active = True self.user.save()
def home_page(request): c = get_common_context(request) c['request_url'] = 'home' c['articles'] = Article.get_recent(10) c['home_who'] = Page.get_page_by_slug('home_who')['content'] c['home_where'] = Page.get_page_by_slug('home_where')['content'] c['home_from'] = Page.get_page_by_slug('home_from')['content'] c['home_reason'] = Page.get_page_by_slug('home_reason')['content'] return render_to_response('home.html', c, context_instance=RequestContext(request))
def write(request): if request.method == 'POST': form = ArticleForm(request.POST) if form.is_valid(): article = Article() article.create_user = request.user article.title = form.cleaned_data.get('title') article.content = form.cleaned_data.get('content') status = form.cleaned_data.get('status') if status in [Article.PUBLISHED, Article.DRAFT]: article.status = form.cleaned_data.get('status') article.save() tags = form.cleaned_data.get('tags') article.create_tags(tags) return redirect('/articles/') else: form = ArticleForm() return render(request, 'articles/write.html', {'form': form})
def create(self, validated_data): article = Article(name=validated_data["name"]) article.save() user = None request = self.context.get("request") if request and hasattr(request, "user"): user = request.user # Create the first revision for the article revision = ArticleRevision( article=article, author=user, content=validated_data["latest_revision"]["content"], ) revision.save() return article
def dashboard(request): if request.method == 'POST': # check for a new title new_title = request.POST.get('title', None) if new_title: article = Article(title=new_title) article.save() if request.POST.get('destination') == 'dashboard': return redirect('dashboard') else: return redirect('article_editor', article_id=article.id) return redirect('dashboard') return render(request, 'dashboard.html', { 'articles': Article.objects.all() })
def to_review(request): to_review = [] to_review.extend(Annotation.items_reviewable_by(request.user)) to_review.extend(Article.items_reviewable_by(request.user)) to_review.extend(Event.items_reviewable_by(request.user)) to_review.extend(Post.items_reviewable_by(request.user)) to_review.extend(Song.items_reviewable_by(request.user)) return { 'to_review': to_review }
def get(self, request, article_id): data = request.GET read_tag = data.get('read_tag', '') count = data.get('count', COMMENTS_PAGE_COUNT_MAX) action = data.get('action', 'next') article = Article.objects(id=article_id, status=STATUS_PUBLISHED).first() status, reason, data = comments_processor.get_comments_by_article(article, read_tag, int(count), action) if not status: raise CommentsGetError return gen_page_response(data['comments'], data['has_next_page'])
def test_article_can_count_links_in_its_body(self): a = G( Article, raw_content= 'this article has two links http://devcharm.com and https://127.0.0.1:8000' ) self.assertEqual(a.count_own_links(), 2) # This should work for 0 links too a.raw_content = 'No links here' self.assertEqual(a.count_own_links(), 0) # And we should also be able to use the static method directly: self.assertEqual( Article.count_links( 'this article has one link http://devcharm.com'), 1) # Duplicate links should not be counted twice self.assertEqual( Article.count_links( 'this article has one link http://devcharm.com http://devcharm.com' ), 1)
def leavecomment(request, article_id): user = request.user try: article = Article.objects.get(id=article_id) except Article.DoesNotExist(): raise Http404('the article you are requesting is no longer available') article.comment_set.create(author_id=user.id, text=strip_tags(request.POST['text'])) return HttpResponseRedirect( reverse('articles:detailview', args=(article.id, )))
def articles(request, page_name=None): if page_name: c = get_common_context(request) c['a'] = ArticleArticle.get_by_slug(page_name) c['articles'] = ArticleArticle.objects.all() c['base_url'] = 'articles' c['base_title'] = u'Статьи' return render_to_response('articles_base.html', c, context_instance=RequestContext(request)) else: return HttpResponseRedirect('/articles/%s/' % ArticleArticle.objects.all()[0].slug)
class NewCommentArticleTestCase(APITestCase): def setUp(self): self.user1 = User(email="*****@*****.**", user_type=3, username="******") self.user1.save() self.user2 = User(email="*****@*****.**", user_type=1, username="******") self.user2.save() self.user3 = User(email="*****@*****.**", user_type=4, username="******") self.user3.save() self.article = Article(title='TestCase', content="Wearetestingamethodpost", date="2020-03-23", redactor=self.user1.redactor, moderatorid=self.user2.moderator, valide=True) self.article.save() commentArticle.objects.create( content="Wearetestingamethodpost", date="2020-03-23", mobileuserid=self.user3.mobileuser, articleid=self.article, ) def testCommentArticleListGet(self): articleid = self.article.id response = self.client.get('/api/article/' + str(articleid) + '/comments/') self.assertEqual(response.status_code, status.HTTP_200_OK) def testCreation(self): data = { "content": "Wearetestingamethodpost", } token = Token.objects.get(user=self.user3).key header = {} header['Authorization'] = "Token " + str(token) response = self.client.post('/api/article/' + str(self.article.id) + '/newComment/', data, format='json', HTTP_AUTHORIZATION=header['Authorization']) self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def add_article(request): if request.method == 'POST': form = ArticleForm(request.POST) if form.is_valid(): article = Article() article.create_user = request.user article.title = form.cleaned_data.get('title') article.content = form.cleaned_data.get('content').replace( '\n', '<br>') node_name = form.cleaned_data.get('node') article.add_node(node_name) article.save() return index(request) else: form = ArticleForm() return render(request, 'add_article.html', {'form': form})
def article(): article = Article() article.title = 'title1' article.description = 'description1' article.updated_at = 'updated_at1' article.category = category() article.published = 'published1' return article
def test_get_available_articles_ignores_disabled_articles(self): s = Series.objects.all()[0] for x in range(10): Article.objects.create(title="Article" + str(x), content="article", shortline="short", series=s, enabled=bool(x % 2)) expected = 6 available = len(Article.get_available_articles()) self.assertEqual(expected, available)
def add_article_view(request): article = Article() if request.method == "POST": serializer = ArticleSerializer(article, data=request.data) if serializer.is_valid(): serializer.save() # data["success"] = 'Article Added' return Response(serializer.data, status.HTTP_201_CREATED) return Response(serializer.errors, status.HTTP_400_BAD_REQUEST)
def test_get_available_articles_ignores_future_publish_articles(self): s = Series.objects.all()[0] for x in range(10): pub_date = fake_now() if x % 2 else fake_later() Article.objects.create(title="Article" + str(x), content="article", shortline="short", series=s, publish_date=pub_date) expected = 6 available = len(Article.get_available_articles()) self.assertEqual(available, expected)
def setUpTestData(cls): # вызывается каждый раз перед запуском теста на уровне настройки # всего класса # print('setUpTestData') cls.title = 'some title' cls.text = 'some text' cls.user = User.objects.create( first_name='John', last_name='Doe', email='*****@*****.**' ) cls.article = Article(title=cls.title, text=cls.text, author=cls.user)
def article(request): if request.method == "GET": # 从数据库获取动态 articles = Article.objects.all() articles = articles[::-1] data = [] for c in articles: passport_id = c.passport_id passport = Passport.object.get(id=passport_id) data.append({ 'user_name': passport.user_name, 'job': passport.job, 'create_time': c.create_time, 'content': c.content }) res = { 'code': 200, 'data': data, } return JsonResponse(res) else: # ajax像数据库上传动态 params = json.loads(request.body.decode('utf-8')) # user_id = params.get('user_id') content = params.get('content') print(content) passport = Passport.object.get(id=2) article = Article(passport=passport, content=content, create_time=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) article.save() # Article.objects.create(passport_id=2,content=content) # return HttpResponse('{"status": "200"}', content_type='application/json') return JsonResponse({ 'code': 200, 'msg': '评论成功', })
def setUp(self): self.user1 = User(email="*****@*****.**", user_type=3, username="******") self.user1.save() self.user2 = User(email="*****@*****.**", user_type=1, username="******") self.user2.save() self.user3 = User(email="*****@*****.**", user_type=4, username="******") self.user3.save() self.article = Article(title='TestCase', content="Wearetestingamethodpost", date="2020-03-23", redactor=self.user1.redactor, moderatorid=self.user2.moderator, valide=True) self.article.save() commentArticle.objects.create( content="Wearetestingamethodpost", date="2020-03-23", mobileuserid=self.user3.mobileuser, articleid=self.article, )