def sendMail(msg, type): MAIL_OPTIONS = Options.OptionReader('MailOptions.txt') if type == 'alert': msg['To'] = email.utils.formataddr(('', MAIL_OPTIONS.getValue('alertmail_recipients'))) elif type == 'publication': msg['To'] = email.utils.formataddr(('', MAIL_OPTIONS.getValue('publicationmail_recipients'))) else: return msg['From'] = email.utils.formataddr((MAIL_OPTIONS.getValue('mail_from'), MAIL_OPTIONS.getValue('mail_sender'))) if type == 'alert': recipients = MAIL_OPTIONS.getValue('alertmail_recipients').split(',') elif type == 'publication': recipients = MAIL_OPTIONS.getValue('publicationmail_recipients').split(',') else: return with open(MAIL_OPTIONS.getValue('mail_credentials'), 'r') as f: password = f.read()[:-1] server_connection = smtplib.SMTP(MAIL_OPTIONS.getValue('mail_server'), int(MAIL_OPTIONS.getValue('mail_port'))) try: # initiate connection server_connection.ehlo() # Try to encrypt the session if server_connection.has_extn('STARTTLS'): server_connection.starttls() # reinitiate server connection over TLS server_connection.ehlo() server_connection.login(MAIL_OPTIONS.getValue('mail_user'), password) server_connection.sendmail(MAIL_OPTIONS.getValue('mail_sender'), recipients, msg.as_string()) finally: server_connection.quit()
def __init__(self, ip, port): Thread.__init__(self) self.ip = ip self.port = int(port) if port == PROXY_OPTIONS.getValue('API_port'): self.type = 'API' # read client_ips, plainkeys from the key file, generate and store the AES-keys self.AES_keys = Options.OptionReader(PROXY_OPTIONS.getValue('AES_key_file')) for ip, plainkey in self.AES_keys.options.iteritems(): AES_key = SHA256.new() AES_key.update(plainkey) AES_key = AES_key.digest() self.AES_keys.setValue(ip, AES_key) if port == PROXY_OPTIONS.getValue('tracker_port'): self.type = 'tracker' self.start()
def __init__(self, mode, system_options=None): self.mode = mode # if we want to contact the Proxy, we need SystemOptions.txt for the AESkey and Proxy address:port if self.mode == 'Proxy': if system_options is not None: self.SYSTEMoptions = system_options required_keys = ('AES_key', 'proxy_address', 'API_port') self.SYSTEMoptions.checkKeys(required_keys) else: raise Errors.FatalError( msg= 'SystemOptions info not provided, only direct API calls possible' ) # if we want to contact the API directly, we need ProxyOptions for the APIkeys and URLs if self.mode == 'PPMS API': try: self.APIoptions = Options.OptionReader('ProxyOptions.txt') except: raise Errors.FatalError( msg='ProxyOptions.txt is missing, only Proxy calls possible' )
print(f'FB Bio: {active_users.number_of_users("bio")}, ' f'FB Che: {active_users.number_of_users("che")}, ' f'FB Phy: {active_users.number_of_users("phy")}') print('--------------------') print('Facility statistics:') year = 2020 print( f'The facility has given {active_users.number_of_trainings(year)} trainings in {year}.' ) print(f'FB Bio: {active_users.number_of_trainings(year, "bio")}, ' f'FB Che: {active_users.number_of_trainings(year, "che")}, ' f'FB Phy: {active_users.number_of_trainings(year, "phy")}') print('--------------------') SYSTEM_OPTIONS = Options.OptionReader('SystemOptions.txt') calling_mode = SYSTEM_OPTIONS.getValue('calling_mode') with Timer('Getting facility system info from PPMS...', 'Microscope list populated!'): equipment = Equipment() with Timer('Getting active users from PPMS...', 'Active user list populated!'): active_bic_users = ActiveBICUsers(equipment) print_microscope_users(equipment.microscope_list) print_user_info(active_bic_users.user_list) print_facility_statistics(equipment, active_bic_users) # for user_login in active_users: # user = BICUser(user_login)
data += packet return data encrypted_call = receive_data(self.connection) iv2 = encrypted_call[:AES.block_size] ciphered_msg = encrypted_call[AES.block_size:] decryptor = AES.new(self.AES_key, AES.MODE_CFB, iv2) decrypted_message = decryptor.decrypt(ciphered_msg) data_from_client = pickle.loads(decrypted_message) print self.address[0] + ' says ' + data_from_client[ 'h'] + data_from_client['s'] server_response = {'h': 'Hello ', 'c': 'client'} iv = Random.new().read(AES.block_size) cipher = AES.new(self.AES_key, AES.MODE_CFB, iv) pickled_response = pickle.dumps(server_response) server_message = iv + cipher.encrypt(pickled_response) data_to_client = struct.pack('>I', len(server_message)) + server_message self.connection.sendall(data_to_client) self.connection.close() proxy_options = Options.OptionReader('ServerOptions.txt') PUMAPIproxy = ListeningSocket(proxy_options.getValue('host_ip'), proxy_options.getValue('API_port'))
self.itemlist.append(self.child.text) return self.itemlist def writeRISFile(self, file_name): with open(file_name, 'w') as self.f: for self.child in self.root.iter('Item'): if self.child.get('Name') in EncodeToRIS.Pubmed_to_RIS: try: self.f.write( EncodeToRIS.Pubmed_to_RIS[self.child.get('Name')] + ' - ' + self.child.text + '\n') except TypeError: # self.child.text returns None if field is empty pass OPTIONS = Options.OptionReader('PublicationTrackerOptions.txt') parser = argparse.ArgumentParser("Publication Tracker") parser.add_argument( "year", nargs='?', help= "Specify the year of publication, if omitted current year (last year, if Jan-Mar) will be used", type=int) args = parser.parse_args() # at the beginning of the year we want to search for papers submitted the year before if args.year is None: date = datetime.now() if date.month < 4: year = str(date.year - 1)
newCall.callParis() self.connection.close() class NewTrackerCall: def __init__(self): self.header = { 'Content-Type': 'application/x-www-form-urlencoded', } # explained in PUMAPI documentation self.data = {} self.URL = PROXY_OPTIONS.getValue('tracker_URL') # adds the parameters specific to each Tracker call def config(self, new_settings): self.data.update(new_settings) # generate full Tracker URL def callParis(self): url = self.URL + '?i=' + self.data['id'] + '&f=' + self.data['freq'] + '&u=' + self.data['user'] requests.post(url, headers=self.header, data=self.data['code']) PROXY_OPTIONS = Options.OptionReader('ProxyOptions.txt') API_proxy = ListeningSocket(PROXY_OPTIONS.getValue('host_ip'), PROXY_OPTIONS.getValue('API_port')) tracker_proxy = ListeningSocket(PROXY_OPTIONS.getValue('host_ip'), PROXY_OPTIONS.getValue('tracker_port'))
if not packet: return None data += packet return data proxy_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) proxy_socket.connect((APIoptions.getValue('proxy_address'), int(APIoptions.getValue('API_port')))) proxy_socket.sendall(message) response = receive_data(proxy_socket) proxy_socket.close() return response APIoptions = Options.OptionReader('ClientOptions.txt') test_dict = {'h': 'Hello ', 's': 'Server'} pickled_dict = pickle.dumps(test_dict) AES_plainkey = APIoptions.getValue('AES_key') AES_key = SHA256.new() AES_key.update(AES_plainkey) AES_key = AES_key.digest() iv = Random.new().read(AES.block_size) cipher = AES.new(AES_key, AES.MODE_CFB, iv) msg = iv + cipher.encrypt(pickled_dict) data_to_server = struct.pack('>I', len(msg)) + msg response = sendToProxy(data_to_server)
#!/usr/bin/env python # -*- coding: utf-8 import datetime import os from lib import Options, PPMSAPICalls, Errors try: current_directory = os.path.dirname(__file__) parent_directory = os.path.split(current_directory)[0] print(parent_directory) SYSTEM_OPTIONS = Options.OptionReader(parent_directory + '/SystemOptions.txt') except Errors.FatalError as e: exit(e.msg) facility_id = SYSTEM_OPTIONS.getValue('PPMS_facilityid') system_id = SYSTEM_OPTIONS.getValue('PPMS_systemid') calling_mode = SYSTEM_OPTIONS.getValue('calling_mode') user_login = SYSTEM_OPTIONS.getValue('user_login') get_systemname = PPMSAPICalls.NewCall(calling_mode, SYSTEM_OPTIONS) try: system_name = get_systemname.getSystemName(system_id) print(system_name) except Errors.APIError as e: print(e.msg) get_booking = PPMSAPICalls.NewCall(calling_mode, SYSTEM_OPTIONS) print(get_booking.getTodaysBookings(facility_id, system_name))