def filter_by_status_and_query_by_name_and_sev(self,
name,
pkg_status,
sev,
conn=None):
try:
if pkg_status in ValidPackageStatuses:
if sev in ValidRvSeverities:
base = (r.table(
self.CurrentAppsPerAgentCollection).get_all(
[pkg_status, self.customer_name],
index=self.CurrentAppsPerAgentIndexes.
StatusAndCustomer).eq_join(
self.CurrentAppsPerAgentKey.AppId,
r.table(self.CurrentAppsCollection)).map(
self.joined_map_hash))
if self.show_hidden == NO:
base = base.filter({self.CurrentAppsKey.Hidden: NO})
packages = list(
base.filter(
(r.row[self.CurrentAppsKey.RvSeverity] == sev)
& (r.row[self.CurrentAppsKey.Name].match(
"(?i)" + name))).distinct().order_by(
self.sort(self.sort_key)).skip(
self.offset).limit(
self.count).run(conn))
pkg_count = (base.pluck(
self.CurrentAppsKey.RvSeverity,
self.CurrentAppsKey.Name).distinct().filter(
(r.row[self.CurrentAppsKey.RvSeverity] == sev)
& (r.row[self.CurrentAppsKey.Name].match(
"(?i)" + name))).count().run(conn))
return_status = (GenericResults(
self.username, self.uri,
self.method).information_retrieved(
packages, pkg_count))
else:
return_status = (PackageResults(
self.username, self.uri,
self.method).invalid_severity(sev))
else:
return_status = (PackageResults(
self.username, self.uri,
self.method).invalid_global_status(pkg_status))
except Exception as e:
return_status = (GenericResults(
self.username, self.uri,
self.method).something_broke("Package Searching went haywire",
'os_updates', e))
logger.exception(e)
return (return_status)
def filter_by_status_and_sev(self, pkg_status, sev, conn=None):
try:
agent = get_agent_info(self.agent_id)
if agent:
if pkg_status in ValidPackageStatuses:
if sev in ValidRvSeverities:
base = (r.table(
self.CurrentAppsPerAgentCollection).get_all(
[pkg_status, self.agent_id],
index=self.CurrentAppsPerAgentIndexes.
StatusAndAgentId).eq_join(
self.CurrentAppsPerAgentKey.AppId,
r.table(self.CurrentAppsCollection)).zip())
if self.show_hidden == NO:
base = base.filter(
{self.CurrentAppsKey.Hidden: NO})
packages = list(
base.filter(r.row[self.CurrentAppsKey.RvSeverity]
== sev).map(self.map_hash).order_by(
self.sort(self.sort_key)).skip(
self.offset).limit(
self.count).run(conn))
pkg_count = (base.filter(
r.row[self.CurrentAppsKey.RvSeverity] ==
sev).count().run(conn))
return_status = (GenericResults(
self.username, self.uri,
self.method).information_retrieved(
packages, pkg_count))
else:
return_status = (PackageResults(
self.username, self.uri,
self.method).invalid_severity(sev))
else:
return_status = (PackageResults(
self.username, self.uri,
self.method).invalid_status(self.agent_id, pkg_status))
else:
return_status = (GenericResults(self.username, self.uri,
self.method).invalid_id(
self.agent_id, 'agents'))
except Exception as e:
return_status = (GenericResults(
self.username, self.uri,
self.method).something_broke("Package Searching went haywire",
'os_updates', e))
logger.exception(e)
return (return_status)
def filter_by_severity(self, sev, conn=None):
try:
if sev in ValidRvSeverities:
base = (r.table(self.CurrentAppsCollection).get_all(
self.customer_name,
sev,
index=self.CurrentAppsIndexes.CustomerAndRvSeverity))
if self.show_hidden == NO:
base = base.filter({self.CurrentAppsKey.Hidden: NO})
packages = list(
base.map(self.map_hash).order_by(self.sort(
self.sort_key)).skip(self.offset).limit(
self.count).run(conn))
pkg_count = (base.pluck(self.pluck_list).count().run(conn))
return_status = (GenericResults(
self.username, self.uri,
self.method).information_retrieved(packages, pkg_count))
else:
return_status = (PackageResults(
self.username, self.uri,
self.method).invalid_severity(sev))
except Exception as e:
return_status = (GenericResults(
self.username, self.uri,
self.method).something_broke("Package Searching went haywire",
'os_updates', e))
logger.exception(e)
return (return_status)
def delete(self):
username = self.get_current_user().encode('utf-8')
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
#app_ids = self.arguments.get('app_ids') The UI needs to past the options as the body not as arguments
app_ids = self.get_arguments('app_ids')
appids_deleted = 0
appids_failed = 0
for appid in app_ids:
deleted = (delete_app_from_rv(appid, CustomAppsCollection,
CustomAppsPerAgentCollection))
if deleted:
appids_deleted += 1
else:
appids_failed += 1
results = (PackageResults(username, uri, method).packages_deleted(
app_ids, appids_deleted, appids_failed))
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
logger.exception(e)
results = (GenericResults(username, uri, method).something_broke(
app_ids, 'failed to delete custom_apps', e))
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def post(self, app_id):
username = self.get_current_user().encode('utf-8')
customer_name = get_current_customer_name(username)
uri = self.request.uri
method = self.request.method
try:
severity = self.arguments.get('severity').capitalize()
if severity in ValidRvSeverities:
sev_data = ({AppsKey.RvSeverity: severity})
update_agent_app(app_id, sev_data)
results = (GenericResults(username, uri,
method).object_updated(
app_id, 'app severity',
[sev_data]))
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
else:
results = (PackageResults(username, uri,
method).invalid_severity(severity))
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
except Exception as e:
results = (GenericResults(username, uri, method).something_broke(
app_id, 'update_severity', e))
logger.exception(e)
self.set_status(results['http_status'])
self.set_header('Content-Type', 'application/json')
self.write(json.dumps(results, indent=4))
def filter_by_sev_and_query_by_name(self, name, sev, conn=None):
try:
tag = tag_exists(self.tag_id)
if tag:
if sev in ValidRvSeverities:
base = (r.table(
TagsPerAgentCollection, use_outdated=True).get_all(
self.tag_id, index=TagsPerAgentIndexes.TagId
).pluck(TagsPerAgentKey.AgentId).eq_join(
self.CurrentAppsPerAgentIndexes.AgentId,
r.table(self.CurrentAppsPerAgentCollection),
index=self.CurrentAppsPerAgentIndexes.AgentId
).eq_join(
lambda y: y['right'][self.CurrentAppsKey.AppId],
r.table(self.CurrentAppsCollection)).map(
self.map_hash))
if self.show_hidden == NO:
base = base.filter({self.CurrentAppsKey.Hidden: NO})
packages = list(
base.filter(
(r.row[self.CurrentAppsKey.RvSeverity] == sev)
& (r.row[self.CurrentAppsKey.Name].match(
"(?i)" + name))).distinct().order_by(
self.sort(self.sort_key)).skip(
self.offset).limit(
self.count).run(conn))
pkg_count = (base.filter(
(r.row[self.CurrentAppsKey.RvSeverity] == sev)
& (r.row[self.CurrentAppsKey.Name].match("(?i)" + name)
)).distinct().count().run(conn))
return_status = (GenericResults(
self.username, self.uri,
self.method).information_retrieved(
packages, pkg_count))
else:
return_status = (PackageResults(
self.username, self.uri,
self.method).invalid_severity(sev))
else:
return_status = (GenericResults(self.username, self.uri,
self.method).invalid_id(
self.tag_id, 'agents'))
except Exception as e:
return_status = (GenericResults(
self.username, self.uri,
self.method).something_broke("Package Searching went haywire",
'os_updates', e))
logger.exception(e)
return (return_status)
def update_hidden_status(username,
customer_name,
uri,
method,
app_ids,
hidden='yes',
table=AppsCollection,
conn=None):
if table == AppsCollection:
CurrentAppsKey = AppsKey
elif table == CustomAppsCollection:
CurrentAppsKey = CustomAppsKey
elif table == SupportedAppsCollection:
CurrentAppsKey = SupportedAppsKey
elif table == AgentAppsPerAgentCollection:
CurrentAppsKey = AgentAppsKey
try:
if hidden == YES or hidden == NO:
(r.expr(app_ids).for_each(lambda app_id: r.table(table).get(
app_id).update({CurrentAppsKey.Hidden: hidden})).run(conn))
elif hidden == 'toggle':
for app_id in app_ids:
toggled = (r.table(table).get(app_id).update({
CurrentAppsKey.Hidden:
(r.branch(r.row[CurrentAppsKey.Hidden] == YES, NO, YES))
}).run(conn))
results = (PackageResults(username, uri,
method).toggle_hidden(app_ids, hidden))
except Exception as e:
logger.exception(e)
results = (GenericResults(username, uri, method).something_broke(
app_ids, 'toggle hidden on os_apps', e))
return (results)
def filter_by_status_and_sev(self, pkg_status, sev, conn=None):
try:
pkg = (
r
.table(self.CurrentAppsCollection, use_outdated=True)
.get(self.app_id)
.run(conn)
)
if pkg:
if pkg_status in ValidPackageStatuses:
if sev in ValidRvSeverities:
agents = list(
r
.table(self.CurrentAppsPerAgentCollection)
.get_all(
[self.app_id, pkg_status],
index=self.CurrentAppsPerAgentIndexes.AppIdAndStatus
)
.eq_join(
self.CurrentAppsPerAgentKey.AppId,
r.table(self.CurrentAppsCollection)
)
.zip()
.eq_join(
self.CurrentAppsPerAgentKey.AgentId,
r.table(AgentsCollection)
)
.zip()
.filter(r.row[self.CurrentAppsKey.RvSeverity] == sev)
.order_by(r.asc(self.CurrentAppsKey.Name))
.skip(self.offset)
.limit(self.count)
.map(self.map_hash)
.run(conn)
)
agent_count = (
r
.table(self.CurrentAppsPerAgentCollection)
.get_all(
[self.app_id, pkg_status],
index=self.CurrentAppsPerAgentIndexes.AppIdAndStatus
)
.eq_join(
self.CurrentAppsPerAgentKey.AppId,
r.table(self.CurrentAppsCollection)
)
.zip()
.filter(r.row[self.CurrentAppsKey.RvSeverity] == sev)
.count()
.run(conn)
)
return_status = (
GenericResults(
self.username, self.uri, self.method
).information_retrieved(agents, agent_count)
)
else:
return_status = (
PackageResults(
self.username, self.uri, self.method
).invalid_severity(sev)
)
else:
return_status = (
PackageResults(
self.username, self.uri, self.method
).invalid_status(self.app_id, pkg_status)
)
else:
return_status = (
GenericResults(
self.username, self.uri, self.method
).invalid_id(self.app_id, 'os_apps')
)
except Exception as e:
return_status = (
GenericResults(
self.username, self.uri, self.method
).something_broke(
"Package Searching went haywire",
'os_updates', e
)
)
logger.exception(e)
return(return_status)
def query_by_name(self, name, conn=None):
try:
pkg = (
r
.table(self.CurrentAppsCollection, use_outdated=True)
.get(self.app_id)
.run(conn)
)
if pkg:
agents = list(
r
.table(self.CurrentAppsPerAgentCollection)
.get_all(self.app_id, index=self.CurrentAppsPerAgentIndexes.AppId)
.eq_join(
self.CurrentAppsPerAgentKey.AgentId,
r.table(AgentsCollection)
)
.zip()
.filter(
r.row[AgentKey.ComputerName].match("(?i)"+name)
|
r.row[AgentKey.DisplayName].match("(?i)"+name)
)
.order_by(r.asc('computer_name'))
.skip(self.offset)
.limit(self.count)
.map(self.map_hash)
.run(conn)
)
agent_count = (
r
.table(self.CurrentAppsPerAgentCollection, use_outdated=True)
.get_all(self.app_id, index=self.CurrentAppsPerAgentIndexes.AppId)
.eq_join(
self.CurrentAppsPerAgentKey.AgentId,
r.table(AgentsCollection)
)
.zip()
.filter(
r.row[AgentKey.ComputerName].match("(?i)"+name)
|
r.row[AgentKey.DisplayName].match("(?i)"+name)
)
.count()
.run(conn)
)
return_status = (
GenericResults(
self.username, self.uri, self.method
).information_retrieved(agents, agent_count)
)
else:
return_status = (
PackageResults(
self.username, self.uri, self.method
).invalid_package_id(self.app_id)
)
except Exception as e:
return_status = (
GenericResults(
self.username, self.uri, self.method
).something_broke(
"Package Searching went haywire",
'os_updates', e
)
)
logger.exception(e)
return(return_status)
