def _server(req):
global SERVER
auth_header = req.get_header('Authorization')
userid = req.get_header('X-Kopano-UserEntryID')
if auth_header and auth_header.startswith('Basic '):
user, passwd = codecs.decode(codecs.encode(auth_header[6:], 'ascii'),
'base64').split(b':')
server = kopano.Server(auth_user=user, auth_pass=passwd)
elif userid in SESSIONDATA:
sessiondata = SESSIONDATA[userid]
mapisession = kc_session_restore(sessiondata)
server = kopano.Server(mapisession=mapisession, parse_args=False)
else:
try:
SERVER
except NameError:
SERVER = kopano.Server(parse_args=False, store_cache=False)
username = SERVER.user(userid=userid).name
server = kopano.Server(auth_user=username,
auth_pass='',
parse_args=False,
store_cache=False)
sessiondata = kc_session_save(server.mapisession)
SESSIONDATA[userid] = sessiondata
return server
def listfolders(self, company=None, user=None, folder=None):
user = dict(user=user)
company = dict(company=company)
foldername = dict(folder=folder)
html = '<html><h1>Company: %s <br>User: %s</h1>' % (company['company'],
user['user'])
if foldername['folder']:
html = html + "<table><tr><th>item.subject</th><th>item.entryid</th><tr>\n"
for folder in kopano.Server().company(company['company']).user(
user['user']).store.folders():
if folder.entryid == foldername['folder']:
for item in folder.items():
html = html + "<tr><td><a href=/listitem/%s/%s/%s/%s>%s</a></td><td>%s</td><tr>\n" % (
company['company'], user['user'], folder.entryid,
item.entryid.encode('hex'),
item.subject.encode("utf-8"),
item.entryid.encode('hex'))
else:
html = html + "<table><tr><th>item.subject</th><th>item.entryid</th><tr>\n"
for folder in kopano.Server().company(company['company']).user(
user['user']).store.folders():
html = html + "<tr><td><a href=/listfolders/%s/%s/%s>%s</a></td><td>%s</td><tr>\n" % (
company['company'], user['user'], folder.entryid,
folder.name, folder.entryid)
html = html + '</table></html>\n'
return html
def main():
options, _ = kopano.parser().parse_args()
server = kopano.Server(options)
# TODO: use optparse to figure this out?
if not server.options.auth_user:
print('No user specified')
if not server.options.folders:
print('No folder specified')
else:
user = kopano.Server().user(server.options.auth_user)
folder = next(user.store.folders()) # First Folder
print('Monitoring folder %s of %s for update and delete events' %
(folder, user.fullname))
# Create mapping
for item in folder.items():
ITEM_MAPPING[item.sourcekey] = item
print('Mapping of items and sourcekey complete')
folder_state = folder.state
new_state = folder.sync(Importer(),
folder_state) # from last known state
while True:
new_state = folder.sync(Importer(),
folder_state) # from last known state
if new_state != folder_state:
folder_state = new_state
time.sleep(1)
def main():
server = kopano.Server()
user = kopano.Server().user(server.options.auth_user)
header = urwid.Text('inbox')
footer = urwid.Text(FOOT1)
mail = Mail(user.store.outbox)
mailbox = MailBox(user.store.inbox, mail)
columns = urwid.Columns([('fixed', 32, mailbox), mail], 1)
frame = urwid.Frame(urwid.AttrWrap(columns, 'body'), header=urwid.AttrMap(header, 'headfoot'), footer=urwid.AttrMap(footer, 'headfoot'))
mailbox.cols = mail.cols = columns
mailbox.footer = mail.footer = footer
urwid.MainLoop(frame, PALETTE).run()
def index(self):
html = '<html>'
for company in kopano.Server().companies():
html = html + '<table>'
html = html + "<tr><th>company.name</th><th>user.name </th><th> user.store.guid</th><th>user.server.name</th><tr>\n"
for user in kopano.Server().company(company.name).users():
html = html + "<tr><td>" + company.name + "</td><td><a href=/viewuser/" + company.name + "/" + user.name + ">" + user.name + "</a><td><a href=/listfolders/" + company.name + "/" + user.name + ">Folders</a></td></td><td>" + user.store.guid + "</td><td>" + user.server.name + "</td><tr>\n"
html = html + '</table>\n'
html = html + '</html>\n'
return html
def main():
options, args = opt_args()
if options.top:
try:
curses.wrapper(top, kopano.Server(options))
except KeyboardInterrupt:
sys.exit(-1)
else:
for option, (table, sort) in TABLES.items():
if getattr(options, option):
table = kopano.Server(options).table(table)
table.sort(sort)
print(table.csv(delimiter=';') if options.dump else table.text())
def _server(req, options):
global LAST_PURGE_TIME
auth = _auth(req, options)
if auth['method'] == 'bearer':
token = auth['token']
sessiondata = TOKEN_SESSION.get(token)
if sessiondata:
mapisession = kc_session_restore(sessiondata[0])
server = kopano.Server(mapisession=mapisession, parse_args=False)
else:
server = kopano.Server(auth_user=auth['userid'],
auth_pass=token,
parse_args=False,
oidc=True)
sessiondata = kc_session_save(server.mapisession)
now = time.time()
TOKEN_SESSION[token] = (sessiondata, now)
# expire tokens after 15 mins TODO make configurable?
if LAST_PURGE_TIME is None or now > LAST_PURGE_TIME + 10:
for (token, (sessiondata, t)) in list(TOKEN_SESSION.items()):
if t < now - 15 * 60:
del TOKEN_SESSION[token]
LAST_PURGE_TIME = now
return server
elif auth['method'] == 'basic':
return kopano.Server(auth_user=auth['user'],
auth_pass=auth['password'],
parse_args=False)
# TODO remove
elif auth['method'] == 'passthrough': # pragma: no cover
userid = auth['userid']
sessiondata = USERID_SESSION.get(userid)
if sessiondata:
mapisession = kc_session_restore(sessiondata)
server = kopano.Server(mapisession=mapisession, parse_args=False)
else:
username = _username(auth['userid'])
server = kopano.Server(auth_user=username,
auth_pass='',
parse_args=False,
store_cache=False)
sessiondata = kc_session_save(server.mapisession)
USERID_SESSION[userid] = sessiondata
return server
def notify_sync(self):
server = kopano.Server(notifications=True,
options=self.options,
parse_args=False) # TODO ugh
while True:
# check command-line add-user requests
try:
user, target_user, subscribe = self.subscribe.get(timeout=0.01)
if subscribe:
self.subscribe_user(server, user, target_user)
else:
self.unsubscribe_user(server, user)
except Empty:
pass
# check worker output queue: more folders for same store?
try:
store_entryid, folder_entryid = self.oqueue.get(timeout=0.01)
with LOCK:
folders_todo = STORE_FOLDERS_TODO.get(store_entryid)
if folders_todo:
self.iqueue.put((store_entryid, folders_todo.pop()))
STORE_FOLDERS_TODO[store_entryid] = folders_todo
else:
del STORE_FOLDER_QUEUED[store_entryid]
except Empty:
pass
def main():
global delcounter
learncounter = 0
(users, allusers, remoteusers, autolearn, autodelete, deleteafter, spamcommand) = getconfig()
z = kopano.Server()
if allusers and not users:
users = []
for user in z.users(remote=remoteusers):
users.append(user.name)
for username in users:
try:
user = z.user(username)
for item in user.store.junk.items():
if autolearn:
if (not item.header('x-spam-flag')) or ( item.header('x-spam-flag') == 'NO'):
print("%s : untagged spam [Subject: %s]" % (user.name, item.subject))
try:
p = subprocess.Popen(spamcommand, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
learn, output_err = p.communicate(item.eml())
except:
print('failed to run [%s] [%s]' % (spamcommand, output_err))
if learn:
print("%s : learned [%s]" % (user.name, learn.rstrip('\n')))
delmsg = 'delete after learn'
deletejunk(user, item, delmsg)
learncounter += 1
continue
if autodelete:
if item.received.date() < (datetime.date.today()-datetime.timedelta(days=deleteafter)):
delmsg = 'autodelete'
deletejunk(user, item, delmsg)
except Exception as error:
print("%s : Unable to open store/item : [%s] [%s]" % (username, username, error))
continue
print("Summary learned %d items, deleted %d items" % (learncounter, delcounter))
def main():
options, args = opt_args()
if options.calc:
calculatepermissions()
sys.exit(0)
if not options.user:
print('please use: %s --user <username>'.format(sys.argv[0]))
sys.exit(1)
server = kopano.Server(options)
user = server.user(options.user)
if options.printrules or options.printrulesall:
listpermissions(user, options)
sys.exit(0)
if options.remove:
if not options.folders:
removepermissions(user, options, user.store, 'Store')
for folder in user.store.folders(parse=True):
removepermissions(user, options, folder)
if options.add:
if options.folders:
for folder in user.store.folders(parse=True):
addpermissions(user, options, folder)
else:
addpermissions(user, options, user.store)
def main(jsonfile, limit, socket, ssl_keyfile, ssl_pass):
try:
server = kopano.Server(server_socket=socket,
sslkey_file=ssl_keyfile,
sslkey_pass=ssl_pass,
parse_args=False)
except Exception as excinfo:
print("Unable to connect to '{}', '{}'".format(socket, excinfo))
sys.exit(-1)
requests = []
limit += 1
for index, user in enumerate(server.users()):
index += 1 # graph's index starts at 1
if index == limit:
break
request = {
'id': index,
'method': 'GET',
'url': '/api/gc/v1/users/{}'.format(user.userid)
}
requests.append(request)
data = {}
data['requests'] = requests
with open(jsonfile, 'w') as fp:
fp.write(json.dumps(data, indent=2))
def listitem(self, company=None, user=None, folder=None, item=None):
user = dict(user=user)
company = dict(company=company)
itemname = dict(item=item)
foldername = dict(folder=folder)
html = ''
print(itemname['item'] + "\n")
html = '<html><h1>Company: %s <br>User: %s</h1>' % (company['company'],
user['user'])
#html = html + "<table><tr><th>prop.name</th><th>prop.value</th><tr>\n"
if itemname['item']:
#html = html + "<table><tr><th>item.subject</th><th>item.entryid</th><tr>\n"
for folder in kopano.Server().company(company['company']).user(
user['user']).store.folders():
if folder.entryid == foldername['folder']:
for item in folder.items():
print("curr %s", item.entryid.encode('hex'))
print("look %s", itemname['item'])
if item.entryid.encode('hex') == itemname['item']:
print("match")
for prop in item.props():
if (prop.idname
== 'PR_HTML') or (prop.idname
== 'PR_BODY'):
try:
html = html + "<table><tr><td>%s</td><td>%s</td><tr>\n" % (
prop.name, str(prop.value))
except:
pass
html = html + '</table></html>\n'
return html
def main():
options, args = opt_args()
if not options.users:
print 'pleas use %s -u <username> ' % sys.argv[0]
sys.exit(1)
for user in kopano.Server(options).users():
print user.name
total_count = 0
for folder in user.store.folders():
folder_item_count = 0
for item in folder.items():
get_date = item.headers().get('date')
if get_date:
new_date = MAPI.Time.unixtime(
mktime(parse(get_date).timetuple()))
if not options.dryrun:
item.mapiobj.SetProps(
[SPropValue(PR_MESSAGE_DELIVERY_TIME, new_date)])
item.mapiobj.SaveChanges(KEEP_OPEN_READWRITE)
total_count += 1
folder_item_count += 1
print 'Changed %s item(s) in folder \'%s\'' % (folder_item_count,
folder.name)
print '\nChanged %s items(s) for user \'%s\'\n' % (folder_item_count,
user.name)
def main():
options, args = opt_args()
if not options.user or not options.days:
print('Please use:\n {} --user <username> --days <days> ',format(sys.argv[0]))
sys.exit(1)
user = kopano.Server(options).user(options.user)
print('Running script for \'{}\''.format(_encode(user.name)))
if options.wastebasket:
folder = user.store.wastebasket
deleteitems(options, user, folder)
if options.junk:
folder = user.store.junk
deleteitems(options, user, folder)
if options.sent:
folder = user.store.sentmail
deleteitems(options, user, folder)
'''
Loop over all the folders that are passed with the -f parameter
'''
if options.folders:
for folder in user.store.folders(options.folders):
deleteitems(options, user, folder)
def __init__(self, *args, **kw):
fuse.Fuse.__init__(self, *args, **kw)
self.server = kopano.Server()
self.path_object = {
} # XXX caching everything, so don't use this on a large account..
def main():
try:
parser, options, args = parser_opt_args()
if args:
raise Exception("extra argument '%s' specified" % args[0])
server = kopano.Server(options)
check_options(parser, options, server)
global_options(options, server)
for c in options.companies:
company_options(c, options, server)
for g in options.groups:
group_options(g, options, server)
for u in options.users:
user_options(u, options, server)
for s in options.stores:
store_options(s, options, server)
except Exception as e:
if 'options' in locals() and options.debug:
print(traceback.format_exc(), file=sys.stderr)
else:
print(_encode(str(e)), file=sys.stderr)
sys.exit(1)
def main():
options, args = opt_args()
users = list(kopano.Server(options).users())
fig, ax = plt.subplots()
if options.store:
data = {user.name: b2m(user.store.size) for user in users}
plt.ylabel('Store size (Mb)')
elif options.plotfolders:
# TODO: add mail only flag?
data = {user.name: len(list(user.store.folders())) for user in users}
plt.ylabel('Folders')
elif options.items:
data ={user.name: sum(folder.count for folder in user.store.folders()) for user in users}
plt.ylabel('Items')
else:
return
if options.sort:
ax.plot(sorted(list(data.values())))
users = sorted(data, key=data.__getitem__)
else:
ax.plot(data.values())
plt.xlabel('Users')
plt.xticks(range(len(users)), [user.name for user in users], size='small')
if options.save:
plt.savefig(options.save)
else:
plt.show()
def main():
global server
global options
global LDAP
options, args = opt_args()
if options.configFile:
if not os.path.isfile(options.configFile):
print('Config file not found')
sys.exit(1)
import importlib
LDAP = importlib.import_module(options.configFile.split('.')[0], package=None)
if 'ldap3' not in sys.modules:
print('please install ldap3 (pip3 install ldap3)')
sys.exit(1)
if not options.user and not options.importFile:
print('please use: {} --user <username> or \n{} --import-exchange-rules <json file>'.format(sys.argv[0],sys.argv[0]))
sys.exit(1)
server = kopano.Server(options)
if options.user:
kopano_rule(server=server, user=options.user, listrules=options.listrules, rule=options.rule,
state=options.state, emptyRules=options.emptyRules, rulename=options.createrule,
conditions=options.conditions, actions=options.actions, exceptions=options.exceptions,
StopProcessingRules=options.StopProcessingRules, CreateFolder=options.CreateFolder)
if options.importFile:
exchange_rules()
def main():
username, config, entryid = [_decode(arg) for arg in sys.argv[1:]]
server = kopano.Server()
user = server.user(username)
autoaccept = user.autoaccept
item = user.item(entryid)
mr = item.meetingrequest
if mr.is_request:
decline_message = None
if not autoaccept.recurring and item.recurring:
decline_message = "Recurring meetings are not allowed"
elif not autoaccept.conflicts:
conflicts = conflict_occurrences(user, item)
if conflicts:
decline_message = conflict_message(conflicts)
if decline_message:
mr.decline(message=decline_message)
else:
mr.accept(add_bcc=True)
elif mr.is_cancellation:
mr.process_cancellation(delete=True)
now = datetime.now()
user.freebusy.publish(now - timedelta(7), now + timedelta(180))
def user():
server = kopano.Server(parse_args=False,
auth_user=USERNAME1,
auth_pass=PASSWORD1)
user = server.user(USERNAME1)
user.auth_header = create_auth_header(USERNAME1, PASSWORD1)
yield user
[f.empty() for f in user.folders(recurse=False)]
def main():
options = opt_args()
folder = False
if options.entryid and len(options.entryid) == 96:
print('Entryid : {}'.format(options.entryid))
storeid = options.entryid[8:40]
print('Guessed storeid : {}'.format(storeid))
try:
store = kopano.Server(options).store(storeid)
except Exception as e:
print('Could not open store : {} Error: {}'.format(storeid, e))
else:
print('Store : {}\nUser : {} ({})'.format(
store.name, store.user.name, store.user.fullname))
try:
item = store.item(options.entryid)
except Exception as e:
print('Error {}'.format(e))
else:
if item.get_prop('PR_FOLDER_TYPE'):
print('Entryid is a Folder: Yes')
folder = True
for remove in ['folder', 'received', 'subject', 'stubbed']:
show_attr.remove(remove)
for show in show_attr:
if hasattr(item, show):
print('{} : {}'.format(
show.capitalize(), getattr(item, show)))
if item.has_attachments:
for attachment in item.attachments():
try:
data = attachment.data
except Exception as e:
print('Attachment could not be read {} error {}'.format(
attachment.filename, e))
else:
print('Attachment could be read : {}'.format(
attachment.name))
if not folder:
if options.eml:
try:
eml = item.eml()
except Exception as e:
print('Eml dump failed : error : {}'.format(e))
else:
filename = '.'.join((options.entryid, 'eml'))
write = open(filename, 'w')
write.write(eml)
write.close()
print('Eml dump: written to {}'.format(filename))
if options.delete:
try:
store.inbox.delete(item)
except Exception as e:
print('{}'.format(e))
else:
print('{} was deleted'.format(options.entryid))
def main():
options, args = opt_args()
for user in kopano.Server(options).users():
if user.store:
if user.junk.name == 'Ongewenste E-mail':
print('Renaming junk folder for user {}'.format(user.name))
user.junk.mapiobj.SetProps(
[SPropValue(PR_DISPLAY_NAME, 'Ongewenste e-mail')])
user.junk.mapiobj.SaveChanges(KEEP_OPEN_READWRITE)
def main():
options, args = opt_args()
if not options.user:
print 'Please use:\n %s --user <username>' % (sys.argv[0])
sys.exit(0)
user = kopano.Server(options).user(options.user)
webapp = user.store.prop(0X6773001F).value
webapp = json.loads(webapp)
if options.backup:
f = open('%s.json' % user.name, 'w')
f.write(json.dumps(webapp, sort_keys=True,
indent=4, separators=(',', ': ')))
f.close()
sys.exit(0)
if options.restore:
if options.restorefile:
filename = options.restorefile
else:
filename = '%s.json' % user.name
with open(filename) as data_file:
data = json.load(data_file)
user.store.mapiobj.SetProps([SPropValue(0X6773001F, u'%s' % json.dumps(data))])
user.store.mapiobj.SaveChanges(KEEP_OPEN_READWRITE)
sys.exit(0)
if options.list:
print json.dumps(webapp, sort_keys=True,
indent=4, separators=(',', ': '))
sys.exit(0)
if options.remove:
newlist = json.loads('{"recipients":[]}')
for rec in webapp['recipients']:
if options.remove in rec['display_name'] or options.remove in rec['smtp_address'] \
or options.remove in rec['email_address']:
print 'removing contact %s [%s]' % (rec['display_name'], rec['smtp_address'])
else:
newlist['recipients'].append(rec)
if not options.dryrun:
user.store.mapiobj.SetProps([SPropValue(0X6773001F, u'%s' % json.dumps(newlist))])
user.store.mapiobj.SaveChanges(KEEP_OPEN_READWRITE)
sys.exit(0)
if options.removeall:
newlist = json.loads('{"recipients":[]}')
if not options.dryrun:
user.store.mapiobj.SetProps([SPropValue(0X6773001F, u'%s' % json.dumps(newlist))])
user.store.mapiobj.SaveChanges(KEEP_OPEN_READWRITE)
sys.exit(0)
def removepermissions(user, options, folder, customname=None):
if options.remove.lower() == 'everyone':
removeuser = '******'
remuser = None
else:
remuser = kopano.Server(options).user(options.remove)
removeuser = remuser.fullname
# so not remove folder if delegate is passed and no folder
if options.delegate:
if not remuser:
print('everyone can not be removed at the moment with the script')
else:
flags = []
if options.private:
flags.append('see_private')
if options.copy:
flags.append('send_copy')
try:
dlg = user.delegation(remuser)
if len(flags) == 0:
user.delete(dlg)
print('removing delegate permission for user {}'.format(remuser.name))
else:
dlg.flags = [f for f in dlg.flags if f not in flags]
print('removing {} for delegate user {}'.format(' '.join(flags), remuser.name))
except kopano.errors.NotFoundError:
print('user {} is not a delegate'.format(remuser.name))
if not options.folders and options.delegate:
sys.exit(0)
acl_table = folder.mapiobj.OpenProperty(PR_ACL_TABLE, IID_IExchangeModifyTable, 0, 0)
table = acl_table.GetTable(0)
table.SetColumns([PR_ENTRYID, PR_MEMBER_ID, CHANGE_PROP_TYPE(PR_MEMBER_NAME, PT_UNICODE), PR_MEMBER_RIGHTS], TBL_BATCH)
acltable = table.QueryRows(-1, 0)
remove = False
for acl in acltable:
for prop in acl:
if prop.ulPropTag == 0x6672001F:
if removeuser == prop.Value:
rowlist = [ROWENTRY(
ROW_REMOVE,
acl
)]
remove = True
break
if remove:
acl_table.ModifyTable(0, rowlist)
if customname:
foldername = customname
else:
foldername = folder.name
print('removing {} from the permission table for folder {}'.format(removeuser, foldername))
def main():
options = opt_args()
for user in kopano.Server(options).users():
print('Checking user store: {}'.format(user.name))
for f in user.folders(recurse=True):
if f.container_class == 'IPF.Imap':
print('{}: IPF.Imap folder detected'.format(f.name))
if not options.dryrun:
print('{}: Changing container_class to IPF.Note'.format(
f.name))
f.container_class = 'IPF.Note'
def _username(userid): # pragma: no cover
global SERVER
reconnect = False
try:
SERVER
except NameError:
reconnect = True
if reconnect:
SERVER = kopano.Server(parse_args=False, store_cache=False)
return SERVER.user(userid=userid).name
def main():
options, args = opt_args()
server = kopano.Server(options)
user = server.user(options.user)
webappsettings = read_settings(user)
if not webappsettings['settings']['zarafa']['v1'].get('plugins'):
webappsettings['settings']['zarafa']['v1']['plugins'] = {}
webappsettings['settings']['zarafa']['v1']['plugins']['files'] = files(
options)
write_settings(user, json.dumps(webappsettings))
def _server(auth_user, auth_pass, oidc=False, reconnect=False):
server = kopano.Server(auth_user=auth_user,
auth_pass=auth_pass,
notifications=True,
parse_args=False,
store_cache=False,
oidc=oidc,
config={})
logging.info('server connection established, server:%s, auth_user:%s',
server, server.auth_user)
return server
def user():
if KOPANO_SSLKEY_FILE:
admin_server = kopano.Server(parse_args=False,
sslkey_file=KOPANO_SSLKEY_FILE,
sslkey_pass=KOPANO_SSLKEY_PASS)
try:
admin_server.user(USERNAME1).create_store()
except kopano.errors.DuplicateError:
pass
server = kopano.Server(parse_args=False,
auth_user=USERNAME1,
auth_pass=PASSWORD1)
user = server.user(USERNAME1)
user.auth_header = create_auth_header(USERNAME1, PASSWORD1)
yield user
if KOPANO_SSLKEY_FILE:
admin_server.user(USERNAME1).unhook()
else:
[f.empty() for f in user.folders(recurse=False)]
def main():
parser = kopano.parser(
"cskp",
usage="Usage: %prog [options] from to subject username msgfile")
options, args = parser.parse_args()
if len(args) != 5:
print(
"Invalid arguments, you have to supply the arguments: from, to, subject, username, and msgfile",
file=sys.stderr)
sys.exit(1)
config_dict = kopano.CONFIG
config_dict.update(CONFIG)
config = kopano.Config(config_dict, options=options, service="autorespond")
log = logger("autorespond", options=options, config=config)
server = kopano.Server(options=options, config=config, parse_args=False)
(from_, to, subject, username, msg_file) = args
(to_me, bcc_me, cc_me) = (
os.getenv("MESSAGE_TO_ME"),
os.getenv("MESSAGE_BCC_ME"),
os.getenv("MESSAGE_CC_ME"),
)
try:
fh = open(msg_file, "r")
msg = fh.read()
fh.close()
except:
log.info("Could not open msg file: %s" % msg_file)
sys.exit(1)
if not (config["autorespond_norecip"] or
(config["autorespond_bcc"] and bcc_me) or
(config["autorespond_cc"] and cc_me) or to_me):
log.debug("Response not send due to configuration")
elif not (from_ and to and username and msg and msg_file):
log.info(
"One of the input arguments was empty (from: %s, to: %s, username: %s, msg: %s)",
from_, to, username, msg)
elif from_ == to:
log.info("Loop detected, from == to (%s)", from_)
elif in_blacklist(log, from_, to):
log.info("From or to is in blacklist (from: %s, to: %s)", from_, to)
elif check_time(config["senddb"], config["timelimit"], username, to):
log.info(
"Ignoring since we already sent OOO message within timelimit (username: %s, to: %s, timelimit: %d)",
username, to, config["timelimit"])
else:
add_time(config["senddb"], username, to)
send_ooo(server, username, msg, config["copy_to_sentmail"])
log.info("Sent OOO to %s (username %s)", to, username)
