def get_translations(request, article_id):
article = Article.objects.get(id=article_id)
if not request.user.is_superuser and article.author_created_id != request.user.id:
return BaseError.NOT_ALLOWED
translations = Article.objects.filter(base_article_id=article.id)
return State.from_objects(translations, TermDefinition.objects.all())
def set_article_owner(request, article_id):
article = Article.objects.get(id=article_id)
new_owner_id = int(request.POST["newOwner"])
article.author_created_id = new_owner_id
article.save()
return State.from_objects(article)
def create_entry(request):
if int(request.POST["articleId"]) != 0:
article = Article.objects.get(id=int(request.POST["articleId"]))
else:
article = Article(author_created=request.user, name=request.POST["name"])
article.save()
entry = DocumentationEntry.objects.create(parent_id=int(request.POST["parentId"]),
name=request.POST["name"],
url_name=request.POST["urlName"],
parent_index=int(request.POST["parentIndex"]),
article=article)
entry.save()
return State.from_objects(entry, entry.article)
def edit_translation(request):
key_info = None
if "editEntries" in request.POST.keys():
decoder = json.JSONDecoder()
entries = decoder.decode(request.POST["editEntries"])
error = check_translation_entries(entries)
if error is not None:
return error
edit_translation_entries(entries)
elif "editKeys" in request.POST.keys():
decoder = json.JSONDecoder()
change = decoder.decode(request.POST["editKeys"])
if change["type"] == "add":
keys = [x.strip() for x in change["keys"].splitlines()]
for key_value in keys:
if not key_value:
return LocalizationError.ONE_INVALID_TRANSLATION_KEY
count_added = 0
for key_value in keys:
if TranslationKey.objects.get_or_create(value=key_value)[1]:
count_added += 1
key_info = {
"added": count_added,
"alreadyExists": len(keys) - count_added
}
elif change["type"] == "delete":
key_id = int(change["keyId"])
key = TranslationKey.objects.get(id=key_id)
if not key:
return LocalizationError.TRANSLATION_KEY_NOT_FOUND
key.delete()
elif change["type"] == "rename":
key_id = int(change["keyId"])
new_value = change["newValue"]
key = TranslationKey.objects.get(id=key_id)
if not key:
return LocalizationError.TRANSLATION_KEY_NOT_FOUND
if not new_value:
return LocalizationError.INVALID_TRANSLATION_VALUE
key.value = new_value
key.save()
return State.from_objects(TranslationEntry.objects.all(),
TranslationKey.objects.all()).to_response({
"succes":
True,
"keyInfo":
key_info
})
def create_message_from_request(self, request, stream_names=None):
user = request.user
content = request.POST["message"]
virtual_id = request.POST.get("virtualId", None)
if virtual_id and len(virtual_id) > 128:
return None, ChatError.INVALID_MESSAGE_CONTENT
message = self.create_message(user,
content,
virtual_id=virtual_id,
stream_names=stream_names)
return message, State.from_objects(message).to_response(
extra={"messageId": message.id})
def edit_entry(request):
entry = DocumentationEntry.objects.get(id=request.POST["entryId"])
if int(request.POST["articleId"]) != 0:
article = Article.objects.get(id=int(request.POST["articleId"]))
else:
article = Article(author_created=request.user, name=request.POST["name"])
article.save()
entry.name = request.POST["name"]
entry.url_name = request.POST["urlName"]
entry.parent_index = int(request.POST["parentIndex"])
entry.article = article
entry.save()
return State.from_objects(entry, entry.article)
def edit_profile(request):
save_user = False
if "firstName" in request.POST and request.user.first_name != request.POST[
"firstName"]:
request.user.first_name = request.POST["firstName"]
save_user = True
if "lastName" in request.POST and request.user.last_name != request.POST[
"lastName"]:
request.user.last_name = request.POST["lastName"]
save_user = True
if "userName" in request.POST and request.user.username != request.POST[
"userName"]:
request.user.username = request.POST["userName"]
save_user = True
if "displayName" in request.POST and request.user.display_name != request.POST[
"displayName"]:
request.user.display_name = json.loads(request.POST["displayName"])
save_user = True
if "receivesEmailAnnouncements" in request.POST:
receives_email_announcements = json.loads(
request.POST["receivesEmailAnnouncements"])
if request.user.receives_email_announcements != receives_email_announcements:
request.user.receives_email_announcements = receives_email_announcements
save_user = True
if "customSettingsKey" in request.POST:
# TODO: add ability to save multiple ones in the same request
request.user.set_custom_setting(request.POST["customSettingsKey"],
request.POST["customSettingsValue"])
if "localeLanguageId" in request.POST:
request.user.locale_language_id = int(request.POST["localeLanguageId"])
save_user = True
if save_user:
try:
request.user.full_clean()
request.user.save()
except ValidationError as e:
return {"error": e.message_dict}
request.user.publish_event("profileChanged", request.user)
return State.from_objects([UserSummary(request.user)
]).to_response(extra={"success": True})
def public_user_profiles(request):
if "usernamePrefix" in request.GET:
username_prefix = request.GET["usernamePrefix"]
precise_user = get_user_manager().filter(
username__iexact=username_prefix)
prefix_users = get_user_manager().filter(
username__istartswith=username_prefix)[:10]
users = list(precise_user) + list(prefix_users)
else:
user_ids = int_list(request.GET.getlist("ids[]"))
if len(user_ids) > 512:
# TODO: log this, may need to ban someone
return AccountsError.TOO_MANY_PROFILES_REQUESTED
users = get_user_manager().filter(id__in=user_ids)
return State.from_objects(get_public_user_class().wrap_user_list(users))
def questionnaire_submit(request):
questionnaire_id = int(request.POST["questionnaireId"])
questionnaire = Questionnaire.objects.get(id=questionnaire_id)
if not request.user.is_superuser and not questionnaire.visible:
return BaseError.NOT_ALLOWED
instance = QuestionnaireInstance.objects.get(user=request.user,
questionnaire=questionnaire)
# if instance.date_submitted:
# return BaseError.NOT_ALLOWED
instance.date_submitted = timezone.now()
instance.save()
return State.from_objects(instance)
def questionnaire_answer(request):
questionnaire_id = int(request.POST["questionnaireId"])
questionnaire = Questionnaire.objects.get(id=questionnaire_id)
if not request.user.is_superuser and not questionnaire.visible:
return BaseError.NOT_ALLOWED
question = QuestionnaireQuestion.objects.get(
id=int(request.POST["questionId"]))
if question.questionnaire_id != questionnaire.id:
return BaseError.NOT_ALLOWED
instance = QuestionnaireInstance.objects.get(user=request.user,
questionnaire=questionnaire)
# if instance.date_submitted:
# return BaseError.NOT_ALLOWED
question_response, created = QuestionnaireQuestionResponse.objects.get_or_create(
instance=instance, question=question)
question_response.text = request.POST.get("text", None)
if question.type == 2: # Single choice
choice_id = request.POST.getlist("choiceIds[]", [])
print(choice_id)
if len(choice_id):
choice_id = choice_id[0]
question_choice = QuestionnaireQuestionOption.objects.get(
id=choice_id)
if question_choice.question_id != question.id:
return BaseError.NOT_ALLOWED
question_response.choices.set([question_choice])
else:
question_response.choices.set([])
if question.type == 3: # Multiple choice
choice_ids = request.POST.getlist("choiceIds[]", [])
question_choices = QuestionnaireQuestionOption.objects.filter(
id__in=choice_ids)
if len(question_choices) != len(choice_ids):
return BaseError.NOT_ALLOWED
for question_choice in question_choices:
if question_choice.question_id != question.id:
return BaseError.NOT_ALLOWED
question_response.choices.set(list(question_choices))
question_response.save()
return State.from_objects(question_response)
def create_article(request):
# TODO: check a limit here
if not request.user.is_superuser:
return BaseError.NOT_ALLOWED
name = request.POST.get("name", "Untitled Article " + str(time.time()))
dependency = request.POST.get("dependency", "")
language_id = request.POST.get("languageId", 1)
is_public = json.loads(request.POST["isPublic"])
owner_id = request.user.id
if "userCreatedId" in request.POST:
owner_id = int(request.POST["userCreatedId"])
article = Article(author_created_id=owner_id,
name=name,
dependency=dependency,
language_id=language_id,
is_public=is_public)
if "baseArticleId" in request.POST:
article.base_article_id = int(request.POST["baseArticleId"])
try:
article.save()
except IntegrityError as e:
# TODO: really @Rocky, 23505????
if e.__cause__.pgcode == '23505':
return ContentError.TRANSLATION_EXISTS
raise
if "markup" in request.POST:
article.edit(
request.user,
request.POST["markup"],
)
state = State.from_objects(article)
return state.to_response({"article": article})
def create_entry_discussion(request):
entry_id = int(request.POST["entryId"])
entry = BlogEntry.objects.get(id=entry_id)
entry.create_discussion()
entry.save()
return State.from_objects(entry)
def account_settings(request):
return State.from_objects(UserSummary(request.user))
def get_available_articles(request):
articles = Article.get_editable_articles(request.user)
return State.from_objects(articles)
def email_manager(request):
return State.from_objects(EmailCampaign.objects.all(),
EmailTemplate.objects.all(),
EmailGateway.objects.all())
def get_user_notifications(request):
return State.from_objects(request.user.notifications.all(),
UserSummary(request.user))
def command_manager(request):
return State.from_objects(CommandInstance.objects.all(),
CommandRun.objects.all())
def article_manager_view(request):
articles = Article.get_editable_articles(request.user)
return State.from_objects(articles)