def pollAirtableForUpdates(): availableBases = [e for e in BaseNamesInUsage.objects.all()] # get entries from Airtable for availableBase in availableBases: if (datetime.now(pytz.timezone("US/Eastern")).date() - availableBase.date) > timedelta(days=30): availableBase.delete() availableBases.remove(availableBase) bases = [[ pollBaseForUpdates(base.base_id, base.base_name), base.base_name ] for base in availableBases] # update Salesforce url = 'https://tribecabeverage.salesforce.com/airtablewebhook/' myobj = [{ "base_name": base_name, "stops": putInSalesforceStyleJSON(base_data) } for base_data, base_name in bases] post = { "method": "ROUTE_UPDATE", "data": myobj, "updateDate": str(datetime.now(pytz.timezone("US/Eastern")).date()) } print("post is: " + str(post)) sf = Salesforce(username=os.environ["SALESFORCE_OAUTH_USERNAME"], password=os.environ["SALESFORCE_OAUTH_PASSWORD"], security_token=os.environ['SALESFORCE_SECURITY_TOKEN']) sf.apexecute("airtablewebhook", method="POST", data=post) return post
def send_donation_info(name, amount, project, address=''): if not settings.SFDC_ACCOUNT: return try: res = None payload = { 'donorName': name, 'projectName': project, 'donationAmount': amount, 'donorAddress': address } sf = Salesforce(username=settings.SFDC_ACCOUNT, password=settings.SFDC_PASSWORD, security_token=settings.SFDC_TOKEN) logger.info('send donation to SFDC with data: %s', payload) res = sf.apexecute(settings.SFDC_REVOLV_DONATION, method='POST', data=payload) if res.lower() != 'success': raise SFDCException(res) logger.info('SFDC donation: success.') except Exception as e: logger.error('SFDC donation: ERROR for name: %s and data: %s, res: %s', name, payload, res, exc_info=True) send_donation_info.retry(args=[name, amount, project, address], countdown=INTERVAL, exc=e, max_retries=MAX_RETRIES)
def main(): args = parse_command_args() with AsyncRobot(args.serial, enable_face_detection=True) as vector: vector.behavior.say_text("I am ready for the next customer.") connection = Salesforce(username=os.environ['SF_USERNAME'], password=os.environ['SF_PASSWORD'], security_token=os.environ['SF_TOKEN']) result = connection.apexecute('nextcustomer', method='GET', data=None)
def send_signup_info( name, email, address=''): try: res = None payload = {'donorName': name, 'email': email, 'donorAddress': address} sf = Salesforce(username=SFDC_ACCOUNT, password=SFDC_PASSWORD, security_token=SFDC_TOKEN) logger.info('send sign-up to SFDC with data: %s', payload) res = sf.apexecute(SFDC_REVOLV_SIGNUP, method='POST', data=payload) if res.lower() != 'success': raise SFDCException(res) logger.info('SFDC sign-up: sucess.') except Exception as e: logger.error('SFDC sign-up: ERROR for name: %s and data: %s, res: %s', name, payload, res, exc_info=True) send_signup_info.retry(args=[name, email, address], countdown=INTERVAL, exc=e, max_retries=MAX_RETRIES)
def send_donation_info(name, amount, project, address=''): if not settings.SFDC_ACCOUNT: return try: res = None payload = {'donorName': name, 'projectName': project, 'donationAmount': amount, 'donorAddress': address} sf = Salesforce(username=SFDC_ACCOUNT, password=SFDC_PASSWORD, security_token=SFDC_TOKEN) logger.info('send donation to SFDC with data: %s', payload) res = sf.apexecute(SFDC_REVOLV_DONATION, method='POST', data=payload) if res.lower() != 'success': raise SFDCException(res) logger.info('SFDC donation: success.') except Exception as e: logger.error('SFDC donation: ERROR for name: %s and data: %s, res: %s', name, payload, res, exc_info=True) send_donation_info.retry(args=[name, amount, project, address], countdown=INTERVAL, exc=e, max_retries=MAX_RETRIES)
def send_signup_info(name, email, address=''): if not settings.SFDC_ACCOUNT: return try: res = None payload = {'donorName': name, 'email': email, 'donorAddress': ''} sf = Salesforce( username=settings.SFDC_ACCOUNT, security_token=settings.SFDC_TOKEN, password=settings.SFDC_PASSWORD ) logger.info('send sign-up to SFDC with data: %s', payload) res = sf.apexecute(settings.SFDC_REVOLV_SIGNUP, method='POST', data=payload) if res.lower() != 'success': raise SFDCException(res) logger.info('SFDC sign-up: sucess.') except Exception as e: logger.error('SFDC sign-up: ERROR for name: %s and data: %s, res: %s', name, payload, res, exc_info=True)
def send_signup_info(name, email, address=''): try: res = None payload = {'donorName': name, 'email': email, 'donorAddress': address} sf = Salesforce(username=SFDC_ACCOUNT, password=SFDC_PASSWORD, security_token=SFDC_TOKEN) logger.info('send sign-up to SFDC with data: %s', payload) res = sf.apexecute(SFDC_REVOLV_SIGNUP, method='POST', data=payload) if res.lower() != 'success': raise SFDCException(res) logger.info('SFDC sign-up: sucess.') except Exception as e: logger.error('SFDC sign-up: ERROR for name: %s and data: %s, res: %s', name, payload, res, exc_info=True) send_signup_info.retry(args=[name, email, address], countdown=INTERVAL, exc=e, max_retries=MAX_RETRIES)
__author__ = 'Brad' from simple_salesforce import Salesforce import json sf = Salesforce( username='******', password='******', security_token='vnWYJMNtLbDPL9NY97JP9tJ5', sandbox=True) print sf metricData ={ "patientId": "DCE-2762", "timestamp": "6/11/2015 12:00 AM", "roomPercentages": [ { "room": "Bathroom", "percentage": 100 }, { "room": "Livingroom", "percentage": 100 }, { "room": "Kitchen", "percentage": 100 } ] } print metricData result = sf.apexecute('FMMetrics/insertMetrics', method='POST', data=metricData) print result
config = configparser.ConfigParser() config.read('config.ini') hostname = socket.gethostname() print(hostname + ' running as user: '******'SALESFORCE']['USERNAME']) #Declare GPIO Setup GPIO.setmode(GPIO.BOARD) GPIO.setup(12, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) # Connect to Salesforce sf = Salesforce(username=config['SALESFORCE']['USERNAME'], password=config['SALESFORCE']['PASSWORD'], security_token=config['SALESFORCE']['TOKEN'], domain=config['SALESFORCE']['DOMAIN']) # Fetch train IP device = sf.apexecute('Device/Train', method='GET') trainIp = device['Last_Known_IP__c'] print('Train last known IP: ' + trainIp) trainStopUrl = 'http://' + trainIp + ':8080/api/train/stop' print('Scanning...') try: while True: sensorValue = GPIO.input(12) if sensorValue == 1: print('Stopping train') time.sleep(float(config['TRAIN']['STOP_DELAY'])) payload = {'sender': hostname} headers = {'content-type': 'application/json'} response = None
from simple_salesforce import Salesforce import requests session = requests.Session() sf = Salesforce(username='******', password='******', security_token='securityToken') account = sf.Account.get('0017F00000LkvYHQAZ') payload = {"name": "from Python"} sf.apexecute('testRestServiceForAWS/test', method='POST', data=payload)
class EventProcessing: def __init__(self, database, database_name, username='******', password='******', security_token='rUrhVtWfeJAcZ6Wf1S7XZml4', sandbox=True): self.dataB = MySQLdb.connect(host=database[0], user=database[1], passwd=database[2]) self.cur = self.dataB.cursor() self.databaseName = database_name self.patient_id = self.databaseName[1:] self.length = 30*86400 self.data = [] self.sf = Salesforce(username=username, password=password, security_token=security_token, sandbox=sandbox) def set_event_length(self, length): """ @param length: double(days) @return:true """ self.length = length*86400 return True def get_event_data(self, data_type, table_name): """ @param data_type: str of the column selected, pass * for all data in table @param table_name: str of the name of the table @return: Double tuple of steps """ current_date = self.get_current_date() date_from_length = current_date-self.length sql = 'SELECT '+data_type+' FROM '+self.databaseName+'.'+table_name+' WHERE datetime >= '+str(date_from_length) self.cur.execute(sql) event_data = self.cur.fetchall() if len(event_data) == 0: return [] else: return list(zip(*event_data)[0]) @staticmethod def get_current_date(self): """ @return:returns the current date in seconds from the epoch """ epoch = datetime.datetime.utcfromtimestamp(0) current_date = datetime.datetime.now() current_date = current_date-epoch current_date = current_date.total_seconds() return current_date def upload_to_sales_force(self, apex_list): event_dict = { "metric": apex_list[0], "severity": apex_list[1], "metricValue": apex_list[2], "message": apex_list[3] } json_dict = { "patientId": self.patient_id, "event": event_dict } result = self.sf.apexecute('FMEvent/insertEvents', method='POST', data=json_dict) return result def upload_to_database(self, event_data): """ @param event_data: List of event data referenced to objnamelist @return:True on success """ # Create event table in database if it does not yet exist try: table_string = '' for i in self.objnamelist: # Splice out __c in object names table_string += i[0:-3] + ' VARCHAR(255),' sql = "CREATE TABLE " + self.databaseName + "." + "Events (datetime DOUBLE NOT NULL,"+table_string+" PRIMARY KEY(datetime))" self.cur.execute(sql) except MySQLdb.Error: print "Event Table found in database: "+self.databaseName try: # Try to see if we can resize the event table #Get number of columns sql = "SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = '"+self.databaseName+"' AND table_name = 'Events' " self.cur.execute(sql) columns = int(list(self.cur.fetchall())[0][0]) #Build list of new columns to add tables = "" if columns < len(self.objnamelist)+1: for i in range(0, len(self.objnamelist)-(columns-1)): tables += "ADD COLUMN "+self.objnamelist[columns+i-1][0:-3]+" VARCHAR(255)," tables = tables[0:-1] #add new columns to table sql = "ALTER TABLE "+self.databaseName+".Events "+tables self.cur.execute(sql) self.dataB.commit() except: print(sys.exc_info()) print "Select Error" try: tables_string = '' # add in additional %s for datetime s_string = '%s,' # Create list of tables in db and %s string for insert for i in self.objnamelist: tables_string += i[0:-3] + ',' s_string += '%s,' # Remove trailing , from string s_string = s_string[0:-1] tables_string = tables_string[0:-1] # Create sql insert string sql = "INSERT INTO " + self.databaseName + "." + "Events (datetime,"+tables_string+") VALUES ("+s_string + ")" insert_list = event_data insert_list.insert(0, self.get_current_date()) # Convert all elements to string for upload for i, z in enumerate(insert_list): insert_list[i] = str(z) # Upload and commit to db self.cur.execute(sql, tuple(insert_list)) self.dataB.commit() return True except MySQLdb.Error: print 'Event insert into database '+self.databaseName+' has failed.' return False
class MetricsClass(AnalysisProcessingClass): def __init__(self, database, patient_id, table_name, metric_type): logging.warning('Watch out!') super(MetricsClass, self).__init__(database=database, patient_id=patient_id, type_name=metric_type, table_name=table_name) self.patient_id = patient_id self.metric_type = self.typename self.sf = Salesforce(username='******', password='******', security_token='vnWYJMNtLbDPL9NY97JP9tJ5', sandbox=True) if not self.table_exists(self.database_name, 'metricsprofile'): self.create_table(database_name = self.database_name, table_name = 'metricsprofile', column_names = ['table_name', 'type_name', 'timestamp'], column_types = ['VARCHAR(100)', 'VARCHAR(100) NOT NULL PRIMARY KEY', 'BIGINT(20)']) def poll_data(self, start_window): """ Returns the data between the time frame specified :return: """ if not self.fetch_from_database(database_name = self.database_name, table_name = self.table_name, to_fetch = 'analysis_data', where = ['start_window', '=', start_window]): return [] else: metric_data = self.fetchall() if len(metric_data) == 0: return [] else: return pickle.loads(zip(*list(zip(*metric_data)))[0][0]) def get_latest_data_stamp(self): if not self.fetch_from_database(database_name = self.database_name, table_name = self.table_name, to_fetch = 'start_window', order_by = ['start_window', 'DESC'], limit = 1): return [] else: latest_data = self.fetchall() if len(latest_data) == 0: return [] else: return zip(*list(zip(*latest_data)))[0][0] def read_timestamp(self): """ Reads in the timestamp of the last processed data :return: Timestamp if exists, otherwise NULL """ if not self.fetch_from_database(database_name = self.database_name, table_name = 'metricsprofile', to_fetch = 'timestamp', where = [['table_name', self.table_name], ['type_name', self.typename]]): # If no analysisprofile database exists then return the start timestamp return self.read_start_stamp() else: # If timestamp column does exist in analysis profile, return it if it has length, # otherwise return the start_stamp timestamp = self.fetchall() if len(timestamp) == 0: # If no timestamp in timestamp column, return start_stamp return self.read_start_stamp() else: # If timestamp exists in timestamp column, return that timestamp = list(zip(*timestamp))[0][0] return timestamp def write_timestamp(self, timestamp): """ Write the latest timestamp, in this case it means the end of a window :param timestamp: :return: """ return self.insert_into_database(database_name = self.database_name, table_name = 'metricsprofile', column_names = ['table_name', 'type_name', 'timestamp'], values = [self.table_name, self.typename, timestamp], on_duplicate_update = [ 2 ]) def upload_to_database(self, start_window, end_window, metric): """ Uploads the metric to the database ['VARCHAR(100) NOT NULL PRIMARY KEY', 'FLOAT'] :return: """ self.create_table(database_name= self.database_name, table_name = self.metric_type, column_names = ['start_window', 'end_window', 'metric'], column_types = ['VARCHAR(100) NOT NULL PRIMARY KEY', 'VARCHAR(100) NOT NULL', 'FLOAT']) self.insert_into_database(database_name = self.database_name, table_name = self.metric_type, column_names = ['start_window', 'end_window', 'metric'], values = [start_window, end_window, metric]) return True def upload_to_salesforce(self, timestamp, metric): """ Uploads the metric to salesforce :return: """ metric_data = { "patientId": self.patient_id, "timestamp": self.utc_to_datetime(timestamp).strftime('%x'), "metricList":[ { "metric": self.metric_type, "metricValue": metric }] } self.sf.apexecute('FMMetrics/insertMetrics', method='POST', data=metric_data) return True def run(self): """ :return: """ timestamp = self.read_timestamp # If no timestamp found, break the analysis code. Bad Profile! if timestamp is None: return False windows = self.get_stamp_windows() for i in windows: start_stamp = i[0] end_stamp = i[1] data = self.poll_data(start_stamp) if data != []: windowed_data = self.split_to_windows(data) metric = self.process_data(windowed_data) self.upload_to_database(start_stamp, end_stamp, metric) self.upload_to_salesforce(start_stamp, metric) self.write_timestamp(start_stamp) return True
class SalesforceLogicSource(BaseLogicSource): def initialize(self, params): self.sfdc = Salesforce(username=SFDC_USERNAME, password=SFDC_PASSWORD, security_token=SFDC_TOKEN) self.channel_id = params['channel_id'][0] self.requester = '@' + params['user_name'][0] self.command = None if 'text' in params: self.command = params['text'][0] def __sfdc_rest_call(self, resource): return self.sfdc.apexecute('handleTTTCommand', method='POST', data={'resource': resource, 'channelId': self.channel_id, 'requestor':self.requester, 'command': self.command }) def __generate_response(self, response_map): print('*** RESPONSE: ',response_map); game_response_type = response_map['game_response_type'] values = response_map['values'].split(',') slack_response_type = None if "slack_response_type" in response_map: slack_response_type = response_map["slack_response_type"] else: slack_response_type = 'Ephemeral' response = None if 'response' in response_map: response = response_map['response'] return RMB.respond(None, game_response_type=game_response_type, values=values, slack_response_type=slack_response_type, response=response) def new_game(self): response = self.__sfdc_rest_call('/ttt') return self.__generate_response(response['body']) def game_help(self): super().game_help() """Help handler which provides information about the game and how to play it. :return: """ return RMB.respond(None, game_response_type='help_text', values=[]) def accept_game(self): response = self.__sfdc_rest_call('/ttt-accept') return self.__generate_response(response['body']) def decline_game(self): response = self.__sfdc_rest_call('/ttt-decline') return self.__generate_response(response['body']) def display_board(self): response = self.__sfdc_rest_call('/ttt-board') return self.__generate_response(response['body']) def play_move(self): response = self.__sfdc_rest_call('/ttt-move') return self.__generate_response(response['body']) def end_game(self): response = self.__sfdc_rest_call('/ttt-end') return self.__generate_response(response['body'])
'a027000000RIuryAAD', 'a027000000RIurUAAT', 'a027000000RIurtAAD', 'a023900000UPD2tAAH', 'a023900000UPD2yAAH', 'a023900000UPD33AAH', 'a023900000UQkYOAA1', 'a023900000UOxIPAA1' ] # time definitions one_day = datetime.timedelta(days=1) utc_zone = pytz.timezone('UTC') est_zone = pytz.timezone('US/Eastern') now_utc_naive = datetime.datetime.utcnow() now_utc_aware = utc_zone.localize(now_utc_naive) now_est_aware = now_utc_aware.astimezone(est_zone) today_12am_est = now_est_aware.replace(hour=0, minute=0, second=0) # fetch data from Salesforce metrics_today = sf.apexecute('metricsdashboard?period=TODAY') metrics_tw = sf.apexecute('metricsdashboard?period=THIS_WEEK') sets_today = sf.query( "select scheduleddate__c, lead__r.county__c, lead__r.LASERCA__Home_State__c, lead__r.ambassador__c, lead__r.hq_rep__c, lead__r.lead_source_hierarchy__c from interaction__c where createddate = today and subject__c = 'Closer Appointment' and lead__c != null" )["records"] appts_tmrw = sf.query( "select scheduleddate__c, lead__r.county__c, lead__r.LASERCA__Home_State__c, lead__r.ambassador__c, lead__r.hq_rep__c, lead__r.lead_source_hierarchy__c from interaction__c where scheduleddate__c = tomorrow and subject__c = 'Closer Appointment' and canceled__c = false and lead__c != null" )["records"] cads_tmrw = sf.query( "select scheduleddate__c, lead__r.county__c, lead__r.LASERCA__Home_State__c, lead__r.ambassador__c, lead__r.hq_rep__c, lead__r.lead_source_hierarchy__c from interaction__c where scheduleddate__c = tomorrow and subject__c = 'CAD Appointment' and canceled__c = false and contact__c != null" )["records"] outcomes = sf.query( "select outcome__c from interaction__c where interactiondate__c = today and subject__c = 'CAD Appointment'" )["records"] # key totals
class MetricsClass(multiprocessing.Process, DatabaseWrapper): def __init__(self, database, patient_id, table_name, metric_type): logging.warning('Watch out!') multiprocessing.Process.__init__(self) DatabaseWrapper.__init__(self, database) self.database_name = '_' + patient_id self.table_name = table_name self.metric_type = metric_type self.sf = Salesforce(username='******', password='******', security_token='V6oPmGSaXW6Q5cv8MAEhLqCK', sandbox=True) @staticmethod def get_day_window(): """ Returns the window between the current day and the last day :return: """ current_date = datetime.datetime.now() start_window = datetime.datetime(current_date.year, current_date.month, current_date.day, current_date.hour) - datetime.timedelta(hours=12) start_window = start_window.strftime('%y-%m-%dT%H:%M:%S.%f') start_window = GenericFileUploader.timestamp_to_UTC(start_window) end_window = datetime.datetime(current_date.year, current_date.month, current_date.day) end_window = end_window.strftime('%y-%m-%dT%H:%M:%S.%f') end_window = GenericFileUploader.timestamp_to_UTC(end_window) return start_window, end_window def poll_data(self, start_window, end_window): """ Returns the data between the time frame specified :return: """ if not self.fetch_from_database(database_name = self.database_name, table_name = self.table_name, where = [['timestamp', '<', start_window], ['timestamp', '>=', end_window]], order_by = ['timestamp', 'ASC']): return [] else: metric_data = self.fetchall() if len(metric_data) == 0: return [] else: return zip(*list(zip(*metric_data))) @abc.abstractmethod def process_data(self, data, start_window): """ Returns the processed metric :param data: :return: """ return def upload_to_database(self, metric, metric_names, metric_types): """ Uploads the metric to the database ['VARCHAR(100) NOT NULL PRIMARY KEY', 'FLOAT'] :return: """ self.create_table(database_name= self.database_name, table_name = self.metric_type, column_names = metric_names, column_types = metric_types) self.insert_into_database(database_name = self.database_name, table_name = self.metric_type, column_names = ['timestamp', 'metric'], values = metric) return True def upload_to_salesforce(self, metric): """ Uploads the metric to salesforce :return: """ metric_data = { "patientId": self.database_name[1:], "metricList": [{ "metric": self.metric_type, "metricValue": metric[1]} ] } self.sf.apexecute('FMMetrics/insertMetrics', method='POST', data=metric_data) return True def run(self): """ :return: """ start_window, end_window = MetricsClass.get_day_window() data = self.poll_data(start_window, end_window) metric, metric_names, metric_types = self.process_data(data, start_window) self.upload_to_database(metric, metric_names, metric_types) self.upload_to_salesforce(metric) return True