def update_agent_operation_pickup_time(
operation_id, db_time, conn=None
):
"""Update an operation per agent.
DO NOT CALL DIRECTLY
Args:
operation_id (str): the id of the operation.
db_time (rql date object): r.epoch_time
Basic Usage:
>>> from vFense.operations._db import update_agent_operation_pickup_time
>>> operation_id = '5dc03727-de89-460d-b2a7-7f766c83d2f1'
>>> db_time = r.epoch_time(time.time())
>>> update_agent_operation_pickup_time(operation_id, db_time)
Returns:
Tuple (status_code, count, error, generated ids)
>>> (2001, 1, None, [])
"""
data = {}
try:
data = (
r
.table(OperationCollections.Agent)
.get(operation_id)
.update(
{
AgentOperationKey.AgentsPendingPickUpCount: (
r.branch(
r.row[AgentOperationKey.AgentsPendingPickUpCount] > 0,
r.row[AgentOperationKey.AgentsPendingPickUpCount] - 1,
r.row[AgentOperationKey.AgentsPendingPickUpCount],
)
),
AgentOperationKey.AgentsPendingResultsCount: (
r.branch(
r.row[AgentOperationKey.AgentsPendingResultsCount] < (
r.row[AgentOperationKey.AgentsTotalCount]
),
r.row[AgentOperationKey.AgentsPendingResultsCount] + 1,
r.row[AgentOperationKey.AgentsPendingResultsCount]
)
),
AgentOperationKey.UpdatedTime: db_time
}
)
.run(conn)
)
except Exception as e:
logger.exception(e)
return data
def user_status_toggle(username, conn=None):
"""Enable or disable a user
Args:
username (str): The username you are enabling or disabling
Basic Usage:
>>> from vFense.user._db import status_toggle
>>> username = '******'
>>> status_toggle(username)
Returns:
Tuple (status_code, count, error, generated ids)
>>> (2001, 1, None, [])
"""
try:
toggled = (r.table(UserCollections.Users).get(username).update({
UserKeys.Enabled:
(r.branch(r.row[UserKeys.Enabled] == CommonKeys.YES, CommonKeys.NO,
CommonKeys.YES))
}).run(conn))
except Exception as e:
logger.exception(e)
return (toggled)
def user_status_toggle(username, conn=None):
"""Enable or disable a user
Args:
username (str): The username you are enabling or disabling
Basic Usage:
>>> from vFense.user._db import status_toggle
>>> username = '******'
>>> status_toggle(username)
Returns:
Tuple (status_code, count, error, generated ids)
>>> (2001, 1, None, [])
"""
try:
toggled = (
r
.table(UserCollections.Users)
.get(username)
.update(
{
UserKeys.Enabled: (
r.branch(
r.row[UserKeys.Enabled] == CommonKeys.YES,
CommonKeys.NO,
CommonKeys.YES
)
)
}
)
.run(conn)
)
except Exception as e:
logger.exception(e)
return(toggled)
def fetch_user_and_all_properties(username, conn=None):
"""Retrieve a user and all of its properties
This query is beautiful :)
Args:
username (str): Name of the user.
Basic Usage:
>>> from vFense.user._db import fetch_user_and_all_properties
>>> username = '******'
>>> fetch_user_and_all_properties(username')
Returns:
Dictionary of user properties.
{
"current_customer": "default",
"customers": [
{
"admin": true,
"name": "default"
}
],
"groups": [
{
"group_id": "1b74a706-34e5-482a-bedc-ffbcd688f066",
"group_name": "Administrator"
}
],
"default_customer": "default",
"user_name": "admin",
"permissions": [
"administrator"
]
}
"""
data = {}
map_hash = (
{
UserKeys.DefaultCustomer: r.row[UserKeys.DefaultCustomer],
UserKeys.CurrentCustomer: r.row[UserKeys.CurrentCustomer],
UserKeys.Email: r.row[UserKeys.Email],
UserKeys.FullName: r.row[UserKeys.FullName],
UserKeys.UserName: r.row[UserKeys.UserName],
UserKeys.Groups: (
r
.table(GroupCollections.GroupsPerUser)
.get_all(username, index=GroupsPerUserIndexes.UserName)
.coerce_to('array')
.pluck(GroupsPerUserKeys.GroupId, GroupsPerUserKeys.GroupName)
),
UserKeys.Customers: (
r
.table(CustomerCollections.CustomersPerUser)
.get_all(username, index=CustomerPerUserIndexes.UserName)
.coerce_to('array')
.map(lambda x:
{
Permissions.ADMINISTRATOR: r.branch(
r
.table(GroupCollections.GroupsPerUser)
.get_all(username, index=GroupsPerUserIndexes.UserName)
.coerce_to('array')
.eq_join(lambda y:
y[GroupKeys.GroupName],
r.table(GroupCollections.Groups),
index=GroupsPerUserIndexes.GroupName
)
.zip()
.filter(
lambda z:
z[GroupKeys.Permissions]
.contains(Permissions.ADMINISTRATOR)
),
True,
False
),
CustomerPerUserKeys.CustomerName: x[CustomerPerUserKeys.CustomerName]
}
)
),
UserKeys.Permissions: (
r
.table(GroupCollections.GroupsPerUser)
.get_all(username, index=GroupsPerUserIndexes.UserName)
.coerce_to('array')
.eq_join(lambda x:
x[GroupKeys.GroupName],
r.table(GroupCollections.Groups),
index=GroupsPerUserIndexes.GroupName
)
.zip()
.map(lambda x: x[GroupKeys.Permissions])[0]
)
}
)
try:
data = (
r
.table(UserCollections.Users)
.get_all(username)
.map(map_hash)
.run(conn)
)
if data:
data = data[0]
except Exception as e:
logger.exception(e)
return(data)
def fetch_users_and_all_properties(customer_name=None, conn=None):
"""Retrieve a user and all of its properties
This query is beautiful :)
Kwargs:
customer_name (str): Name of the customer, where the users belong to.
Basic Usage:
>>> from vFense.user._db import fetch_users_and_all_properties
>>> customer_name = 'default'
>>> fetch_user_and_all_properties(username')
Returns:
List of users and their properties.
[
{
"current_customer": "default",
"customers": [
{
"admin": true,
"name": "default"
}
],
"groups": [
{
"group_id": "1b74a706-34e5-482a-bedc-ffbcd688f066",
"group_name": "Administrator"
}
],
"default_customer": "default",
"user_name": "admin",
"permissions": [
"administrator"
]
}
]
"""
data = []
map_hash = (lambda x:
{
UserKeys.DefaultCustomer: x[UserKeys.DefaultCustomer],
UserKeys.CurrentCustomer: x[UserKeys.CurrentCustomer],
UserKeys.UserName: x[UserKeys.UserName],
UserKeys.Groups: (
r
.table(GroupCollections.GroupsPerUser)
.get_all(x
[GroupsPerUserKeys.UserName],
index=GroupsPerUserIndexes.UserName
)
.coerce_to('array')
.pluck(GroupsPerUserKeys.GroupId, GroupsPerUserKeys.GroupName)
),
UserKeys.Customers: (
r
.table(CustomerCollections.CustomersPerUser)
.get_all(
x[CustomerPerUserKeys.UserName],
index=CustomerPerUserIndexes.UserName
)
.coerce_to('array')
.map(lambda y:
{
Permissions.ADMINISTRATOR: r.branch(
r
.table(GroupCollections.GroupsPerUser)
.get_all(
y[GroupsPerUserKeys.UserName],
index=GroupsPerUserIndexes.UserName
)
.coerce_to('array')
.eq_join(lambda z:
z[GroupKeys.GroupName],
r.table(GroupCollections.Groups),
index=GroupsPerUserIndexes.GroupName
)
.zip()
.filter({GroupsPerUserKeys.UserName: y[GroupsPerUserKeys.UserName]})
.filter(
lambda a:
a[GroupKeys.Permissions]
.contains(Permissions.ADMINISTRATOR)
).distinct(),
True,
False
),
CustomerPerUserKeys.CustomerName: y[CustomerPerUserKeys.CustomerName]
}
)
),
UserKeys.Permissions: (
r
.table(GroupCollections.GroupsPerUser)
.get_all(x[GroupsPerUserKeys.UserName], index=GroupsPerUserIndexes.UserName)
.coerce_to('array')
.eq_join(lambda b:
b[GroupKeys.GroupName],
r.table(GroupCollections.Groups),
index=GroupsPerUserIndexes.GroupName
)
.zip()
.map(lambda b: b[GroupKeys.Permissions])[0]
)
}
)
try:
if customer_name:
data = list(
r
.table(CustomerCollections.CustomersPerUser)
.get_all(
customer_name, index=CustomerPerUserIndexes.CustomerName
)
.pluck(CustomerPerUserKeys.CustomerName, CustomerPerUserKeys.UserName)
.distinct()
.eq_join(lambda x:
x[UserKeys.UserName],
r.table(UserCollections.Users)
)
.zip()
.map(map_hash)
.run(conn)
)
else:
data = list(
r
.table(UserCollections.Users)
.map(map_hash)
.run(conn)
)
except Exception as e:
logger.exception(e)
return(data)
def fetch_app_data_to_send_to_agent(
app_id, agent_id,
collection=AppCollections.UniqueApplications,
conn=None
):
"""Fetch application data by app id
Args:
app_id (str): 64 character ID of the application.
agent_id (str): 36 character UUID of the agent.
Kwargs:
collection (str): The name of the apps per agent collection,
that will be used when updating the application data.
Basic Usage:
>>> from vFense.plugins.patching._db import fetch_app_data
>>> app_id = 'c726edf62d1d17ca8b420f24bbdc9c8fa58d000b51d31614e3826c2fb37a2929'
>>> agent_id = '33ba8521-b2e5-47dc-9bdc-0f1e3384049d'
>>> collection = 'unique_applications'
>>> fetch_app_data_by_agentid(app_id, agent_id, collection)
Returns:
Dictionary
{
"file_data": [
{
"file_hash": "47dc1daa42e6d53e1a881f4ed9c5472f6732665af2cba082f8fa3931199fb746",
"file_name": "gpgv_1.4.11-3ubuntu2.5_amd64.deb",
"file_uri": "http://us.archive.ubuntu.com/ubuntu/pool/main/g/gnupg/gpgv_1.4.11-3ubuntu2.5_amd64.deb",
"file_size": 185400
}
],
"cli_options": "",
"version": "1.4.11-3ubuntu2.5",
"name": "gpgv"
}
"""
data = {}
try:
data = list(
r
.table(collection)
.get_all(app_id)
.map(
lambda app:
{
DbCommonAppKeys.Name: app[DbCommonAppKeys.Name],
DbCommonAppKeys.Version: app[DbCommonAppKeys.Version],
DbCommonAppKeys.CliOptions: (
r.branch(
app.has_fields(DbCommonAppKeys.CliOptions) == False,
'',
app[DbCommonAppKeys.CliOptions]
)
),
CommonFileKeys.PKG_FILEDATA: (
r
.table(FileCollections.Files)
.filter(
lambda x: (
x[FilesKey.AppIds].contains(app_id)
&
x[FilesKey.AgentIds].contains(agent_id)
)
)
.coerce_to('array')
.without(FilesKey.AppIds, FilesKey.AgentIds)
)
}
)
.run(conn)
)
if data:
data = data[0]
except Exception as e:
logger.exception(e)
return data
def update_hidden_status(
app_ids, hidden=CommonKeys.TOGGLE,
collection=AppCollections.UniqueApplications,
conn=None
):
"""Update the global hidden status of an application
Args:
app_ids (list): List of application ids.
Kwargs:
hidden (str, optional): yes, no, or toggle
default = toggle
collection (str, optional): The collection you are updating for.
collection = unique_applications
Basic Usage:
>>> from vFense.plugins.patching._db import update_hidden_status
>>> hidden = 'toggle'
>>> app_ids = ['c71c32209119ad585dd77e67c082f57f1d18395763a5fb5728c02631d511df5c']
>>> update_hidden_status(app_ids, hidden)
Returns:
Tuple (status_code, count, error, generated ids)
>>> (2001, 1, None, [])
"""
data = {}
try:
if hidden == CommonKeys.YES or hidden == CommonKeys.NO:
data = (
r
.expr(app_ids)
.for_each(
lambda app_id:
r
.table(collection)
.get(app_id)
.update(
{
DbCommonAppKeys.Hidden: hidden
}
)
)
.run(conn)
)
elif hidden == CommonKeys.TOGGLE:
for app_id in app_ids:
data = (
r
.table(collection)
.get(app_id)
.update(
{
DbCommonAppKeys.Hidden: (
r.branch(
r.row[DbCommonAppKeys.Hidden] == CommonKeys.YES,
CommonKeys.NO,
CommonKeys.YES
)
)
}
)
.run(conn)
)
except Exception as e:
logger.exception(e)
return data
