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,
)
