def run(batch_id, source_file_name, output_file_name, reference_date=today):
data_gen = DataGenerator()
# load source file
source_columns = ['External_Id__c', 'Name', 'UserRole.Name']
data_gen.load_source_file(source_file_name, source_columns)
data_gen.filter(lambda cv: 'RVP' not in cv['UserRole.Name'])
data_gen.filter(
lambda cv: 'CSM' not in cv['UserRole.Name']) # comes from Service
data_gen.rename_column('External_Id__c', 'QuotaOwner_Id__c')
data_gen.rename_column('Name', 'OwnerName__c')
# generate id
data_gen.add_formula_column(
'External_Id__c',
formula=lambda: 'W_Quota.' + str(data_gen.current_row + 1))
data_gen.duplicate_rows(24)
def quota_formula():
# first month of quarter = 300k
# second month of quarter = 500k
# third month of quarter = 500k
quarter = data_gen.current_row % 3
if quarter == 0:
return 300000
elif quarter == 1:
return 750000
else:
return 500000
data_gen.add_formula_column('QuotaAmount__c', quota_formula)
current_year = reference_date.year
last_year = current_year - 1
def start_date_formula():
user_row = data_gen.current_row % 24
month = str((user_row % 12) + 1).zfill(2)
day = '01'
if user_row < 12:
year = str(last_year)
else:
year = str(current_year)
return dateutil.parser.parse(year + '-' + month + '-' + day).date()
data_gen.add_formula_column('StartDate__c', start_date_formula)
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
# apply transformations and write file
data_gen.apply_transformations()
data_gen.write(output_file_name, [
'External_Id__c', 'QuotaOwner_Id__c', 'OwnerName__c', 'StartDate__c',
'QuotaAmount__c'
])
def run(batch_id, source_file_name, output_file_name, reference_datetime=today, id_offset=0):
data_gen = DataGenerator()
# load source file
source_columns = [
'External_Id__c',
'Owner.External_Id__c',
'CreatedDate__c',
'LastActivityDate__c'
]
data_gen.load_source_file(source_file_name, source_columns)
data_gen.rename_column('External_Id__c', 'What.External_Id__c')
data_gen.rename_column('LastActivityDate__c', 'ActivityDate')
# generate a random number of tasks per opportunity
data_gen.duplicate_rows(duplication_factor=lambda: randint(1, 3))
data_gen.add_formula_column('External_Id__c', formula=lambda: 'W_Task.' + str(id_offset + data_gen.current_row + 1))
data_gen.add_formula_column('TaskSubtype', formula=task.oppty_task_subtype)
data_gen.add_formula_column('CallDurationInSeconds', formula=task.task_call_duration)
data_gen.add_formula_column('CallDisposition', formula=task.task_call_disposition)
data_gen.add_formula_column('CallType', formula=task.task_call_type)
data_gen.add_formula_column('Status', formula=task.task_status)
data_gen.add_formula_column('Priority', formula=task.task_priority)
def create_date_formula(column_values):
oppty_create_date = dateutil.parser.parse(column_values['CreatedDate__c'])
oppty_last_activity_date = dateutil.parser.parse(column_values['ActivityDate'])
create_date = fake.date_time_between_dates(oppty_create_date, oppty_last_activity_date)
if create_date > reference_datetime:
create_date = reference_datetime
return create_date.isoformat(sep=' ')
data_gen.add_formula_column('CreatedDate__c', create_date_formula)
def activity_date_formula(column_values):
create_date = dateutil.parser.parse(column_values['CreatedDate__c']).date()
return (create_date + timedelta(days=randint(0, 14))).isoformat()
data_gen.add_formula_column('ActivityDate', activity_date_formula)
data_gen.add_formula_column('Subject', formula=task.task_subject)
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
# apply transformations and write
data_gen.apply_transformations()
data_gen.write(output_file_name)
def run(batch_id, source_file_name, output_file_name):
data_gen = DataGenerator()
# load source file
source_columns = [
'External_Id__c', 'Owner.External_Id__c', 'CreatedDate__c'
]
data_gen.load_source_file(source_file_name, source_columns)
data_gen.rename_column('External_Id__c', 'Case.External_Id__c')
data_gen.rename_column('Owner.External_Id__c', 'User.External_Id__c')
# todo one case article per case? at most 1? distribution?
data_gen.duplicate_rows(
duplication_factor=lambda: choice([0, 1], p=[.75, .25]))
data_gen.add_formula_column(
'External_Id__c',
formula=lambda: 'W_CaseArticle.' + str(data_gen.current_row + 1))
data_gen.add_formula_column(
'KnowledgeArticle.External_Id__c',
formula=lambda: 'W_KCSArticle.' + str(data_gen.current_row + 1))
data_gen.add_constant_column('ArticleVersionNumber__c', 1)
data_gen.add_constant_column('IsSharedByEmail__c', ['true', 'false'])
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
# apply transformations and write file
data_gen.apply_transformations()
output_columns = [
'External_Id__c', 'User.External_Id__c', 'ArticleVersionNumber__c',
'CreatedDate__c', 'KnowledgeArticle.External_Id__c',
'IsSharedByEmail__c', 'Case.External_Id__c',
'analyticsdemo_batch_id__c'
]
data_gen.write(output_file_name, output_columns)
def run(batch_id,
source_file_name,
output_file_name,
reference_datetime=today):
data_gen = DataGenerator()
# load source file
data_gen.load_source_file(source_file_name)
data_gen.rename_column('External_Id__c', 'Case.External_Id__c')
data_gen.rename_column('Owner.External_Id__c', 'User.External_Id__c')
data_gen.duplicate_rows(duplication_factor=lambda: choice(
[1, 2, 3, 4, 5], p=[.65, .15, .10, .05, .05]))
data_gen.add_formula_column(
'External_Id__c',
formula=lambda: 'W_AgentWork.' + str(data_gen.current_row + 1))
data_gen.add_copy_column('RequestDateTime__c', 'CreatedDate__c')
def created_date_formula(column_values):
created_date = dateutil.parser.parse(column_values['CreatedDate__c'])
closed_date = dateutil.parser.parse(column_values['ClosedDate__c'])
if closed_date > reference_datetime:
closed_date = reference_datetime
mid_date = created_date + (closed_date - created_date) / 2
return fake.date_time_between_dates(created_date,
mid_date).isoformat(sep=' ')
data_gen.add_formula_column('CreatedDate__c', created_date_formula)
def assigned_date_formula(column_values):
created_date = dateutil.parser.parse(column_values['CreatedDate__c'])
return (created_date +
timedelta(seconds=randint(0, 120))).isoformat(sep=' ')
data_gen.add_formula_column('AssignedDateTime__c', assigned_date_formula)
def accept_date_formula(column_values):
assigned_date = dateutil.parser.parse(
column_values['AssignedDateTime__c'])
return (assigned_date +
timedelta(seconds=randint(30, 600))).isoformat(sep=' ')
data_gen.add_formula_column('AcceptDateTime__c', accept_date_formula)
def close_date_formula(column_values):
accept_date = dateutil.parser.parse(column_values['AcceptDateTime__c'])
return (accept_date +
timedelta(seconds=randint(30, 1800))).isoformat(sep=' ')
data_gen.add_formula_column('CloseDateTime__c', close_date_formula)
def active_time_formula(column_values):
accept_date = dateutil.parser.parse(column_values['AcceptDateTime__c'])
close_date = dateutil.parser.parse(column_values['CloseDateTime__c'])
return int((close_date - accept_date).total_seconds())
data_gen.add_formula_column('ActiveTime__c', active_time_formula)
data_gen.add_formula_column('AgentCapacityWhenDeclined__c',
lambda: randint(30, 1800))
def cancel_date_formula(column_values):
assigned_date = dateutil.parser.parse(
column_values['AssignedDateTime__c'])
return (assigned_date +
timedelta(seconds=randint(30, 600))).isoformat(sep=' ')
data_gen.add_formula_column('CancelDateTime__c', cancel_date_formula)
data_gen.add_formula_column('CapacityPercentage__c',
lambda: randint(1, 101))
data_gen.add_formula_column('CapacityWeight__c', lambda: randint(1, 7))
def decline_date_formula(column_values):
assigned_date = dateutil.parser.parse(
column_values['AssignedDateTime__c'])
return (assigned_date +
timedelta(seconds=randint(30, 600))).isoformat(sep=' ')
data_gen.add_formula_column('DeclineDateTime__c', decline_date_formula)
data_gen.add_formula_column('DeclineReason__c', formula=fake.sentence)
data_gen.add_copy_column('HandleTime__c', 'ActiveTime__c')
data_gen.add_formula_column('OriginalQueue.DeveloperName', [
'GeneralQueue', 'InternationalQueue', 'Knowledge_Translations',
'Social_Queue', 'TargetCampaign', 'Tier1Queue', 'Tier2Queue',
'Tier3Queue'
])
data_gen.add_formula_column('PushTimeout__c', lambda: randint(0, 100))
def push_timeout_date_formula(column_values):
create_date = dateutil.parser.parse(column_values['CreatedDate__c'])
return create_date + timedelta(seconds=column_values['PushTimeout__c'])
data_gen.add_formula_column('PushTimeoutDateTime__c',
push_timeout_date_formula)
data_gen.add_formula_column(
'ServiceChannel.DeveloperName',
['Cases', 'LiveMessage', 'sfdc_liveagent', 'Leads'])
def speed_to_answer_formula(column_values):
request_date = dateutil.parser.parse(
column_values['RequestDateTime__c'])
accept_date = dateutil.parser.parse(column_values['AcceptDateTime__c'])
return int((accept_date - request_date).total_seconds())
data_gen.add_formula_column('SpeedToAnswer__c', speed_to_answer_formula)
data_gen.add_formula_column('Status__c', [
'Assigned', 'Unavailable', 'Declined', 'Opened', 'Closed',
'DeclinedOnPushTimeout', 'Canceled'
])
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
def filter_func(column_values):
created_date = dateutil.parser.parse(column_values['CreatedDate__c'])
cutoff_date = reference_datetime - timedelta(days=60)
return column_values['Origin'] == 'Chat' and created_date >= cutoff_date
data_gen.filter(filter_function=filter_func)
data_gen.apply_transformations()
data_gen.sort_by('RequestDateTime__c')
output_columns = [
'External_Id__c', 'RequestDateTime__c', 'CreatedDate__c',
'AssignedDateTime__c', 'AcceptDateTime__c', 'CloseDateTime__c',
'ActiveTime__c', 'AgentCapacityWhenDeclined__c', 'CancelDateTime__c',
'CapacityPercentage__c', 'CapacityWeight__c', 'DeclineDateTime__c',
'DeclineReason__c', 'HandleTime__c', 'OriginalQueue.DeveloperName',
'PushTimeout__c', 'PushTimeoutDateTime__c',
'ServiceChannel.DeveloperName', 'SpeedToAnswer__c', 'Status__c',
'User.External_Id__c', 'Case.External_Id__c',
'analyticsdemo_batch_id__c'
]
return data_gen.write(output_file_name, output_columns, 6000)
def run(batch_id, source_file_name, output_file_name, accounts_file_name, contacts_file_name):
data_gen = DataGenerator()
# load source file
source_columns = [
'External_Id__c',
'AccountExternalId__c',
'Owner.External_Id__c',
'LeadSource',
'CloseDate',
'CreatedDate__c'
]
data_gen.load_source_file(source_file_name, source_columns)
# load accounts as dataset
account_columns = [
'External_Id__c',
'Name',
'BillingState',
'Industry'
]
account_dataset = data_gen.load_dataset('accounts', accounts_file_name, account_columns)
accounts_by_id = account_dataset.group_by('External_Id__c')
# load contacts as dataset
contact_columns = [
'External_Id__c',
'FirstName',
'LastName'
]
contact_dataset = data_gen.load_dataset('contacts', contacts_file_name, contact_columns)
contacts_by_id = contact_dataset.group_by('External_Id__c')
# helper method to get account data
def get_account_data(column_values, account_column_name):
return accounts_by_id.get(column_values['ConvertedAccount.External_Id__c'])[0].get(account_column_name)
# helper method to get contact data
def get_contact_data(column_values, contact_column_name):
return contacts_by_id.get(column_values['ConvertedContact.External_Id__c'])[0].get(contact_column_name)
# rename columns
data_gen.rename_column('External_Id__c', 'ConvertedOpportunity.External_Id__c')
data_gen.rename_column('AccountExternalId__c', 'ConvertedAccount.External_Id__c')
data_gen.rename_column('CloseDate', 'ConvertedDate__c')
# generate converted lead at a random ratio
data_gen.duplicate_rows(duplication_factor=lambda: choice([0, 1], p=[.75, .25]))
# generate id
data_gen.add_formula_column('External_Id__c', formula=lambda: 'W_Lead.' + str(data_gen.current_row + 1))
# generate create date
def create_date_formula(column_values):
oppty_create_date = dateutil.parser.parse(column_values['CreatedDate__c'])
return oppty_create_date - timedelta(days=randint(0, 45))
data_gen.add_formula_column('CreatedDate__c', create_date_formula)
# generate status
data_gen.add_formula_column('Status', formula=lead.lead_status)
# generate status
data_gen.add_map_column('IsConverted', 'Status', {
'Qualified - Convert': 'true',
None: 'false'
})
# generate opportunity
data_gen.add_map_column('ConvertedOpportunity.External_Id__c', 'Status', {
'Qualified - Convert': lambda cv: cv['ConvertedOpportunity.External_Id__c'],
None: ''
})
# generate account
data_gen.add_map_column('ConvertedAccount.External_Id__c', 'Status', {
'Qualified - Convert': lambda cv: cv['ConvertedAccount.External_Id__c'],
None: ''
})
# generate contact
data_gen.add_map_column('ConvertedContact.External_Id__c', 'Status', {
'Qualified - Convert': lambda cv: cv['ConvertedAccount.External_Id__c'].replace('W_Account', 'W_Contact'),
None: ''
})
# generate converted date
data_gen.add_map_column('ConvertedDate__c', 'Status', {
'Qualified - Convert': lambda cv: cv['ConvertedDate__c'],
None: ''
})
# generate name
data_gen.add_map_column('FirstName', 'Status', {
'Qualified - Convert': lambda cv: get_contact_data(cv, 'FirstName'),
None: lambda: fake.first_name()
})
data_gen.add_map_column('LastName', 'Status', {
'Qualified - Convert': lambda cv: get_contact_data(cv, 'LastName'),
None: lambda: fake.last_name()
})
# generate company
data_gen.add_map_column('Company', 'Status', {
'Qualified - Convert': lambda cv: get_account_data(cv, 'Name'),
None: 'Not Applicable'
})
# generate industry
data_gen.add_map_column('Industry', 'Status', {
'Qualified - Convert': lambda cv: get_account_data(cv, 'Industry'),
None: ''
})
# generate state
data_gen.add_map_column('State', 'Status', {
'Qualified - Convert': lambda cv: get_account_data(cv, 'BillingState'),
None: ''
})
# generate is unread by owner
data_gen.add_map_column('IsUnreadByOwner', 'Status', {
'Qualified - Convert': 'false',
None: lead.lead_is_unread_by_owner
})
# generate rating
data_gen.add_formula_column('Rating', formula=lead.lead_rating)
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
# apply transformations and write file
data_gen.apply_transformations()
data_gen.write(output_file_name)
def run(batch_id, source_file_name, output_file_name, reference_datetime=today):
data_gen = DataGenerator()
# load source file
source_columns = [
'External_Id__c',
'Owner.External_Id__c',
'CreatedDate__c',
'LastActivityDate__c'
]
data_gen.load_source_file(source_file_name, source_columns)
data_gen.rename_column('External_Id__c', 'Case.External_Id__c')
data_gen.duplicate_rows(duplication_factor=lambda: randint(0, 3))
data_gen.add_formula_column('External_Id__c', formula=lambda: 'W_Services_Event.' + str(data_gen.current_row + 1))
data_gen.add_formula_column('Subject', formula=event.event_subject)
data_gen.add_formula_column('EventSubtype', formula=event.event_subtype)
data_gen.add_formula_column('DurationInMinutes', formula=event.event_call_duration)
def create_date_formula(column_values):
case_create_date = dateutil.parser.parse(column_values['CreatedDate__c'])
case_close_date = datetime.combine(dateutil.parser.parse(column_values['LastActivityDate__c']), case_create_date.time())
if case_close_date > reference_datetime:
case_close_date = reference_datetime
create_date = fake.date_time_between_dates(case_create_date, case_close_date)
if create_date > reference_datetime:
create_date = reference_datetime
return create_date.isoformat(sep=' ')
data_gen.add_formula_column('CreatedDate__c', create_date_formula)
data_gen.add_copy_column('LastModifiedDate__c', 'CreatedDate__c')
def activity_date_formula(column_values):
create_date = dateutil.parser.parse(column_values['CreatedDate__c']).date()
return (create_date + timedelta(days=randint(0, 14))).isoformat()
data_gen.add_formula_column('ActivityDate', activity_date_formula)
def activity_datetime_formula(column_values):
return dateutil.parser.parse(column_values['ActivityDate'])
data_gen.add_formula_column('ActivityDateTime', activity_datetime_formula)
data_gen.add_constant_column('ShowAs', 'Busy')
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
# apply transformations and write
data_gen.apply_transformations()
output_columns = [
'External_Id__c',
'Owner.External_Id__c',
'Case.External_Id__c',
'Subject',
'EventSubtype',
'DurationInMinutes',
'ShowAs',
'CreatedDate__c',
'LastModifiedDate__c',
'ActivityDate',
'ActivityDateTime',
'analyticsdemo_batch_id__c'
]
data_gen.write(output_file_name, output_columns)
def run(batch_id,
source_file_name,
output_file_name,
reference_datetime=today):
data_gen = DataGenerator()
# load source file
source_columns = [
'External_Id__c', 'Owner.External_Id__c', 'CreatedDate__c',
'ClosedDate__c', 'Origin'
]
data_gen.load_source_file(source_file_name, source_columns)
data_gen.rename_column('External_Id__c', 'Case.External_Id__c')
data_gen.rename_column('ClosedDate__c', 'EndTime__c')
data_gen.duplicate_rows(duplication_factor=lambda: choice(
[1, 2, 3, 4, 5], p=[.65, .15, .10, .05, .05]))
data_gen.add_formula_column(
'External_Id__c',
lambda: 'W_LiveChatTranscript.' + str(data_gen.current_row + 1))
data_gen.add_formula_column('Abandoned__c', lambda: randint(1, 300))
data_gen.add_formula_column('AverageResponseTimeOperator__c',
lambda: randint(1, 180))
data_gen.add_formula_column('AverageResponseTimeVisitor__c',
lambda: randint(1, 180))
data_gen.add_formula_column('Body__c', formula=fake.body)
data_gen.add_formula_column('Browser__c', formula=fake.browser)
data_gen.add_constant_column('BrowserLanguage__c', 'en_US')
data_gen.add_formula_column('ChatDuration__c', lambda: randint(1, 600))
data_gen.add_formula_column('ChatKey__c', formula=fake.md5)
data_gen.add_formula_column('IpAddress__c', formula=fake.ipv4)
data_gen.add_formula_column('LiveChatButton.DeveloperName',
['Public_Website_Chat_Button'])
data_gen.add_formula_column('Location__c', formula=fake.city)
data_gen.add_formula_column('MaxResponseTimeOperator__c',
lambda: randint(1, 120))
data_gen.add_formula_column('MaxResponseTimeVisitor__c',
lambda: randint(1, 240))
data_gen.add_formula_column('Name__c',
lambda: str(data_gen.current_row + 1).zfill(8))
data_gen.add_formula_column('OperatorMessageCount__c',
lambda: randint(1, 100))
data_gen.add_formula_column(
'Platform__c', ['MacOSX', 'iOS', 'Android', 'Windows', 'Unix'])
referrer = [
"https://na17.salesforce.com/setup/forcecomHomepage.apexp?setupid=ForceCom&retURL=%2Fui%2Fsupport%2Fservicedesk%2FServiceDeskPage",
"https://na13.salesforce.com/home/home.jsp",
"https://sdodemo-main.force.com/partners/servlet/servlet.Integration?lid=01ra0000001VlbA&ic=1",
"https://sitestudio.na17.force.com/?exitURL=%2F_ui%2Fnetworks%2Fsetup%2FSetupNetworksPage%2Fd",
"https://mail.google.com/mail/u/0/",
"https://sdodemo-main.force.com/customers/servlet/servlet.Integration?lid=01ra0000001VlbP&ic=1",
"https://sdodemo-main.force.com/consumers/servlet/servlet.Integration?lid=01ro0000000EN78&ic=1",
"https://na17.salesforce.com/servlet/servlet.su?oid=00D300000007EfQ&retURL=%2F0033000000PuxU2&sunetworkuserid=005a000000AuCha&sunetworkid=0DBo0000000Gn4h",
"https://sdodemo-main.force.com/customers/servlet/servlet.Integration?ic=1&lid=01ra0000001VlbP"
]
data_gen.add_formula_column('ReferrerUri__c', referrer)
def create_date_formula(column_values):
case_create_date = dateutil.parser.parse(
column_values['CreatedDate__c'])
case_close_date = dateutil.parser.parse(column_values['EndTime__c'])
create_date = fake.date_time_between_dates(case_create_date,
case_close_date)
if create_date > reference_datetime:
create_date = reference_datetime
return create_date.isoformat(sep=' ')
data_gen.add_formula_column('CreatedDate__c', create_date_formula)
def start_time_formula(column_values):
create_date = dateutil.parser.parse(column_values['CreatedDate__c'])
start_time = create_date + timedelta(seconds=randint(1, 300))
return start_time.isoformat(sep=' ')
data_gen.add_formula_column('StartTime__c', start_time_formula)
def end_time_formula(column_values):
create_date = dateutil.parser.parse(column_values['StartTime__c'])
end_time = create_date + timedelta(seconds=randint(1, 600))
return end_time.isoformat(sep=' ')
data_gen.add_formula_column('EndTime__c', end_time_formula)
data_gen.add_copy_column('RequestTime__c', 'CreatedDate__c')
data_gen.add_formula_column(
'Status__c', lambda: choice(['Missed', 'Completed'], p=[.20, .80]))
data_gen.add_map_column('EndedBy__c', 'Status__c', {
'Completed': ['Visitor', 'Agent'],
None: 'Visitor'
})
data_gen.add_constant_column('SupervisorTranscriptBody__c', '')
data_gen.add_constant_column('ScreenResolution__c', '')
data_gen.add_formula_column('UserAgent__c', formula=fake.user_agent)
data_gen.add_formula_column('VisitorMessageCount__c',
lambda: randint(1, 50))
data_gen.add_formula_column('WaitTime__c', lambda: randint(1, 120))
def last_referenced_date_formula(column_values):
create_date = dateutil.parser.parse(column_values['CreatedDate__c'])
last_referenced_date = create_date + timedelta(seconds=randint(1, 300))
return last_referenced_date.isoformat(sep=' ')
data_gen.add_formula_column('LastReferencedDate__c',
last_referenced_date_formula)
data_gen.add_copy_column('LastViewedDate__c', 'LastReferencedDate__c')
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
def filter_func(column_values):
return column_values['Origin'] == 'Chat'
data_gen.filter(filter_function=filter_func)
# apply transformations and write file
data_gen.apply_transformations()
data_gen.sort_by('StartTime__c')
output_columns = [
'External_Id__c', 'Abandoned__c', 'AverageResponseTimeOperator__c',
'MaxResponseTimeOperator__c', 'OperatorMessageCount__c', 'Body__c',
'Browser__c', 'BrowserLanguage__c', 'Case.External_Id__c',
'ChatDuration__c', 'ChatKey__c', 'CreatedDate__c', 'StartTime__c',
'EndTime__c', 'EndedBy__c', 'LastReferencedDate__c',
'LastViewedDate__c', 'LiveChatButton.DeveloperName', 'Location__c',
'Owner.External_Id__c', 'Platform__c', 'ReferrerUri__c',
'ScreenResolution__c', 'RequestTime__c', 'Status__c',
'SupervisorTranscriptBody__c', 'UserAgent__c',
'AverageResponseTimeVisitor__c', 'IpAddress__c',
'MaxResponseTimeVisitor__c', 'VisitorMessageCount__c', 'WaitTime__c',
'analyticsdemo_batch_id__c'
]
data_gen.write(output_file_name, output_columns)
def run(batch_id,
source_file_name,
output_file_name,
reference_datetime=today):
data_gen = DataGenerator()
# load source file
account_columns = [
'External_Id__c', 'Owner.External_Id__c', 'OpportunityCloseDate__c'
]
data_gen.load_source_file(source_file_name, account_columns)
data_gen.rename_column('External_Id__c', 'Account.External_Id__c')
data_gen.rename_column('OpportunityCloseDate__c', 'CreatedDate__c')
# generate a random number of cases per account
data_gen.duplicate_rows(
duplication_factor=lambda: int(lognormal(0) + randint(0, 2)))
data_gen.add_formula_column(
'External_Id__c',
formula=lambda: 'W_Sales_Case.' + str(data_gen.current_row + 1))
# generate contact
def contact_formula(column_values):
return column_values['Account.External_Id__c'].replace(
'W_Account', 'W_Contact')
data_gen.add_formula_column('Contact.External_Id__c', contact_formula)
data_gen.add_formula_column('IsEscalated', case.case_is_escalated)
data_gen.add_formula_column('CSAT__c', case.case_csat)
data_gen.add_formula_column('Origin', formula=case.case_origin)
data_gen.add_formula_column('Type', formula=case.case_type)
data_gen.add_formula_column('Subject', formula=case.case_subject)
data_gen.add_formula_column('Priority', formula=case.case_priority)
data_gen.add_formula_column('Status', formula=case.case_status)
def create_date_formula(column_values):
oppty_close_date = dateutil.parser.parse(
column_values['CreatedDate__c'])
create_date = oppty_close_date + timedelta(days=randint(0, 90))
if create_date > reference_datetime:
create_date = reference_datetime
return create_date.isoformat(sep=' ')
data_gen.add_formula_column('CreatedDate__c', create_date_formula)
def close_date_formula(column_values):
create_date = dateutil.parser.parse(column_values['CreatedDate__c'])
if column_values['Status'] == 'Closed':
close_date = create_date + timedelta(days=randint(0, 10))
if close_date > reference_datetime:
close_date = reference_datetime
return close_date.isoformat(sep=' ')
else:
return ''
data_gen.add_formula_column('ClosedDate__c', close_date_formula)
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
data_gen.apply_transformations()
data_gen.write(output_file_name)
def run(batch_id,
source_file_name,
output_file_name,
reference_datetime=today,
id_offset=0):
data_gen = DataGenerator()
# load source file
source_columns = [
'External_Id__c', 'Owner.External_Id__c', 'CreatedDate__c',
'LastActivityDate__c'
]
data_gen.load_source_file(source_file_name, source_columns)
data_gen.rename_column('External_Id__c', 'What.External_Id__c')
data_gen.rename_column('LastActivityDate__c', 'ActivityDate')
# generate a random number of events per opportunity
data_gen.duplicate_rows(duplication_factor=lambda: randint(1, 3))
data_gen.add_formula_column(
'External_Id__c',
formula=lambda: 'W_Event.' + str(id_offset + data_gen.current_row + 1))
data_gen.add_formula_column('Subject', formula=event.event_subject)
data_gen.add_formula_column('EventSubtype', formula=event.event_subtype)
data_gen.add_formula_column('DurationInMinutes',
formula=event.event_call_duration)
is_first = True
def create_date_formula(column_values):
oppty_create_date = dateutil.parser.parse(
column_values['CreatedDate__c'])
oppty_last_activity_date = dateutil.parser.parse(
column_values['ActivityDate'])
nonlocal is_first
if is_first:
create_date = oppty_last_activity_date
else:
create_date = fake.date_time_between_dates(
oppty_create_date, oppty_last_activity_date)
is_first = False
if create_date > reference_datetime:
create_date = reference_datetime
return create_date.isoformat(sep=' ')
data_gen.add_formula_column('CreatedDate__c', create_date_formula)
def activity_date_formula(column_values):
create_date = dateutil.parser.parse(
column_values['CreatedDate__c']).date()
return (create_date + timedelta(days=randint(0, 14))).isoformat()
data_gen.add_formula_column('ActivityDate', activity_date_formula)
def activity_datetime_formula(column_values):
return dateutil.parser.parse(column_values['ActivityDate'])
data_gen.add_formula_column('ActivityDateTime', activity_datetime_formula)
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
# apply transformations and write
data_gen.apply_transformations()
data_gen.write(output_file_name)
def run(batch_id,
source_file_name,
output_file_name,
reference_date=today_datetime):
data_gen = DataGenerator()
# load source file
data_gen.load_source_file(source_file_name, ['External_Id__c'])
data_gen.rename_column('External_Id__c', 'User.External_Id__c')
data_gen.add_copy_column('Owner.External_Id__c', 'User.External_Id__c')
data_gen.duplicate_rows(duplication_factor=lambda: int(normal(60, 10)))
data_gen.add_formula_column(
'External_Id__c',
lambda: 'W_UserServicePresence.' + str(data_gen.current_row + 1))
data_gen.add_formula_column('AtCapacityDuration__c',
lambda: randint(30, 900))
data_gen.add_formula_column('AverageCapacity__c', lambda: randint(30, 500))
data_gen.add_formula_column('ConfiguredCapacity__c',
lambda: randint(30, 600))
start_date = reference_date - timedelta(days=365)
end_date = reference_date
data_gen.add_formula_column(
'CreatedDate__c', lambda: fake.date_time_between_dates(
start_date, end_date).isoformat(sep=' '))
data_gen.add_formula_column('IdleDuration__c', lambda: randint(30, 600))
data_gen.add_formula_column('IsCurrentState__c',
lambda: choice(['true', 'false']))
data_gen.add_formula_column('IsAway__c', lambda: choice(['true', 'false']))
data_gen.add_formula_column('StatusDuration__c', lambda: randint(30, 900))
data_gen.add_copy_column('StatusStartDate__c', 'CreatedDate__c')
def status_end_date_formula(column_values):
start_date = dateutil.parser.parse(column_values['StatusStartDate__c'])
status_duration = int(column_values['StatusDuration__c'])
return (start_date +
timedelta(seconds=status_duration)).isoformat(sep=' ')
data_gen.add_formula_column('StatusEndDate__c',
formula=status_end_date_formula)
data_gen.add_formula_column('ServicePresenceStatus.DeveloperName', [
'Busy', 'Online', 'Available_Live_Agent', 'Busy_Break', 'Busy_Lunch',
'Busy_Training', 'Available_LiveMessage'
])
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
data_gen.apply_transformations()
output_columns = [
'External_Id__c', 'User.External_Id__c', 'Owner.External_Id__c',
'AtCapacityDuration__c', 'AverageCapacity__c', 'ConfiguredCapacity__c',
'CreatedDate__c', 'IdleDuration__c', 'IsAway__c', 'IsCurrentState__c',
'StatusDuration__c', 'StatusStartDate__c', 'StatusEndDate__c',
'ServicePresenceStatus.DeveloperName', 'analyticsdemo_batch_id__c'
]
data_gen.write(output_file_name, output_columns)
def run(batch_id, source_file_name, output_file_name, reference_datetime=today):
data_gen = DataGenerator()
# load source file
source_columns = [
'External_Id__c',
'Owner.External_Id__c',
'CreatedDate__c',
'LastActivityDate__c',
'Team__c'
]
data_gen.load_source_file(source_file_name, source_columns)
data_gen.rename_column('External_Id__c', 'Case.External_Id__c')
data_gen.rename_column('LastActivityDate__c', 'ActivityDate')
data_gen.rename_column('Team__c', 'CallObject')
# generate a random number of tasks per case
data_gen.duplicate_rows(duplication_factor=lambda: randint(0, 3))
data_gen.add_formula_column('External_Id__c', formula=lambda: 'W_Services_Task.' + str(data_gen.current_row + 1))
data_gen.add_formula_column('TaskSubtype', formula=task.task_subtype)
data_gen.add_formula_column('CallDurationInSeconds', formula=task.task_call_duration)
data_gen.add_formula_column('CallDisposition', formula=task.task_call_disposition)
data_gen.add_formula_column('CallType', formula=task.task_call_type)
data_gen.add_formula_column('Status', formula=task.task_status)
data_gen.add_formula_column('Priority', formula=task.task_priority)
def create_date_formula(column_values):
case_create_date = dateutil.parser.parse(column_values['CreatedDate__c'])
case_close_date = datetime.combine(dateutil.parser.parse(column_values['ActivityDate']), case_create_date.time())
create_date = fake.date_time_between_dates(case_create_date, case_close_date)
if create_date > reference_datetime:
create_date = reference_datetime
return create_date.isoformat(sep=' ')
data_gen.add_formula_column('CreatedDate__c', create_date_formula)
data_gen.add_copy_column('LastModifiedDate__c', 'CreatedDate__c')
def activity_date_formula(column_values):
create_date = dateutil.parser.parse(column_values['CreatedDate__c']).date()
return (create_date + timedelta(days=randint(0, 14))).isoformat()
data_gen.add_formula_column('ActivityDate', activity_date_formula)
data_gen.add_formula_column('Subject', formula=task.task_subject_simple)
data_gen.add_map_column('Type', 'Subject', value_map={
'Call': lambda: choice(['Call', 'Meeting'], p=[.70, .30]),
'Send Letter': 'Email',
'Send Quote': 'Email',
None: lambda: choice(['Meeting', 'Prep', 'Other'], p=[.50, .25, .25])
})
# add a UUID for each row that is created in this batch
data_gen.add_constant_column('analyticsdemo_batch_id__c', batch_id)
# apply transformations and write
data_gen.apply_transformations()
output_columns = [
'External_Id__c',
'Owner.External_Id__c',
'Case.External_Id__c',
'CreatedDate__c',
'LastModifiedDate__c',
'ActivityDate',
'Subject',
'Type',
'TaskSubtype',
'CallDurationInSeconds',
'CallDisposition',
'CallType',
'CallObject',
'Status',
'Priority',
'analyticsdemo_batch_id__c'
]
data_gen.write(output_file_name, output_columns)
