def subscription(request):
profile = request.user.get_profile()
if request.method == "GET":
subscriptions = Subscription.objects.filter(profile=profile)
subscriptions_json = [{'id': s.feed.id,
'title': s.feed.title,
'unread_entries': profile.unread_entries(s.feed)}
for s in subscriptions]
return HttpResponse(json.dumps(subscriptions_json),
content_type='application/json')
if request.method == "POST":
link = json.loads(request.body)['link']
if not link.startswith('http://'):
link = 'http://{}'.format(link)
parser = feedparser.parse(link)
feed = parser.feed
try:
title = feed.title
except AttributeError:
return HttpResponseBadRequest('Invalid feed')
try:
feed_obj = Feed.objects.get(link=link)
except ObjectDoesNotExist:
feed_obj = Feed(link=link, title=title)
feed_obj.save()
if Subscription.objects.filter(profile=profile, feed=feed_obj).exists():
return HttpResponseBadRequest('You are already subscribed to this '
'feed')
Subscription.objects.get_or_create(profile=profile, feed=feed_obj)
try:
poll_feed(feed_obj)
except AttributeError:
return HttpResponseBadRequest('Invalid feed')
return HttpResponse()
def _update_feed(
cls,
feed_subscription: FeedSubscription,
feed_data: FeedParserDict,
) -> Feed:
"""
Create or update Feed based on parsed data.
:param feed_subscription: FeedSubscription related instance.
:param feed_data: Parsed RSS data.
:return: Processed Feed instance.
"""
cloud = feed_data.feed.get('cloud', {})
image = feed_data.feed.get('image', {})
text_input = feed_data.feed.get('textinput', {})
# Create a filed_name:value dict out of fetched data for Feed
data = {
'cloud_domain': cloud.get('domain'),
'cloud_path': cloud.get('path'),
'cloud_port': cloud.get('port'),
'cloud_protocol': cloud.get('protocol'),
'cloud_register_procedure': cloud.get('registerProcedure'),
'copyright': feed_data.feed.get('rights'),
'description': feed_data.feed.get('subtitle'),
'docs': feed_data.feed.get('docs'),
'encoding': feed_data.get('encoding'),
'generator': feed_data.feed.get('generator'),
'image_description': image.get('description'),
'image_height': image.get('height'),
'image_link': image.get('width'),
'image_title': image.get('title'),
'image_url': image.get('href'),
'image_width': image.get('width'),
'language': feed_data.feed.get('language'),
'link': feed_data.feed.get('link'),
'managing_editor': feed_data.feed.get('author'),
'pub_date': cls.get_pub_date(feed_data.feed),
'subscription': feed_subscription,
'text_input_description': text_input.get('description'),
'text_input_link': text_input.get('link'),
'text_input_name': text_input.get('name'),
'text_input_title': text_input.get('title'),
'title': feed_data.feed.get('title'),
'ttl': feed_data.feed.get('ttl'),
'version': feed_data.get('version'),
'web_master': feed_data.feed.get('publisher')
}
try:
feed = feed_subscription.feed
# Update Feed with fetched values
for name, value in data.items():
setattr(feed, name, value)
except FeedSubscription.feed.RelatedObjectDoesNotExist:
# Make a new Feed instance with fetched values
feed = Feed(**data)
feed.save()
return feed
def post(request):
feed = Feed()
feed.user = request.user
# data: $("#compose-form").serialize(),
feed.post = request.POST['post']
feed.save()
return render(request, 'feeds/partial_feed.html', {'feed': feed})
def save(request):
data = json.loads(request.POST['feedinfo'])
if 'feed_id' in data and data['feed_id']:
feed_id = data['feed_id']
else:
feed_id = str(uuid.uuid4())
data['feed_id'] = feed_id
# folder = os.path.join( settings.FEED_STORAGE_DIR + '/' + feed_id)
# if not os.path.exists(folder):
# os.makedirs(folder)
# with open(folder + '/feed.json', 'w') as f:
# print folder
# f.write(json.dumps(data))
try:
new_feed = Feed.objects.get(guid=feed_id)
except ObjectDoesNotExist:
new_feed = Feed(guid = feed_id)
new_feed.create_time = timezone.now()
new_feed.owner_id = request.user.id
new_feed.title = 'demo'
new_feed.desc = 'demo'
new_feed.conf = json.dumps(data)
new_feed.version = new_feed.version + 1
new_feed.update_time = timezone.now()
new_feed.save()
response = {'result':'ok', 'feed_id' : feed_id}
return HttpResponse(json.dumps(response))
def create_book(request):
if not request.user.is_authenticated():
render(request, 'core/cover.html')
else:
form = BookForm(request.POST or None, request.FILES or None)
if form.is_valid():
books = form.save(commit=False)
books.user = request.user
books.logo = request.FILES['logo']
file_type = books.logo.url.split('.')[-1]
file_type = file_type.lower()
if file_type not in IMAGE_FILE_TYPES:
context = {
'books': books,
'form': form,
'error_message': 'Image file must be PNG, JPG, or JPEG',
}
return render(request, 'mylibrary/create_book.html', context)
books.save()
user = request.user
welcome_post = '{0} has added <a href="{1}">{2}</a>.'.format(
escape(user.username), reverse('mylibrary:index'), books.book_title)
feed = Feed(user=user, post=welcome_post)
feed.save()
return render(request, 'mylibrary/detail.html', {'books': books})
context = {
"form": form,
}
return render(request, 'mylibrary/create_book.html', context)
def register(request):
if request.method == 'POST':
user_form = RegistrationForm(request.POST)
if user_form.is_valid():
username = user_form.cleaned_data.get('username')
email = user_form.cleaned_data.get('email')
password = user_form.cleaned_data.get('password')
User.objects.create_user(
username=username,
email=email,
password=password,
)
user = authenticate(username=username, password=password)
login(request, user)
_success_msg = 'User {0} added'.format(user.username)
feed = Feed(user=user, posts=_success_msg)
feed.save()
return redirect('/feeds/')
else:
return render(request, 'authentication/register.html',
{'form': user_form})
else:
user_form = RegistrationForm()
return render(request, 'authentication/register.html', {'form': user_form})
def _save_feed(self):
"""
Custom internal method to create and save a new feed to the DB.
"""
feed = Feed()
feed.name = self.plugin.meta.name
feed.save()
feed.owner.set([self.owner])
feed.save()
return feed
def _save_feed(self):
"""
Custom method to create and save a new feed to the DB.
"""
feed = Feed()
feed.plugin_inst = self
feed.save()
feed.name = self.plugin.name
feed.owner = [self.owner]
feed.save()
def _save_feed(self):
"""
Custom method to create and save a new feed to the DB.
"""
feed = Feed()
feed.name = self.plugin.name
feed.save()
feed.owner.set([self.owner])
feed.save()
return feed
def test_deleting_a_subscription(self):
"""Users should be able to unsubscribe to a feed through the API."""
feed = Feed(url="http://example.org/feed")
feed.save()
feed.subscribers.add(self.user)
response = self.client.delete('/api/subscriptions/%d/' % (feed.id,))
assert response.status_code == 204
assert self.user not in feed.subscribers.all()
def test_feed_save_method(self):
feed = Feed(link=self.feed_url)
feed.save()
new_feed = Feed.objects.get(link=self.feed_url)
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(new_feed.title, self.feedparser_dict.feed['title'])
self.assertEqual(new_feed.description,
self.feedparser_dict.feed['description'])
self.assertEqual(new_feed.link, self.feed_url)
self.assertEqual(new_feed.version, self.feedparser_dict['version'])
def build_articles(self, subscriber, feed_count=2, article_count=2):
"""Create two feeds and several articles for a user."""
for _ in range(feed_count):
feed = Feed(url=fake.uri())
feed.save()
feed.subscribers.add(subscriber)
for _ in range(article_count):
feed.items.create(uid=fake.md5(),
title=fake.sentence(),
link=fake.uri(),
published_at=timezone.now())
class FeedTestCase(TestCase):
"""This class defines the test suite for the Feed model."""
def setUp(self) -> None:
title = 'Simple is Better Than Complex'
link = 'https://simpleisbetterthancomplex.com/'
rss = 'https://simpleisbetterthancomplex.com/feed.xml/'
self.feed = Feed(title=title, link=link, rss=rss)
def test_model_can_create_a_feed(self):
old_count = Feed.objects.count()
self.feed.save()
new_count = Feed.objects.count()
return self.assertNotEqual(old_count, new_count)
def post(request):
last_feed = request.POST.get('last_feed')
user = request.user
csrf_token = unicode(csrf(request)['csrf_token'])
feed = Feed()
feed.user = user
post = request.POST['post']
post = post.strip()
if len(post) > 0:
feed.post = post[:255]
feed.save()
html = _html_feeds(last_feed, user, csrf_token)
return HttpResponse(html)
def post(request):
last_feed = request.POST.get('last_feed')
user = request.user
csrf_token = (csrf(request)['csrf_token'])
feed = Feed()
feed.user = user
post = request.POST['post']
post = post.strip()
if len(post) > 0:
feed.post = post[:255]
feed.save()
html = _html_feeds(last_feed, user, csrf_token)
return HttpResponse(html)
def create(self, validated_data):
try:
feed = Feed.objects.get(url=validated_data['url'])
except Feed.DoesNotExist:
feed = Feed(url=validated_data['url'])
feed.save()
feed.sync()
subscriber = validated_data['subscriber']
if subscriber in feed.subscribers.all():
raise serializers.ValidationError(
"You are already subscribed to this feed.")
feed.subscribers.add(subscriber)
return feed
def form_valid(self, form):
user = self.request.user
link = form.cleaned_data['link']
if not link.startswith('http://'):
link = 'http://{}'.format(link)
parser = feedparser.parse(link)
feed = parser.feed
title = feed.title
try:
feed_obj = Feed.objects.get(link=link)
except ObjectDoesNotExist:
feed_obj = Feed(link=link, title=title)
feed_obj.save()
profile = user.get_profile()
Subscription(profile=profile, feed=feed_obj).save()
poll_feed(feed_obj)
return super(DashboardView, self).form_valid(form)
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if not form.is_valid():
return render(request, 'authentication/signup.html', {'form': form})
else:
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
User.objects.create_user(username=username, password=password, email=email)
user = authenticate(username=username, password=password)
login(request, user)
welcome_post = u'{0} has joined the network.'.format(user.username)
feed = Feed(user=user, post=welcome_post)
feed.save()
return redirect('/')
else:
return render(request, 'authentication/signup.html', {'form': SignUpForm()})
def activate(request, uidb64, token):
try:
uid = force_text(urlsafe_base64_decode(uidb64))
user = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
user = None
if user is not None and account_activation_token.check_token(user, token):
user.is_active = True
user.profile.email_confirmed = True
user.save()
login(request, user)
welcome_post = '{0} has joined the network.'.format(user.username,
user.username)
feed = Feed(user=user, post=welcome_post)
feed.save()
return redirect('/')
else:
return render(request, 'authentication/account_activation_invalid.html')
def post(request): #feeds on profiles
to_user = request.POST.get('to_user')
# profile_pk = request.POST.get('profile_pk')
# last_feed = request.POST.get('last_feed')
to_user = get_object_or_404(User, username=to_user)
to_user_profile_pk = to_user.profile.pk
user = request.user
csrf_token = (csrf(request)['csrf_token'])
feed = Feed()
feed.user = user
feed.to_user = to_user
feed.profile_pk = to_user_profile_pk
# if not to_user:
# feed.profile_pk = profile_pk
# else:
# feed.profile_pk = to_user.profile.pk
# profile_pk = to_user.profile.pk
post = request.POST['post']
post = post.strip()
if len(post) > 0 and to_user:
feed.post = post[:255]
feed.save()
profile = Profile.objects.get(pk=to_user_profile_pk) # to_user_profile
# wrote_on_profile = Activity.objects.filter(activity_type=Activity.WROTE_ON_PROFILE, profile=profile_pk,
# user=user)
wrote_on_profile = Activity(activity_type=Activity.WROTE_ON_PROFILE, profile=to_user_profile_pk, user=user)
wrote_on_profile.save()
user.profile.notify_wrote_on_profile(profile,feed)
html = ''
html = '{0}{1}'.format(html,
render_to_string('feeds/partial_feed_profile.html',
{
'feed': feed,
'user': request.user,
'csrf_token': csrf_token,
}))
else:
html = ''
return HttpResponse(html)
def handle(self, *args, **options):
try:
user = User.objects.get(username=args[0])
except (IndexError,User.DoesNotExist):
raise CommandError('No valid username given.')
try:
xml = et.parse(args[1])
except (IndexError,IOError):
raise CommandError('No valid inputfile given.')
for categoryNode in xml.find('body').findall('outline'):
categoryTitle = categoryNode.attrib['title']
print ' category',categoryTitle
try:
category = Category.objects.get(title=categoryTitle,user=user)
except Category.DoesNotExist:
category = Category(title=categoryTitle,user=user)
category.save()
for subscriptionNode in categoryNode.findall('outline'):
subscriptionTitle = subscriptionNode.attrib['title']
subscriptionHtmlUrl = subscriptionNode.attrib['htmlUrl']
subscriptionXmlUrl = subscriptionNode.attrib['xmlUrl']
print ' subscription',subscriptionTitle
try:
feed = Feed.objects.get(xmlUrl=subscriptionXmlUrl)
except Feed.DoesNotExist:
feed = Feed(xmlUrl=subscriptionXmlUrl)
feed.fetchItems()
feed.save()
try:
subscription = Subscription.objects.get(category=category,feed=feed)
except Subscription.DoesNotExist:
subscription = Subscription(category=category,feed=feed)
subscription.save()
def signup(request):
if request.method == 'POST':
form = SignUpForm(request.POST)
if not form.is_valid():
return render(request, 'auth/signup.html', {'form': form})
else:
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
User.objects.create_user(username=username,
password=password,
email=email)
user = authenticate(username=username, password=password)
login(request, user)
welcome_post = u'{0} has joined the network.'.format(
user.username, user.username)
feed = Feed(user=user, post=welcome_post)
feed.save()
return redirect('/')
else:
return render(request, 'auth/signup.html', {'form': SignUpForm()})
def test_save_without_link_raises_error(self):
feed = Feed()
with self.assertRaises(TypeError):
feed.save()
self.assertEqual(Feed.objects.count(), 0)
self.assertFalse(self.mock_fetch_feedparser_dict.called)
class TestAllViewsLoggedIn(TestCase):
"""
Test Feeds views for users that are authenticated.
"""
fixtures = [
'WebSite.yaml',
'Feed_all.yaml',
]
username = "******"
password = "******"
def setUp(self):
"""
Set up enivironment to test models
"""
self.user = User.objects.create_user(self.username,
'*****@*****.**',
self.password)
"""Test user."""
self.feed1 = Feed(feed_url=reverse('planet:rss1'),
name="rss1",
short_name="rss1")
self.feed1.save()
"""Feed 1."""
self.feed2 = Feed(feed_url=reverse('planet:rss2'),
name="rss2",
short_name="rss2")
self.feed2.save()
"""Feed 2."""
self.client = Client()
"""Test Client."""
def website_home(self):
"""
go to website-home
.. todo::
Requires login or credential.
"""
result = self.client.get(reverse('planet:website-home'))
self.assertEqual(result.status_code, 200)
def website_add(self):
""".. todo:: todo"""
pass
def test_website(self):
"""
test_site
---------
Test all aspects of "Site" as a logged in user.
- home
- add
- submit
- view
- update
"""
self.website_home()
self.website_add()
def feed_home(self):
"""
go to feed-home
.. todo:: rename and restructure as in
:py:mod:`feeds.tests.ViewsAnonymousTest`.
.. todo::
Requires login or credential.
"""
result = self.client.get(reverse('planet:feed-home'))
self.assertEqual(result.status_code, 302)
def feed_subscribe(self):
"""
test feed-subscribe
---------
:url: url(
r'^list/$',
FeedSubscribeView.as_view(),
name="feed-subscription"
)
Should return 302 for an authenticated user and redirect to the
details-page for the just subscribed feed.
"""
self.client.login(username=self.username, password=self.password)
result = self.client.get(
reverse('planet:feed-subscribe', kwargs={'pk': 1}))
self.assertEqual(result.status_code, 302)
self.assertRedirects(result,
reverse('planet:feed-detail', kwargs={'pk': 1}))
def feed_subscription(self):
"""
test feed-subscription
---------
:url: url(
r'^list/$',
FeedSubscriptionView.as_view(),
name="feed-subscription"
)
Should return 200 for an authenticated user.
"""
self.client.login(username=self.username, password=self.password)
result = self.client.get(reverse('planet:feed-subscriptions'))
self.assertEqual(result.status_code, 200)
def feed_update(self):
"""
test FeedUpdateView
"""
self.client.login(username=self.username, password=self.password)
result = self.client.get(
reverse('planet:feed-update', kwargs={'pk': 1}))
self.assertEqual(result.status_code, 200)
def feed_delete(self):
"""
Test FeedDeleteView
Probably better through Selenium
"""
pass
def test_feed(self):
"""
Run tests for all views related to feeds.
- self.feed_home
"""
self.feed_home()
self.feed_subscribe()
self.feed_subscription()
self.feed_update()
self.feed_delete()
def test_feed_add(self):
"""
Go to feed-add, not logged in.
This should require logged in requests, and redirect to login first.
"""
result = self.client.get(reverse('planet:feed-add'), follow=False)
self.assertEqual(result.status_code, 302)
self.assertRedirects(result, '/accounts/login/?next=/feeds/add/')
def test_feed_add_logged_in_no_permission(self):
"""
Go to feed-add, logged in test-user.
This should require permission and respond with "403".
"""
self.client.login(username=self.username, password=self.password)
result = self.client.get(reverse('planet:feed-add'), follow=True)
self.assertEqual(result.status_code, 403)
def test_feed_add_logged_in_valid_permission(self):
"""
go to feed-add
"""
self.user = User.objects.get(username=self.username)
permission = Permission.objects.get(codename="add_feed")
self.user.user_permissions.add(permission)
self.user.save()
self.client.login(username=self.username, password=self.password)
"""
.. todo:: this currently gives
'AttributeError: 'module' object has no
attribute 'CRISPY_TEMPLATE_PACK'.
"""
result = self.client.get(reverse('planet:feed-add'), follow=False)
# self.assertEqual(result.status_code, 200)
def test_feed_add_post_anonymous(self):
"""
go to feed-add, anonymous client
"""
result = self.client.post(reverse('planet:feed-add'))
self.client.login(username=self.username, password=self.password)
self.assertEqual(result.status_code, 302)
def test_feed_detail(self):
"""
go to feed-detail for feed 1
.. todo::
Requires login or credential.
"""
feed_id = Feed.objects.all()[0].pk
result = self.client.get(
reverse('planet:feed-detail', args=(feed_id, )))
self.assertEqual(result.status_code, 302)
def test_feed_refresh_view(self):
"""
manually refresh a feed
"""
c = Client()
feeds = Feed.objects.all()
result = c.get(reverse('planet:feed-refresh', args=(feeds[0].pk, )))
self.assertEqual(result.status_code, 302)
def test_create_post(self):
"""
create a new post
"""
feed = Feed.objects.all()[0]
"""
Get first feed from the db.
We use fixtures, so we can assume there are feeds.
"""
with self.assertNumQueries(1):
Post.objects.create(feed=feed, published=timezone.now())
def signup_products(request):
print('inside signup_products, authentication.view')
recent_challenge_feeds = Feed.get_feeds().filter(
is_challenge=1).order_by('-date')
if recent_challenge_feeds:
users_challenges = recent_challenge_feeds
else:
users_challenges = []
if request.method == 'POST':
form = SignUpForm(request.POST)
flag = 'products'
print('flag', 'products')
if not form.is_valid():
return render(
request, 'authentication/signup.html', {
'form_products': form,
'flag': flag,
'users_challenges': users_challenges,
})
else:
is_product = request.POST.get('is_product')
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
User.objects.create_user(username=username,
password=password,
email=email)
user = authenticate(username=username, password=password)
profile_pk = user.profile.pk
print(profile_pk, user.username)
if is_product:
print('user is a product')
user.profile.is_product = 1
user.save()
login(request, user)
profile_pk = user.profile.pk # profile_pk of newley registered user
profile = user.profile # profile object of newly registered user
print(profile_pk, user.username)
hohos = get_object_or_404(User, username='******')
hohoshelp = get_object_or_404(User, username='******')
like_by_hohos = Activity(activity_type=Activity.LIKE_PROFILE,
profile=profile_pk,
user=hohos)
like_by_hohoshelp = Activity(activity_type=Activity.LIKE_PROFILE,
profile=profile_pk,
user=hohoshelp)
like_by_hohos.save()
like_by_hohoshelp.save()
hohos.profile.notify_liked_profile(
profile) # hohos to=> user(newly registered)
hohoshelp.profile.notify_liked_profile(
profile) # hohoshelp to user(newly registered)
like = Activity(activity_type=Activity.LIKE_PROFILE,
profile=profile_pk,
user=user)
like.save()
to_user = user
from_user = get_object_or_404(User, username='******')
if from_user:
welcome_post = 'Hey ' + to_user.username + ' Get ready to solve your customers issues.'
feed = Feed()
feed.user = from_user
feed.to_user = to_user
to_user_profile_pk = profile_pk # newley registered users profile pk
feed.profile_pk = to_user_profile_pk
feed.post = welcome_post
feed.save()
wrote_on_profile = Activity(
activity_type=Activity.WROTE_ON_PROFILE,
profile=to_user_profile_pk,
user=from_user)
wrote_on_profile.save()
hohos.profile.notify_wrote_on_profile(profile, feed)
messages.add_message(
request, messages.SUCCESS, 'Hey ,' + user.username +
'\n Its what people and products are talking about, \
See what people are talking with your friend products\
You are live now you can talk to the people who use you\
and people can talk you on your live profile!'
)
from_email = django_settings.EMAIL_HOST_USER
to = [email]
subject = 'Welcome at hohos ' + user.username
message = 'Dear '+user.username+'!\n'\
+ 'We are happy to see you on hohos.\n' \
+ 'You will have lots of amazing experience along the time. It will get better if '\
+ 'people using you start sharing their feedback\n'\
+ 'This will help you become better and more efficient'\
+ 'This way both you and customers may get the best of available\n'\
+ 'Moreover you can become the part of OpenChat community at - hohos.tech/feeds/openchat/h_h/ '\
+ ' here You can talk to your daily use products too. Which makes things a lot easier.\n\n'\
+ 'Build you profile for better interaction.'\
+ 'First hohos.tech/login and then move to hohos.tech/settings/human/\n\n'\
+ 'Best wishes!\n'\
+ '-Team iA at hohos.tech'
if to:
try:
send_mail(subject,
message,
from_email,
to,
fail_silently=False)
except:
pass
print('inside signup, authentication.views')
print('user\'s pk %d' % (user.pk))
return redirect('/feeds/openchat/h_p/')
else:
return render(request, 'authentication/signup.html', {
'form_products': SignUpForm(),
'users_challenges': users_challenges,
})
class TestAllViewsLoggedIn(TestCase):
"""
Test Feeds views for users that are authenticated.
"""
fixtures = [
'Feed_all.yaml',
]
username = "******"
password = "******"
def setUp(self):
"""
Set up enivironment to test models
"""
self.user = User.objects.create_user(
self.username,
'*****@*****.**',
self.password
)
"""Test user."""
self.feed1 = Feed(
feed_url=reverse('planet:rss1'),
name="rss1",
short_name="rss1"
)
self.feed1.save()
"""Feed 1."""
self.feed2 = Feed(
feed_url=reverse('planet:rss2'),
name="rss2",
short_name="rss2"
)
self.feed2.save()
"""Feed 2."""
self.client = Client()
"""Test Client."""
def site_add(self):
""".. todo:: todo"""
pass
def test_site(self):
"""
test_site
---------
Test all aspects of "Site" as a logged in user.
- add
- submit
- view
- update
"""
self.site_add()
def feed_home(self):
"""
go to feed-home
.. todo:: rename and restructure as in
:py:mod:`feeds.tests.ViewsAnonymousTest`.
.. todo::
Requires login or credential.
"""
result = self.client.get(reverse('planet:feed-home'))
self.assertEqual(result.status_code, 302)
def feed_subscribe(self):
"""
test feed-subscribe
---------
:url: url(
r'^list/$',
FeedSubscribeView.as_view(),
name="feed-subscription"
)
Should return 302 for an authenticated user and redirect to the
details-page for the just subscribed feed.
"""
self.client.login(
username=self.username,
password=self.password
)
result = self.client.get(
reverse('planet:feed-subscribe', kwargs={'pk': 1})
)
self.assertEqual(result.status_code, 302)
self.assertRedirects(
result,
reverse('planet:feed-view', kwargs={'pk': 1})
)
def feed_subscription(self):
"""
test feed-subscription
---------
:url: url(
r'^list/$',
FeedSubscriptionView.as_view(),
name="feed-subscription"
)
Should return 200 for an authenticated user.
"""
self.client.login(
username=self.username,
password=self.password
)
result = self.client.get(reverse('planet:feed-subscriptions'))
self.assertEqual(result.status_code, 200)
def feed_update(self):
"""
test FeedUpdateView
"""
self.client.login(
username=self.username,
password=self.password
)
result = self.client.get(
reverse('planet:feed-update', kwargs={'pk': 1})
)
self.assertEqual(result.status_code, 200)
def feed_delete(self):
"""
Test FeedDeleteView
Probably better through Selenium
"""
pass
def test_feed(self):
"""
Run tests for all views related to feeds.
- self.feed_home
"""
self.feed_home()
self.feed_subscribe()
self.feed_subscription()
self.feed_update()
self.feed_delete()
def test_feed_add(self):
"""
Go to feed-add.
This should require the proper credentials.
"""
result = self.client.get(reverse('planet:feed-add'), follow=False)
self.assertEqual(result.status_code, 302)
def test_feed_add_no_credentials(self):
"""
go to feed-add
"""
self.client.login(username=self.username, password=self.password)
result = self.client.get(reverse('planet:feed-add'), follow=False)
self.assertEqual(result.status_code, 302)
# self.assertRedirects(result, '/accounts/login')
def test_feed_add_logged_in_valid_credentials(self):
"""
go to feed-add
"""
self.user = User.objects.get(username=self.username)
permission = Permission.objects.get(codename="add_feed")
self.user.user_permissions.add(permission)
self.user.save()
self.client.login(
username=self.username,
password=self.password
)
"""
.. todo:: this currently gives
'AttributeError: 'module' object has no
attribute 'CRISPY_TEMPLATE_PACK'.
"""
# result = self.client.get(reverse('planet:feed-add'), follow=False)
# self.assertEqual(result.status_code, 200)
def test_feed_add_post_anonymous(self):
"""
go to feed-add, anonymous client
"""
result = self.client.post(reverse('planet:feed-add'))
self.client.login(username=self.username, password=self.password)
self.assertEqual(result.status_code, 302)
def test_feed_view(self):
"""
go to feed-view for feed 1
.. todo::
Requires login or credential.
"""
feed_id = Feed.objects.all()[0].pk
result = self.client.get(reverse('planet:feed-view', args=(feed_id,)))
self.assertEqual(result.status_code, 302)
def test_feed_refresh_view(self):
"""
manually refresh a feed
"""
c = Client()
feeds = Feed.objects.all()
result = c.get(reverse('planet:feed-refresh', args=(feeds[0].pk,)))
self.assertEqual(result.status_code, 302)
def test_create_post(self):
"""
create a new post
"""
feed = Feed.objects.all()[0]
"""
Get first feed from the db.
We use fixtures, so we can assume there are feeds.
"""
with self.assertNumQueries(1):
Post.objects.create(
feed=feed,
published=timezone.now()
)
def signup_human(request):
print('inside signup_human, authentication.view')
recent_challenge_feeds = Feed.get_feeds().filter(
is_challenge=1).order_by('-date')[:20]
if recent_challenge_feeds:
users_challenges = recent_challenge_feeds
else:
users_challenges = []
if request.method == 'POST':
form = SignUpForm(request.POST)
flag = 'human'
print('flag', flag)
if not form.is_valid():
return render(
request, 'authentication/signup.html', {
'form_human': form,
'flag': flag,
'users_challenges': users_challenges,
})
else:
username = form.cleaned_data.get('username')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
gender = form.cleaned_data.get('gender')
User.objects.create_user(
username=username, password=password,
email=email) # removed email at signup to make signup fast
user = authenticate(username=username, password=password)
user.profile.gender = gender
user.save()
login(request, user)
profile_pk = user.profile.pk # profile_pk of newley registered user
profile = user.profile # profile object of newly registered user
print(profile_pk, user.username)
hohos = get_object_or_404(User, username='******')
hohoshelp = get_object_or_404(User, username='******')
like_by_hohos = Activity(activity_type=Activity.LIKE_PROFILE,
profile=profile_pk,
user=hohos)
like_by_hohoshelp = Activity(activity_type=Activity.LIKE_PROFILE,
profile=profile_pk,
user=hohoshelp)
like_by_hohos.save()
like_by_hohoshelp.save()
hohos.profile.notify_liked_profile(
profile) # hohos to=> user(newly registered)
hohoshelp.profile.notify_liked_profile(
profile) # hohoshelp to user(newly registered)
like = Activity(activity_type=Activity.LIKE_PROFILE,
profile=profile_pk,
user=user)
like.save()
to_user = user
from_user = hohos # get_object_or_404(User, username='******')
wel_post = ''
welcome1= ' You seem to love facial expressions?? You can Make it awesome!\n'\
+'Challenge your friends and imitate them. Sounds cool??\n'\
+'Welcome!\nhttp://www.hohos.tech/feeds/challenge/'
welcome2= ' Get ready to speak through your awesome facial expressions...\n'\
+'http://www.hohos.tech/feeds/'
welcome3= ' You are awesome! \n'\
+'Imitate your friends expressions and challenge them yours.'\
+'You should try it once!\n'\
+'Its amazing!\nhttp://www.hohos.tech/feeds/'
post_no = random.randint(1, 3)
if post_no == 1: wel_post = welcome1
elif post_no == 2: wel_post = welcome2
else: wel_post = welcome3
if from_user:
welcome_post = 'Hey ' + to_user.username + wel_post
feed = Feed()
feed.user = from_user
feed.to_user = to_user
to_user_profile_pk = profile_pk # newley registered users profile pk
feed.profile_pk = to_user_profile_pk
feed.post = welcome_post
feed.save()
wrote_on_profile = Activity(
activity_type=Activity.WROTE_ON_PROFILE,
profile=to_user_profile_pk,
user=from_user)
wrote_on_profile.save()
hohos.profile.notify_wrote_on_profile(profile, feed)
messages.add_message(
request, messages.SUCCESS,
'Get ready to show your own flavours!!' + user.username +
'\n If you want to make people make a special pose for you, \
just share that and see if your friends could make that better?\
you Can visit your friends profile and say something\
about him/her!')
from_email = django_settings.EMAIL_HOST_USER
to = [email]
subject = 'Welcome at hohos ' + user.username
message = 'Dear '+user.username+'!\n'\
+ 'We are happy to see you on hohos.tech\n' \
+ 'You will have lots of amazing experience along the time. It will get better if '\
+ 'you participate in share and imitate culture at hohos.tech/feeds/\n'\
+ 'Challenge your facial expressions, let your likers and other people imitate them.'\
+ 'Because its awesome to see the different versions of same thing.\n'\
+ 'This becomes rejoicing when your own friends imitate you.\n\n'\
+ 'Moreover you can become the part of OpenChat community at - hohos.tech/feeds/openchat/h_h/ '\
+ ' here You can talk to your daily use products too. Which makes things a lot easier.\n\n'\
+ 'Build you profile for better interaction.'\
+ 'First hohos.tech/login and then move to hohos.tech/settings/human/\n\n'\
+ 'Best wishes!\n'\
+ '-Team iA at hohos.tech'
if to:
try:
send_mail(subject,
message,
from_email,
to,
fail_silently=False)
except:
pass
# print('inside signup, authentication.views')
# print('user\'s pk %d'%(user.pk))
return redirect('feeds')
else:
return render(request, 'authentication/signup.html', {
'form_human': SignUpForm(),
'users_challenges': users_challenges,
})
class PollFeedTest(TestCase):
def setUp(self):
self.feed = Feed(link="http://link.to/rss.xml", title="A Feed")
self.feed.save()
# Create an entry
published = datetime.datetime(2013, 9, 25, 4, 0)
published = published.timetuple()
self.entry1 = FeedParserEntry(title="An Entry", link="http://entry", published_parsed=published)
# Create another entry
published = datetime.datetime(2013, 9, 28, 4, 0)
published = published.timetuple()
self.entry2 = FeedParserEntry(title="Another Entry", link="http://another/entry", published_parsed=published)
# Create users
user1 = User(username="******")
user1.save()
self.profile1 = UserProfile(user=user1)
self.profile1.save()
user2 = User(username="******")
user2.save()
self.profile2 = UserProfile(user=user2)
self.profile2.save()
def test_profile_display(self):
self.assertEqual(str(self.profile1), "user1's profile")
self.assertEqual(str(self.profile2), "user2's profile")
@mock.patch("feedparser.parse")
def test_poll_new_subscriber(self, mock_parse):
"""Test a successful polling of a feed."""
# Set up mock data
parser = mock.MagicMock()
parser.entries = [self.entry1, self.entry2]
mock_parse.return_value = parser
Subscription(profile=self.profile1, feed=self.feed).save()
# Verify initial state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 0)
self.assertEqual(UserEntryDetail.objects.count(), 0)
# Perform poll
tasks.poll_feed(self.feed)
# Verify final state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 2)
self.assertEqual(UserEntryDetail.objects.count(), 2)
@mock.patch("feedparser.parse")
def test_poll_two_new_subscribers(self, mock_parse):
"""Test a successful polling of a feed."""
# Set up mock data
parser = mock.MagicMock()
parser.entries = [self.entry1, self.entry2]
mock_parse.return_value = parser
Subscription(profile=self.profile1, feed=self.feed).save()
Subscription(profile=self.profile2, feed=self.feed).save()
# Verify initial state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 0)
self.assertEqual(UserEntryDetail.objects.count(), 0)
# Perform poll
tasks.poll_feed(self.feed)
# Verify final state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 2)
self.assertEqual(UserEntryDetail.objects.count(), 4)
@mock.patch("feedparser.parse")
def test_poll_new_and_existing_subscribers(self, mock_parse):
"""Test a successful polling of a feed."""
# Set up mock data
parser = mock.MagicMock()
parser.entries = [self.entry1, self.entry2]
mock_parse.return_value = parser
Subscription(profile=self.profile1, feed=self.feed).save()
Subscription(profile=self.profile2, feed=self.feed).save()
entry1 = Entry(
link=self.entry1.link,
feed=self.feed,
title=self.entry1.title,
published=datetime.datetime(2013, 9, 25, 4, 0),
)
entry1.save()
UserEntryDetail(profile=self.profile1, entry=entry1).save()
# Verify initial state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 1)
self.assertEqual(UserEntryDetail.objects.count(), 1)
# Perform poll
tasks.poll_feed(self.feed)
# Verify final state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 2)
self.assertEqual(UserEntryDetail.objects.count(), 4)
@mock.patch("feedparser.parse")
def test_poll_after_unsubscribe(self, mock_parse):
# Set up mock data
parser = mock.MagicMock()
parser.entries = [self.entry1]
mock_parse.return_value = parser
Subscription(profile=self.profile1, feed=self.feed).save()
# Verify initial state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 0)
self.assertEqual(UserEntryDetail.objects.count(), 0)
# Perform poll
tasks.poll_feed(self.feed)
# Verify state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 1)
self.assertEqual(UserEntryDetail.objects.count(), 1)
# Unsubscribe
self.profile1.unsubscribe(self.feed)
# Verify state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 1)
self.assertEqual(UserEntryDetail.objects.count(), 0)
# Resubscribe
self.profile1.subscribe(self.feed)
# Perform poll (find another entry)
parser.entries = [self.entry1, self.entry2]
tasks.poll_feed(self.feed)
# Verify final state
self.assertEqual(Feed.objects.count(), 1)
self.assertEqual(Entry.objects.count(), 2)
self.assertEqual(UserEntryDetail.objects.count(), 2)
@mock.patch("feedparser.parse")
def test_mark_read_unread(self, mock_parse):
parser = mock.MagicMock()
parser.entries = [self.entry1, self.entry2]
mock_parse.return_value = parser
unread_entries = self.profile1.unread_entries(self.feed)
self.assertEqual(unread_entries, 0)
self.profile1.subscribe(self.feed)
tasks.poll_feed(self.feed)
unread_entries = self.profile1.unread_entries(self.feed)
self.assertEqual(unread_entries, 2)
self.profile1.mark_read(self.feed)
unread_entries = self.profile1.unread_entries(self.feed)
self.assertEqual(unread_entries, 0)
self.profile1.mark_unread(self.feed)
unread_entries = self.profile1.unread_entries(self.feed)
self.assertEqual(unread_entries, 2)
from feeds.models import Feed
keywords = ['cyclone', 'dhrought', 'earthquake', 'epidemic', 'fire', 'flood', 'heatwave', 'rain', 'infestation', 'landslide', 'snowfall', 'storm', 'tornado', 'tsunami', 'wind', 'volcano']
for keyword in keywords:
# google
print 'Generating a google feed for keyword: %s' % keyword
f1 = Feed()
f1.name = 'Feed from Google News for "%s"' % keyword
f1.description = f1.name
f1.url_xml = 'https://news.google.it/news/feeds?hl=en&q=%s' % keyword
f1.url_html = f1.url_xml
f1.enabled = True
f1.save()
f1.tags.add('crisis', keyword)
# twitter
f2 = Feed()
f2.name = 'Tweets for "%s"' % keyword
f2.description = f2.name
f2.url_xml = 'http://search.twitter.com/search.rss?q=%s' % keyword
f2.url_html = f2.url_xml
f2.enabled = True
f2.save()
f2.tags.add('crisis', 'twitter', keyword)
