def releases_list(project, request):
q = request.params.get("q")
project_name = request.matchdict["project_name"]
if project_name != project.normalized_name:
raise HTTPMovedPermanently(
request.current_route_path(
project_name=project.normalized_name,
),
)
try:
page_num = int(request.params.get("page", 1))
except ValueError:
raise HTTPBadRequest("'page' must be an integer.") from None
releases_query = (request.db.query(Release)
.filter(Release.project == project)
.order_by(Release._pypi_ordering.desc()))
if q:
terms = shlex.split(q)
filters = []
for term in terms:
if ":" in term:
field, value = term.split(":", 1)
if field.lower() == "version":
filters.append(Release.version.ilike(value))
releases_query = releases_query.filter(or_(*filters))
releases = SQLAlchemyORMPage(
releases_query,
page=page_num,
items_per_page=25,
url_maker=paginate_url_factory(request),
)
return {
"releases": releases,
"project": project,
"query": q,
}
def journals_list(request):
q = request.params.get("q")
try:
page_num = int(request.params.get("page", 1))
except ValueError:
raise HTTPBadRequest("'page' must be an integer.") from None
journals_query = (
request.db.query(JournalEntry)
.options(joinedload(JournalEntry.submitted_by))
.order_by(JournalEntry.submitted_date.desc(), JournalEntry.id.desc())
)
if q:
terms = shlex.split(q)
filters = []
for term in terms:
if ":" in term:
field, value = term.split(":", 1)
if field.lower() == "project":
filters.append(JournalEntry.name.ilike(value))
if field.lower() == "version":
filters.append(JournalEntry.version.ilike(value))
if field.lower() == "user":
filters.append(JournalEntry._submitted_by.like(value))
if field.lower() == "ip":
filters.append(JournalEntry.submitted_from.ilike(value))
else:
filters.append(JournalEntry.name.ilike(term))
journals_query = journals_query.filter(and_(*filters))
journals = SQLAlchemyORMPage(
journals_query,
page=page_num,
items_per_page=25,
url_maker=paginate_url_factory(request),
)
return {"journals": journals, "query": q}
def journals_list(project, request):
q = request.params.get("q")
project_name = request.matchdict["project_name"]
if project_name != project.normalized_name:
raise HTTPMovedPermanently(
request.current_route_path(project_name=project.normalized_name)
)
try:
page_num = int(request.params.get("page", 1))
except ValueError:
raise HTTPBadRequest("'page' must be an integer.") from None
journals_query = (
request.db.query(JournalEntry)
.options(joinedload("submitted_by"))
.filter(JournalEntry.name == project.name)
.order_by(JournalEntry.submitted_date.desc(), JournalEntry.id.desc())
)
if q:
terms = shlex.split(q)
filters = []
for term in terms:
if ":" in term:
field, value = term.split(":", 1)
if field.lower() == "version":
filters.append(JournalEntry.version.ilike(value))
journals_query = journals_query.filter(or_(*filters))
journals = SQLAlchemyORMPage(
journals_query,
page=page_num,
items_per_page=25,
url_maker=paginate_url_factory(request),
)
return {"journals": journals, "project": project, "query": q}
def test_some(self, db_request):
check = MalwareCheckFactory.create()
for _ in range(10):
MalwareVerdictFactory.create(check=check)
query = db_request.db.query(MalwareVerdict).order_by(
MalwareVerdict.run_date.desc())
verdicts = SQLAlchemyORMPage(
query,
page=1,
items_per_page=25,
url_maker=paginate_url_factory(db_request),
)
assert views.get_verdicts(db_request) == {
"verdicts": verdicts,
"check_names": set([check.name]),
"classifications": set(["threat", "indeterminate", "benign"]),
"confidences": set(["low", "medium", "high"]),
}
def email_list(request):
q = request.params.get("q")
try:
page_num = int(request.params.get("page", 1))
except ValueError:
raise HTTPBadRequest("'page' must be an integer.") from None
email_query = request.db.query(EmailMessage).order_by(
EmailMessage.created.desc(), EmailMessage.id)
if q:
terms = shlex.split(q)
filters = []
for term in terms:
if ":" in term:
field, value = term.split(":", 1)
if field.lower() == "to":
filters.append(EmailMessage.to.ilike(value))
if field.lower() == "from":
filters.append(EmailMessage.from_.ilike(value))
if field.lower() == "subject":
filters.append(EmailMessage.subject.ilike(value))
if field.lower() == "status":
filters.append(
cast(EmailMessage.status, String).ilike(value))
else:
filters.append(EmailMessage.to.ilike(term))
email_query = email_query.filter(or_(*filters))
emails = SQLAlchemyORMPage(
email_query,
page=page_num,
items_per_page=25,
url_maker=paginate_url_factory(request),
)
return {"emails": emails, "query": q}
def manage_project_journal(project, request):
try:
page_num = int(request.params.get("page", 1))
except ValueError:
raise HTTPBadRequest("'page' must be an integer.")
journals_query = (request.db.query(JournalEntry).options(
joinedload("submitted_by")).filter(
JournalEntry.name == project.name).order_by(
JournalEntry.submitted_date.desc(), JournalEntry.id.desc()))
journals = SQLAlchemyORMPage(
journals_query,
page=page_num,
items_per_page=25,
url_maker=paginate_url_factory(request),
)
if journals.page_count and page_num > journals.page_count:
raise HTTPNotFound
return {"project": project, "journals": journals}
def manage_project_history(project, request):
try:
page_num = int(request.params.get("page", 1))
except ValueError:
raise HTTPBadRequest("'page' must be an integer.")
events_query = (request.db.query(ProjectEvent).join(
ProjectEvent.project).filter(
ProjectEvent.project_id == project.id).order_by(
ProjectEvent.time.desc()))
events = SQLAlchemyORMPage(
events_query,
page=page_num,
items_per_page=25,
url_maker=paginate_url_factory(request),
)
if events.page_count and page_num > events.page_count:
raise HTTPNotFound
return {"project": project, "events": events}
def test_manually_reviewed_filter(self, db_request, manually_reviewed):
check = MalwareCheckFactory.create()
for _ in range(5):
MalwareVerdictFactory.create(
check=check, manually_reviewed=bool(manually_reviewed)
)
# Create other verdicts to ensure filter works properly
for _ in range(10):
MalwareVerdictFactory.create(
check=check, manually_reviewed=not bool(manually_reviewed)
)
db_request.GET["manually_reviewed"] = str(manually_reviewed)
query = (
db_request.db.query(MalwareVerdict)
.filter(MalwareVerdict.manually_reviewed == bool(manually_reviewed))
.order_by(MalwareVerdict.run_date.desc())
)
verdicts = SQLAlchemyORMPage(
query,
page=1,
items_per_page=25,
url_maker=paginate_url_factory(db_request),
)
response = {
"verdicts": verdicts,
"check_names": set([check.name]),
"classifications": set(["threat", "indeterminate", "benign"]),
"confidences": set(["low", "medium", "high"]),
}
assert views.get_verdicts(db_request) == response
def organization_list(request):
if request.flags.enabled(AdminFlagValue.DISABLE_ORGANIZATIONS):
raise HTTPNotFound
q = request.params.get("q", "")
terms = shlex.split(q)
try:
page_num = int(request.params.get("page", 1))
except ValueError:
raise HTTPBadRequest("'page' must be an integer.") from None
organizations_query = request.db.query(Organization).order_by(
Organization.normalized_name)
if q:
filters = []
for term in terms:
# Examples:
# - search individual words or "whole phrase" in any field
# - name:psf
# - organization:python
# - url:.org
# - description:word
# - description:"whole phrase"
# - is:approved
# - is:declined
# - is:submitted
# - is:active
# - is:inactive
try:
field, value = term.lower().split(":", 1)
except ValueError:
field, value = "", term
if field == "name":
# Add filter for `name` or `normalized_name` fields.
filters.append([
Organization.name.ilike(f"%{value}%"),
Organization.normalized_name.ilike(f"%{value}%"),
])
elif field == "org" or field == "organization":
# Add filter for `display_name` field.
filters.append(Organization.display_name.ilike(f"%{value}%"))
elif field == "url" or field == "link_url":
# Add filter for `link_url` field.
filters.append(Organization.link_url.ilike(f"%{value}%"))
elif field == "desc" or field == "description":
# Add filter for `description` field.
filters.append(Organization.description.ilike(f"%{value}%"))
elif field == "is":
# Add filter for `is_approved` or `is_active` field.
if "approved".startswith(value):
filters.append(
Organization.is_approved == True) # noqa: E712
elif "declined".startswith(value):
filters.append(
Organization.is_approved == False) # noqa: E712
elif "submitted".startswith(value):
filters.append(
Organization.is_approved == None) # noqa: E711
elif "active".startswith(value):
filters.append(
Organization.is_active == True) # noqa: E712
elif "inactive".startswith(value):
filters.append(
Organization.is_active == False) # noqa: E712
else:
# Add filter for any field.
filters.append([
Organization.name.ilike(f"%{term}%"),
Organization.normalized_name.ilike(f"%{term}%"),
Organization.display_name.ilike(f"%{term}%"),
Organization.link_url.ilike(f"%{term}%"),
Organization.description.ilike(f"%{term}%"),
])
# Use AND to add each filter. Use OR to combine subfilters.
for filter_or_subfilters in filters:
if isinstance(filter_or_subfilters, list):
# Add list of subfilters combined with OR.
organizations_query = organizations_query.filter(
or_(*filter_or_subfilters))
else:
# Add single filter.
organizations_query = organizations_query.filter(
filter_or_subfilters)
organizations = SQLAlchemyORMPage(
organizations_query,
page=page_num,
items_per_page=25,
url_maker=paginate_url_factory(request),
)
return {"organizations": organizations, "query": q, "terms": terms}
