all the project copy
This commit is contained in:
926
api/ai_retriever.py
Normal file
926
api/ai_retriever.py
Normal file
@@ -0,0 +1,926 @@
|
||||
from datetime import datetime
|
||||
from difflib import SequenceMatcher
|
||||
from pathlib import Path
|
||||
import re
|
||||
import sys
|
||||
import time
|
||||
import unicodedata
|
||||
|
||||
import psycopg2
|
||||
from psycopg2.extras import DictCursor, Json
|
||||
|
||||
|
||||
ROOT_DIR = Path(__file__).resolve().parents[1]
|
||||
CONN_DIR = ROOT_DIR / "conn"
|
||||
if str(CONN_DIR) not in sys.path:
|
||||
sys.path.insert(0, str(CONN_DIR))
|
||||
|
||||
import config
|
||||
import mysql5
|
||||
from ai_index import clean_text, ensure_ai_schema, extract_codes, refresh_feedback_summary
|
||||
|
||||
|
||||
MIN_SCORE = 0.07
|
||||
CONFIDENCE_MIN_SCORE = {
|
||||
"bassa": MIN_SCORE,
|
||||
"media": 0.18,
|
||||
"alta": 0.35,
|
||||
}
|
||||
DEFAULT_LIMIT = 5
|
||||
DIVERSITY_POOL_MULTIPLIER = 8
|
||||
MAX_SOLUTION_TOKEN_SIMILARITY = 0.62
|
||||
MAX_SOLUTION_TOKEN_OVERLAP = 0.65
|
||||
MAX_SOLUTION_TEXT_SIMILARITY = 0.70
|
||||
_SCHEMA_READY = False
|
||||
TOKEN_RE = re.compile(r"\b\w{3,}\b", re.IGNORECASE)
|
||||
SIGNATURE_SPACE_RE = re.compile(r"\s+")
|
||||
|
||||
|
||||
def get_pg_connection():
|
||||
return psycopg2.connect(**config.POSTGRES_CONFIG)
|
||||
|
||||
|
||||
def ensure_runtime_schema():
|
||||
global _SCHEMA_READY
|
||||
if not _SCHEMA_READY:
|
||||
ensure_ai_schema()
|
||||
_SCHEMA_READY = True
|
||||
|
||||
|
||||
def _id_value(value):
|
||||
if value is None or value == "":
|
||||
return None
|
||||
try:
|
||||
return int(value)
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def _normalize_int_list(value):
|
||||
if value is None:
|
||||
return []
|
||||
if not isinstance(value, (list, tuple, set)):
|
||||
value = [value]
|
||||
|
||||
values = []
|
||||
for item in value:
|
||||
parsed = _id_value(item)
|
||||
if parsed is not None and parsed not in values:
|
||||
values.append(parsed)
|
||||
return values
|
||||
|
||||
|
||||
def _query_text(ticket):
|
||||
parts = [
|
||||
ticket.get("subject"),
|
||||
ticket.get("problem"),
|
||||
ticket.get("product"),
|
||||
ticket.get("area"),
|
||||
ticket.get("subarea"),
|
||||
ticket.get("competence"),
|
||||
ticket.get("program"),
|
||||
ticket.get("program_type"),
|
||||
]
|
||||
codes = extract_codes(*parts)
|
||||
cleaned = clean_text(" ".join(str(p) for p in parts if p))
|
||||
return " ".join(part for part in (cleaned, " ".join(codes)) if part)
|
||||
|
||||
|
||||
def _confidence(score):
|
||||
if score >= CONFIDENCE_MIN_SCORE["alta"]:
|
||||
return "Alta"
|
||||
if score >= CONFIDENCE_MIN_SCORE["media"]:
|
||||
return "Media"
|
||||
return "Bassa"
|
||||
|
||||
|
||||
def _min_score_from_filters(filters):
|
||||
filters = filters or {}
|
||||
if filters.get("min_score") is not None:
|
||||
try:
|
||||
return float(filters["min_score"])
|
||||
except (TypeError, ValueError):
|
||||
return MIN_SCORE
|
||||
|
||||
confidence = str(filters.get("min_confidence") or "").lower()
|
||||
return CONFIDENCE_MIN_SCORE.get(confidence, MIN_SCORE)
|
||||
|
||||
|
||||
def _solution_tokens(solution):
|
||||
text = clean_text(solution).lower()
|
||||
return set(TOKEN_RE.findall(text))
|
||||
|
||||
|
||||
def _solution_signature(solution):
|
||||
text = clean_text(solution).lower()
|
||||
text = "".join(
|
||||
char for char in unicodedata.normalize("NFKD", text)
|
||||
if not unicodedata.combining(char)
|
||||
)
|
||||
text = re.sub(r"\b(gentile|buongiorno|ciao|salve)\b", " ", text)
|
||||
text = re.sub(r"\b(cliente|mauro|martina|lisa|cinzia|nadia)\b", " ", text)
|
||||
return SIGNATURE_SPACE_RE.sub(" ", text).strip()
|
||||
|
||||
|
||||
def _jaccard_similarity(left, right):
|
||||
if not left or not right:
|
||||
return 0
|
||||
return len(left & right) / len(left | right)
|
||||
|
||||
|
||||
def _overlap_similarity(left, right):
|
||||
if not left or not right:
|
||||
return 0
|
||||
return len(left & right) / min(len(left), len(right))
|
||||
|
||||
|
||||
def _matches_filter(row, filters, key, row_key):
|
||||
values = _normalize_int_list((filters or {}).get(key))
|
||||
return values and row.get(row_key) in values
|
||||
|
||||
|
||||
def _passes_strict_metadata_filters(row, filters):
|
||||
filters = filters or {}
|
||||
filter_columns = (
|
||||
("product_ids", "product_id"),
|
||||
("area_ids", "area_id"),
|
||||
("subarea_ids", "subarea_id"),
|
||||
("competence_ids", "competence_id"),
|
||||
("client_ids", "client_id"),
|
||||
)
|
||||
for key, column in filter_columns:
|
||||
values = _normalize_int_list(filters.get(key))
|
||||
if not values:
|
||||
values = _normalize_int_list(filters.get(column))
|
||||
if values and row.get(column) not in values:
|
||||
return False
|
||||
|
||||
excluded_clients = _normalize_int_list(filters.get("exclude_client_ids"))
|
||||
if not excluded_clients:
|
||||
excluded_clients = _normalize_int_list(filters.get("exclude_client_id"))
|
||||
if excluded_clients and row.get("client_id") in excluded_clients:
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
def _diverse_suggestions(rows, query_ticket, limit, filters=None):
|
||||
selected = []
|
||||
selected_solution_tokens = []
|
||||
selected_solution_signatures = []
|
||||
duplicates_skipped = 0
|
||||
min_score = _min_score_from_filters(filters)
|
||||
|
||||
for row in rows:
|
||||
row_dict = dict(row)
|
||||
if not _passes_strict_metadata_filters(row_dict, filters):
|
||||
continue
|
||||
if row_dict["total_score"] < min_score:
|
||||
continue
|
||||
|
||||
solution_tokens = _solution_tokens(row_dict.get("solution_preview"))
|
||||
solution_signature = _solution_signature(row_dict.get("solution_preview"))
|
||||
is_duplicate = any(
|
||||
_jaccard_similarity(solution_tokens, existing_tokens) >= MAX_SOLUTION_TOKEN_SIMILARITY
|
||||
or _overlap_similarity(solution_tokens, existing_tokens) >= MAX_SOLUTION_TOKEN_OVERLAP
|
||||
or SequenceMatcher(None, solution_signature, existing_signature).ratio() >= MAX_SOLUTION_TEXT_SIMILARITY
|
||||
for existing_tokens, existing_signature in zip(selected_solution_tokens, selected_solution_signatures)
|
||||
)
|
||||
if is_duplicate:
|
||||
duplicates_skipped += 1
|
||||
continue
|
||||
|
||||
row_dict["confidence"] = _confidence(row_dict["total_score"])
|
||||
row_dict["reasons"] = _reasons(row_dict, query_ticket, filters)
|
||||
row_dict["duplicates_skipped_before"] = duplicates_skipped
|
||||
selected.append(row_dict)
|
||||
selected_solution_tokens.append(solution_tokens)
|
||||
selected_solution_signatures.append(solution_signature)
|
||||
|
||||
if len(selected) >= limit:
|
||||
break
|
||||
|
||||
return selected
|
||||
|
||||
|
||||
def _reasons(row, query_ticket=None, filters=None):
|
||||
query_ticket = query_ticket or {}
|
||||
filters = filters or {}
|
||||
reasons = []
|
||||
|
||||
if row["lexical_score"] >= 0.08:
|
||||
reasons.append("termini esatti")
|
||||
if row["trigram_score"] >= 0.12:
|
||||
reasons.append("testo simile")
|
||||
if row["code_score"] > 0:
|
||||
reasons.append("stesso codice")
|
||||
|
||||
if _matches_filter(row, filters, "product_ids", "product_id"):
|
||||
reasons.append("filtro prodotto")
|
||||
elif row["product_id"] is not None and row["product_id"] == _id_value(query_ticket.get("product_id")):
|
||||
reasons.append("stesso prodotto")
|
||||
|
||||
if _matches_filter(row, filters, "subarea_ids", "subarea_id"):
|
||||
reasons.append("filtro sottoarea")
|
||||
elif row["subarea_id"] is not None and row["subarea_id"] == _id_value(query_ticket.get("subarea_id")):
|
||||
reasons.append("stessa sottoarea")
|
||||
elif _matches_filter(row, filters, "area_ids", "area_id"):
|
||||
reasons.append("filtro area")
|
||||
elif row["area_id"] is not None and row["area_id"] == _id_value(query_ticket.get("area_id")):
|
||||
reasons.append("stessa area")
|
||||
|
||||
if _matches_filter(row, filters, "competence_ids", "competence_id"):
|
||||
reasons.append("filtro competenza")
|
||||
elif row["competence_id"] is not None and row["competence_id"] == _id_value(query_ticket.get("competence_id")):
|
||||
reasons.append("stessa competenza")
|
||||
|
||||
if _matches_filter(row, filters, "client_ids", "client_id"):
|
||||
reasons.append("stesso cliente")
|
||||
if row["feedback_score"] > 0:
|
||||
reasons.append("feedback positivo")
|
||||
if filters.get("recent_months"):
|
||||
reasons.append("periodo recente")
|
||||
if not reasons:
|
||||
reasons.append("somiglianza generale")
|
||||
return reasons[:5]
|
||||
|
||||
|
||||
def _format_date(value):
|
||||
if not value:
|
||||
return "-"
|
||||
if hasattr(value, "strftime"):
|
||||
return value.strftime("%Y-%m-%d")
|
||||
return str(value)
|
||||
|
||||
|
||||
def _format_suggestion(query_ticket_id, suggestion, rank):
|
||||
ticket_id = suggestion["ticket_id"]
|
||||
link = f"https://tsnew.sanmarcoweb.com/it/ticket/index/index/operation/view/id/{ticket_id}"
|
||||
product = suggestion.get("product") or "-"
|
||||
area = suggestion.get("area") or "-"
|
||||
subarea = suggestion.get("subarea") or "-"
|
||||
competence = suggestion.get("competence") or "-"
|
||||
client = suggestion.get("client") or "-"
|
||||
confidence = suggestion["confidence"]
|
||||
reasons = ", ".join(suggestion["reasons"])
|
||||
solution = suggestion.get("solution_preview") or "Soluzione non disponibile"
|
||||
diversity_note = ""
|
||||
if suggestion.get("duplicates_skipped_before"):
|
||||
diversity_note = f"Alternative simili saltate: {suggestion['duplicates_skipped_before']}\n"
|
||||
|
||||
feedback_line = ""
|
||||
if query_ticket_id:
|
||||
feedback_line = f"Feedback: /utile_{query_ticket_id}_{ticket_id} /non_utile_{query_ticket_id}_{ticket_id}\n"
|
||||
|
||||
return (
|
||||
f"\n\n----- {rank}. Confidenza {confidence} -----\n"
|
||||
f"[ /Ticket_dettaglio_{ticket_id} ]\n"
|
||||
f"{link}\n"
|
||||
f"Cliente: {client}\n"
|
||||
f"Prodotto: {product} | Competenza: {competence}\n"
|
||||
f"Area: {area} | Sottoarea: {subarea}\n"
|
||||
f"Apertura: {_format_date(suggestion.get('opened_at'))}\n"
|
||||
f"Perche: {reasons}\n"
|
||||
f"{diversity_note}"
|
||||
f"Score: {suggestion['total_score']:.3f}\n"
|
||||
f"SOLUZIONE: {solution}\n"
|
||||
f"{feedback_line}"
|
||||
)
|
||||
|
||||
|
||||
def _has_metadata_filters(filters):
|
||||
filters = filters or {}
|
||||
return any(
|
||||
_normalize_int_list(filters.get(key))
|
||||
for key in ("product_ids", "area_ids", "subarea_ids", "competence_ids", "client_ids")
|
||||
)
|
||||
|
||||
|
||||
def _metadata_candidate_clause(ticket, filters=None):
|
||||
clauses = []
|
||||
params = {}
|
||||
for field in ("product_id", "area_id", "subarea_id", "competence_id"):
|
||||
value = _id_value((ticket or {}).get(field))
|
||||
params[field] = value
|
||||
if value is not None:
|
||||
clauses.append(f"i.{field} = %({field})s")
|
||||
if _has_metadata_filters(filters):
|
||||
clauses.append("TRUE")
|
||||
if not clauses:
|
||||
clauses.append("FALSE")
|
||||
return " OR ".join(clauses), params
|
||||
|
||||
|
||||
def _strict_filter_clause(filters):
|
||||
filters = filters or {}
|
||||
clauses = []
|
||||
params = {}
|
||||
|
||||
filter_columns = (
|
||||
("product_ids", "product_id"),
|
||||
("area_ids", "area_id"),
|
||||
("subarea_ids", "subarea_id"),
|
||||
("competence_ids", "competence_id"),
|
||||
("client_ids", "client_id"),
|
||||
)
|
||||
for key, column in filter_columns:
|
||||
values = _normalize_int_list(filters.get(key))
|
||||
if not values:
|
||||
values = _normalize_int_list(filters.get(column))
|
||||
if values:
|
||||
clauses.append(f"i.{column} = ANY(%({key})s::int[])")
|
||||
params[key] = values
|
||||
|
||||
excluded_clients = _normalize_int_list(filters.get("exclude_client_ids"))
|
||||
if not excluded_clients:
|
||||
excluded_clients = _normalize_int_list(filters.get("exclude_client_id"))
|
||||
if excluded_clients:
|
||||
clauses.append("NOT (i.client_id = ANY(%(exclude_client_ids)s::int[]))")
|
||||
params["exclude_client_ids"] = excluded_clients
|
||||
|
||||
if filters.get("require_code_match"):
|
||||
clauses.append("i.codes && %(query_codes)s::text[]")
|
||||
|
||||
recent_months = _id_value(filters.get("recent_months"))
|
||||
if recent_months is not None and recent_months > 0:
|
||||
clauses.append("i.opened_at >= now() - (%(recent_days)s::int * interval '1 day')")
|
||||
params["recent_days"] = recent_months * 31
|
||||
|
||||
return " AND ".join(clauses) if clauses else "TRUE", params
|
||||
|
||||
|
||||
def _safe_filters(filters):
|
||||
safe = {}
|
||||
for key, value in (filters or {}).items():
|
||||
if value is None or value is False or value == []:
|
||||
continue
|
||||
if isinstance(value, (list, tuple, set)):
|
||||
safe[key] = list(value)
|
||||
else:
|
||||
safe[key] = value
|
||||
return safe
|
||||
|
||||
|
||||
def _search(query_kind, query_text, query_ticket_id=None, query_ticket=None, user_id=None, limit=DEFAULT_LIMIT, offset=0, filters=None, log_results=True):
|
||||
ensure_runtime_schema()
|
||||
query_text = clean_text(query_text)
|
||||
if not query_text:
|
||||
return []
|
||||
|
||||
query_ticket = query_ticket or {}
|
||||
filters = filters or {}
|
||||
limit = max(int(limit or DEFAULT_LIMIT), 1)
|
||||
offset = max(int(offset or 0), 0)
|
||||
pool_target = offset + limit
|
||||
query_codes = extract_codes(query_text)
|
||||
metadata_clause, metadata_params = _metadata_candidate_clause(query_ticket, filters)
|
||||
strict_clause, strict_params = _strict_filter_clause(filters)
|
||||
|
||||
params = {
|
||||
"query_ticket_id": int(query_ticket_id) if query_ticket_id is not None else None,
|
||||
"query_text": query_text,
|
||||
"problem_text": clean_text(query_ticket.get("problem") or query_text),
|
||||
"subject_text": clean_text(query_ticket.get("subject") or query_text),
|
||||
"candidate_limit": max(pool_target * 50, 250),
|
||||
"final_limit": max(pool_target * DIVERSITY_POOL_MULTIPLIER * 2, 40),
|
||||
"query_product_id": _id_value(query_ticket.get("product_id")),
|
||||
"query_area_id": _id_value(query_ticket.get("area_id")),
|
||||
"query_subarea_id": _id_value(query_ticket.get("subarea_id")),
|
||||
"query_competence_id": _id_value(query_ticket.get("competence_id")),
|
||||
"query_codes": query_codes,
|
||||
}
|
||||
params.update(metadata_params)
|
||||
params.update(strict_params)
|
||||
|
||||
sql = f"""
|
||||
WITH q AS (
|
||||
SELECT websearch_to_tsquery('simple', %(query_text)s) AS tsq
|
||||
),
|
||||
lexical_candidates AS (
|
||||
SELECT i.ticket_id
|
||||
FROM ticket_ai_index i, q
|
||||
WHERE (%(query_ticket_id)s IS NULL OR i.ticket_id <> %(query_ticket_id)s)
|
||||
AND ({strict_clause})
|
||||
AND i.search_vector @@ q.tsq
|
||||
ORDER BY ts_rank_cd(i.search_vector, q.tsq) DESC
|
||||
LIMIT %(candidate_limit)s
|
||||
),
|
||||
metadata_candidates AS (
|
||||
SELECT i.ticket_id
|
||||
FROM ticket_ai_index i
|
||||
WHERE (%(query_ticket_id)s IS NULL OR i.ticket_id <> %(query_ticket_id)s)
|
||||
AND ({strict_clause})
|
||||
AND ({metadata_clause})
|
||||
ORDER BY i.opened_at DESC NULLS LAST
|
||||
LIMIT %(candidate_limit)s
|
||||
),
|
||||
code_candidates AS (
|
||||
SELECT i.ticket_id
|
||||
FROM ticket_ai_index i
|
||||
WHERE (%(query_ticket_id)s IS NULL OR i.ticket_id <> %(query_ticket_id)s)
|
||||
AND ({strict_clause})
|
||||
AND i.codes && %(query_codes)s::text[]
|
||||
ORDER BY i.opened_at DESC NULLS LAST
|
||||
LIMIT %(candidate_limit)s
|
||||
),
|
||||
candidate_ids AS (
|
||||
SELECT ticket_id FROM lexical_candidates
|
||||
UNION
|
||||
SELECT ticket_id FROM code_candidates
|
||||
UNION
|
||||
SELECT ticket_id FROM metadata_candidates
|
||||
),
|
||||
scored AS (
|
||||
SELECT
|
||||
i.ticket_id,
|
||||
i.subject_text,
|
||||
i.problem_text,
|
||||
i.solution_preview,
|
||||
i.competence_id,
|
||||
i.competence,
|
||||
i.product_id,
|
||||
i.product,
|
||||
i.area_id,
|
||||
i.area,
|
||||
i.subarea_id,
|
||||
i.subarea,
|
||||
i.client_id,
|
||||
i.client,
|
||||
i.opened_at,
|
||||
ts_rank_cd(i.search_vector, q.tsq) AS lexical_score,
|
||||
GREATEST(
|
||||
similarity(i.problem_text, %(problem_text)s),
|
||||
similarity(i.subject_text, %(subject_text)s)
|
||||
) AS trigram_score,
|
||||
CASE WHEN i.codes && %(query_codes)s::text[] THEN 0.18 ELSE 0 END AS code_score,
|
||||
(
|
||||
CASE WHEN i.product_id IS NOT DISTINCT FROM %(query_product_id)s THEN 0.045 ELSE 0 END +
|
||||
CASE WHEN i.subarea_id IS NOT DISTINCT FROM %(query_subarea_id)s THEN 0.035 ELSE 0 END +
|
||||
CASE WHEN i.area_id IS NOT DISTINCT FROM %(query_area_id)s THEN 0.020 ELSE 0 END +
|
||||
CASE WHEN i.competence_id IS NOT DISTINCT FROM %(query_competence_id)s THEN 0.015 ELSE 0 END
|
||||
) AS metadata_score,
|
||||
LEAST(
|
||||
GREATEST(COALESCE(fs.positive_count, 0) - COALESCE(fs.negative_count, 0), 0) * 0.015,
|
||||
0.12
|
||||
) AS feedback_score
|
||||
FROM candidate_ids c
|
||||
JOIN ticket_ai_index i ON i.ticket_id = c.ticket_id
|
||||
CROSS JOIN q
|
||||
LEFT JOIN ticket_ai_feedback_summary fs ON fs.ticket_id = i.ticket_id
|
||||
)
|
||||
SELECT
|
||||
*,
|
||||
(
|
||||
lexical_score * 0.62 +
|
||||
trigram_score * 0.28 +
|
||||
code_score +
|
||||
metadata_score +
|
||||
feedback_score
|
||||
) AS total_score
|
||||
FROM scored
|
||||
ORDER BY total_score DESC, lexical_score DESC, opened_at DESC NULLS LAST
|
||||
LIMIT %(final_limit)s
|
||||
"""
|
||||
|
||||
started_at = time.perf_counter()
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor(cursor_factory=DictCursor)
|
||||
cursor.execute(sql, params)
|
||||
rows = cursor.fetchall()
|
||||
all_suggestions = _diverse_suggestions(rows, query_ticket, pool_target, filters)
|
||||
suggestions = all_suggestions[offset:offset + limit]
|
||||
elapsed_ms = int((time.perf_counter() - started_at) * 1000)
|
||||
|
||||
if log_results:
|
||||
_log_search(cursor, user_id, query_kind, query_ticket_id, query_text, filters, len(all_suggestions), elapsed_ms)
|
||||
if query_kind == "ticket" and query_ticket_id is not None and suggestions:
|
||||
_log_suggestions(cursor, user_id, int(query_ticket_id), query_text, suggestions, rank_offset=offset)
|
||||
connection.commit()
|
||||
|
||||
cursor.close()
|
||||
connection.close()
|
||||
return suggestions
|
||||
|
||||
|
||||
def search_similar_tickets(query_ticket_id, user_id=None, limit=DEFAULT_LIMIT, offset=0, filters=None, log_results=True):
|
||||
query_ticket = mysql5.get_ticket_context(query_ticket_id)
|
||||
if not query_ticket:
|
||||
return []
|
||||
|
||||
query_text = _query_text(query_ticket)
|
||||
return _search(
|
||||
"ticket",
|
||||
query_text,
|
||||
query_ticket_id=int(query_ticket_id),
|
||||
query_ticket=query_ticket,
|
||||
user_id=user_id,
|
||||
limit=limit,
|
||||
offset=offset,
|
||||
filters=filters,
|
||||
log_results=log_results,
|
||||
)
|
||||
|
||||
|
||||
def search_similar_text(query_text, user_id=None, limit=DEFAULT_LIMIT, offset=0, filters=None, log_results=True):
|
||||
query_text = clean_text(query_text)
|
||||
if not query_text:
|
||||
return []
|
||||
return _search(
|
||||
"text",
|
||||
query_text,
|
||||
query_ticket_id=None,
|
||||
query_ticket={},
|
||||
user_id=user_id,
|
||||
limit=limit,
|
||||
offset=offset,
|
||||
filters=filters,
|
||||
log_results=log_results,
|
||||
)
|
||||
|
||||
|
||||
def _log_search(cursor, user_id, query_kind, query_ticket_id, query_text, filters, result_count, elapsed_ms):
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO ticket_ai_search_log (
|
||||
user_id,
|
||||
query_kind,
|
||||
query_ticket_id,
|
||||
query_text,
|
||||
filters,
|
||||
result_count,
|
||||
elapsed_ms
|
||||
) VALUES (%s, %s, %s, %s, %s, %s, %s)
|
||||
""",
|
||||
(
|
||||
user_id,
|
||||
query_kind,
|
||||
int(query_ticket_id) if query_ticket_id is not None else None,
|
||||
query_text,
|
||||
Json(_safe_filters(filters)),
|
||||
int(result_count),
|
||||
int(elapsed_ms),
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def _log_suggestions(cursor, user_id, query_ticket_id, query_text, suggestions, rank_offset=0):
|
||||
for rank, suggestion in enumerate(suggestions, start=1 + rank_offset):
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO ticket_ai_query_log (
|
||||
user_id,
|
||||
query_ticket_id,
|
||||
suggested_ticket_id,
|
||||
rank,
|
||||
total_score,
|
||||
lexical_score,
|
||||
trigram_score,
|
||||
code_score,
|
||||
metadata_score,
|
||||
feedback_score,
|
||||
confidence,
|
||||
query_text,
|
||||
reasons
|
||||
) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
""",
|
||||
(
|
||||
user_id,
|
||||
query_ticket_id,
|
||||
suggestion["ticket_id"],
|
||||
rank,
|
||||
float(suggestion["total_score"]),
|
||||
float(suggestion["lexical_score"]),
|
||||
float(suggestion["trigram_score"]),
|
||||
float(suggestion["code_score"]),
|
||||
float(suggestion["metadata_score"]),
|
||||
float(suggestion["feedback_score"]),
|
||||
suggestion["confidence"],
|
||||
query_text,
|
||||
suggestion["reasons"],
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def record_feedback(user_id, query_ticket_id, suggested_ticket_id, feedback, note=None):
|
||||
ensure_runtime_schema()
|
||||
if feedback not in ("useful", "not_useful", "favorite", "opened"):
|
||||
raise ValueError("feedback must be useful, not_useful, favorite, or opened")
|
||||
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor()
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO ticket_ai_feedback (
|
||||
user_id,
|
||||
query_ticket_id,
|
||||
suggested_ticket_id,
|
||||
feedback,
|
||||
note
|
||||
) VALUES (%s, %s, %s, %s, %s)
|
||||
""",
|
||||
(user_id, int(query_ticket_id), int(suggested_ticket_id), feedback, note),
|
||||
)
|
||||
connection.commit()
|
||||
cursor.close()
|
||||
connection.close()
|
||||
refresh_feedback_summary()
|
||||
return True
|
||||
|
||||
|
||||
def record_favorite(user_id, ticket_id, query_ticket_id=None, note=None):
|
||||
ensure_runtime_schema()
|
||||
ticket_id = int(ticket_id)
|
||||
query_ticket_id = int(query_ticket_id) if query_ticket_id is not None else ticket_id
|
||||
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor()
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT 1
|
||||
FROM ticket_ai_feedback
|
||||
WHERE user_id = %s
|
||||
AND suggested_ticket_id = %s
|
||||
AND feedback = 'favorite'
|
||||
LIMIT 1
|
||||
""",
|
||||
(user_id, ticket_id),
|
||||
)
|
||||
if cursor.fetchone():
|
||||
cursor.close()
|
||||
connection.close()
|
||||
return False
|
||||
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO ticket_ai_feedback (
|
||||
user_id,
|
||||
query_ticket_id,
|
||||
suggested_ticket_id,
|
||||
feedback,
|
||||
note
|
||||
) VALUES (%s, %s, %s, 'favorite', %s)
|
||||
""",
|
||||
(user_id, query_ticket_id, ticket_id, note),
|
||||
)
|
||||
connection.commit()
|
||||
cursor.close()
|
||||
connection.close()
|
||||
refresh_feedback_summary()
|
||||
return True
|
||||
|
||||
|
||||
def get_user_favorites(user_id, limit=20):
|
||||
ensure_runtime_schema()
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor(cursor_factory=DictCursor)
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT *
|
||||
FROM (
|
||||
SELECT DISTINCT ON (f.suggested_ticket_id)
|
||||
f.suggested_ticket_id AS ticket_id,
|
||||
f.query_ticket_id,
|
||||
f.created_at,
|
||||
i.product,
|
||||
i.area,
|
||||
i.subject_text
|
||||
FROM ticket_ai_feedback f
|
||||
LEFT JOIN ticket_ai_index i ON i.ticket_id = f.suggested_ticket_id
|
||||
WHERE f.user_id = %s
|
||||
AND f.feedback = 'favorite'
|
||||
ORDER BY f.suggested_ticket_id, f.created_at DESC
|
||||
) favorites
|
||||
ORDER BY created_at DESC
|
||||
LIMIT %s
|
||||
""",
|
||||
(user_id, int(limit)),
|
||||
)
|
||||
rows = [dict(row) for row in cursor.fetchall()]
|
||||
cursor.close()
|
||||
connection.close()
|
||||
return rows
|
||||
|
||||
|
||||
def get_user_bot_settings(user_id):
|
||||
ensure_runtime_schema()
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor(cursor_factory=DictCursor)
|
||||
cursor.execute(
|
||||
"""
|
||||
INSERT INTO ticket_bot_user_settings (user_id)
|
||||
VALUES (%s)
|
||||
ON CONFLICT (user_id) DO NOTHING
|
||||
""",
|
||||
(int(user_id),),
|
||||
)
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT *
|
||||
FROM ticket_bot_user_settings
|
||||
WHERE user_id = %s
|
||||
""",
|
||||
(int(user_id),),
|
||||
)
|
||||
settings = dict(cursor.fetchone())
|
||||
connection.commit()
|
||||
cursor.close()
|
||||
connection.close()
|
||||
return settings
|
||||
|
||||
|
||||
def update_user_bot_settings(user_id, **updates):
|
||||
allowed = {
|
||||
"notifications_enabled",
|
||||
"quiet_start_hour",
|
||||
"quiet_end_hour",
|
||||
"digest_minutes",
|
||||
"high_gravity_only",
|
||||
"last_notification_at",
|
||||
}
|
||||
clean_updates = {key: value for key, value in updates.items() if key in allowed}
|
||||
if not clean_updates:
|
||||
return get_user_bot_settings(user_id)
|
||||
|
||||
get_user_bot_settings(user_id)
|
||||
assignments = [f"{key} = %s" for key in clean_updates]
|
||||
values = list(clean_updates.values())
|
||||
values.append(int(user_id))
|
||||
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor()
|
||||
cursor.execute(
|
||||
f"""
|
||||
UPDATE ticket_bot_user_settings
|
||||
SET {", ".join(assignments)},
|
||||
updated_at = now()
|
||||
WHERE user_id = %s
|
||||
""",
|
||||
values,
|
||||
)
|
||||
connection.commit()
|
||||
cursor.close()
|
||||
connection.close()
|
||||
return get_user_bot_settings(user_id)
|
||||
|
||||
|
||||
def set_notifications_enabled(user_id, enabled):
|
||||
return update_user_bot_settings(user_id, notifications_enabled=bool(enabled))
|
||||
|
||||
|
||||
def set_quiet_hours(user_id, start_hour, end_hour):
|
||||
return update_user_bot_settings(
|
||||
user_id,
|
||||
quiet_start_hour=max(0, min(23, int(start_hour))),
|
||||
quiet_end_hour=max(0, min(23, int(end_hour))),
|
||||
)
|
||||
|
||||
|
||||
def clear_quiet_hours(user_id):
|
||||
return update_user_bot_settings(user_id, quiet_start_hour=None, quiet_end_hour=None)
|
||||
|
||||
|
||||
def set_digest_minutes(user_id, minutes):
|
||||
return update_user_bot_settings(user_id, digest_minutes=max(0, int(minutes)))
|
||||
|
||||
|
||||
def set_high_gravity_only(user_id, enabled):
|
||||
return update_user_bot_settings(user_id, high_gravity_only=bool(enabled))
|
||||
|
||||
|
||||
def _is_quiet_now(settings, now=None):
|
||||
start = settings.get("quiet_start_hour")
|
||||
end = settings.get("quiet_end_hour")
|
||||
if start is None or end is None or start == end:
|
||||
return False
|
||||
|
||||
hour = (now or datetime.now()).hour
|
||||
if start < end:
|
||||
return start <= hour < end
|
||||
return hour >= start or hour < end
|
||||
|
||||
|
||||
def should_send_notifications(user_id, now=None):
|
||||
settings = get_user_bot_settings(user_id)
|
||||
now = now or datetime.now()
|
||||
if not settings.get("notifications_enabled", True):
|
||||
return False
|
||||
if _is_quiet_now(settings, now=now):
|
||||
return False
|
||||
|
||||
digest_minutes = int(settings.get("digest_minutes") or 0)
|
||||
last_notification_at = settings.get("last_notification_at")
|
||||
if digest_minutes > 0 and last_notification_at:
|
||||
elapsed_seconds = (now - last_notification_at).total_seconds()
|
||||
if elapsed_seconds < digest_minutes * 60:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def mark_notification_sent(user_id):
|
||||
return update_user_bot_settings(user_id, last_notification_at=datetime.now())
|
||||
|
||||
|
||||
def get_ai_stats():
|
||||
ensure_runtime_schema()
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor(cursor_factory=DictCursor)
|
||||
cursor.execute("SELECT COUNT(*) AS indexed_count, MAX(indexed_at) AS last_indexed_at FROM ticket_ai_index")
|
||||
index_stats = dict(cursor.fetchone())
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT
|
||||
COUNT(*) AS search_count,
|
||||
COALESCE(AVG(elapsed_ms), 0)::integer AS avg_elapsed_ms,
|
||||
COALESCE(SUM(CASE WHEN result_count = 0 THEN 1 ELSE 0 END), 0) AS no_result_count
|
||||
FROM ticket_ai_search_log
|
||||
"""
|
||||
)
|
||||
search_stats = dict(cursor.fetchone())
|
||||
cursor.execute("SELECT feedback, COUNT(*) AS count FROM ticket_ai_feedback GROUP BY feedback")
|
||||
feedback_counts = {row["feedback"]: row["count"] for row in cursor.fetchall()}
|
||||
cursor.close()
|
||||
connection.close()
|
||||
return {
|
||||
**index_stats,
|
||||
**search_stats,
|
||||
"feedback_counts": feedback_counts,
|
||||
}
|
||||
|
||||
|
||||
def get_no_result_searches(limit=10):
|
||||
ensure_runtime_schema()
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor(cursor_factory=DictCursor)
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT created_at, user_id, query_kind, query_ticket_id, query_text, filters, elapsed_ms
|
||||
FROM ticket_ai_search_log
|
||||
WHERE result_count = 0
|
||||
ORDER BY created_at DESC
|
||||
LIMIT %s
|
||||
""",
|
||||
(int(limit),),
|
||||
)
|
||||
rows = [dict(row) for row in cursor.fetchall()]
|
||||
cursor.close()
|
||||
connection.close()
|
||||
return rows
|
||||
|
||||
|
||||
def get_negative_feedback(limit=10):
|
||||
ensure_runtime_schema()
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor(cursor_factory=DictCursor)
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT
|
||||
f.created_at,
|
||||
f.user_id,
|
||||
f.query_ticket_id,
|
||||
f.suggested_ticket_id,
|
||||
i.product,
|
||||
i.area,
|
||||
i.subject_text
|
||||
FROM ticket_ai_feedback f
|
||||
LEFT JOIN ticket_ai_index i ON i.ticket_id = f.suggested_ticket_id
|
||||
WHERE f.feedback = 'not_useful'
|
||||
ORDER BY f.created_at DESC
|
||||
LIMIT %s
|
||||
""",
|
||||
(int(limit),),
|
||||
)
|
||||
rows = [dict(row) for row in cursor.fetchall()]
|
||||
cursor.close()
|
||||
connection.close()
|
||||
return rows
|
||||
|
||||
|
||||
def get_top_useful(limit=10):
|
||||
ensure_runtime_schema()
|
||||
connection = get_pg_connection()
|
||||
cursor = connection.cursor(cursor_factory=DictCursor)
|
||||
cursor.execute(
|
||||
"""
|
||||
SELECT
|
||||
fs.ticket_id,
|
||||
fs.positive_count,
|
||||
fs.negative_count,
|
||||
i.product,
|
||||
i.area,
|
||||
i.subject_text
|
||||
FROM ticket_ai_feedback_summary fs
|
||||
LEFT JOIN ticket_ai_index i ON i.ticket_id = fs.ticket_id
|
||||
ORDER BY fs.positive_count DESC, fs.negative_count ASC
|
||||
LIMIT %s
|
||||
""",
|
||||
(int(limit),),
|
||||
)
|
||||
rows = [dict(row) for row in cursor.fetchall()]
|
||||
cursor.close()
|
||||
connection.close()
|
||||
return rows
|
||||
|
||||
|
||||
def start_guessing_manual(ticket, user_id=None, filters=None, limit=DEFAULT_LIMIT, offset=0):
|
||||
suggestions = search_similar_tickets(ticket, user_id=user_id, limit=limit, offset=offset, filters=filters)
|
||||
return [_format_suggestion(int(ticket), suggestion, rank + offset) for rank, suggestion in enumerate(suggestions, start=1)]
|
||||
Reference in New Issue
Block a user