def migrate_to_following(self):
skip = 0
while True:
query = 'MATCH (profile:Pleb) RETURN profile ' \
'SKIP %s LIMIT 25' % skip
skip += 24
res, _ = db.cypher_query(query)
if not res.one:
break
for profile in [Pleb.inflate(row[0]) for row in res]:
friend_query = 'MATCH (a:Pleb {username: "******"})' \
'-[:FRIENDS_WITH]->(b:Pleb) ' \
'RETURN b' % profile.username
friend_res, _ = db.cypher_query(friend_query)
for friend in [
Pleb.inflate(friend_row[0])
for friend_row in friend_res
]:
try:
profile.follow(friend.username)
friend.follow(profile.username)
except (ConstraintViolation, Exception):
pass
self.stdout.write("completed friend migration\n", ending='')
return True
def test_is_following_was_following(self):
test_pleb = Pleb(username=str(uuid1())).save()
rel = self.pleb.following.connect(test_pleb)
rel.active = False
rel.save()
res = test_pleb.is_following(self.pleb.username)
self.assertFalse(res)
def setUp(self):
settings.CELERY_ALWAYS_EAGER = True
self.email = "*****@*****.**"
res = create_user_util_test(self.email, task=True)
self.assertNotEqual(res, False)
wait_util(res)
self.pleb = Pleb.nodes.get(email=self.email)
self.user = User.objects.get(email=self.email)
try:
pleb = Pleb.nodes.get(
email='*****@*****.**',
username="******")
pleb.delete()
user = User.objects.get(
email='*****@*****.**',
username="******")
user.delete()
except (Pleb.DoesNotExist, User.DoesNotExist):
pass
self.fake_user = User.objects.create_user(
first_name='test', last_name='test',
email='*****@*****.**',
password='******',
username='******')
self.fake_user.save()
self.fake_pleb = Pleb(email=self.fake_user.email,
username=self.fake_user.username).save()
def test_three_solutions_different_authors(self):
pleb = Pleb(email=str(uuid1()),
first_name="test",
last_name="test",
username=str(uuid1())).save()
pleb2 = Pleb(email=str(uuid1()),
first_name="test",
last_name="test",
username=str(uuid1())).save()
solution = Solution(content=uuid1(),
owner_username=self.pleb.username).save()
solution2 = Solution(content=uuid1(),
owner_username=pleb.username).save()
solution3 = Solution(content=uuid1(),
owner_username=pleb2.username).save()
self.question.solutions.connect(solution)
self.question.solutions.connect(solution2)
self.question.solutions.connect(solution3)
authors = self.question.get_conversation_authors()
self.assertIn(self.pleb.first_name, authors)
self.assertIn(self.pleb.last_name, authors)
self.assertIn(pleb.first_name, authors)
self.assertIn(pleb.last_name, authors)
self.assertIn(pleb2.first_name, authors)
self.assertIn(pleb2.last_name, authors)
self.assertEqual(authors.count(','), 2)
def test_get_solution_ids(self):
query = 'MATCH (n:Solution) OPTIONAL MATCH (n)-[r]-() DELETE n, r'
db.cypher_query(query)
pleb = Pleb(email=str(uuid1()),
first_name="test",
last_name="test",
username=str(uuid1())).save()
pleb2 = Pleb(email=str(uuid1()),
first_name="test",
last_name="test",
username=str(uuid1())).save()
solution = Solution(content=uuid1(),
owner_username=self.pleb.username).save()
solution2 = Solution(content=uuid1(),
owner_username=pleb.username).save()
solution3 = Solution(content=uuid1(),
owner_username=pleb2.username).save()
self.question.solutions.connect(solution)
self.question.solutions.connect(solution2)
self.question.solutions.connect(solution3)
solutions = self.question.get_solution_ids()
self.assertEqual(len(solutions), 3)
self.assertIn(solution.object_uuid, solutions)
self.assertIn(solution2.object_uuid, solutions)
self.assertIn(solution3.object_uuid, solutions)
class TestCreateWallTask(TestCase):
def setUp(self):
settings.CELERY_ALWAYS_EAGER = True
self.email = "*****@*****.**"
res = create_user_util_test(self.email, task=True)
self.assertNotEqual(res, False)
wait_util(res)
self.pleb = Pleb.nodes.get(email=self.email)
self.user = User.objects.get(email=self.email)
try:
pleb = Pleb.nodes.get(
email='*****@*****.**',
username="******")
pleb.delete()
user = User.objects.get(
email='*****@*****.**',
username="******")
user.delete()
except (Pleb.DoesNotExist, User.DoesNotExist):
pass
self.fake_user = User.objects.create_user(
first_name='test', last_name='test',
email='*****@*****.**',
password='******',
username='******')
self.fake_user.save()
self.fake_pleb = Pleb(email=self.fake_user.email,
username=self.fake_user.username).save()
def tearDown(self):
self.fake_pleb.delete()
self.fake_user.delete()
settings.CELERY_ALWAYS_EAGER = False
def test_create_wall_task_success(self):
task_data = {
'username': self.fake_user.username
}
res = create_wall_task.apply_async(kwargs=task_data)
while not res.ready():
time.sleep(1)
self.assertFalse(isinstance(res.result, Exception))
def test_create_wall_task_pleb_has_wall(self):
wall = Wall(wall_id=str(uuid1())).save()
wall.owned_by.connect(self.fake_pleb)
self.fake_pleb.wall.connect(wall)
task_data = {
'username': self.fake_user.username,
}
res = create_wall_task.apply_async(kwargs=task_data)
while not res.ready():
time.sleep(1)
self.assertFalse(isinstance(res.result, Exception))
def test_multiple_posts_multiple_comments_friends(self):
wall = self.pleb.get_wall()
pleb_array = []
post_array = []
comment_array = []
for item in range(0, 2):
test_pleb = Pleb(email=str(uuid1())[:32],
username=str(uuid1())[:32])
test_pleb.save()
pleb_array.append(test_pleb)
for number in range(0, 10):
test_post = Post(content='test',
object_uuid=str(uuid1()),
owner_username=self.pleb.username,
wall_owner_username=self.pleb.username)
test_post.save()
test_post.posted_on_wall.connect(wall)
wall.posts.connect(test_post)
test_post.owned_by.connect(test_pleb)
post_array.append(test_post)
for num in range(0, 1):
my_comment = Comment(content='test comment',
object_uuid=str(uuid1()),
owner_username=self.pleb.username)
my_comment.save()
my_comment.owned_by.connect(test_pleb)
test_post.comments.connect(my_comment)
comment_array.append(my_comment)
my_comment = Comment(content='test comment',
object_uuid=str(uuid1()),
owner_username=self.pleb.username)
my_comment.save()
my_comment.owned_by.connect(self.pleb)
test_post.comments.connect(my_comment)
comment_array.append(my_comment)
test_post = Post(content='test',
object_uuid=str(uuid1()),
owner_username=self.pleb.username,
wall_owner_username=self.pleb.username)
test_post.save()
test_post.posted_on_wall.connect(wall)
wall.posts.connect(test_post)
test_post.owned_by.connect(self.pleb)
request = self.factory.get('/%s' % self.pleb.username)
request.user = self.user
profile_page = ProfileView.as_view()
response = profile_page(request, self.pleb.username)
self.assertIn(response.status_code,
[status.HTTP_200_OK, status.HTTP_302_FOUND])
for item in pleb_array:
item.delete()
for post in post_array:
post.delete()
for comment in comment_array:
comment.delete()
test_post.delete()
def create_vote_node(node_id, vote_type, voter, parent_object):
"""
Creates a vote node that we can use to track reputation changes over time
for users.
This node is hooked up to the object that has been voted on and the
user that voted. The node is created every time someone votes and does not
get updated when someone changes their vote, it just makes a new one, this
may not be the final functionality but this is the current implementation.
:param node_id:
:param vote_type:
:param voter:
:param parent_object:
:return:
"""
sb_object = get_parent_votable_content(parent_object)
try:
current_pleb = Pleb.get(username=voter)
except (DoesNotExist, Pleb.DoesNotExist, CypherException, ClientError,
IOError) as e:
raise create_vote_node.retry(exc=e, countdown=10, max_retries=None)
try:
owner = Pleb.get(username=sb_object.owner_username)
except (DoesNotExist, Pleb.DoesNotExist, CypherException, ClientError,
IOError) as e:
raise create_vote_node.retry(exc=e, countdown=10, max_retries=None)
last_vote = sb_object.get_last_user_vote(current_pleb.username)
if sb_object.visibility == 'public':
if vote_type == 1:
reputation_change = sb_object.up_vote_adjustment
else:
reputation_change = sb_object.down_vote_adjustment
else:
reputation_change = 0
try:
vote_node = Vote.nodes.get(object_uuid=node_id)
except (Vote.DoesNotExist, DoesNotExist):
vote_node = Vote(object_uuid=node_id, vote_type=vote_type,
reputation_change=reputation_change).save()
if last_vote is None:
sb_object.first_votes.connect(vote_node)
sb_object.last_votes.connect(vote_node)
else:
sb_object.last_votes.disconnect(last_vote)
last_vote.next_vote.connect(vote_node)
sb_object.last_votes.connect(vote_node)
vote_node.vote_on.connect(sb_object)
vote_node.owned_by.connect(current_pleb)
if not owner.last_counted_vote_node:
owner.last_counted_vote_node = node_id
owner.reputation_update_seen = False
owner.save()
cache.delete(owner.username)
# See reputation_change method on pleb for where this is set
cache.delete("%s_reputation_change" % owner.username)
return True
def complete_order(self, request, object_uuid=None):
if request.user.username != "tyler_wiersing" \
and request.user.username != "devon_bleibtrey":
return Response({"detail": "You do not have permission to "
"perform this action.",
"status_code": status.HTTP_403_FORBIDDEN},
status=status.HTTP_403_FORBIDDEN)
order = self.get_object()
tracking_url = request.data.get("tracking_url", None)
if tracking_url:
order.tracking_url = tracking_url
order.completed = True
order.save()
order_owner = Pleb.get(order.owner_username)
message_data = {
'message_type': 'email',
'subject': 'Sagebrew Order Processed',
'body': 'Hi %s,\nYour Order has been processed and you '
'can track the delivery here:\n\n%s '
% (order_owner.first_name, tracking_url),
'template': "personal",
'from_user': {
'type': "admin",
'id': settings.INTERCOM_ADMIN_ID_DEVON},
'to_user': {
'type': "user",
'user_id': order.owner_username}
}
serializer = IntercomMessageSerializer(data=message_data)
if serializer.is_valid():
serializer.save()
mission = order.get_mission()
mission_owner = Pleb.get(mission.owner_username)
message_data = {
'message_type': 'email',
'subject': 'Someone has given you a Gift!',
'body': 'Hi %s,\nSomeone has sent you a Gift from your '
'Giftlist!\nYou can track the delivery here:\n\n'
'%s'
% (mission_owner.first_name, tracking_url),
'template': "personal",
'from_user': {
'type': "admin",
'id': settings.INTERCOM_ADMIN_ID_DEVON},
'to_user': {
'type': "user",
'user_id': mission.owner_username}
}
serializer = IntercomMessageSerializer(data=message_data)
if serializer.is_valid():
serializer.save()
return Response(OrderSerializer(order).data, status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
wall_pleb = Pleb.get(self.kwargs[self.lookup_field])
friend_with = wall_pleb.is_friends_with(request.user.username)
if friend_with is False and wall_pleb.username != request.user.username:
return Response(
{"detail": "Sorry you are not friends with this"
" person."},
status=status.HTTP_400_BAD_REQUEST)
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
instance = serializer.save(wall_owner_profile=wall_pleb)
spawn_task(task_func=spawn_notifications,
task_param={
"from_pleb":
request.user.username,
"sb_object":
serializer.data['object_uuid'],
"url":
reverse('single_post_page',
kwargs={
"object_uuid":
serializer.data["object_uuid"]
}),
"to_plebs": [
self.kwargs[self.lookup_field],
],
"notification_id":
str(uuid1()),
"action_name":
instance.action_name
})
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data,
context={'request': request})
if serializer.is_valid():
pleb = Pleb.get(request.user.username)
parent_object = cache.get(self.kwargs[self.lookup_field])
if parent_object is None:
parent_object = SBContent.nodes.get(
object_uuid=self.kwargs[self.lookup_field])
# Don't set it here as only questions will be
# retrievable/settable
serializer.save(owner=pleb, parent_object=parent_object)
serializer_data = serializer.data
'''
Not doing this yet as I don't know how much info we want to give
to someone about there info being flagged. I think we'll just want
to notify them just not give them the person who did flag their
content. We'll also need to allow them to provide a rebuttal.
data = {
"username": request.user.username,
"flag": serializer_data['object_uuid'],
"url": serializer_data['url'],
"parent_object": self.kwargs[self.lookup_field]
}
spawn_task(task_func=create_flag_relations, task_param=data)
'''
return Response(serializer_data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def populate_last_reputation_node(self):
skip = 0
while True:
query = 'MATCH (profile:Pleb) RETURN profile ' \
'SKIP %s LIMIT 25' % skip
skip += 24
res, _ = db.cypher_query(query)
if not res.one:
break
for profile in [Pleb.inflate(row[0]) for row in res]:
if profile.last_counted_vote_node is not None:
continue
else:
query = 'MATCH (v:Vote)<-[:LAST_VOTES]-' \
'(content:VotableContent)-[:OWNED_BY]->' \
'(p:Pleb {username: "******"}) ' \
'WITH v ORDER BY v.created DESC ' \
'RETURN v LIMIT 1' % profile.username
res, _ = db.cypher_query(query)
if res.one is not None:
profile.last_counted_vote_node = res.one['object_uuid']
profile.save()
self.stdout.write("completed vote population\n", ending='')
return True
def create(self, validated_data):
request, _, _, _, _ = gather_request_data(self.context)
stripe.api_key = settings.STRIPE_SECRET_KEY
stripe.api_version = settings.STRIPE_API_VERSION
donor = Pleb.get(request.user.username)
token = validated_data.pop('token', None)
# TODO add payment_method selection support to direct donations
# this pop is just to allow the donation to save using **validated_data
validated_data.pop('payment_method', None)
donation = Donation(owner_username=donor.username,
**validated_data).save()
if not donor.stripe_customer_id:
customer = stripe.Customer.create(
description="Customer for %s" % donor.username,
card=token,
email=donor.email)
donor.stripe_customer_id = customer['id']
donor.save()
cache.delete(donor.username)
donor.refresh()
donor.donations.connect(donation)
donation.owned_by.connect(donor)
charge = stripe.Charge.create(
amount=donation.amount,
currency="usd",
customer=donor.stripe_customer_id,
receipt_email=donor.email,
description="Donation to Sagebrew from %s" % donor.username
)
donation.stripe_charge_id = charge['id']
donation.save()
spawn_task(task_func=check_privileges,
task_param={"username": donor.username})
return donation
def create(self, validated_data):
request = self.context["request"]
owner = Pleb.get(request.user.username)
wall_owner = validated_data.pop('wall_owner_profile', None)
images = validated_data.pop('images', [])
included_urls = validated_data.pop('included_urls', [])
uuid = str(uuid1())
url = reverse('profile_page',
kwargs={'pleb_username': request.user.username},
request=request)
href = reverse('post-detail',
kwargs={'object_uuid': uuid},
request=request)
post = Post(owner_username=owner.username,
wall_owner_username=wall_owner.username,
object_uuid=uuid,
url=url,
href=href,
**validated_data).save()
post.owned_by.connect(owner)
wall = wall_owner.get_wall()
post.posted_on_wall.connect(wall)
wall.posts.connect(post)
[
post.uploaded_objects.connect(
UploadedObject.nodes.get(object_uuid=image))
for image in images
]
for url in included_urls:
try:
post.url_content.connect(URLContent.nodes.get(url=url))
except (DoesNotExist, URLContent.DoesNotExist):
pass
return post
def create(self, request, *args, **kwargs):
croppic = request.query_params.get('croppic', 'false').lower()
editor = request.query_params.get('editor', 'false').lower()
file_object = request.data.get('file_object', None)
if file_object is None:
file_object = request.data.get('file', None)
if file_object is None:
file_object = request.data.get('img', None)
serializer = self.get_serializer(data={"file_object": file_object},
context={'request': request})
if serializer.is_valid():
owner = Pleb.get(request.user.username)
upload = serializer.save(owner=owner)
if croppic == 'true':
return Response(
{
"status": "success",
"url": upload.url,
"width": upload.width,
"height": upload.height
},
status=status.HTTP_200_OK)
if editor == 'true':
return Response({"files": [serializer.data]},
status=status.HTTP_200_OK)
return Response(serializer.data, status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_notification_from(self, obj):
query = 'MATCH (a:Notification {object_uuid: "%s"})-' \
'[:NOTIFICATION_FROM]->(b:Pleb) RETURN b' % obj.object_uuid
res, _ = db.cypher_query(query)
if res.one is None:
return {}
return PlebSerializerNeo(Pleb.inflate(res[0][0])).data
def create(self, validated_data):
request = self.context["request"]
# Note that DRF requires us to use the source as the key here but
# tags prior to serializing
mission = None
tags = validated_data.pop('get_tags', [])
owner = Pleb.get(request.user.username)
mission_id = validated_data.get('mission', '')
if mission_id:
mission = Mission.get(mission_id)
validated_data['owner_username'] = owner.username
uuid = str(uuid1())
validated_data['content'] = render_content(
validated_data.get('content', ""))
url = reverse('question_detail_page',
kwargs={
'question_uuid': uuid,
"slug": slugify(validated_data['title'])
},
request=request)
href = reverse('question-detail',
kwargs={'object_uuid': uuid},
request=request)
soup = BeautifulSoup(validated_data['content'], "lxml").get_text()
question = Question(url=url,
href=href,
object_uuid=uuid,
summary=smart_truncate(soup),
**validated_data).save()
question.owned_by.connect(owner)
if mission is not None:
mission.associated_with.connect(question)
for tag in tags:
query = 'MATCH (t:Tag {name:"%s"}) WHERE NOT t:AutoTag ' \
'RETURN t' % slugify(tag)
res, _ = db.cypher_query(query)
if not res.one:
if (request.user.username == "devon_bleibtrey"
or request.user.username == "tyler_wiersing"
or owner.reputation >= 1250):
tag_obj = Tag(name=slugify(tag)).save()
question.tags.connect(tag_obj)
else:
continue
else:
tag_obj = Tag.inflate(res.one)
question.tags.connect(tag_obj)
spawn_task(task_func=update_tags, task_param={"tags": tags})
if validated_data.get('external_location_id', None) is not None:
spawn_task(
task_func=create_location_tree,
task_param={"external_id": question.external_location_id})
spawn_task(task_func=add_auto_tags_to_question_task,
task_param={"object_uuid": question.object_uuid})
spawn_task(task_func=create_question_summary_task,
task_param={'object_uuid': question.object_uuid})
question.refresh()
cache.set(question.object_uuid, question)
return question
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data,
context={"request": request})
if serializer.is_valid():
question = Question.nodes.get(
object_uuid=self.kwargs[self.lookup_field])
instance = serializer.save(question=question)
query = "MATCH (a:Question {object_uuid:'%s'})-[:OWNED_BY]->" \
"(b:Pleb) RETURN b" % (self.kwargs[self.lookup_field])
res, col = db.cypher_query(query)
question_owner = Pleb.inflate(res[0][0])
serializer = serializer.data
to_plebs = [question_owner.username]
mission = question.get_mission(question.object_uuid)
if mission:
to_plebs.append(mission['owner_username'])
spawn_task(task_func=spawn_notifications, task_param={
"from_pleb": request.user.username,
"sb_object": serializer['object_uuid'],
"url": reverse(
'single_solution_page',
kwargs={"object_uuid": serializer["object_uuid"]}),
# TODO discuss notifying all the people who have provided
# solutions on a given question.
"to_plebs": to_plebs,
"notification_id": str(uuid1()),
'action_name': instance.action_name
})
# Not going to add until necessary for search
# spawn_task(task_func=add_solution_to_search_index,
# task_param={"solution": serializer})
return Response(serializer, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def remove_profiles(self, instance):
for profile in self.data['profiles']:
profile_pleb = Pleb.get(username=profile)
instance.accountants.disconnect(profile_pleb)
profile_pleb.campaign_accountant.disconnect(instance)
cache.delete("%s_accountants" % instance.object_uuid)
return instance
def update_view_count_task(object_uuid, username):
try:
profile = Pleb.get(username)
except (Pleb.DoesNotExist, DoesNotExist) as e:
raise update_view_count_task.retry(exc=e, max_retries=5, countdown=45)
sb_object = cache.get(object_uuid)
if sb_object is None:
sb_object = Searchable.nodes.get(object_uuid=object_uuid)
query = 'MATCH (a:Pleb {username: "******"})-[b:VIEWED]->' \
' (c:Searchable {object_uuid: "%s"}) RETURN b' % (
username, object_uuid)
res, col = db.cypher_query(query)
if len(res) == 0:
res = update_view_count(sb_object)
if isinstance(res, Exception):
raise update_view_count_task.retry(exc=res,
countdown=5,
max_retries=None)
relationship = profile.viewed.connect(sb_object)
sb_object.viewed_by.connect(profile)
else:
relationship = profile.viewed.relationship(sb_object)
relationship.times_viewed += 1
relationship.save()
return True
def repopulate_elasticsearch(self):
# Profiles
skip = 0
while True:
query = 'MATCH (profile:Pleb) RETURN DISTINCT profile ' \
'SKIP %s LIMIT 25' % skip
skip += 24
res, _ = db.cypher_query(query)
if not res.one:
break
for profile in [Pleb.inflate(row[0]) for row in res]:
update_search_object.apply_async(kwargs={
"object_uuid": profile.object_uuid,
"label": "pleb"
})
# Questions
skip = 0
while True:
query = 'MATCH (question:Question) RETURN DISTINCT question ' \
'SKIP %s LIMIT 25' % skip
skip += 24
res, _ = db.cypher_query(query)
if not res.one:
break
for question in [Question.inflate(row[0]) for row in res]:
update_search_object.apply_async(kwargs={
"object_uuid": question.object_uuid,
"label": "question"
})
# Quests
skip = 0
while True:
query = 'MATCH (quest:Quest) RETURN DISTINCT quest ' \
'SKIP %s LIMIT 25' % skip
skip += 24
res, _ = db.cypher_query(query)
if not res.one:
break
for quest in [Quest.inflate(row[0]) for row in res]:
update_search_object.apply_async(kwargs={
"object_uuid": quest.object_uuid,
"label": "quest"
})
# Missions
skip = 0
while True:
query = 'MATCH (mission:Mission) RETURN DISTINCT mission ' \
'SKIP %s LIMIT 25' % skip
skip += 24
res, _ = db.cypher_query(query)
if not res.one:
break
for mission in [Mission.inflate(row[0]) for row in res]:
update_search_object.apply_async(kwargs={
"object_uuid": mission.object_uuid,
"label": "mission"
})
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
if serializer.is_valid():
serializer.save(owner=Pleb.get(self.request.user.username))
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def dispatch(self, *args, **kwargs):
profile = Pleb.get(username=self.request.user.username)
if self.request.user.username == 'tyler_wiersing' \
or self.request.user.username == 'devon_bleibtrey' or \
profile.reputation >= 10000:
return super(CouncilView, self).dispatch(*args, **kwargs)
return redirect('profile_page',
pleb_username=self.request.user.username)
def create(self, request, *args, **kwargs):
object_uuid = self.kwargs[self.lookup_field]
now = str(datetime.now(pytz.utc))
vote_data = request.data
serializer = self.get_serializer(data=vote_data,
context={"request": request})
if not Pleb.get(request.user.username).is_verified:
return Response(
{
"detail":
"Sorry, you cannot vote unless you are verified!",
"status":
status.HTTP_401_UNAUTHORIZED,
"developer_message":
"A user can only vote on content "
"if they are verified."
},
status=status.HTTP_401_UNAUTHORIZED)
if serializer.is_valid():
parent_object_uuid = self.kwargs[self.lookup_field]
vote_status = int(serializer.validated_data['vote_type'])
handle_vote(parent_object_uuid, vote_status, request.user.username,
now)
async_result = cache.get("%s_%s_vote" %
(request.user.username, object_uuid))
task_params = {
"username": request.user.username,
"object_uuid": object_uuid
}
if async_result is not None:
# if there is already a task lined up,
# revoke it and spawn a new one
async_result.revoke()
# spawn a task which will execute 30 seconds from now
# potential improvement here is to have a way to detect if the
new_task = spawn_task(spawn_user_updates,
task_param=task_params,
countdown=30)
cache.set("%s_%s_vote" % (request.user.username, object_uuid),
new_task)
search_result = cache.get("%s_vote_search_update" % object_uuid)
if search_result is not None:
search_result.revoke()
task_param = {"object_uuid": object_uuid}
spawned = spawn_task(task_func=update_search_object,
task_param=task_param,
countdown=10)
cache.set("%s_vote_search_update" % object_uuid, spawned)
return Response({
"detail": "Successfully created or modified "
"vote.",
"status": status.HTTP_200_OK,
"developer_message": None
})
else:
return Response(serializer.errors, status=400)
def endorsements(self, request, object_uuid=None):
serialized = []
endorsements = Mission.get_endorsements(object_uuid)
page = self.paginate_queryset(endorsements)
for node in page:
if "Pleb" in node.labels:
serialized.append(PlebSerializerNeo(Pleb.inflate(node.e)).data)
if "Quest" in node.labels:
serialized.append(QuestSerializer(Quest.inflate(node.e)).data)
return self.get_paginated_response(serialized)
def update(self, instance, validated_data):
current_moderators = cache.get(
"%s_moderators" % instance.owner_username, [])
for profile in \
list(set(validated_data['profiles']) - set(
current_moderators)):
profile_pleb = Pleb.get(username=profile)
instance.moderators.connect(profile_pleb)
cache.delete("%s_moderators" % instance.owner_username)
return instance
def update(self, instance, validated_data):
request, _, _, _, _ = gather_request_data(self.context)
stripe.api_key = settings.STRIPE_SECRET_KEY
stripe.api_version = settings.STRIPE_API_VERSION
mission = validated_data.pop('mission', None)
quest = validated_data.pop('quest', None)
payment_method = validated_data.pop('payment_method', None)
donor = Pleb.get(instance.owner_username)
quest_desc = quest.title \
if quest.title else "%s %s" % (quest.first_name, quest.last_name)
mission_desc = mission.get_mission_title()
description = "Gift purchase to %s's mission for %s" % (quest_desc,
mission_desc)
payment_method = payment_method if payment_method is not None \
else donor.stripe_default_card_id
stripe_res = stripe.Charge.create(customer=donor.stripe_customer_id,
amount=instance.total,
currency="usd",
description=description,
receipt_email=donor.email,
source=payment_method)
instance.stripe_charge_id = stripe_res['id']
instance.paid = True
instance.save()
message_data = {
'message_type':
'email',
'subject':
'New Gift',
'body':
get_template('orders/email/new_order.html').render(
Context({
'first_name': quest.first_name,
'mission_title': mission_desc,
"donor_first_name": donor.first_name,
"donor_last_name": donor.last_name,
})),
'template':
"personal",
'from_user': {
'type': "admin",
'id': settings.INTERCOM_ADMIN_ID_DEVON
},
'to_user': {
'type': "user",
'user_id': quest.owner_username
}
}
serializer = IntercomMessageSerializer(data=message_data)
serializer.is_valid(raise_exception=True)
serializer.save()
return instance
def update(self, instance, validated_data):
current_accountants = cache.get(
"%s_accountants" % instance.object_uuid, [])
for profile in \
list(set(validated_data['profiles']) - set(
current_accountants)):
profile_pleb = Pleb.get(username=profile)
instance.accountants.connect(profile_pleb)
profile_pleb.campaign_accountant.connect(instance)
cache.delete("%s_accountants" % instance.object_uuid)
return instance
def update_search_query(username, query_param, keywords):
"""
This task creates a search query node then calls the task to create and
attach keyword nodes to the search query node
:param username:
:param query_param:
:param keywords:
:return:
"""
try:
res, _ = db.cypher_query("MATCH (a:Pleb {username:'******'}) RETURN a" %
username)
if res.one:
res.one.pull()
pleb = Pleb.inflate(res.one)
else:
raise update_search_query.retry(exc=DoesNotExist(
"Profile with username: "******"%s does not exist" % username),
countdown=3,
max_retries=None)
except (CypherException, IOError) as e:
raise update_search_query.retry(exc=e, countdown=3, max_retries=None)
try:
search_query = SearchQuery.nodes.get(search_query=query_param)
if pleb.searches.is_connected(search_query):
rel = pleb.searches.relationship(search_query)
rel.times_searched += 1
rel.last_searched = datetime.now(pytz.utc)
rel.save()
return True
else:
rel = pleb.searches.connect(search_query)
rel.save()
search_query.searched_by.connect(pleb)
return True
except (SearchQuery.DoesNotExist, DoesNotExist):
search_query = SearchQuery(search_query=query_param)
search_query.save()
search_query.searched_by.connect(pleb)
rel = pleb.searches.connect(search_query)
rel.save()
for keyword in keywords:
keyword['query_param'] = query_param
spawned = spawn_task(task_func=create_keyword, task_param=keyword)
if isinstance(spawned, Exception) is True:
return spawned
return True
except (CypherException, IOError) as e:
raise update_search_query.retry(exc=e, countdown=3, max_retries=None)
except Exception as e:
raise update_search_query.retry(exc=e, countdown=3, max_retries=None)
def crop(self, request, object_uuid=None):
resize = self.request.query_params.get("resize", "false").lower()
croppic = self.request.query_params.get('croppic', 'false').lower()
img_file = urllib2.urlopen(request.data['imgUrl'])
read_file = img_file.read()
file_object = BytesIO(read_file)
image = Image.open(file_object)
image_format = image.format
crop_serializer = CropSerializer(data=request.data)
if crop_serializer.is_valid():
crop_data = crop_serializer.data
else:
return Response(crop_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
if resize == 'true':
image = resize_image(image, int(crop_data['resize_width']),
int(crop_data['resize_height']))
cropped_image = crop_image2(image, crop_data['crop_width'],
crop_data['crop_height'],
crop_data['image_x1'],
crop_data['image_y1'])
# Fill cropped image into buffer
file_stream = BytesIO()
cropped_image.save(file_stream, format=image_format)
file_stream.seek(0)
# Upload cropped pic and then run serializer
# Not the best solution but simplifies the logic. If someone has a
# better approach feel free to update. Perhaps an InMemoryFile passed
# to the serializer
file_name = "%s-%sx%s.%s" % (object_uuid, crop_data['crop_width'],
crop_data['crop_height'],
image_format.lower())
serializer = upload_modified_image(file_name, file_stream.read(),
request, object_uuid)
if serializer.is_valid():
owner = Pleb.get(request.user.username)
upload = serializer.save(owner=owner)
if croppic == 'true':
profile_page_url = reverse(
"profile_page",
kwargs={"pleb_username": request.user.username},
request=request)
return Response(
{
"status": "success",
"url": upload.url,
"profile": profile_page_url
},
status=status.HTTP_200_OK)
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)