def test_create_tagreport_1(self):
os.environ["STAGE"] = "dev"
with Session() as session:
# creating items
item = Item()
item.content = "RKI bestätigt Covid-19 Sterblichkeitsrate von 0,01 Prozent in (...) - Corona Transition "
item.language = "de"
item = item_handler.create_item(item, session)
list_tags = [
'Corona-Maßnahmen', 'Senkung der Treibhausgasemissionen',
'China', 'Film', 'Menschen', 'Kanzlerkandidatur', 'sars-cov-2',
'#verunglimpft', 'g.co/privacytools', 'Gregor Gysi',
'Bundestagswahl2021', '19', '-',
'Statistik falsch interpretiert', 'Bild.de', 'JF',
'MdB Hansjörg Müller (AFD)', '100 Tage', 'Gruene',
'#notwendige Polizeimaßnahmen', 'Sonne'
]
for _ in range(200):
list_tags.append(
random.choice(list_tags) + "-" + random.choice(list_tags))
# store tags
event = {"item": item.to_dict(), "Tags": list_tags}
context = ""
EnrichItem.store_itemtags(event, context)
event = ""
context = ""
s = time.perf_counter()
GetTags.create_tagreport(event, context)
elapsed = time.perf_counter() - s
assert elapsed < 30
def test_questions_and_answers():
with Session() as session:
q1 = ReviewQuestion()
q1.id = "1"
q1.content = "Es ist eine Quelle angegeben."
q2 = ReviewQuestion()
q2.id = "2"
q2.content = "Die Rechtschreibung ist korrekt."
o1 = AnswerOption()
o1.id = "1"
o1.text = "Stimme zu"
o1.value = 4
q1.options = [o1]
assert len(q1.options) == 1
assert len(o1.questions) == 1
q2.options = [o1]
assert len(q1.options) == 1
assert len(o1.questions) == 2
session.add(q1)
session.add(q2)
session.add(o1)
options = session.query(AnswerOption).all()
assert len(options) == 1
def test_get_items(test_item_type, item1, item2, item_with_type):
with Session() as session:
session.add(test_item_type)
session.add(item1)
session.add(item2)
session.add(item_with_type)
session.commit()
event = {}
response_body = json.loads(get_items(event, None)['body'])
assert len(response_body) == 3
assert all('test' in i['item_type']['name'] for i in response_body)
event = {'queryStringParameters': None}
response_body = json.loads(get_items(event, None)['body'])
assert len(response_body) == 3
assert all('test' in i['item_type']['name'] for i in response_body)
event = get_event('status', 'open')
response_body = json.loads(get_items(event, None)['body'])
assert len(response_body) == 2
assert all('test' in i['item_type']['name'] for i in response_body)
event = get_event('NotAnAttribute', 'open')
response = get_items(event, None)
assert response['statusCode'] == 400
def test_submit_unsafe_item(monkeypatch):
# Set environment variable
monkeypatch.setenv("STAGE", "dev")
monkeypatch.setenv("MOTO_ACCOUNT_ID", '891514678401')
from moto import mock_ses, mock_stepfunctions
with mock_stepfunctions(), mock_ses():
# Initialize mock clients
sf_client = boto3.client('stepfunctions', region_name="eu-central-1")
sf_client.create_state_machine(
name='SearchFactChecks_new-dev',
definition='{}',
roleArn=
'arn:aws:iam::891514678401:role/detektivkollektiv-stepfunct-StateMachineLambdaRole'
)
ses_client = boto3.client("ses", region_name="eu-central-1")
ses_client.verify_email_identity(EmailAddress="*****@*****.**")
with Session() as session:
session = setup_scenarios.create_questions(session)
# Submit first item
response = submit_item(create_event2(), None)
assert response['statusCode'] == 403
assert response['headers']['new-item-created'] == "True"
# Check database entries
assert session.query(Item).count() == 1
assert session.query(Submission).count() == 1
submission = session.query(Submission).first()
assert submission.status == 'Unsafe'
assert submission.item.urls[0].url.unsafe is None
assert submission.item.urls[1].url.unsafe == "GOOGLE:MALWARE"
def confirm_submission(event, context):
helper.log_method_initiated("Confirm submission", event, logger)
submission_id = event['pathParameters']['submission_id']
stage = os.environ['STAGE']
if stage == 'prod':
link = 'https://codetekt.org'
else:
link = 'https://{}.codetekt.org'.format(stage)
body_html = io.open(os.path.join(os.path.dirname(__file__), 'resources',
'submission_confirmed_webpage.html'), mode='r', encoding='utf-8').read().format(link)
with Session() as session:
try:
submission_handler.confirm_submission(submission_id, session)
response = {
'statusCode': 200,
'headers': {"content-type": "text/html; charset=utf-8"},
'body': body_html
}
except Exception:
response = {
"statusCode": 500,
"body": "Could not confirm submission. Stacktrace: {}".format(traceback.format_exc())
}
return helper.set_cors(response, event)
def test_reset_locked_items(item, pair, old_junior_review, new_senior_review):
with Session() as session:
session.add(item)
session.add(old_junior_review)
session.add(new_senior_review)
session.add(pair)
session.commit()
rips = session.query(Review).all()
assert len(rips) == 2
response = reset_locked_items(None, None)
assert response['statusCode'] == 200
assert "1" in response['body']
rips = session.query(Review).all()
assert len(rips) == 1
item = item_handler.get_item_by_id(item.id, session)
assert item.in_progress_reviews_level_2 == 1
assert item.in_progress_reviews_level_1 == 0
# reload object instead of refreshing the session
pair = session.query(ReviewPair).one()
assert pair.junior_review_id == None
assert pair.senior_review_id == new_senior_review.id
def reset_locked_items(event, context):
logger = logging.getLogger()
logger.setLevel(logging.INFO)
helper.log_method_initiated("Reset locked items", event, logger)
with Session() as session:
try:
reviews_in_progress = review_handler.get_old_reviews_in_progress(
session)
review_handler.delete_old_reviews_in_progress(
reviews_in_progress, session)
return {
"statusCode": 200,
'headers': {
"content-type": "application/json; charset=utf-8"
},
"body": "{} Review(s) deleted".format(len(reviews_in_progress))
}
except Exception:
return {
"statusCode":
400,
"body":
"Something went wrong. Check HTTP POST payload. Stacktrace: {}"
.format(traceback.format_exc())
}
def test_extract_claim_1(self):
with Session() as session:
urls = [
"https://www.spiegel.de/wissenschaft/mensch/corona-krise-und-klimawandel-fuenf-desinformations-tricks-die-jeder-kennen-sollte-a-6892ff9b-fb28-43ae-8438-55b49d607e57?sara_ecid=soci_upd_wbMbjhOSvViISjc8RPU89NcCvtlFcJ"
]
item = create_item_with_urls(session, urls)
event = {
"item": {
"content":
"Wollen wir auch einen Channel für solche Themen anlegen?"
"https://www.spiegel.de/wissenschaft/mensch/corona-krise-und-klimawandel-fuenf"
"-desinformations-tricks-die-jeder-kennen-sollte-a-6892ff9b-fb28-43ae-8438-55b49d607e57"
"?sara_ecid=soci_upd_wbMbjhOSvViISjc8RPU89NcCvtlFcJ",
"id":
item.id,
"language":
""
}
}
resp = ExtractClaim.extract_claim(event, "")
text_0 = "Wollen wir auch einen Channel für solche Themen anlegen?"
title = "Corona-Krise und Klimawandel: Fünf Desinformations-Tricks, die jeder kennen sollte " \
"- DER SPIEGEL "
assert resp["title"] == title
assert resp["concatenation"]["Text"] == text_0 + '\n' + title
def test_level_system():
with Session() as session:
session = setup_scenarios.create_levels_junior_and_senior_detectives(
session)
junior_detective1 = user_handler.get_user_by_id("1", session)
assert junior_detective1.level_id == 1
assert junior_detective1.experience_points == 0
user_handler.give_experience_point(junior_detective1.id, session)
junior_detective1 = user_handler.get_user_by_id(
junior_detective1.id, session)
assert junior_detective1.level_id == 1
assert junior_detective1.experience_points == 1
for _ in range(5):
user_handler.give_experience_point(junior_detective1.id, session)
junior_detective1 = user_handler.get_user_by_id(
junior_detective1.id, session)
assert junior_detective1.level_id == 2
assert junior_detective1.experience_points == 6
def store_itemtags(event, context):
"""stores tags of an item
Parameters
----------
event: dict, required
item
Tags
Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
context: object, required
Lambda Context runtime methods and attributes
Context doc: https://docs.aws.amazon.com/lambda/latest/dg/python-context-object.html
Returns
------
API Gateway Lambda Proxy Output Format: application/json
Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
"""
with Session() as session:
# extract item id
item_id = event['item']['id']
# Store all tags of the item
for str_tag in event['Tags']:
tag_handler.store_tag_for_item(item_id, str_tag, session)
def update_item(event, context):
"""stores data related to item
Parameters
----------
event: dict, required
item
Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
context: object, required
Lambda Context runtime methods and attributes
Context doc: https://docs.aws.amazon.com/lambda/latest/dg/python-context-object.html
Returns
------
API Gateway Lambda Proxy Output Format: application/json
Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
"""
with Session() as session:
# Parse event dict to Item object
item = Item()
json_event = event['item']
for key in json_event:
setattr(item, key, json_event[key])
update_object(item, session)
def post_comment_on_item(event, context=None):
"""
Creates comment on item from archive
"""
with Session() as session:
logger = logging.getLogger()
logger.setLevel(logging.INFO)
try:
body = json.loads(event['body']) if isinstance(
event['body'], str) else event['body']
except:
return helper.get_text_response(
400, "Malformed request. Please provide a valid request.",
event)
try:
user_id = helper.cognito_id_from_event(event)
body = json.loads(event['body']) if isinstance(
event['body'], str) else event['body']
except:
return helper.get_text_response(
400,
"Malformed request. Could not read user_id from context data.",
event)
if 'item_id' not in body:
return helper.get_text_response(
400, "Malformed request. Please provide an item_id.", event)
try:
item = item_handler.get_item_by_id(body['item_id'], session)
except:
return helper.get_text_response(404, "Item not found", event)
# Save qualitative_comment
if 'comment' in body:
try:
comment = comment_handler.create_comment(
session,
comment=body['comment'],
user_id=user_id,
parent_type='item',
parent_id=item.id)
response = {
"statusCode": 201,
'headers': {
"content-type": "application/json; charset=utf-8"
},
"body": json.dumps(comment.to_dict())
}
return helper.set_cors(response, event)
except:
return helper.get_text_response(
404, "No qualitative comment found.", event)
def store_itemphrases(event, context):
"""stores key phrases of an item
Parameters
----------
event: dict, required
item
KeyPhrases
Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
context: object, required
Lambda Context runtime methods and attributes
Context doc: https://docs.aws.amazon.com/lambda/latest/dg/python-context-object.html
Returns
------
API Gateway Lambda Proxy Output Format: application/json
Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
"""
with Session() as session:
# Store all entities of the item
for str_phrase in event['KeyPhrases']:
phrase = Keyphrase()
# search for entity in database
try:
phrase = keyphrase_handler.get_phrase_by_content(str_phrase, session)
except Exception:
# store phrase in database
phrase.id = str(uuid4())
phrase.phrase = str_phrase
try:
update_object(phrase, session)
except Exception as e:
logger.error(
"Could not store key phrase. Exception: %s", e, exc_info=True)
raise
# store item keyphrase in database
itemphrase = ItemKeyphrase()
# item phrase already exists?
item_id = event['item']['id']
try:
itemphrase = keyphrase_handler.get_itemphrase_by_phrase_and_item_id(
phrase.id, item_id, session)
except Exception:
itemphrase.id = str(uuid4())
itemphrase.item_id = item_id
itemphrase.keyphrase_id = phrase.id
try:
update_object(itemphrase, session)
except Exception as e:
logger.error(
"Could not store item key phrase. Exception: %s", e, exc_info=True)
raise
def store_itemsentiment(event, context):
"""stores sentiment of an item
Parameters
----------
event: dict, required
item
Sentiment
Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
context: object, required
Lambda Context runtime methods and attributes
Context doc: https://docs.aws.amazon.com/lambda/latest/dg/python-context-object.html
Returns
------
API Gateway Lambda Proxy Output Format: application/json
Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
"""
with Session() as session:
# Store the sentiment of the item
sentiment = Sentiment()
# search for sentiment in database
str_sentiment = event['Sentiment']
try:
sentiment = sentiment_handler.get_sentiment_by_content(str_sentiment, session)
except Exception:
# store sentiment in database
sentiment.id = str(uuid4())
sentiment.sentiment = str_sentiment
try:
update_object(sentiment, session)
except Exception as e:
logger.error(
"Could not store sentiment. Exception: %s", e, exc_info=True)
raise
# store item sentiment in database
itemsentiment = ItemSentiment()
# item entity already exists?
item_id = event['item']['id']
try:
itemsentiment = sentiment_handler.get_itemsentiment_by_sentiment_and_item_id(
sentiment.id, item_id, session)
except Exception:
itemsentiment.id = str(uuid4())
itemsentiment.item_id = item_id
itemsentiment.sentiment_id = sentiment.id
try:
update_object(itemsentiment, session)
except Exception as e:
logger.error(
"Could not store item sentiment. Exception: %s", e, exc_info=True)
raise
def test_tags_to_dict():
with Session() as session:
user = User(id=str(uuid4()), name='user1')
level = Level(id=1, description='beginner')
item = Item(id=str(uuid4()), content='item')
tag1 = Tag(id=str(uuid4()), tag='tag1')
tag2 = Tag(id=str(uuid4()), tag='tag2')
tag3 = Tag(id=str(uuid4()), tag='tag3')
review = Review()
review.id = str(uuid4())
review.is_peer_review = False
review.user_id = user.id
review.item_id = item.id
session.add_all([user, item, tag1, tag2, tag3, review, level])
session.commit()
review_dict = review.to_dict(with_tags=True, with_user=True)
assert 'tags' in review_dict
assert len(review_dict['tags']) == 0
item_tag1 = ItemTag(id=str(uuid4()),
item_id=item.id,
tag_id=tag1.id,
review_id=review.id)
session.add(item_tag1)
session.commit()
session.refresh(review)
review_dict = review.to_dict(with_tags=True, with_user=True)
assert 'tags' in review_dict
assert len(review_dict['tags']) == 1
assert review_dict['tags'][0] == 'tag1'
item_tag2 = ItemTag(id=str(uuid4()),
item_id=item.id,
tag_id=tag2.id,
review_id=review.id)
session.add(item_tag2)
session.commit()
session.refresh(review)
review_dict = review.to_dict(with_tags=True, with_user=True)
assert 'tags' in review_dict
assert len(review_dict['tags']) == 2
assert 'tag2' in review_dict['tags']
session.delete(item_tag1)
session.commit()
session.refresh(review)
review_dict = review.to_dict(with_tags=True, with_user=True)
assert 'tags' in review_dict
assert len(review_dict['tags']) == 1
assert review_dict['tags'][0] == 'tag2'
def get_review(event, context):
"""Gets a review.
Parameters
----------
- user_id is retrieved from the event
- review_id is retrieved from query parameters
Returns
------
- Status code 200 OK
- The requested review
"""
logger = logging.getLogger()
logger.setLevel(logging.INFO)
helper.log_method_initiated("Get Review", event, logger)
try:
# get cognito id
user_id = helper.cognito_id_from_event(event)
except:
return helper.get_text_response(
400, "Malformed request. Please provide a valid request.", event)
with Session() as session:
try:
# get user from database
user = user_handler.get_user_by_id(user_id, session)
except:
return helper.get_text_response(404, "No user found.", event)
try:
# Try to receive review
review = review_handler.get_open_review(user_id, session)
except:
return helper.get_text_response(404, "No review found", event)
if review is None:
return responses.NoContent(
event, 'No review in progress found for current user.'
).to_json_string()
try:
if review.user_id == user.id:
return responses.Success(
event,
json.dumps(
review.to_dict(with_questions_and_answers=True,
with_tags=True))).to_json_string()
else:
return responses.Forbidden(
event,
'User is not allowed to access review').to_json_string()
except Exception as e:
return responses.InternalError(event, "Internal error",
e).to_json_string()
def test_get_all_questions(fixtures):
with Session() as session:
session.add_all(fixtures)
session.commit()
review_questions = review_question_handler.get_all_review_questions_db(session)
assert len(review_questions) == 3
def test_get_items_by_url():
os.environ["STAGE"] = "dev"
with Session() as session:
item = Item()
item.content = "Test content"
item.language = "de"
item.status = "closed"
item = item_handler.create_item(item, session)
item2 = Item()
item2.content = "Test content2"
item2.language = "de"
item2.status = "closed"
item2 = item_handler.create_item(item2, session)
url = URL()
url.id = "url_id"
url.url = "www.test.de/artikel1"
item_url = ItemURL()
item_url.id = "item_url_id"
item_url.item_id = item.id
item_url.url_id = url.id
session.add_all([url, item_url])
session.commit()
# Testing get_items without url query param 204
for event in [{}, {"queryStringParameters": None}]:
response = get_closed_items(event, None)
assert response['statusCode'] == 200
body = json.loads(response['body'])
assert len(body) == 2
# Testing get_items with url query param 200
for url in [url.url, url.url + '?queryparam=shouldbeignored']:
response = get_closed_items(get_url_event(url), None)
assert response['statusCode'] == 200
body = json.loads(response['body'])
assert len(body) == 1
assert body[0]['id'] == item.id
# Testing get_items with url query param 204 - no item with url
for url in ['sinnloseUrl', 'www.test.de/artikel2', 'www.test.de']:
response = get_closed_items(get_url_event(url), None)
assert response['statusCode'] == 204
# Testing get_items with url query param 204 - item not closed
item.status = "open"
session.merge(item)
session.commit()
response = get_closed_items(get_url_event("www.test.de/artikel1"),
None)
assert response['statusCode'] == 204
def test_create_item():
with Session() as session:
item = Item()
item.content = "Testitem"
item = item_handler.create_item(item, session)
assert item.id is not None
assert item.open_reviews == 4
assert item.open_reviews_level_1 == 4
assert item.open_reviews_level_2 == 4
assert item.in_progress_reviews_level_1 == 0
assert item.in_progress_reviews_level_2 == 0
assert item.open_timestamp is not None
def handle_item_closed(event, context):
try:
helper.log_method_initiated("Send notification", event, logger)
if "detail" not in event or "item_id" not in event["detail"]:
return BadRequest(event,
"Event contains no item_id.",
add_cors_headers=False).to_json_string()
with Session() as session:
item_id = event["detail"]["item_id"]
item = item_handler.get_item_by_id(item_id, session)
if item is None:
return BadRequest(
event,
f"No item was found with the given item_id [{item_id}].",
add_cors_headers=False).to_json_string()
item = item_handler.update_item_warning_tags(item, session)
rating = int(item.result_score * 25)
rating_text = get_rating_text(rating)
parameters = dict(rating=rating,
rating_text=rating_text,
item_id=item.id,
content=item.content)
for submission in item.submissions:
if submission.mail is not None:
try:
mail_sender.send_notification("item_closed",
mail=submission.mail,
replacements=parameters)
except Exception as e:
logger.exception(e)
if submission.telegram_id is not None:
try:
mail_sender.send_notification(
"item_closed",
telegram_id=submission.telegram_id,
replacements=parameters)
except Exception as e:
logger.exception(e)
return Success(event, add_cors_headers=False).to_json_string()
except Exception as e:
return InternalError(event,
"Error sending notification",
e,
add_cors_headers=False).to_json_string()
def test_get_closed_items(item_id, review_id, review_answer_id, user_id,
comment_id):
os.environ["STAGE"] = "dev"
with Session() as session:
item = Item(id=item_id)
review = Review(id=review_id, item_id=item_id, user_id=user_id)
review_question = ReviewQuestion(id='Question1')
review_answer = ReviewAnswer(id=review_answer_id,
review_id=review_id,
review_question_id=review_question.id)
user = User(id=user_id, name='User')
level = Level(id=1, description='beginner')
comment = Comment(id=comment_id,
comment='testcomment',
is_review_comment=True,
user_id=user_id,
item_id=item_id)
session.add_all([
item, review, review_question, review_answer, user, level, comment
])
session.commit()
# Test no query param
event = {}
response = get_item.get_item(event, None)
assert response['statusCode'] == 400
# Test invalid item id
event = get_event('Quatsch_mit_Soße')
response = get_item.get_item(event, None)
assert response['statusCode'] == 404
event = get_event(item_id)
response = get_item.get_item(event, None)
assert response['statusCode'] == 403
item.status = 'closed'
session.merge(item)
session.commit()
response = get_item.get_item(event, None)
assert response['statusCode'] == 200
body = json.loads(response['body'])
assert body['id'] == item.id
session.delete(user)
session.expire_all()
response = get_item.get_item(event, None)
assert response['statusCode'] == 200
body = json.loads(response['body'])
assert body['users'][0] is None
def test_get_all_parent_questions(fixtures, child_question1, type_id_1):
with Session() as session:
session.add_all(fixtures)
session.add(child_question1)
session.commit()
all_questions_type_1 = review_question_handler.get_review_questions_by_item_type_id(type_id_1, session)
assert len(all_questions_type_1) == 2
assert child_question1 in all_questions_type_1
parent_questions_type_1 = review_question_handler.get_all_parent_questions(type_id_1, session)
assert len(parent_questions_type_1) == 1
assert child_question1 not in parent_questions_type_1
def test_prepare_and_store_urls_with_unsafe_items():
with Session() as session:
str_urls = ["http://testsafebrowsing.appspot.com/s/malware.html"]
item = Item()
item = item_handler.create_item(item, session)
url_handler.prepare_and_store_urls(item, str_urls, session)
for str_url in str_urls:
url = verify_and_get_url(item, str_url, session)
assert url.unsafe is not None
assert item.status == 'Unsafe'
def test_prepare_and_store_urls_for_localhost_url():
with Session() as session:
str_urls = [
"http://LOCALHOST/utes-moma-127-8-altmaier-will-haertere-strafen-bei-verstoessen-gegen-die-corona-regeln/",
"http://127.0.0.1/utes-moma-127-8-altmaier-will-haertere-strafen-bei-verstoessen-gegen-die-corona-regeln/"
]
item = Item()
item = item_handler.create_item(item, session)
url_handler.prepare_and_store_urls(item, str_urls, session)
assert item.urls == []
assert item.status != 'Unsafe'
def test_tags_and_urls(self):
with Session() as session:
session = setup_scenarios.create_levels_junior_and_senior_detectives(
session)
session = setup_scenarios.create_questions(session)
junior_detective1 = user_handler.get_user_by_id("1", session)
item1 = Item()
item1.content = "Item 1"
item1.status = "open"
item1.item_type_id = "Type1"
item1 = item_handler.create_item(item1, session)
url = URL()
url.id = str(uuid4())
url.url = 'www.test.com'
item_url = ItemURL()
item_url.id = str(uuid4())
item_url.item_id = item1.id
item_url.url_id = url.id
tag = Tag()
tag.id = str(uuid4())
tag.tag = "Test Tag"
item_tag = ItemTag()
item_tag.id = str(uuid4())
item_tag.item_id = item1.id
item_tag.tag_id = tag.id
session.add_all([url, item_url, tag, item_tag])
event = event_creator.get_create_review_event(
junior_detective1.id, item1.id)
response = get_open_items(event, None)
assert response['statusCode'] == 200
body = json.loads(response['body'])
items = body['items']
assert len(items) == 1
urls = items[0]['urls']
assert len(urls) == 1
assert urls[0]['url'] == 'www.test.com'
tags = items[0]['tags']
assert len(tags) == 1
assert tags[0] == "Test Tag"
def test_create_review(item_id, junior_user_id, senior_user_id):
with Session() as session:
session = setup_scenarios.create_questions(session)
session = setup_scenarios.create_levels_junior_and_senior_detectives(session)
item = Item(id=item_id, item_type_id="Type1")
session.add(item)
session.commit()
# Create junior review
event = event_creator.get_create_review_event(junior_user_id, item_id)
response = create_review.create_review(event, None)
assert response['statusCode'] == 201
reviews = session.query(Review).all()
assert len(reviews) == 1
review = Review()
review = reviews[0]
assert review.user_id == junior_user_id
assert review.item_id == item_id
question_ids = []
for answer in review.review_answers:
question_ids.append(answer.review_question_id)
assert "other_type" not in question_ids
parent_question_counter = 0
for answer in review.review_answers:
if answer.review_question.max_children > 0:
child_questions = session.query(ReviewQuestion).filter(
ReviewQuestion.parent_question_id == answer.review_question_id).all()
for child_question in child_questions:
assert child_question.id in question_ids
if answer.review_question.parent_question_id is None:
parent_question_counter += 1
assert parent_question_counter == 6
event = event_creator.get_create_review_event(senior_user_id, item_id)
response = create_review.create_review(event, None)
assert response['statusCode'] == 201
reviews = session.query(Review).all()
assert len(reviews) == 2
reviews = session.query(Review).filter(
Review.user_id == senior_user_id).all()
assert len(reviews) == 1
review = reviews[0]
assert review.user_id == senior_user_id
assert review.item_id == item_id
for answer in review.review_answers:
assert answer.review_question_id in question_ids
def test_get_user_ranking():
with Session() as session:
session = setup_scenarios.create_users_for_ranking(session)
my_detective = user_handler.get_user_by_id("999", session)
event = event_creator.get_create_review_event(my_detective.id, None)
resp = get_user_ranking(event, None)
user_rankings = json.loads(resp["body"])
assert len(user_rankings) == 3
assert ("top_users" in user_rankings) == True
assert ("top_users_by_level" in user_rankings) == True
assert ("top_users_by_period" in user_rankings) == True
top_users = user_rankings['top_users']
# ten top users in list
assert len(top_users) == 10
assert top_users[0]['experience_points'] == 60
# each EXP should be higher than the next (for the sorted column "experience_points")
assert int(top_users[0]['experience_points']) > int(
top_users[1]['experience_points'])
top_users_by_level = user_rankings['top_users_by_level']
assert len(top_users_by_level) == 10
assert int(top_users_by_level[0]['experience_points']) > int(
top_users_by_level[1]['experience_points'])
# the first/ top user's experience points
assert top_users_by_level[0]['experience_points'] == 40
# My User's experience points:
assert top_users_by_level[5]['experience_points'] == 35
# the last user's experience points
assert top_users_by_level[9]['experience_points'] == 32
# the first/ top users's level (= my level)
assert top_users_by_level[0]['level'] == 2
# the last users's level (= my level)
assert top_users_by_level[9]['level'] == 2
top_users_by_period = user_rankings['top_users_by_period']
# For period = 1 week only 7 users found
assert len(top_users_by_period) == 7
assert int(top_users_by_period[0]['experience_points']) > int(
top_users_by_period[1]['experience_points'])
assert top_users_by_period[1]['experience_points'] == 6
assert top_users_by_period[6]['experience_points'] == 1
def submit_issue(event, context):
helper.log_method_initiated("Submit issue", event, logger)
issue = Issue() # create object from issue_model.py (DB table: issues)
issue = helper.body_to_object(event['body'], issue)
# add ip address
try:
ip_address = event['requestContext']['identity']['sourceIp']
setattr(issue, 'ip_address', ip_address)
except Exception:
response = {
"statusCode":
400,
"body":
"Could not read/add ip address. Check HTTP POST payload. Stacktrace: {}"
.format(traceback.format_exc())
}
with Session() as session:
issue = add_object(issue, session)
if issue is None:
response = {
"statusCode":
400,
"body":
"Could not write issue to database. Check HTTP POST payload. Stacktrace: {}"
.format(traceback.format_exc())
}
response_cors = helper.set_cors(response, event)
return response_cors
response = send_issue_notification(issue)
if response == False:
response = {
"statusCode":
500,
"body":
"Could not send issue mail. Stacktrace: {}".format(
traceback.format_exc())
}
response_cors = helper.set_cors(response, event)
return response_cors
else:
response = {"statusCode": 201, "body": json.dumps(issue.to_dict())}
response_cors = helper.set_cors(response, event)
return response_cors
def handle_item_rejected(event, context):
try:
helper.log_method_initiated("Handle item rejected", event, logger)
if "detail" not in event or "item_id" not in event["detail"]:
return BadRequest(event,
"Event contains no item_id.",
add_cors_headers=False).to_json_string()
with Session() as session:
item_id = event["detail"]["item_id"]
item = item_handler.get_item_by_id(item_id, session)
if item is None:
return BadRequest(
event,
f"No item was found with the given item_id [{item_id}].",
add_cors_headers=False).to_json_string()
parameters = dict(content=item.content)
for submission in item.submissions:
if submission.mail is not None:
try:
mail_sender.send_notification("item_rejected",
mail=submission.mail,
replacements=parameters)
except Exception as e:
logger.exception(e)
if submission.telegram_id is not None:
try:
mail_sender.send_notification(
"item_rejected",
telegram_id=submission.telegram_id,
replacements=parameters)
except Exception as e:
logger.exception(e)
return Success(event, add_cors_headers=False).to_json_string()
except Exception as e:
response = InternalError(event,
"Error sending notification",
e,
add_cors_headers=False).to_json_string()
logger.error(response)
return response
def get_closed_items(event, context):
helper.log_method_initiated("Get all closed items", event, logger)
with Session() as session:
try:
# Get all closed items
print("\n \n \n Getting items \n \n \n")
allow_all_origins = False
if 'queryStringParameters' in event and isinstance(
event['queryStringParameters'],
dict) and 'url' in event['queryStringParameters']:
url_without_query_params = event['queryStringParameters'][
'url'].split('?')[0]
items = item_handler.get_closed_items_by_url(
url_without_query_params, session)
allow_all_origins = True
else:
items = item_handler.get_all_closed_items(session)
if len(items) == 0:
response = {"statusCode": 204, "body": "No closed items found"}
else:
items_list = []
for item in items:
items_list.append(
item.to_dict(with_tags=True, with_warnings=True))
response = {
"statusCode": 200,
'headers': {
"content-type": "application/json; charset=utf-8"
},
"body": json.dumps(items_list)
}
except Exception:
response = {
"statusCode":
400,
"body":
"Could not get closed items. Stacktrace: {}".format(
traceback.format_exc())
}
response_cors = helper.set_cors(response, event, allow_all_origins)
return response_cors