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)