class ThesaurusLocalBaseSchema(validators.RootSchema):
if_key_missing = None
Used = validators.DictConverter(UsedOptions)
UseAll = validators.DictConverter(UseAllOptions)
SubjCat_ID = validators.IDValidator()
SRC_ID = validators.IDValidator()
Inactive = validators.Bool()
def edit(self):
request = self.request
user = request.user
if not user.cic or user.cic.CanUpdatePubs != const.UPDATE_ALL:
self._security_failure()
model_state = request.model_state
model_state.validators = {
"PB_ID": validators.IDValidator(not_empty=True),
"GH_ID": validators.IDValidator(),
}
model_state.method = None
if not model_state.validate():
# XXX invalid PB_ID
if model_state.is_error("PB_ID"):
self._error_page(_("Invalid Publication ID", request))
self._error_page(_("Invalid Heading ID", request))
PB_ID = model_state.value("PB_ID")
GH_ID = model_state.value("GH_ID")
is_add = not GH_ID
if user.cic.LimitedView and PB_ID and PB_ID != user.cic.PB_ID:
self._security_failure()
edit_values = self._get_edit_info(is_add, PB_ID, GH_ID)
data = model_state.form.data
data["generalheading"] = edit_values.generalheading
data["descriptions"] = edit_values.generalheading_descriptions
data["RelatedHeadings"] = edit_values.relatedheadings
data["MustMatch"] = edit_values.must_match
data["MatchAny"] = edit_values.match_any
if not is_add:
val = edit_values.generalheading.Used
data["generalheading.Used"] = RUsedOptions.get(val, val)
if is_add:
title = _("Add Heading", request)
else:
title = (
_("Edit Heading: %s", request)
% edit_values.generalheading.CurrentDisplayName
)
return self._create_response_namespace(
title, title, edit_values._asdict(), no_index=True
)
class DomainSchema(Schema):
if_key_missing = None
DMAP_ID = validators.IDValidator(not_empty=True)
DefaultCulture = validators.ActiveCulture(not_empty=True)
CICViewType = validators.IDValidator()
VOLViewType = validators.IDValidator()
SecondaryName = validators.Bool()
GoogleMapsAPIKeyCIC = validators.String(max=100)
GoogleMapsClientIDCIC = validators.UnicodeString(max=100)
GoogleMapsChannelCIC = validators.UnicodeString(max=100)
GoogleMapsAPIKeyVOL = validators.String(max=100)
GoogleMapsClientIDVOL = validators.UnicodeString(max=100)
GoogleMapsChannelVOL = validators.UnicodeString(max=100)
def _basic_info(self):
request = self.request
user = request.user
if not user.SuperUser:
self._security_failure()
domain, shown_cultures = viewbase.get_domain_and_show_cultures(
request.params)
if not domain:
return self._go_to_page("~/admin/setup.asp")
if (domain.id == const.DM_CIC
and not user.cic.SuperUser) or (domain.id == const.DM_VOL
and not user.vol.SuperUser):
self._security_failure()
validator = ciocvalidators.IDValidator(not_empty=True)
try:
ViewType = validator.to_python(request.params.get("ViewType"))
except validators.Invalid as e:
self._error_page(_("Invalid View Type: ", request) + e.msg)
return ViewType, domain, shown_cultures
def close(self):
request = self.request
user = request.user
if not user.SuperUserGlobal:
self._security_failure()
validator = validators.IDValidator(not_empty=True)
try:
NoticeID = validator.to_python(request.params.get("NoticeID"))
except validators.Invalid:
self._error_page(_("Invalid ID", request))
with request.connmgr.get_connection("admin") as conn:
notice = conn.execute("EXEC sp_GBL_Admin_Notice_s ?",
NoticeID).fetchone()
if not notice:
self._error_page(_("Not Found", request))
domains = self._get_domains()
if notice.Domain not in domains:
self._security_failure()
data = request.model_state.form.data
data["ActionNotes"] = notice.ActionNotes
data["ActionTaken"] = notice.ActionTaken
title = _("Close Admin Notice", request)
return self._create_response_namespace(title,
title,
dict(notice=notice,
NoticeID=NoticeID),
no_index=True)
def delete(self):
request = self.request
user = request.user
if not (user.SuperUser or user.WebDeveloper):
self._security_failure()
model_state = request.model_state
model_state.validators = {
"TemplateID": ciocvalidators.IDValidator(not_empty=True)
}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid ID", request))
TemplateID = model_state.form.data["TemplateID"]
request.override_renderer = "cioc.web:templates/confirmdelete.mak"
title = _("Manage Templates", request)
return self._create_response_namespace(
title,
title,
dict(
id_name="TemplateID",
id_value=TemplateID,
route="admin_template",
action="delete",
),
no_index=True,
)
def sharedstate(self):
chk_type = self.request.context.chk_type
self._check_security(chk_type, True)
request = self.request
model_state = request.model_state
model_state.validators = {
"state": validators.OneOf(["local", "shared"], not_empty=True),
"ID": ciocvalidators.IDValidator(not_empty=True),
}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid ID", request))
ID = model_state.form.data["ID"]
title = _("Manage Publications", request)
return self._create_response_namespace(
title,
title,
dict(ID=ID, state=model_state.value("state"), chk_type=chk_type),
no_index=True,
)
class HideSchema(Schema):
allow_extra_fields = True
filter_extra_fields = True
if_key_missing = None
ChkHide = foreach.ForEach(ciocvalidators.IDValidator())
class InterestSchema(validators.Schema):
allow_extra_fields = True
filter_extra_fields = True
if_key_missing = None
pre_validators = [viewbase.cull_extra_cultures("descriptions")]
Code = validators.CodeValidator()
descriptions = validators.CultureDictSchema(
InterestDescriptionSchema(),
record_cultures=True,
delete_empty=False,
chained_validators=[
validators.FlagRequiredIfNoCulture(InterestDescriptionSchema)
],
)
groups = validators.All(
validators.Set(use_set=True, if_missing=validators.NoDefault),
validators.ForEach(
validators.IDValidator(not_empty=True),
not_empty=True,
if_missing=validators.NoDefault,
),
)
def delete(self):
request = self.request
user = request.user
if not user.vol.SuperUserGlobal:
self._security_failure()
model_state = request.model_state
model_state.validators = {"AI_ID": validators.IDValidator(not_empty=True)}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid ID", request))
AI_ID = model_state.form.data["AI_ID"]
request.override_renderer = "cioc.web:templates/confirmdelete.mak"
title = _("Manage Areas of Interest", request)
return self._create_response_namespace(
title,
title,
dict(
id_name="AI_ID",
id_value=AI_ID,
route="admin_interests",
action="delete",
),
no_index=True,
)
def delete(self):
request = self.request
user = request.user
if not user.cic.SuperUserGlobal:
self._security_failure()
model_state = request.model_state
model_state.validators = {"Code": ciocvalidators.IDValidator(not_empty=True)}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid ID", request))
Code = model_state.form.data["Code"]
request.override_renderer = "cioc.web:templates/confirmdelete.mak"
title = _("Delete NAICS Code", request)
return self._create_response_namespace(
title,
title,
dict(id_name="Code", id_value=Code, route="admin_naics", action="delete"),
no_index=True,
)
class PostSchema(Schema):
allow_extra_fields = True
filter_extra_fields = True
if_key_missing = None
HideField = ForEach(ciocvalidators.IDValidator())
class Pull2Schema(Schema):
allow_extra_fields = True
filter_extra_fields = True
if_key_missing = None
NewRecords = ForEach(ciocvalidators.NumValidator())
NewFields = ForEach(ciocvalidators.IDValidator())
def delete(self):
request = self.request
user = request.user
if not user.cic or not user.cic.SuperUser:
self._security_failure()
model_state = request.model_state
model_state.validators = {"SubjID": validators.IDValidator(not_empty=True)}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid Subject ID", request))
SubjID = model_state.form.data["SubjID"]
request.override_renderer = "cioc.web:templates/confirmdelete.mak"
title = _("Manage Subjects", request)
return self._create_response_namespace(
title,
title,
dict(
id_name="SubjID",
id_value=SubjID,
route="admin_thesaurus",
action="delete",
),
no_index=True,
)
def sharedstate(self):
request = self.request
user = request.user
if not user.cic.SuperUserGlobal:
self._security_failure()
model_state = request.model_state
model_state.validators = {
"state": validators.OneOf(["local", "shared"], not_empty=True),
"PB_ID": validators.IDValidator(not_empty=True),
}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid Publication ID", request))
PB_ID = model_state.form.data["PB_ID"]
title = _("Manage Publications", request)
return self._create_response_namespace(
title,
title,
dict(PB_ID=PB_ID, state=model_state.value("state")),
no_index=True,
)
def clearrecords(self):
request = self.request
user = request.user
if not user.cic.SuperUser:
self._security_failure()
model_state = request.model_state
model_state.method = None
model_state.validators = {
"PB_ID": validators.IDValidator(not_empty=True)
}
if not model_state.validate():
self._error_page(_("Invalid Publication ID", request))
PB_ID = model_state.form.data["PB_ID"]
edit_values = self._get_edit_info(False, PB_ID)
request.override_renderer = (
"cioc.web.cic:templates/publication/clearrecords.mak")
title = _("Manage Publication from Records", request)
return self._create_response_namespace(
title,
title,
dict(
id_name="PB_ID",
id_value=PB_ID,
route="cic_publication",
action="clearrecords",
publication=edit_values.publication,
),
no_index=True,
)
def delete(self):
request = self.request
user = request.user
if not user.cic or user.cic.CanUpdatePubs != const.UPDATE_ALL:
self._security_failure()
model_state = request.model_state
model_state.method = None
model_state.validators = {
"PB_ID": validators.IDValidator(not_empty=True)
}
if not model_state.validate():
self._error_page(_("Invalid Publication ID", request))
PB_ID = model_state.form.data["PB_ID"]
request.override_renderer = "cioc.web:templates/confirmdelete.mak"
title = _("Manage Publications", request)
return self._create_response_namespace(
title,
title,
dict(
id_name="PB_ID",
id_value=PB_ID,
route="cic_publication",
action="delete",
),
no_index=True,
)
def delete(self):
request = self.request
domain = self.get_domain()
model_state = request.model_state
model_state.validators = {"PageID": validators.IDValidator(not_empty=True)}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid ID", request))
PageID = model_state.form.data["PageID"]
request.override_renderer = "cioc.web:templates/confirmdelete.mak"
extra_values = [("DM", domain.id)]
title = _("Delete Page (%s)", request) % _(domain.label, request)
return self._create_response_namespace(
title,
title,
dict(
id_name="PageID",
id_value=PageID,
route="admin_pages",
action="delete",
extra_values=extra_values,
),
no_index=True,
)
def delete_confirm(self):
request = self.request
user = request.user
if not user.cic or not user.cic.SuperUser:
self._security_failure()
model_state = request.model_state
model_state.validators = {"SubjID": validators.IDValidator(not_empty=True)}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid Subject ID", request))
SubjID = model_state.form.data["SubjID"]
with request.connmgr.get_connection("admin") as conn:
sql = """
DECLARE @ErrMsg as nvarchar(500),
@RC as int
EXECUTE @RC = dbo.sp_THS_Subject_d ?, ?, @ErrMsg=@ErrMsg OUTPUT
SELECT @RC as [Return], @ErrMsg AS ErrMsg
"""
cursor = conn.execute(
sql,
SubjID,
None
if request.user.cic.SuperUserGlobal
else request.dboptions.MemberID,
)
result = cursor.fetchone()
cursor.close()
if not result.Return:
self._go_to_page(
"~/admin/thesaurus.asp",
{
"InfoMsg": _(
"The Subject Term has been successfully deleted.", request
)
},
)
if result.Return == 3:
# XXX check that this is the only #3
self._error_page(_("Unable to delete Subject:", request) + result.ErrMsg)
self._go_to_route(
"admin_thesaurus",
action="edit",
_query=[
("ErrMsg", _("Unable to delete Subject: ") + result.ErrMsg),
("SubjID", SubjID),
],
)
def _get_cmid(self, required=False):
validator = ciocvalidators.IDValidator(not_empty=required)
try:
CM_ID = validator.to_python(self.request.params.get("CM_ID"))
except validators.Invalid:
self._error_page(_("Invalid Community ID", self.request))
return CM_ID
def edit(self):
request = self.request
user = request.user
if not user.SuperUserGlobal:
self._security_failure()
model_state = request.model_state
model_state.validators = {"MAP_ID": ciocvalidators.IDValidator()}
model_state.method = None
if not model_state.validate():
# XXX invalid MAP_ID
self._error_page(_("Invalid ID", request))
MAP_ID = model_state.form.data.get("MAP_ID")
is_add = not MAP_ID
mapping = None
mapping_descriptions = {}
if not is_add:
with request.connmgr.get_connection("admin") as conn:
cursor = conn.execute("EXEC dbo.sp_GBL_MappingSystem_s ?",
MAP_ID)
mapping = cursor.fetchone()
if mapping:
cursor.nextset()
for lng in cursor.fetchall():
mapping_descriptions[lng.Culture.replace("-",
"_")] = lng
cursor.close()
if not mapping:
# not found
self._error_page(_("Mapping System Not Found", request))
domain, shown_cultures = viewbase.get_domain_and_show_cultures(
request.params)
model_state.form.data["mapping"] = mapping
model_state.form.data["descriptions"] = mapping_descriptions
title = _("Manage Mapping Systems", request)
return self._create_response_namespace(
title,
title,
dict(
mapping=mapping,
MAP_ID=MAP_ID,
is_add=is_add,
shown_cultures=shown_cultures,
record_cultures=syslanguage.active_record_cultures(),
),
no_index=True,
)
def delete_confirm(self):
request = self.request
user = request.user
if not (user.SuperUser or user.WebDeveloper):
self._security_failure()
model_state = request.model_state
model_state.validators = {
"LayoutID": ciocvalidators.IDValidator(not_empty=True)
}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid ID", request))
LayoutID = model_state.form.data["LayoutID"]
with request.connmgr.get_connection("admin") as conn:
sql = """
DECLARE @ErrMsg as nvarchar(500),
@RC as int
EXECUTE @RC = dbo.sp_GBL_Template_Layout_d ?, ?, ?, @ErrMsg=@ErrMsg OUTPUT
SELECT @RC as [Return], @ErrMsg AS ErrMsg
"""
cursor = conn.execute(sql, LayoutID, request.dboptions.MemberID,
user.Agency)
result = cursor.fetchone()
cursor.close()
if not result.Return:
self._go_to_route(
"admin_template_layout_index",
_query=[(
"InfoMsg",
_("The Template Layout was successfully deleted.",
request),
)],
)
if result.Return == 3:
self._error_page(
_("Unable to delete Template Layout: ", request) +
result.ErrMsg)
self._go_to_route(
"admin_template_layout",
action="edit",
_query=[
("ErrMsg",
_("Unable to delete Template Layout: ") + result.ErrMsg),
("LayoutID", LayoutID),
],
)
def delete(self):
request = self.request
user = request.user
if not user.cic or user.cic.CanUpdatePubs != const.UPDATE_ALL:
self._security_failure()
model_state = request.model_state
model_state.validators = {
"GH_ID": validators.IDValidator(not_empty=True),
"PB_ID": validators.IDValidator(not_empty=True),
}
model_state.method = None
if not model_state.validate():
if model_state.is_error("PB_ID"):
self._error_page(
_("Publication ID:", request)
+ model_state.renderer.errorlist("PB_ID")
)
self._error_page(_("Invalid Heading ID", request))
GH_ID = model_state.form.data["GH_ID"]
PB_ID = model_state.form.data["PB_ID"]
if user.cic.LimitedView and PB_ID and user.cic.PB_ID != PB_ID:
self._security_failure()
request.override_renderer = "cioc.web:templates/confirmdelete.mak"
title = _("Delete Heading", request)
return self._create_response_namespace(
title,
title,
dict(
id_name="GH_ID",
id_value=GH_ID,
route="cic_generalheading",
action="delete",
extra_values=[("PB_ID", PB_ID)],
),
no_index=True,
)
def delete_confirm(self):
request = self.request
user = request.user
if not user.SuperUserGlobal:
self._security_failure()
model_state = request.model_state
model_state.validators = {
"SM_ID": ciocvalidators.IDValidator(not_empty=True)
}
model_state.method = None
if not model_state.validate():
self._error_page(_("Invalid ID", request))
SM_ID = model_state.form.data["SM_ID"]
with request.connmgr.get_connection("admin") as conn:
sql = """
DECLARE @ErrMsg as nvarchar(500),
@RC as int
EXECUTE @RC = dbo.sp_GBL_SocialMedia_d ?, @ErrMsg=@ErrMsg OUTPUT
SELECT @RC as [Return], @ErrMsg AS ErrMsg
"""
cursor = conn.execute(sql, SM_ID)
result = cursor.fetchone()
cursor.close()
if not result.Return:
self._go_to_route(
"admin_socialmedia_index",
_query=[(
"InfoMsg",
_("The Social Media Type was successfully deleted.",
request),
)],
)
if result.Return == 3:
self._error_page(
_("Unable to delete Social Media Type: ", request) +
result.ErrMsg)
self._go_to_route(
"admin_socialmedia",
action="edit",
_query=[
("ErrMsg",
_("Unable to delete Social Media Type: ") + result.ErrMsg),
("SM_ID", SM_ID),
],
)
def edit(self):
request = self.request
user = request.user
if not user.SuperUserGlobal:
self._security_failure()
model_state = request.model_state
model_state.validators = {"SM_ID": ciocvalidators.IDValidator()}
model_state.method = None
if not model_state.validate():
# XXX invalid SM_ID
self._error_page(_("Invalid ID", request))
SM_ID = model_state.form.data.get("SM_ID")
is_add = not SM_ID
socialmedia = None
socialmedia_descriptions = {}
if not is_add:
with request.connmgr.get_connection("admin") as conn:
cursor = conn.execute("EXEC dbo.sp_GBL_SocialMedia_s ?", SM_ID)
socialmedia = cursor.fetchone()
if socialmedia:
cursor.nextset()
for lng in cursor.fetchall():
socialmedia_descriptions[lng.Culture.replace(
"-", "_")] = lng
cursor.close()
if not socialmedia:
# not found
self._error_page(_("Social Media Type Not Found", request))
domain, shown_cultures = viewbase.get_domain_and_show_cultures(
request.params)
model_state.form.data["socialmedia"] = socialmedia
model_state.form.data["descriptions"] = socialmedia_descriptions
title = _("Manage Social Media Types", request)
return self._create_response_namespace(
title,
title,
dict(
socialmedia=socialmedia,
SM_ID=SM_ID,
is_add=is_add,
shown_cultures=shown_cultures,
record_cultures=syslanguage.active_record_cultures(),
),
no_index=True,
)
class ReminderBaseSchema(validators.Schema):
if_key_missing = None
ActiveDate = validators.DateConverter()
Culture = validators.ActiveCulture(record_cultures=True)
DueDate = validators.DateConverter()
NoteTypeID = validators.IDValidator()
Notes = validators.UnicodeString(not_empty=True)
DismissForAll = validators.DictConverter(dismiss_options, not_empty=True)
class ProfileSchema(Schema):
allow_extra_fields = True
filter_extra_fields = True
if_key_missing = None
profile = ProfileBaseSchema()
descriptions = ciocvalidators.CultureDictSchema(ProfileDescriptionSchema())
Views = All(validators.Set(use_set=True), ForEach(ciocvalidators.IDValidator()))
Fields = ForEach(FieldOrderSchema())
class ReminderSchema(validators.RootSchema):
if_key_missing = None
reminder = ReminderBaseSchema()
reminder_agency_ID = ForEach(validators.AgencyCodeValidator)
reminder_user_ID = ForEach(validators.IDValidator())
NUM = ForEach(validators.NumValidator(), convert_to_list=True)
VNUM = ForEach(validators.VNumValidator(), convert_to_list=True)
def activations_save(self):
request = self.request
user = request.user
if not user.cic or user.cic.CanUpdatePubs != const.UPDATE_ALL:
self._security_failure()
validator = validators.IDValidator(not_empty=True)
try:
PB_ID = validator.to_python(request.POST.get("PB_ID"))
except validators.Invalid as e:
self._error_page(_("Publication ID:", request) + e.msg)
if user.cic.LimitedView and PB_ID and user.cic.PB_ID != PB_ID:
self._security_failure()
model_state = request.model_state
model_state.schema = CodesSchema()
if model_state.validate():
args = [
PB_ID,
user.Mod,
request.dboptions.MemberID,
not request.dboptions.OtherMembersActive
or user.cic.SuperUserGlobal,
",".join(model_state.value("Code")),
]
with request.connmgr.get_connection("admin") as conn:
sql = """
DECLARE @RC int, @ErrMsg nvarchar(500), @BadCodes nvarchar(max)
EXEC @RC = dbo.sp_CIC_GeneralHeading_i_QuickTax ?,?,?,?,?, @BadCodes OUTPUT, @ErrMsg OUTPUT
SELECT @RC AS [Return], @ErrMsg AS ErrMsg, @BadCodes AS BadCodes
"""
cursor = conn.execute(sql, args)
result = cursor.fetchone()
cursor.close()
if not result.Return:
info_msg = (_(
"The General Heading(s) were successfully added.", request)
if result.BadCodes is None else result.BadCodes)
self._go_to_route(
"cic_publication",
action="edit",
_query=[("PB_ID", PB_ID), ("InfoMsg", info_msg)],
)
self._error_page(result.ErrMsg)
self._error_page(_("There were validation errors.", request))
class FieldHelpSchema(Schema):
allow_extra_fields = True
filter_extra_fields = True
if_key_missing = None
pre_validators = [viewbase.cull_extra_cultures("descriptions")]
FieldID = ciocvalidators.IDValidator(not_empty=True)
descriptions = ciocvalidators.CultureDictSchema(
FieldHelpDescriptionSchema(), record_cultures=True, delete_empty=False)
