def get_strings_for_duplicates_or_reasons(search_value: str, issue_uid: int,
statement_uid: int) -> list:
"""
Checks different textversion-strings for a match with given value
:param search_value: string
:param issue_uid: Issue.uid
:param statement_uid: integer
:return: dict()
"""
issues_statements_uids = [
el.statement_uid
for el in DBDiscussionSession.query(StatementToIssue).filter_by(
issue_uid=issue_uid).all()
]
db_statements = get_enabled_statement_as_query().filter(
Statement.uid.in_(issues_statements_uids)).all()
return_array = []
for stat in db_statements:
if stat.uid is statement_uid:
continue
db_tv = DBDiscussionSession.query(TextVersion).filter_by(
statement_uid=stat.uid).order_by(TextVersion.uid.asc()).first()
if search_value.lower() in db_tv.content.lower(
): # and db_tv.content.lower() != oem_value.lower():
rd = __get_fuzzy_string_dict(current_text=search_value,
return_text=db_tv.content,
uid=db_tv.statement_uid)
return_array.append(rd)
return_array = __sort_array(return_array)
return return_array[:RESULT_LENGTH]
def get_suggestions_for_positions(search_value: str, issue_uid: int,
position: bool) -> list:
"""
Checks different position-strings for a match with given value
:param search_value: text to be searched for
:param issue_uid: uid of the issue to be searched in
:param position: position of the statement
:return: suggestions for statements with a certain position matching the search_value
"""
statement2issues_uid = [
el.statement_uid
for el in DBDiscussionSession.query(StatementToIssue).filter_by(
issue_uid=issue_uid).all()
]
db_statements = get_enabled_statement_as_query().filter(
Statement.is_position == position,
Statement.uid.in_(statement2issues_uid)).all()
return_array = []
for stat in db_statements:
db_tv = DBDiscussionSession.query(TextVersion).filter_by(
statement_uid=stat.uid).order_by(TextVersion.uid.asc()).first()
if search_value.lower() in db_tv.content.lower():
rd = __get_fuzzy_string_dict(current_text=search_value,
return_text=db_tv.content,
uid=db_tv.statement_uid)
return_array.append(rd)
return_array = __sort_array(return_array)
return return_array[:RESULT_LENGTH]
def get_all_statements_with_value(search_value: str, issue_uid: int) -> list:
"""
Returns all statements matching the given search_value
:param issue_uid: uid of the issue to be searched in
:param search_value: text to be searched for
:return: statements matching the given search value in the given issue, uses levensthein.
"""
issues_statements_uids = [
el.statement_uid
for el in DBDiscussionSession.query(StatementToIssue).filter_by(
issue_uid=issue_uid).all()
]
db_statements = get_enabled_statement_as_query().filter(
Statement.uid.in_(issues_statements_uids)).all()
return_array = []
slug = DBDiscussionSession.query(Issue).get(issue_uid).slug
_um = UrlManager(slug=slug)
for stat in db_statements:
db_tv = DBDiscussionSession.query(TextVersion).filter_by(
statement_uid=stat.uid).order_by(TextVersion.uid.asc()).first()
if search_value.lower() in db_tv.content.lower():
rd = __get_fuzzy_string_dict(current_text=search_value,
return_text=db_tv.content,
uid=db_tv.statement_uid)
rd['url'] = _um.get_url_for_statement_attitude(db_tv.statement_uid)
return_array.append(rd)
return_array = __sort_array(return_array)
return return_array[:RESULT_LENGTH]
def get_number_of_authors(issue_uid: int) -> int:
"""
Returns number of active users for the issue
:param issue_uid: Issue Issue.uid
:return: Integer
"""
issues_statements_uids = [
el.statement_uid
for el in DBDiscussionSession.query(StatementToIssue).filter_by(
issue_uid=issue_uid).all()
]
active_statements_uids = [
el.uid for el in get_enabled_statement_as_query().filter(
Statement.uid.in_(issues_statements_uids)).all()
]
active_users = [
el.author_uid for el in DBDiscussionSession.query(TextVersion).filter(
TextVersion.statement_uid.in_(active_statements_uids))
]
return len(set(active_users))
def get_strings_for_search(search_value: str) -> dict:
"""
Returns all statements which have a substring of the given value
:param search_value: String
:return: dict() with Statements.uid as key and 'text', 'distance' as well as 'arguments' as values
"""
tmp_dict = OrderedDict()
db_statements = get_enabled_statement_as_query().join(
TextVersion, Statement.textversion_uid == TextVersion.uid).all()
for stat in db_statements:
if search_value.lower() in stat.textversions.content.lower():
# get distance between input value and saved value
rd = __get_fuzzy_string_dict(current_text=search_value,
return_text=stat.textversions.content,
uid=stat.uid)
tmp_dict[str(stat.uid)] = rd
tmp_dict = __sort_dict(tmp_dict)
return_index = list(islice(tmp_dict, RESULT_LENGTH))
return_dict = OrderedDict()
for index in return_index:
return_dict[index] = tmp_dict[index]
return return_dict
def get_d3_data(db_issue: Issue, all_statements=None, all_arguments=None):
"""
Given an issue, create an dictionary and return it
:param db_issue: Current issue
:param all_statements:
:param all_arguments:
:return: dictionary
"""
a = [a.uid
for a in all_statements] if all_statements is not None else 'all'
b = [b.uid for b in all_arguments] if all_arguments is not None else 'all'
LOG.debug("Return D3 data. Statements: %s, arguments: %s", a, b)
edge_type = 'arrow'
nodes_array = []
edges_array = []
extras_dict = {}
LOG.debug("Titel: %s", db_issue.title)
db_textversions: List[TextVersion] = DBDiscussionSession.query(
TextVersion).all()
if all_statements is None:
issues_statements_uids = [
el.statement_uid
for el in DBDiscussionSession.query(StatementToIssue).filter_by(
issue_uid=db_issue.uid).all()
]
all_statements = get_enabled_statement_as_query().filter(
Statement.uid.in_(issues_statements_uids)).all()
if all_arguments is None:
all_arguments = get_enabled_arguments_as_query().filter_by(
issue_uid=db_issue.uid).all()
# issue
node_dict = __get_node_dict(uid='issue',
label=db_issue.info,
node_type='issue',
timestamp=db_issue.date.timestamp)
nodes_array.append(node_dict)
all_node_ids = ['issue']
# for each statement a node will be added
all_ids, nodes, edges, extras = __prepare_statements_for_d3_data(
all_statements, db_textversions, edge_type)
all_node_ids += all_ids
nodes_array += nodes
edges_array += edges
extras_dict.update(extras)
# for each argument edges will be added as well as the premises
all_ids, nodes, edges, extras = __prepare_arguments_for_d3_data(
all_arguments, edge_type)
all_node_ids += all_ids
nodes_array += nodes
edges_array += edges
extras_dict.update(extras)
error = __sanity_check_of_d3_data(all_node_ids, edges_array)
d3_dict = {
'nodes': nodes_array,
'edges': edges_array,
'extras': extras_dict
}
return d3_dict, error
def test_get_enabled_statement_as_query(self):
query_len = get_enabled_statement_as_query().count()
res_len = DBDiscussionSession.query(Statement).filter_by(is_disabled=False).count()
self.assertEqual(res_len, query_len)
