def fragment_matches(self):
"""Information about summaries which match the title fragment."""
if not hasattr(self, "_fragment_matches"):
if not self.fragment:
bail("No title fragment to match")
pattern = f"{self.fragment}%"
query = db.Query("document d", "d.id", "d.title").order(2, 1)
query.join("doc_type t", "t.id = d.doc_type")
query.where("t.name = 'Summary'")
query.where(query.Condition("d.title", pattern, "LIKE"))
self._fragment_matches = []
class Summary:
def __init__(self, doc_id, display, tooltip=None):
self.id = doc_id
self.display = display
self.tooltip = tooltip
for doc_id, title in query.execute(self.cursor).fetchall():
if len(title) > 60:
short_title = title[:57] + "..."
summary = Summary(doc_id, short_title, title)
else:
summary = Summary(doc_id, title)
self._fragment_matches.append(summary)
return self._fragment_matches
def grouping(self):
"""Whether the grouping should be by drug or by approval."""
if not hasattr(self, "_grouping"):
self._grouping = self.fields.getvalue("grouping")
if self._grouping not in [g[0] for g in self.GROUPINGS]:
bail()
return self._grouping
def prod_filters(self):
"""Dictionary of PROD filters, indexed by title."""
if not hasattr(self, "_prod_filters"):
if not self.refresh_cache:
try:
with open(self.CACHED_PROD_FILTERS) as fp:
self._prod_filters = json.load(fp)
return self._prod_filters
except Exception as e:
self.logger.warning("Failure loading from cache: %s", e)
self._prod_filters = {}
for filt in cdr.getFilters("guest", tier="PROD"):
url = self.URL.format(filt.id)
response = requests.get(url)
if response.status_code != requests.codes.ok:
msg = f"{url}: {response.status_code} ({response.reason})"
cdrcgi.bail(msg)
self._prod_filters[filt.name] = response.text
try:
with open(self.CACHED_PROD_FILTERS, "w") as fp:
json.dump(self._prod_filters, fp)
except:
pass
return self._prod_filters
def audience(self):
"""Either patient or health_professional."""
if not hasattr(self, "_audience"):
self._audience = self.fields.getvalue("audience")
if self._audience and self._audience not in self.AUDIENCES:
bail()
return self._audience
def filename(self):
"""Configuration file currently being edited."""
if not hasattr(self, "_filename"):
self._filename = self.fields.getvalue("filename") or self.FILES[0]
if self._filename not in self.FILES:
bail()
return self._filename
def board(self):
"""Sequence of IDs for the boards to be included."""
if not hasattr(self, "_board"):
self._board = self.fields.getlist("board")
for board in self._board:
if board != "all" and int(board) not in self.boards:
bail()
return self._board
def language(self):
"""Either english or spanish."""
if not hasattr(self, "_language"):
self._language = self.fields.getvalue("language")
if self._language and self._language not in self.LANGUAGES:
bail()
return self._language
def indication(self):
"""Which approved indication(s) the report should show."""
if not hasattr(self, "_indication"):
self._indication = self.fields.getlist("indication")
for indication in self._indication:
if indication != "all":
if indication not in self.all_indications:
bail()
return self._indication
def report_type(self):
"""User's decision as to whether to report by board or by date."""
if not hasattr(self, "_report_type"):
self._report_type = self.fields.getvalue("report_type")
if not self._report_type:
self._report_type = self.BY_BOARD
elif self._report_type not in self.REPORT_TYPES:
bail()
return self._report_type
def types(self):
"User-selected types, validated and sorted correctly." ""
if not hasattr(self, "_types"):
types = self.fields.getlist("type")
for markup_type in types:
if markup_type not in self.TYPES:
bail()
self._types = [t for t in self.TYPES if t in types]
return self._types
def concept(self):
"""Load the concept document from NCI Thesaurus service."""
if not hasattr(self, "_concept"):
try:
self._concept = Concept(code=self.code)
except Exception as e:
self.logger.exception("unable to load %r", self.code)
bail(f"Failure importing concept from NCI Thesaurus: {e}")
return self._concept
def delete(self):
"""Delete the current filter set and navigate back to the sets."""
filter_set = FilterSet(self.session, id=self.set.id)
name = filter_set.name
try:
filter_set.delete()
except Exception as e:
self.logger.exception("failure deleting %s", self.set.name)
bail(str(e))
navigateTo(self.EDIT_SETS, self.session.name, deleted=name)
def run(self):
"""Override so we can handle some custom commands."""
if not self.session.can_do("SET_SYS_VALUE"):
bail("Not authorized to manage control values")
if self.request == self.SAVE:
self.save()
elif self.request == self.DELETE:
self.inactivate()
else:
Controller.run(self)
def type(self):
"""The basic option for which type of report to generate.
Validate the data to ensure that it hasn't been tampered
with. In the event of hacking, we provide an error message
which is as uninformative as possible.
"""
if not hasattr(self, "_type"):
self._type = self.fields.getvalue("type")
if self._type not in [t[0] for t in self.TYPES]:
bail()
return self._type
def run(self):
"""Override the top-level entry point, as this isn't a report."""
if not self.session.can_do("SET_SYS_VALUE"):
bail("You are not authorized to use this tool")
if self.request == self.SAVE:
try:
self.save()
except Exception as e:
self.logger.exception("Failure saving")
bail(str(e))
else:
Controller.run(self)
def run(self):
"""Override base class so we can handle the extra buttons."""
try:
if self.request == self.INACTIVATE:
return self.inactivate()
elif self.request in (self.SAVE_CHANGES, self.SAVE_NEW):
return self.save()
elif self.request == self.SUBMENU:
return self.return_to_users_menu()
except Exception as e:
bail(f"Failure: {e}")
Controller.run(self)
def run(self):
"""Override base class so we can handle the extra buttons."""
try:
if self.request == self.DELETE:
return self.delete()
elif self.request == self.SAVE:
return self.save()
elif self.request == self.SUBMENU:
return self.return_to_groups_menu()
except Exception as e:
bail(f"Failure: {e}")
Controller.run(self)
def send_json(self):
"""Return JSON-encoded results from the current query to the user."""
if self.sql:
rows = self.rows
if not self.cursor.description:
bail("No query results")
payload = dict(columns=self.cursor.description, rows=rows)
print("Content-type: application/json\n")
print(dumps(payload, default=str, indent=2))
sys.exit(0)
else:
self.show_form()
def run(self):
"""Handle our custom actions."""
if not self.session.can_do("MODIFY FILTER SET"):
bail("You are not authorized to use this page")
try:
request = self.request or self.fields.getvalue("action")
if request == self.SAVE:
return self.save()
elif self.request == self.DELETE:
return self.delete()
elif self.request == self.SETS:
navigateTo(self.EDIT_SETS, self.session.name)
except Exception as e:
self.logger.exception("Failure")
bail(str(e))
Controller.run(self)
def widthFromRes(size, res):
width, height = size
if res == "300":
return None # don't resize
elif res == "150":
return int(round(width / 2.0))
elif res == "72":
return int(round(width * .24))
elif res == "thumb":
if width >= height:
if width <= 120:
return None
return 120
if height <= 120:
return None
return int(round(width * (120.0 / height)))
else:
cdrcgi.bail("invalid res value '%s'" % res)
def run(self):
"""Run the report (top-level entry point)."""
if cdr.isProdHost():
cdrcgi.bail("Can't compare the production server to itself")
lines = []
for name in sorted(self.filter_names, key=str.lower):
if name not in self.local_filters:
lines += self.only_on(name, "PROD")
elif name not in self.prod_filters:
lines += self.only_on(name, self.tier.name)
else:
lines += self.compare(name)
if not lines:
lines = [f"Filters on {self.tier.name} and PROD are identical"]
lines = "\n".join(lines) + "\n"
stdout.buffer.write(b"Content-type: text/plain; charset=utf-8\n\n")
stdout.buffer.write(lines.encode("utf-8"))
def run(self):
"""Override the run() method of the base class.
We need to handle requests to import or update PubMed
articles from NLM.
"""
if self.request in ("Import", "Update"):
try:
citation = Citation(self)
citation.save()
self.show_form(citation.message, citation.error)
except Exception as e:
self.session.logger.exception("%s from PubMed", self.request)
error = f"Unable to import {self.pmid!r} from PubMed: {e}"
bail(error)
else:
AdvancedSearch.run(self)
def run(self):
"""Override the run() method of the base class.
We need to handle requests to import or update PubMed
articles from NLM.
"""
if self.request in ("Import", "Update"):
try:
term = Term(self)
term.save()
self.changes = term.changes
self.show_form(term.message)
except Exception as e:
self.session.logger.exception("%s from NCIT", self.request)
error = f"Unable to import {self.code!r} from NCIT: {e}"
bail(error)
else:
AdvancedSearch.run(self)
def show_title_form(self):
"""Let the user pick a summary from those which match her fragment."""
if not self.fragment_matches:
bail("No summaries match that title fragment")
page = self.form_page
page.form.append(page.hidden_field("method", value="id"))
page.form.append(page.hidden_field("level", self.level))
if self.include_id:
page.form.append(page.hidden_field("include_id", "Y"))
fieldset = page.fieldset("Choose Summary")
fieldset.set("style", "width: 600px")
for summary in self.fragment_matches:
opts = dict(value=summary.id, label=summary.display)
if summary.tooltip:
opts["tooltip"] = summary.tooltip
fieldset.append(page.radio_button("id", **opts))
page.form.append(fieldset)
page.send()
def inactivate(self):
"""Suppress a value which is no longer needed."""
group = self.fields.getvalue("group")
name = self.fields.getvalue("name")
if not (group and name):
bail("Nothing to inactivate")
args = self.session, group, name
try:
self.session.tier.inactivate_control_value(*args)
except Exception as e:
bail(str(e))
names = "_group", "_name", "_value", "_comment"
self._groups = Groups()
for name in names:
if hasattr(self, name):
delattr(self, name)
self.subtitle = "Value successfully deleted"
self.show_form()
def save(self):
"""Save the new or modified document type object."""
if not self.name:
bail("Required name is missing")
if self.doctype.name:
self.subtitle = f"Changes to {self.name} saved successfully"
else:
self.subtitle = f"New doctype {self.name} saved successfully"
opts = dict(
active=self.active,
comment=self.comment,
format=self.format,
name=self.name,
schema=self.schema,
title_filter=self.title_filter,
versioning=self.versioning,
)
self.doctype = Doctype(self.session, **opts)
self.doctype.save()
self.show_form()
def save(self):
"""Save the new or modified user account object."""
if not self.name:
bail("Required name is missing")
if self.user.name:
self.subtitle = f"Changes to {self.name} saved successfully"
else:
self.subtitle = f"New user {self.name} saved successfully"
opts = dict(
authmode=self.authmode,
comment=self.comment,
email=self.email,
fullname=self.fullname,
groups=self.group,
name=self.name,
office=self.office,
phone=self.phone,
)
if self.authmode == "local":
if self.password != self.confirm:
bail("Password confirmation mismatch")
password = self.password or None
if not self.user.name and not password:
bail("Password required for local system accounts")
else:
password = None
self.user = self.session.User(self.session, **opts)
self.user.save(password)
self.show_form()
def save(self):
"""Save a new or updated control value."""
group = self.new_group
if not group and self.group:
group = self.group.name
name = self.new_name
if not name and self.group:
name = self.group[self.name].name
if not (group and name):
bail("Can't save without both a group and a name.")
args = self.session, group, name, self.value
opts = dict(comment=self.comment)
try:
self.session.tier.set_control_value(*args, **opts)
except Exception as e:
bail(str(e))
if self.new_group or self.new_name:
self._groups = Groups()
self._group = self.groups[group.lower()]
self._name = name.lower()
self.subtitle = "Value successfully saved"
self.show_form()
def save(self):
"""Save the new or modified filter set."""
original_name = self.set.name
opts = dict(
name=self.name,
description=self.description,
notes=self.notes,
members=self.members,
)
if self.set.id:
opts["id"] = self.set.id
filter_set = FilterSet(self.session, **opts)
try:
filter_set.save()
args = filter_set.id, filter_set.name, len(filter_set.members)
self.subtitle = "Saved set {} ({}) with {} members".format(*args)
if self.set.id and self.set.name != filter_set.name:
self.subtitle += f" (name changed from {self.set.name})"
except Exception as e:
self.logger.exception("failure saving %s", self.name)
bail(str(e))
self._set = filter_set
self.show_form()
# BZIssue::5001
#----------------------------------------------------------------------
import sys, cgi, cdr, cdrcgi
from io import BytesIO
from PIL import Image, ImageEnhance
from cdrapi import db
message = "GetCdrImage: No doc ID found"
fields = cgi.FieldStorage()
width = fields.getvalue("width")
res = fields.getvalue("res")
fname = fields.getvalue("fname")
quality = fields.getvalue("quality") or "85"
sharpen = fields.getvalue("sharpen")
pp = fields.getvalue("pp") or ""
cdrId = fields.getvalue("id") or cdrcgi.bail(message)
conn = db.connect()
cursor = conn.cursor()
#----------------------------------------------------------------------
# Support for Visuals Online. Four possible values for res:
# 300 - full size (for printing)
# 72 - 24% (viewing on screen)
# 150 - 1/2 size (in between)
# thumb - max 120px on a side (thumbnails)
#----------------------------------------------------------------------
def widthFromRes(size, res):
width, height = size
if res == "300":
return None # don't resize
