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 get_focused_on(self, request=None):
from api.neo_models import SBObject
from sb_quests.neo_models import Position
from sb_quests.serializers import PositionSerializer
from sb_tags.neo_models import Tag
from sb_tags.serializers import TagSerializer
from sb_questions.neo_models import Question
from sb_questions.serializers import QuestionSerializerNeo
query = 'MATCH (a:Mission {object_uuid: "%s"})-[:FOCUSED_ON]->(b)' \
'RETURN b' % self.object_uuid
res, _ = db.cypher_query(query)
if res.one:
child_label = SBObject.inflate(res.one).get_child_label()
if child_label == "Position":
return PositionSerializer(Position.inflate(res.one),
context={
'request': request
}).data
elif child_label == "Tag":
return TagSerializer(Tag.inflate(res.one),
context={
'request': request
}).data
elif child_label == "Question":
return QuestionSerializerNeo(Question.inflate(res.one),
context={
'request': request
}).data
else:
return None
def create(self, validated_data):
from sb_tags.neo_models import Tag
from sb_tags.serializers import TagSerializer
request, _, _, _, _ = gather_request_data(self.context)
generated_tags = []
if request is None:
raise serializers.ValidationError(
"Must perform creation from web request")
for tag in validated_data['interests']:
try:
query = 'MATCH (profile:Pleb {username: "******"}), ' \
'(tag:Tag {name: "%s"}) ' \
'CREATE UNIQUE (profile)-[:INTERESTED_IN]->(tag) ' \
'RETURN tag' % (request.user.username, slugify(tag))
res, _ = db.cypher_query(query)
generated_tags.append(TagSerializer(Tag.inflate(res.one)).data)
except(ConstraintViolation, Exception):
pass
cache.delete(request.user.username)
return generated_tags
def limit_offset_query(skip, limit):
query = 'MATCH (tag:Tag) WHERE NOT tag:AutoTag ' \
'RETURN tag SKIP %s LIMIT %s' % (skip, limit)
res, _ = db.cypher_query(query)
return [Tag.inflate(row[0]) for row in res]
