def static_fn():
fn = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static",
name)
if os.path.exists(fn):
return open(fn, "rb").read()
critical("root_static_file: file %s not found!" % fn)
return abort(404, "static file %s not found." % fn)
def __init__(self,
shortname,
data=None,
editing=False,
showing=False,
saving=False):
if data is None and not editing:
data = db.institutions.lookup(shortname, projection=3)
if data is None:
raise ValueError("Institution %s does not exist" % shortname)
self.new = data is None
if self.new:
self.shortname = shortname
self.type = "university"
self.timezone = "US/Eastern"
self.admin = current_user.email
for key, typ in db.institutions.col_type.items():
if key == "id" or hasattr(self, key):
continue
elif typ == "text":
setattr(self, key, "")
elif typ == "text[]":
setattr(self, key, [])
else:
critical(
"Need to update institution code to account for schema change key=%s"
% key)
setattr(self, key, None)
else:
self.__dict__.update(data)
def save(self, data):
data = dict(data) # copy
email = data.pop("email", None)
if not email:
raise ValueError("data must contain email")
user = self.lookup(email)
if not user:
raise ValueError("user does not exist")
if not data:
raise ValueError("no data to save")
if "new_email" in data:
data["email"] = data.pop("new_email")
try:
# standerdize email
data["email"] = validate_email(data["email"])["email"]
except EmailNotValidError as e:
flash_error("""Oops, email '%s' is not allowed. %s""", data["email"], str(e))
return False
if self.user_exists(data["email"]):
flash_error("There is already a user registered with email = %s", data["email"])
return False
for key in list(data):
if key not in self.search_cols:
if key != "id":
critical("Need to update pwdmanager code to account for schema change key=%s" % key)
data.pop(key)
with DelayCommit(db):
if "email" in data:
newemail = data["email"]
db.institutions.update({"admin": ilike_query(email)}, {"admin": newemail})
db.seminars.update({"owner": ilike_query(email)}, {"owner": newemail})
db.seminar_organizers.update({"email": ilike_query(email)}, {"email": newemail})
db.talks.update({"speaker_email": ilike_query(email)}, {"speaker_email": newemail})
self.update({"email": ilike_query(email)}, data, restat=False)
return True
def __init__(
self,
seminar_id=None,
seminar_ctr=None,
data=None,
seminar=None,
editing=False,
include_deleted=False,
include_pending=False,
):
if data is None and not editing:
data = talks_lookup(seminar_id, seminar_ctr, include_deleted=include_deleted, include_pending=include_pending)
if data is None:
raise ValueError("Talk %s/%s does not exist" % (seminar_id, seminar_ctr))
data = dict(data.__dict__)
elif data is not None:
data = dict(data)
# avoid Nones
if data.get("topics") is None:
data["topics"] = []
if data and data.get("deleted"):
include_deleted = True
if seminar is None:
seminar = WebSeminar(seminar_id, include_deleted=include_deleted)
self.seminar = seminar
self.new = data is None
if self.new:
self.seminar_id = seminar_id
self.seminar_ctr = None
self.token = secrets.token_hex(8)
self.by_api = False # reset by API code if needed
self.timezone = seminar.timezone
self.deleted = False
self.deleted_with_seminar = False
self.hidden = False
for key, typ in db.talks.col_type.items():
if key == "id" or hasattr(self, key):
continue
if key in inherited_talk_columns:
setattr(self, key, getattr(seminar, key))
elif typ == "text":
setattr(self, key, "")
elif typ == "text[]":
setattr(self, key, [])
else:
# don't complain about columns we know are going to be set later
if not key in ["edited_by", "edited_at", "start_time", "end_time"]:
critical("Need to update talk code to account for schema change key=%s" % key)
setattr(self, key, None)
else:
# The output from psycopg2 seems to always be given in the server's time zone
if data.get("timezone"):
tz = pytz.timezone(data["timezone"])
if data.get("start_time"):
data["start_time"] = adapt_datetime(data["start_time"], tz)
if data.get("end_time"):
data["end_time"] = adapt_datetime(data["end_time"], tz)
self.__dict__.update(data)
self.cleanse()
def __init__(
self,
semid=None,
semctr=None,
data=None,
seminar=None,
editing=False,
showing=False,
saving=False,
deleted=False,
):
if data is None and not editing:
data = talks_lookup(semid, semctr, include_deleted=deleted)
if data is None:
raise ValueError("Talk %s/%s does not exist" % (semid, semctr))
data = dict(data.__dict__)
elif data is not None:
data = dict(data)
# avoid Nones
if data.get("topics") is None:
data["topics"] = []
if seminar is None:
seminar = WebSeminar(semid, deleted=deleted)
self.seminar = seminar
self.new = data is None
self.deleted=False
if self.new:
self.seminar_id = semid
self.seminar_ctr = None
self.token = "%016x" % random.randrange(16 ** 16)
self.display = seminar.display
self.online = getattr(seminar, "online", bool(seminar.live_link))
self.timezone = seminar.timezone
for key, typ in db.talks.col_type.items():
if key == "id" or hasattr(self, key):
continue
elif db.seminars.col_type.get(key) == typ and getattr(seminar, key, None):
# carry over from seminar, but not comments
setattr(self, key, getattr(seminar, key) if key != "comments" else "")
elif typ == "text":
setattr(self, key, "")
elif typ == "text[]":
setattr(self, key, [])
else:
critical("Need to update talk code to account for schema change key=%s" % key)
setattr(self, key, None)
else:
# The output from psycopg2 seems to always be given in the server's time zone
if data.get("timezone"):
tz = pytz.timezone(data["timezone"])
if data.get("start_time"):
data["start_time"] = adapt_datetime(data["start_time"], tz)
if data.get("end_time"):
data["end_time"] = adapt_datetime(data["end_time"], tz)
# transition to topics including the subject
if data.get("topics"):
data["topics"] = [(topic if "_" in topic else "math_" + topic) for topic in data["topics"]]
self.__dict__.update(data)
def __init__(
self,
seminar_id=None,
seminar_ctr=None,
data=None,
seminar=None,
editing=False,
showing=False,
saving=False,
deleted=False,
):
if data is None and not editing:
data = talks_lookup(seminar_id,
seminar_ctr,
include_deleted=deleted)
if data is None:
raise ValueError("Talk %s/%s does not exist" %
(seminar_id, seminar_ctr))
data = dict(data.__dict__)
elif data is not None:
data = dict(data)
# avoid Nones
if data.get("topics") is None:
data["topics"] = []
if data and data.get("deleted"):
deleted = True
if seminar is None:
seminar = WebSeminar(seminar_id, deleted=deleted)
self.seminar = seminar
self.new = data is None
self.deleted = False
if self.new:
self.seminar_id = seminar_id
self.seminar_ctr = None
self.token = secrets.token_hex(8)
self.display = seminar.display
self.online = getattr(seminar, "online", bool(seminar.live_link))
self.by_api = False # reset by API code if needed
self.timezone = seminar.timezone
for key, typ in db.talks.col_type.items():
if key == "id" or hasattr(self, key):
continue
elif db.seminars.col_type.get(key) == typ and getattr(
seminar, key, None):
# carry over from seminar, but not comments
setattr(self, key,
getattr(seminar, key) if key != "comments" else "")
print("talk inherited %s = %s from seminar" %
(key, getattr(self, key)))
elif typ == "text":
setattr(self, key, "")
elif typ == "text[]":
setattr(self, key, [])
else:
critical(
"Need to update talk code to account for schema change key=%s"
% key)
setattr(self, key, None)
else:
# The output from psycopg2 seems to always be given in the server's time zone
if data.get("timezone"):
tz = pytz.timezone(data["timezone"])
if data.get("start_time"):
data["start_time"] = adapt_datetime(data["start_time"], tz)
if data.get("end_time"):
data["end_time"] = adapt_datetime(data["end_time"], tz)
self.__dict__.update(data)
self.cleanse()
def static_fn():
fn = os.path.join(os.path.dirname(os.path.abspath(__file__)), "static", name)
if os.path.exists(fn):
return open(fn).read()
critical("root_static_file: file %s not found!" % fn)
return abort(404, 'static file %s not found.' % fn)
def __init__(
self,
shortname,
data=None,
organizers=None,
editing=False,
include_deleted=False,
include_pending=False,
user=None,
):
if user is None:
user = current_user
if data is None and not editing:
data = seminars_lookup(shortname,
include_deleted=include_deleted,
include_pending=include_pending)
if data is None:
raise ValueError("Seminar %s does not exist" % shortname)
data = dict(data.__dict__)
elif data is not None:
data = dict(data)
if data.get("topics") is None:
data["topics"] = []
if data.get("institutions") is None:
data["institutions"] = []
if data.get("timezone") is None:
data["timesone"] = str(user.tz)
self.new = data is None
self.deleted = False
if self.new:
self.shortname = shortname
self.display = user.is_creator
self.online = True # default
self.by_api = False # reset by API code if needed
self.access_control = 4 # default is instant registration
self.edited_by = user.id
self.visibility = 2 # public by default, once display is set to True
self.audience = 0 # default is researchers
self.is_conference = False # seminar by default
self.frequency = 7
self.per_day = 1
self.weekday = self.start_time = self.end_time = None
self.timezone = str(user.tz)
self.language = 'en' # default is English
for key, typ in db.seminars.col_type.items():
if key == "id" or hasattr(self, key):
continue
elif typ == "text":
setattr(self, key, "")
elif typ == "text[]":
setattr(self, key, [])
elif typ == "smallint[]":
setattr(self, key, [])
elif typ == "timestamp with time zone":
setattr(self, key, None)
elif typ == "timestamp with time zone[]":
setattr(self, key, [])
elif typ == "date":
setattr(self, key, None)
else:
from lmfdb.logger import critical
# don't write these to the flasklog
critical(
"Need to update seminar code to account for schema change key=%s"
% key)
setattr(self, key, None)
if organizers is None:
organizers = [{
"seminar_id": self.shortname,
"email": user.email,
"homepage": user.homepage,
"name": user.name,
"order": 0,
"curator": False,
"display": True,
}]
else:
self.__dict__.update(data)
if organizers is None:
organizers = list(
db.seminar_organizers.search({"seminar_id": self.shortname},
sort=["order"]))
self.organizers = organizers
self.cleanse()
def __init__(
self, shortname, data=None, organizers=None, editing=False, showing=False, saving=False, deleted=False, user=None,
):
if user is None:
user = current_user
if data is None and not editing:
data = seminars_lookup(shortname, include_deleted=deleted)
if data is None:
raise ValueError("Seminar %s does not exist" % shortname)
data = dict(data.__dict__)
elif data is not None:
data = dict(data)
if data.get("topics") is None:
data["topics"] = []
if data.get("institutions") is None:
data["institutions"] = []
if data.get("timezone") is None:
data["timesone"] = str(user.tz)
self.new = data is None
self.deleted = False
if self.new:
self.shortname = shortname
self.display = user.is_creator
self.online = True # default
self.by_api = False # reset by API code if needed
self.access = "open" # default FIXME: remove once we switch to access_control
self.access_control = 4 # default is instant registration
self.access_time = None
self.edited_by = user.id
self.visibility = 2 # public by default, once display is set to True
self.level = 0 # default is research seminar
self.is_conference = False # seminar by default
self.frequency = 7
self.per_day = 1
self.weekday = self.start_time = self.end_time = None
self.timezone = str(user.tz)
for key, typ in db.seminars.col_type.items():
if key == "id" or hasattr(self, key):
continue
elif typ == "text":
setattr(self, key, "")
elif typ == "text[]":
setattr(self, key, [])
elif typ == "smallint[]":
setattr(self, key, [])
elif typ == "timestamp with time zone":
setattr(self, key, None)
elif typ == "timestamp with time zone[]":
setattr(self, key, [])
elif typ == "date":
setattr(self, key, None)
else:
critical(
"Need to update seminar code to account for schema change key=%s" % key
)
setattr(self, key, None)
if organizers is None:
organizers = [
{
"seminar_id": self.shortname,
"email": user.email,
"homepage": user.homepage,
"name": user.name,
"order": 0,
"curator": False,
"display": True,
"contact": True,
}
]
else:
# The output from psycopg2 seems to always be given in the server's time zone
if data.get("timezone"):
tz = pytz.timezone(data["timezone"])
if data.get("start_time"):
data["start_time"] = adapt_datetime(data["start_time"], tz)
if data.get("end_time"):
data["end_time"] = adapt_datetime(data["end_time"], tz)
self.__dict__.update(data)
if organizers is None:
organizers = list(
db.seminar_organizers.search({"seminar_id": self.shortname}, sort=["order"])
)
self.organizers = organizers
self.cleanse()
def __init__(self,
shortname,
data=None,
organizer_data=None,
editing=False,
showing=False,
saving=False,
deleted=False):
if data is None and not editing:
data = seminars_lookup(shortname, include_deleted=deleted)
if data is None:
raise ValueError("Seminar %s does not exist" % shortname)
data = dict(data.__dict__)
elif data is not None:
data = dict(data)
if data.get("topics") is None:
data["topics"] = []
if data.get("institutions") is None:
data["institutions"] = []
if data.get("timezone") is None:
data["timesone"] = str(current_user.tz)
self.new = data is None
self.deleted = False
if self.new:
self.shortname = shortname
self.display = current_user.is_creator
self.online = True # default
self.access = "open" # default
self.visibility = 2 # public by default, once display is set to True
self.is_conference = False # seminar by default
self.frequency = 7
self.per_day = 1
self.weekday = self.start_time = self.end_time = None
self.timezone = str(current_user.tz)
for key, typ in db.seminars.col_type.items():
if key == "id" or hasattr(self, key):
continue
elif typ == "text":
setattr(self, key, "")
elif typ == "text[]":
setattr(self, key, [])
elif typ == "smallint[]":
setattr(self, key, [])
elif typ == "timestamp with time zone":
setattr(self, key, None)
elif typ == "timestamp with time zone[]":
setattr(self, key, [])
elif typ == "date":
setattr(self, key, None)
elif typ == "bigint":
setattr(self, key, None)
else:
critical(
"Need to update seminar code to account for schema change key=%s"
% key)
setattr(self, key, None)
if organizer_data is None:
organizer_data = [{
"seminar_id": self.shortname,
"email": current_user.email,
"homepage": current_user.homepage,
"full_name": current_user.name,
"order": 0,
"curator": False,
"display": True,
"contact": True,
}]
else:
# The output from psycopg2 seems to always be given in the server's time zone
if data.get("timezone"):
tz = pytz.timezone(data["timezone"])
if data.get("start_time"):
data["start_time"] = adapt_datetime(data["start_time"], tz)
if data.get("end_time"):
data["end_time"] = adapt_datetime(data["end_time"], tz)
# transition to topics including the subject
if data.get("topics"):
data["topics"] = [(topic if "_" in topic else "math_" + topic)
for topic in data["topics"]]
self.__dict__.update(data)
if organizer_data is None:
organizer_data = list(
db.seminar_organizers.search({"seminar_id": self.shortname},
sort=["order"]))
self.organizer_data = organizer_data
self.convert_time_to_times()