def run(batch_id, source_file_name, output_file_name, source_service_resources, delta=timedelta(days=14)):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)


    data_gen.add_formula_column('Start',
                                lambda cv: "" if cv['Start'] == "" else (dateutil.parser.parse(cv['Start']) + timedelta(days=delta.days - 1)).replace(tzinfo=None))

    data_gen.add_formula_column('End',
                                lambda cv: "" if cv['End'] == "" else (dateutil.parser.parse(cv['End']) + timedelta(days=delta.days - 1)).replace(tzinfo=None))


    service_resources = data_gen.load_dataset("ServiceResources", source_service_resources, ['Id', 'External_ID__c']).dict('Id', 'External_ID__c')

    data_gen.add_map_column('Resource.External_Id__c', 'ResourceId', service_resources)

    data_gen.apply_transformations()

    data_gen.add_copy_column('CreatedDate__c', 'Start')

    data_gen.apply_transformations()

    data_gen.write(output_file_name, columns=[
        'External_ID__c',
        'Resource.External_Id__c',
        'CreatedDate__c',
        'Start',
        'End',
        'Type',
        #'State',
        #'Country',
        #'City'
    ])
Пример #2
0
def run(batch_id, source_file_name, output_file_name, source_service_resources,
        source_service_appointments):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    service_resources = data_gen.load_dataset("ServiceResources",
                                              source_service_resources,
                                              ['Id', 'External_ID__c']).dict(
                                                  'Id', 'External_ID__c')
    data_gen.add_map_column('ServiceResource.External_Id__c',
                            'ServiceResourceId', service_resources)

    service_appointments = data_gen.load_dataset(
        "ServiceAppointments", source_service_appointments,
        ['Id', 'External_ID__c']).dict('Id', 'External_ID__c')
    data_gen.add_map_column('ServiceAppointment.External_Id__c',
                            'ServiceAppointmentId', service_appointments)

    data_gen.apply_transformations()

    data_gen.write(output_file_name,
                   columns=[
                       'External_ID__c', 'ServiceResource.External_Id__c',
                       'ServiceAppointment.External_Id__c', 'ActualTravelTime',
                       'EstimatedTravelTime'
                   ])
Пример #3
0
def run(batch_id,
        source_file_name,
        output_file_name,
        source_operating_hours,
        reference_datetime=today_datetime):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    data_gen.add_constant_column('CreatedDate__c',
                                 reference_datetime.isoformat(sep=' '))

    operating_hours = data_gen.load_dataset("OperatingHours",
                                            source_operating_hours,
                                            ['Id', 'External_ID__c']).dict(
                                                'Id', 'External_ID__c')

    data_gen.add_map_column('OperatingHours.External_Id__c',
                            'OperatingHoursId', operating_hours)

    data_gen.apply_transformations()

    data_gen.write(output_file_name,
                   columns=[
                       'External_ID__c', 'OperatingHours.External_Id__c',
                       'StartTime', 'EndTime'
                   ])
def run(batch_id, source_file_name, output_file_name, source_accounts):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    accounts = data_gen.load_dataset("Accounts", source_accounts, ['Id', 'External_ID__c']).dict('Id', 'External_ID__c')

    data_gen.add_map_column('Account.External_Id__c', 'AccountId', accounts)

    data_gen.apply_transformations()

    data_gen.write(output_file_name, columns=[
        'External_ID__c',
        'Account.External_Id__c',
        'Subject'
    ])
Пример #5
0
def updateCreatedDate(source_file_name,
                      output_file_name,
                      source_service_appointments,
                      reference_datetime=today_datetime):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    service_appointments = data_gen.load_dataset(
        "ServiceAppointments", source_service_appointments,
        ['External_ID__c']).dict('External_ID__c', 'External_ID__c')
    service_appointments[None] = 'None'

    data_gen.add_map_column('ServiceAppointment.External_Id__c',
                            'ServiceAppointment.External_Id__c',
                            service_appointments)

    data_gen.apply_transformations()

    data_gen.filter(lambda cv: cv['ServiceAppointment.External_Id__c'].
                    startswith('ServiceAppointment'))

    data_gen.apply_transformations()

    service_appointment_dates = data_gen.load_dataset(
        "ServiceAppointmentDates", source_service_appointments,
        ['External_ID__c', 'CreatedDate__c']).dict('External_ID__c',
                                                   'CreatedDate__c')
    service_appointment_dates[None] = reference_datetime + timedelta(days=-1)
    data_gen.add_map_column('CreatedDate__c',
                            'ServiceAppointment.External_Id__c',
                            service_appointment_dates)

    data_gen.apply_transformations()

    data_gen.write(output_file_name,
                   columns=[
                       'External_ID__c', 'ServiceResource.External_Id__c',
                       'ServiceAppointment.External_Id__c', 'CreatedDate__c',
                       'ActualTravelTime', 'EstimatedTravelTime'
                   ])
def run(batch_id, source_file_name, output_file_name, source_products):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    products = data_gen.load_dataset("Products", source_products,
                                     ['Id', 'External_ID__c']).dict(
                                         'Id', 'External_ID__c')
    data_gen.add_map_column('Product2.External_Id__c', 'Product2Id', products)

    data_gen.add_constant_column('Pricebook2.Name', 'Standard Price Book')

    data_gen.apply_transformations()

    data_gen.write(output_file_name,
                   columns=[
                       'External_Id__c', 'Product2.External_Id__c', 'IsActive',
                       'Pricebook2.Name', 'UnitPrice'
                   ])
def run(batch_id, source_file_name, output_file_name, source_pricebook, source_work_orders):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    pricebook = data_gen.load_dataset("Pricebook", source_pricebook, ['Id', 'External_Id__c']).dict('Id', 'External_Id__c')
    data_gen.add_map_column('PricebookEntry.External_Id__c', 'PricebookEntryId', pricebook)

    work_orders = data_gen.load_dataset("WorkOrders", source_work_orders, ['Id', 'External_ID__c']).dict('Id', 'External_ID__c')
    data_gen.add_map_column('WorkOrder.External_Id__c', 'WorkOrderId', work_orders)

    data_gen.apply_transformations()

    data_gen.write(output_file_name, columns=[
        'External_ID__c',
        'PricebookEntry.External_Id__c',
        'WorkOrder.External_Id__c',
        'QuantityConsumed'
    ])
Пример #8
0
def run(batch_id, source_file_name, output_file_name, source_operating_hours):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    operating_hours = data_gen.load_dataset("OperatingHours", source_operating_hours, ['Id', 'External_ID__c']).dict('Id', 'External_ID__c')

    data_gen.add_map_column('OperatingHours.External_Id__c', 'OperatingHoursId', operating_hours)

    data_gen.apply_transformations()

    data_gen.write(output_file_name, columns=[
        'External_ID__c',
        'Name',
        'OperatingHours.External_Id__c',
        'State',
        'IsActive',
        'Country',
        'City'
    ])
def update(source_file_name, output_file_name, source_work_orders):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    service_appointments = data_gen.load_dataset("WorkOrders", source_work_orders, ['External_ID__c']).dict('External_ID__c', 'External_ID__c')
    service_appointments[None] = 'None'

    data_gen.add_map_column('WorkOrder.External_Id__c', 'WorkOrder.External_Id__c', service_appointments)

    data_gen.apply_transformations()

    data_gen.filter(lambda cv: cv['WorkOrder.External_Id__c'].startswith('WO.'))

    data_gen.apply_transformations()

    data_gen.write(output_file_name, columns=[
        'External_ID__c',
        'PricebookEntry.External_Id__c',
        'WorkOrder.External_Id__c',
        'QuantityConsumed'
    ])
Пример #10
0
def run(batch_id, source_file_name, output_file_name, source_cases, source_accounts, source_work_types, source_service_appointments, reference_datetime=today_datetime):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    cases = data_gen.load_dataset("Cases", source_cases, ['Id', 'External_ID__c']).dict('Id', 'External_ID__c')
    data_gen.add_map_column('Case.External_Id__c', 'CaseId', cases)

    accounts = data_gen.load_dataset("Accounts", source_accounts, ['Id', 'External_ID__c']).dict('Id', 'External_ID__c')
    data_gen.add_map_column('Account.External_Id__c', 'AccountId', accounts)

    work_types = data_gen.load_dataset("WorkTypes", source_work_types, ['Id', 'External_ID__c']).dict('Id', 'External_ID__c')
    data_gen.add_map_column('WorkType.External_Id__c', 'WorkTypeId', work_types)

    data_gen.add_constant_column('Pricebook2.Name', 'Standard Price Book')

    service_appointment_dates = data_gen.load_dataset("ServiceAppointmentDates", source_service_appointments, ['WorkOrder.External_Id__c', 'CreatedDate__c']).dict('WorkOrder.External_Id__c', 'CreatedDate__c')
    service_appointment_dates[None] = reference_datetime + timedelta(days=-1)
    data_gen.add_map_column('CreatedDate__c', 'External_ID__c', service_appointment_dates)

    data_gen.apply_transformations()

    data_gen.filter(lambda cv: cv['WorkType.External_Id__c'].startswith('WT.'))

    data_gen.apply_transformations()

    data_gen.write(output_file_name, columns=[
        'External_ID__c',
        'CreatedDate__c',
        'Status',
        'Pricebook2.Name',
        'Priority',
        'Case.External_Id__c',
        'Account.External_Id__c',
        'WorkType.External_Id__c'
    ])
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',
        '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(source_file_name, output_file_name):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    # find mean and std of profit
    profits = []
    for row in data_gen.rows:
        column_values = data_gen.row_to_column_values(row)
        profits.append(float(column_values['Profit']))


    profit_mean = mean(profits)
    profit_std = std(profits)

    # filter out profits more than 2 std out.
    def filter_func(column_values):
        profit = float(column_values['Profit'])
        z_score = abs((profit - profit_mean) / profit_std)
        return z_score <= 2
    data_gen.filter(filter_function=filter_func)


    store_tier_map = {
        'New York 4': "Tier 1",
        'New York 3': "Tier 1",
        'New York 2': "Tier 1",
        'New York 1': "Tier 1",
        'Chicago 3': "Tier 1",
        'Chicago 2': "Tier 2",
        'Chicago 1': "Tier 2",
        'Boston 2': "Tier 2",
        'Boston 1': "Tier 3"
    }
    data_gen.add_map_column('Tier', 'Store', store_tier_map)


    month_channel_map = {
        'January': 'Chat',
        'February': 'Chat',
        'March': 'Chat',
        'April': 'Chat',
        'May': 'Chat',
        'June': 'Email',
        'July': 'Email',
        'August': 'Facebook',
        'September': 'Phone',
        'October': 'Phone',
        'November': 'Website',
        'December': 'Website'
    }
    data_gen.add_map_column('Origin', 'Month', month_channel_map)


    discount_support_map = {
        '0': 'Free',
        '0.05': 'Free',
        '0.15': 'Basic',
        '0.1': 'Silver',
        '0.2': 'Platinum'
    }
    data_gen.add_map_column('Type_of_Support__c', 'Discount', discount_support_map)


    camp_reason_map = {
        "Bundled": "Documentation",
        "Buy More & Save": "Unknown Failure",
        "Competitor Focus": "Feature Question",
        "Door Buster": "Hardware Question",
        "Friends & Family": "Late Delivery",
        "Local": "Software Question",
        "Paper Circular": "General Question",
        "Regional": "Item Damaged",
        "Social": "Item Damaged"
    }
    data_gen.add_map_column('Reason', 'Marketing Campaign', camp_reason_map)


    city_priority_map = {
        "Boston": "Low",
        "Chicago": "Medium",
        "New York": "High"
    }
    data_gen.add_map_column('Priority', 'City', city_priority_map)


    comp_sla_map = {
        "High": "Violation",
        "Normal": "Compliant",
        "Low": "Compliant"
    }
    data_gen.add_map_column('SLA', 'Competition', comp_sla_map)


    data_gen.add_constant_column('Status', 'Closed')


    sla_first_contact_close_map = {
        'Compliant': lambda: choice(['true', 'false'], p=[.9, .1]),
        'Violation': lambda: choice(['true', 'false'], p=[.7, .3])
    }
    data_gen.add_map_column('First_Contact_Close__c', 'SLA', sla_first_contact_close_map)


    sla_time_open_map = {
        'Compliant': lambda: choice([12, 24, 36, 48], p=[.50, .20, .20, .10]),
        'Violation': lambda: choice([60, 72, 84, 96, 108, 120], p=[.60, .20, .10, .05, .03, .02])
    }
    data_gen.add_map_column('Time_Open__c', 'SLA', sla_time_open_map)


    def region_formula(column_values):
        average_age = float(column_values['Average Age'])
        if average_age < 40:
            return 'West CSR'
        elif average_age >= 40.0 and average_age < 50:
            return 'Central CSR'
        else:
            return 'East CSR'
    data_gen.add_formula_column('Team__c', region_formula)


    def user_formula(column_values):
        average_age = float(column_values['Average Age'])
        if average_age < 40:
            return 'W_Services_User.' + str(choice([1, 2, 3, 4, 5]))
        elif average_age >= 40.0 and average_age < 50:
            return 'W_Services_User.' + str(choice([6, 7, 8, 9, 10, 11]))
        else:
            return 'W_Services_User.' + str(choice([12, 13, 14, 15, 16, 17]))
    data_gen.add_formula_column('Owner.External_Id__c', user_formula)


    # generate offer voucher - give vouchers to customers that were unhappy with Video Games or Cables to boost CSAT
    def offer_voucher_formula(column_values):
        csat = float(column_values['Profit Linear'])
        item = column_values['Item']

        if item in ['Video Games', 'Cables']:
            return choice(['true', 'false'], p=[csat/100, (100 - csat) / 100])
        else:
            return 'false'
    data_gen.add_formula_column('Offer_Voucher__c', offer_voucher_formula)


    def send_field_service_formula(column_values):
        csat = float(column_values['Profit Linear'])
        item = column_values['Item']

        if csat >= 80.0 and item == 'Tablet':
            return 'true'
        else:
            return choice(['true', 'false'], p=[.25, .75])
    data_gen.add_formula_column('Send_FieldService__c', send_field_service_formula)

    data_gen.add_map_column('IsEscalated', 'Tier', {'Tier 1': 'true', None: 'false'})

    # generate close date offset
    # random offset covering the last 14 months
    data_gen.add_formula_column('close_date_offset', lambda: randint(1, 30 * 14))


    # generate account id - generate a long tail distribution - cubic function +- randint
    # helper dataset used for account selection
    data_gen.add_dataset('current_account', {'account_id': 0, 'account_count': 0})


    # generate a distribution of account ids
    def account_id_formula(column_values):
        current_account = data_gen.datasets['current_account']
        account_id = current_account['account_id']
        account_count = current_account['account_count']

        if account_count > 0:
            # continue with the current account_id if there are still any to take
            # but first decrement account count
            account_count += -1
            current_account['account_count'] = account_count
        else:
            # use new account id
            account_id += 1
            account_count = int(round(lognormal(1))) + randint(1, 7)

            # update account dataset for next iteration
            account_count += -1
            current_account['account_count'] = account_count
            current_account['account_id'] = account_id
        return 'W_Services_Account.' + str(account_id)
    data_gen.add_formula_column('Account.External_Id__c', account_id_formula)

    def csat_formula(column_values):
        # first normalize csat between 30-90
        csat = float(column_values['Profit Linear'])
        new_delta = 70
        csat = (new_delta * csat / 100) + 30
        channel = column_values['Origin']
        is_escalated = column_values['IsEscalated']
        send_field_service = column_values['Send_FieldService__c']
        offer_voucher = column_values['Offer_Voucher__c']

        if is_escalated == 'true':
            if channel == 'Phone':
                csat = csat - 2
            else:
                csat = csat + 2

        if send_field_service == 'true':
            if channel == 'Phone':
                csat = csat - 2
            else:
                csat = csat + 4

        if offer_voucher == 'true':
            if channel == 'Phone':
                csat = csat - 2
            else:
                csat = csat + 4

        return csat
    data_gen.add_formula_column('CSAT__c', formula=csat_formula)

    data_gen.add_map_column('Outlier', 'Outlier', value_map={
        'TRUE': 'true',
        None: 'false'
    })

    data_gen.apply_transformations()


    data_gen.add_map_column('Time_Open__c', 'First_Contact_Close__c', value_map={
        'true': 0,
        None: lambda cv: cv['Time_Open__c']
    })

    data_gen.apply_transformations()

    rename_map = {
        'Item': 'Product_Family_KB__c'
    }
    data_gen.rename_columns(rename_map)

    output_columns = [
        'Origin',
        'Store',
        'Tier',
        'Product_Family_KB__c',
        'Priority',
        'Average Age',
        'Percent Male',
        'SLA',
        'Daily Revenue',
        'Reason',
        'Reg Price',
        'Type_of_Support__c',
        'Price',
        'Quantity',
        'Cost',
        'Profit',
        'CSAT__c',
        'Profit Log',
        'Outlier',
        'Status',
        'First_Contact_Close__c',
        'Time_Open__c',
        'Team__c',
        'Owner.External_Id__c',
        'close_date_offset',
        'Account.External_Id__c',
        'Offer_Voucher__c',
        'Send_FieldService__c',
        'IsEscalated'
    ]
    data_gen.write(output_file_name, output_columns)
def run(batch_id,
        source_file_name,
        output_file_name,
        source_accounts,
        source_service_resources,
        source_service_territories,
        source_work_orders,
        reference_datetime=today):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    data_gen.add_formula_column(
        'EarliestStartTime',
        lambda cv: dateutil.parser.parse(cv['EarliestStartTime']))

    data_gen.apply_transformations()

    data_gen.sort_by('EarliestStartTime', reverse=True)

    # shift dates to be 2 weeks prior to the reference date
    delta = reference_datetime.date() - data_gen.row_to_column_values(
        data_gen.rows[0])['EarliestStartTime'].date()
    data_gen.add_formula_column(
        'EarliestStartTime', lambda cv: (cv['EarliestStartTime'] + timedelta(
            days=delta.days - 1)).replace(tzinfo=None))

    data_gen.add_formula_column(
        'ActualStartTime', lambda cv: "" if cv['ActualStartTime'] == "" else
        (dateutil.parser.parse(cv['ActualStartTime']) + timedelta(
            days=delta.days - 1)).replace(tzinfo=None))

    data_gen.add_formula_column(
        'ActualEndTime', lambda cv: "" if cv['ActualEndTime'] == "" else
        (dateutil.parser.parse(cv['ActualEndTime']) + timedelta(
            days=delta.days - 1)).replace(tzinfo=None))

    data_gen.add_formula_column(
        'ArrivalWindowStartTime', lambda cv: ""
        if cv['ArrivalWindowStartTime'] == "" else
        (dateutil.parser.parse(cv['ArrivalWindowStartTime']) + timedelta(
            days=delta.days - 1)).replace(tzinfo=None))

    data_gen.add_formula_column(
        'ArrivalWindowEndTime', lambda cv: ""
        if cv['ArrivalWindowEndTime'] == "" else
        (dateutil.parser.parse(cv['ArrivalWindowEndTime']) + timedelta(
            days=delta.days - 1)).replace(tzinfo=None))

    data_gen.add_formula_column(
        'DueDate', lambda cv: ""
        if cv['DueDate'] == "" else (dateutil.parser.parse(cv[
            'DueDate']) + timedelta(days=delta.days - 1)).replace(tzinfo=None))

    data_gen.apply_transformations()

    data_gen.add_copy_column('CreatedDate__c', 'EarliestStartTime')

    accounts = data_gen.load_dataset("Accounts", source_accounts,
                                     ['Id', 'External_ID__c']).dict(
                                         'Id', 'External_ID__c')

    data_gen.add_map_column('Account.External_Id__c', 'AccountId', accounts)

    service_resources = data_gen.load_dataset("ServiceResources",
                                              source_service_resources,
                                              ['Id', 'External_ID__c']).dict(
                                                  'Id', 'External_ID__c')

    data_gen.add_map_column('ServiceResource.External_Id__c',
                            'FSLDemoTools_Service_Resource__c',
                            service_resources)

    service_territories = data_gen.load_dataset("ServiceTerritories",
                                                source_service_territories,
                                                ['Id', 'External_ID__c']).dict(
                                                    'Id', 'External_ID__c')

    data_gen.add_map_column('ServiceTerritory.External_Id__c',
                            'ServiceTerritoryId', service_territories)

    work_orders = data_gen.load_dataset("WorkOrders", source_work_orders,
                                        ['Id', 'External_ID__c']).dict(
                                            'Id', 'External_ID__c')

    data_gen.add_map_column('WorkOrder.External_Id__c', 'ParentRecordId',
                            work_orders)

    data_gen.apply_transformations()

    data_gen.filter(
        lambda cv: cv['WorkOrder.External_Id__c'].startswith('WO.'))

    data_gen.apply_transformations()

    data_gen.write(
        output_file_name,
        columns=[
            'External_ID__c', 'CreatedDate__c',
            'ServiceResource.External_Id__c',
            'ServiceTerritory.External_Id__c', 'WorkOrder.External_Id__c',
            'ActualStartTime', 'ArrivalWindowStartTime', 'ActualDuration',
            'EarliestStartTime', 'Duration', 'DurationType', 'Status',
            'DueDate', 'ActualEndTime', 'ArrivalWindowEndTime'
        ])
    return delta
Пример #15
0
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)
def run(source_file_name, output_file_name):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    rename_map = {
        'Supplies Group': 'Product2Family__c',
        'Region': 'Region__c',
        'Route To Market': 'LeadSource',
        'Elapsed Days In Sales Stage': 'TimeToClose__c',
        'Sales Stage Change Count': 'SalesStageCount__c',
        'Opportunity Amount USD': 'Amount',
        'Deal Size Category': 'DealSizeCategory__c'
    }
    data_gen.rename_columns(rename_map)

    # multiple time to close by 2
    data_gen.add_formula_column('TimeToClose__c',
                                lambda cv: int(cv['TimeToClose__c']) * 2)

    # map existing columns to new columns
    data_gen.add_map_column('Competitor__c', 'Competitor Type',
                            definitions.competitor_type)
    data_gen.add_map_column('Product2Name__c', 'Supplies Subgroup',
                            definitions.supplies_subgroup_map)
    data_gen.add_map_column('AccountAnnualRevenue__c',
                            'Client Size By Revenue',
                            definitions.client_size_rev)
    data_gen.add_map_column('AccountNumberOfEmployees__c',
                            'Client Size By Employee Count',
                            definitions.client_size_employees)
    data_gen.add_map_column('AccountBookings__c',
                            'Revenue From Client Past Two Years',
                            definitions.client_past_revenue)
    data_gen.add_map_column('IsWon', 'Opportunity Result', definitions.isWon)

    # generate external id
    data_gen.add_formula_column(
        'External_Id__c',
        formula=lambda: 'W_Opportunity.' + str(data_gen.current_row + 1))

    data_gen.add_formula_column(
        'Exec_Meeting__c', lambda: choice(['true', 'false'], p=[.35, .65]))

    data_gen.add_formula_column(
        'Interactive_Demo__c', lambda: choice(['true', 'false'], p=[.30, .70]))

    def ttc_formula(column_values):
        ttc = int(column_values['TimeToClose__c'])
        exec_meeting = column_values['Exec_Meeting__c']
        competitor_type = column_values['Competitor Type']
        demo = column_values['Interactive_Demo__c']
        rev = column_values['AccountAnnualRevenue__c']

        if ttc == 0:
            return 0

        if exec_meeting == 'true':
            if competitor_type == 'None':
                ttc = ttc + 4
            else:
                ttc = ttc - 6
        if demo == 'true':
            if rev == 'T100':
                ttc = ttc + 6
            else:
                ttc = ttc - 5

        if ttc < 0:
            return 0

        return ttc

    data_gen.add_formula_column('TimeToClose__c', formula=ttc_formula)

    data_gen.add_constant_column('IsClosed', 'true')

    data_gen.add_formula_column(
        'RecordType.DeveloperName',
        formula=lambda: choice(['SimpleOpportunity', 'ChannelPartner'],
                               p=[.70, .30]))

    # generate opportunity type
    types = [
        'Add-On Business', 'Existing Business', 'New Business',
        'New Business / Add-on'
    ]
    data_gen.add_formula_column(
        'Type', formula=lambda: choice(types, p=[0.1, 0.3, 0.5, 0.1]))

    # generate a close date year and quarter
    data_gen.add_formula_column('close_date_year',
                                formula=lambda: choice(list(range(0, 30))))
    data_gen.add_formula_column(
        'close_date_quarter',
        formula=lambda: choice([1, 2, 3, 4], p=[0.21, 0.24, 0.22, 0.33]))

    # generate a close date offset from the year and quarter
    def offset_formula(column_values):
        day = int(round(chisquare(9) * 5))
        offset = 365 * (column_values['close_date_year']) + 91 * (
            column_values['close_date_quarter'] - 1) + day
        return offset

    data_gen.add_formula_column('close_date_offset__c', offset_formula)

    # generate a close date
    def close_date_formula(column_values):
        last_day = date(date.today().year, 12, 31)
        offset = column_values['close_date_offset__c']
        # last day of current year - offset
        close_date = last_day - timedelta(days=int(offset))
        return str(close_date)

    data_gen.add_formula_column('CloseDate', close_date_formula)

    # generate a create date
    def create_date_formula(column_values):
        close_date = dateutil.parser.parse(column_values['CloseDate'])
        offset = column_values['TimeToClose__c']
        create_date = close_date - timedelta(days=int(offset))
        return create_date.isoformat(sep=' ')

    data_gen.add_formula_column('CreatedDate__c', create_date_formula)

    # generate last activity date
    def last_activity_date_formula(column_values):
        create_date = dateutil.parser.parse(column_values['CreatedDate__c'])
        close_date = dateutil.parser.parse(column_values['CloseDate'])
        if close_date > today_datetime:
            close_date = today_datetime
        if create_date > today_datetime:
            create_date = today_datetime
        return fake.date_time_between_dates(create_date, close_date).date()

    data_gen.add_formula_column('LastActivityDate__c',
                                formula=last_activity_date_formula)

    # generate StageName, ForecastCategory, and Probability
    data_gen.add_map_column('StageName',
                            'Opportunity Result',
                            value_map={
                                'Won': 'Closed Won',
                                None: 'Closed Lost'
                            })
    data_gen.add_map_column('ForecastCategory',
                            'Opportunity Result',
                            value_map={
                                'Won': 'Closed',
                                None: 'Omitted'
                            })
    data_gen.add_map_column('ForecastCategoryName',
                            'Opportunity Result',
                            value_map={
                                'Won': 'Closed',
                                None: 'Omitted'
                            })
    data_gen.add_map_column('Probability',
                            'Opportunity Result',
                            value_map={
                                'Won': '100',
                                None: '0'
                            })

    # randomly pick an owner from the same region
    region_territory_map = {
        'Pacific':
        lambda: 'W_Sales_User.' + str(choice([1, 2, 3, 4, 5, 6])),
        "Northwest":
        lambda: 'W_Sales_User.' + str(choice([1, 2, 3, 4, 5, 6])),
        "Midwest":
        lambda: 'W_Sales_User.' + str(choice([7, 8, 9, 10, 11])),
        "Southwest":
        lambda: 'W_Sales_User.' + str(choice([7, 8, 9, 10, 11])),
        "Mid-Atlantic":
        lambda: 'W_Sales_User.' + str(choice([7, 8, 9, 10, 11])),
        "Northeast":
        lambda: 'W_Sales_User.' + str(choice([12, 13, 14, 15, 16, 17])),
        "Southeast":
        lambda: 'W_Sales_User.' + str(choice([12, 13, 14, 15, 16, 17]))
    }
    data_gen.add_map_column('Owner.External_Id__c', 'Region__c',
                            region_territory_map)

    # build out helper column for account selection
    def account_cat_formula(column_values):
        x1 = column_values['Client Size By Revenue']
        x2 = column_values['Client Size By Employee Count']
        x3 = column_values['Revenue From Client Past Two Years']
        return str(x1) + '.' + str(x2) + '.' + str(x3)

    data_gen.add_formula_column('account_cat', account_cat_formula)

    # apply pending transformations now so we can sort by account_cat
    data_gen.apply_transformations()

    data_gen.sort_by('account_cat')

    # helper dataset used for account selection
    data_gen.add_dataset('account_segment', {
        'account_id': 0,
        'account_count': 0,
        'current_account_cat': None
    })

    # generate a distribution of account ids
    def account_id_formula(column_values):
        account_segment = data_gen.datasets['account_segment']
        account_id = account_segment['account_id']
        account_count = account_segment['account_count']
        current_account_cat = account_segment['current_account_cat']

        if column_values[
                'account_cat'] == current_account_cat and account_count > 0:
            # continue with the current account_id if there are still any to take
            # but first decrement account count
            account_count += -1
            account_segment['account_count'] = account_count

            return account_id
        else:
            # use new account id
            account_id += 1
            # generate a random number of opportunties to associate to an account
            account_count = int(round(lognormal(1))) + randint(1, 7)
            current_account_cat = column_values['account_cat']

            # update account segment dataset for next iteration
            account_count += -1
            account_segment['account_id'] = account_id
            account_segment['account_count'] = account_count
            account_segment['current_account_cat'] = current_account_cat

            return account_id

    data_gen.add_formula_column('AccountId__c', account_id_formula)

    # generate account id string
    data_gen.add_formula_column(
        'AccountExternalId__c',
        formula=lambda cv: 'W_Account.' + str(cv['AccountId__c']))

    # generate account name string
    account_names = {}

    def account_name_formula(column_values):
        account_id = column_values['AccountId__c']
        if account_id in account_names:
            return account_names[account_id]
        else:
            account_name = account.account_name()
            account_names[account_id] = account_name
            return account_name

    data_gen.add_formula_column('AccountName__c', formula=account_name_formula)

    # generate name
    def name_formula(column_values):
        account_name = column_values['AccountName__c']
        amount = column_values['Amount']
        product_2_name = column_values['Product2Name__c']
        return account_name + ' ' + str(data_gen.current_row % 256)

    data_gen.add_formula_column('Name', name_formula)

    # apply remaining transformations
    data_gen.apply_transformations()

    # sort by account id
    data_gen.sort_by('AccountId__c')

    columns_to_write = [
        'External_Id__c', 'Product2Name__c', 'Product2Family__c', 'Region__c',
        'LeadSource', 'TimeToClose__c', 'SalesStageCount__c', 'Amount',
        'AccountAnnualRevenue__c', 'AccountNumberOfEmployees__c',
        'AccountBookings__c', 'Competitor__c', 'DealSizeCategory__c',
        'AccountExternalId__c', 'AccountName__c', 'close_date_year',
        'close_date_quarter', 'close_date_offset__c', 'Exec_Meeting__c',
        'Interactive_Demo__c', 'IsWon', 'IsClosed', 'Owner.External_Id__c',
        'Name', 'Type', 'StageName', 'ForecastCategory',
        'ForecastCategoryName', 'Probability', 'RecordType.DeveloperName'
    ]

    data_gen.write(output_file_name, columns_to_write)
def run(batch_id, source_file_name, output_file_name, manager_output_file_name):
    data_gen = DataGenerator()

    # load source file
    source_columns = ['Owner.External_Id__c', 'Team__c']
    data_gen.load_source_file(source_file_name, source_columns)
    data_gen.unique()

    # rename columns
    data_gen.rename_column('Owner.External_Id__c', 'External_Id__c')
    data_gen.rename_column('Team__c', 'UserRole.Name')

    # add 3 manager users
    west_manager = ['W_User.M.' + str(len(data_gen.rows) + 1), 'West CSM']
    east_manager = ['W_User.M.' + str(len(data_gen.rows) + 2), 'East CSM']
    central_manager = ['W_User.M.' + str(len(data_gen.rows) + 3), 'Central CSM']
    ## managers from Sales ##
    # west_manager = ['RVP West', 'W_Sales_User.M.' + str(len(data_gen.rows) + 1)]
    # east_manager = ['RVP East', 'W_Sales_User.M.' + str(len(data_gen.rows) + 2)]
    # central_manager = ['RVP Central', 'W_Sales_User.M.' + str(len(data_gen.rows) + 3)]
    ########################

    data_gen.rows.append(west_manager)
    data_gen.rows.append(east_manager)
    data_gen.rows.append(central_manager)

    # generate company name
    data_gen.add_formula_column('CompanyName', formula=fake.company)

    # generate fake first and last name
    def first_name_formula(column_values):
        id = int(column_values['External_Id__c'].split('.')[-1])
        return fake.first_name_female() if id < 13 else fake.first_name_male()
    data_gen.add_formula_column('FirstName', formula=first_name_formula)
    data_gen.add_formula_column('LastName', formula=fake.last_name)

    # generate data based on fake first and last name
    data_gen.add_formula_column('Name', lambda cv: cv['FirstName'] + ' ' + cv['LastName'])

    # generate data based on fake first and last name
    def alias_formula(column_values):
        alias = (column_values['FirstName'][0] + column_values['LastName']).lower()
        trimmed_alias = alias[:8] if len(alias) > 8 else alias
        return trimmed_alias
    data_gen.add_formula_column('Alias', formula=alias_formula)
    data_gen.add_formula_column('Username', lambda cv: cv['Alias'] + '@demo.user')
    data_gen.add_formula_column('CommunityNickname', lambda cv: cv['Alias'] + str(randint(100, 999)))
    data_gen.add_formula_column('Email', lambda cv: cv['Alias'] + '@webmail.com')

    data_gen.add_formula_column('Phone', formula=fake.phone_number)

    titles = ['Customer Service Representative', 'Senior Customer Service Representative']
    data_gen.add_formula_column('Title', lambda: choice(titles, p=[.70, .30]))

    # generate constant values
    data_gen.add_constant_column('IsActive', 'false')
    data_gen.add_constant_column('TimeZoneSidKey', 'America/Los_Angeles')
    data_gen.add_constant_column('Profile.Name', 'Standard User')
    # from oppty> data_gen.add_constant_column('Profile.Name', 'Standard User')
    data_gen.add_constant_column('LocaleSidKey', 'en_US')
    data_gen.add_constant_column('LanguageLocaleKey', 'en_US')
    data_gen.add_constant_column('EmailEncodingKey', 'ISO-8859-1')
    data_gen.add_constant_column('ForecastEnabled', 'true') # this comes from Sales

    data_gen.add_constant_column('UserPermissionsAvantgoUser', 'false')
    data_gen.add_constant_column('UserPermissionsCallCenterAutoLogin', 'false')
    data_gen.add_constant_column('UserPermissionsChatterAnswersUser', 'false')
    data_gen.add_constant_column('UserPermissionsInteractionUser', 'false')
    data_gen.add_constant_column('UserPermissionsJigsawProspectingUser', 'false')
    data_gen.add_constant_column('UserPermissionsKnowledgeUser', 'false')
    data_gen.add_constant_column('UserPermissionsLiveAgentUser', 'false')
    data_gen.add_constant_column('UserPermissionsMarketingUser', 'false')
    data_gen.add_constant_column('UserPermissionsMobileUser', 'false')
    data_gen.add_constant_column('UserPermissionsOfflineUser', 'false')
    data_gen.add_constant_column('UserPermissionsSFContentUser', 'false')
    data_gen.add_constant_column('UserPermissionsSiteforceContributorUser', 'false')
    data_gen.add_constant_column('UserPermissionsSiteforcePublisherUser', 'false')
    data_gen.add_constant_column('UserPermissionsSupportUser', 'false')
    data_gen.add_constant_column('UserPermissionsWorkDotComUserFeature', 'false')
    data_gen.add_constant_column('UserPreferencesActivityRemindersPopup', 'false')
    data_gen.add_constant_column('UserPreferencesApexPagesDeveloperMode', 'false')
    data_gen.add_constant_column('UserPreferencesCacheDiagnostics', 'false')
    data_gen.add_constant_column('UserPreferencesContentEmailAsAndWhen', 'false')
    data_gen.add_constant_column('UserPreferencesContentNoEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableAllFeedsEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableBookmarkEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableChangeCommentEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableEndorsementEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableFeedbackEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableFileShareNotificationsForApi', 'false')
    data_gen.add_constant_column('UserPreferencesDisableFollowersEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableLaterCommentEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableLikeEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableMentionsPostEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableMessageEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableProfilePostEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableRewardEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableSharePostEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisableWorkEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisCommentAfterLikeEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisMentionsCommentEmail', 'false')
    data_gen.add_constant_column('UserPreferencesDisProfPostCommentEmail', 'false')
    data_gen.add_constant_column('UserPreferencesEnableAutoSubForFeeds', 'false')
    data_gen.add_constant_column('UserPreferencesEventRemindersCheckboxDefault', 'false')
    data_gen.add_constant_column('UserPreferencesHideBiggerPhotoCallout', 'false')
    data_gen.add_constant_column('UserPreferencesHideChatterOnboardingSplash', 'false')
    data_gen.add_constant_column('UserPreferencesHideCSNDesktopTask', 'false')
    data_gen.add_constant_column('UserPreferencesHideCSNGetChatterMobileTask', 'false')
    data_gen.add_constant_column('UserPreferencesHideEndUserOnboardingAssistantModal', 'false')
    data_gen.add_constant_column('UserPreferencesHideLightningMigrationModal', 'false')
    data_gen.add_constant_column('UserPreferencesHideS1BrowserUI', 'false')
    data_gen.add_constant_column('UserPreferencesHideSecondChatterOnboardingSplash', 'false')
    data_gen.add_constant_column('UserPreferencesHideSfxWelcomeMat', 'false')
    data_gen.add_constant_column('UserPreferencesJigsawListUser', 'false')
    data_gen.add_constant_column('UserPreferencesLightningExperiencePreferred', 'false')
    data_gen.add_constant_column('UserPreferencesPathAssistantCollapsed', 'false')
    data_gen.add_constant_column('UserPreferencesPreviewLightning', 'false')
    data_gen.add_constant_column('UserPreferencesReminderSoundOff', 'false')
    data_gen.add_constant_column('UserPreferencesShowCityToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowCityToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowCountryToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowCountryToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowEmailToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowEmailToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowFaxToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowFaxToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowManagerToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowManagerToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowMobilePhoneToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowMobilePhoneToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowPostalCodeToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowPostalCodeToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowProfilePicToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowStateToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowStateToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowStreetAddressToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowStreetAddressToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowTitleToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowTitleToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowWorkPhoneToExternalUsers', 'false')
    data_gen.add_constant_column('UserPreferencesShowWorkPhoneToGuestUsers', 'false')
    data_gen.add_constant_column('UserPreferencesSortFeedByComment', 'false')
    data_gen.add_constant_column('UserPreferencesTaskRemindersCheckboxDefault', 'false')
    data_gen.add_constant_column('EmailPreferencesAutoBcc', 'false')
    data_gen.add_constant_column('EmailPreferencesAutoBccStayInTouch', 'false')
    data_gen.add_constant_column('EmailPreferencesStayInTouchReminder', 'false')
    data_gen.add_constant_column('UserPreferencesGlobalNavBarWTShown', 'false')
    data_gen.add_constant_column('UserPreferencesGlobalNavGridMenuWTShown', 'false')
    data_gen.add_constant_column('UserPreferencesCreateLEXAppsWTShown', '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()
    data_gen.write(output_file_name)

    # create manager file
    data_gen.filter(lambda cv: 'CSM' not in cv['UserRole.Name'])

    manager_map = {
        'West CSR': west_manager[0],
        'East CSR': east_manager[0],
        'Central CSR': central_manager[0]
    }
    ### this is the manager file section in Sales> ###
    # # create manager file
    # data_gen.filter(lambda cv: 'RVP' not in cv['UserRole.Name'])
    # manager_map = {
    #     'West Sales': west_manager[1],
    #     'East Sales': east_manager[1],
    #     'Central Sales': central_manager[1],
    # }
    ##################################################
    data_gen.add_map_column('Manager.External_Id__c', 'UserRole.Name', manager_map)

    data_gen.apply_transformations()
    data_gen.write(manager_output_file_name, ['External_Id__c', 'Manager.External_Id__c'])
Пример #18
0
def run(batch_id, source_file_name, output_file_name, source_profiles):
    data_gen = DataGenerator()

    # load source file
    data_gen.load_source_file(source_file_name)

    accounts = data_gen.load_dataset("Profiles", source_profiles, ['Id', 'Name']).dict('Id', 'Name')

    data_gen.add_map_column('Profile.Name', 'ProfileId', accounts)

    data_gen.apply_transformations()

    data_gen.write(output_file_name, columns=[
        'External_ID__c',
        'FirstName',
        'LastName',
        'Alias',
        'Email',
        'TimeZoneSidKey',
        'Profile.Name',
        'LocaleSidKey',
        'LanguageLocaleKey',
        'EmailEncodingKey',
        'UserPermissionsAvantgoUser',
        'UserPermissionsCallCenterAutoLogin',
        #'UserPermissionsChatterAnswersUser',
        'UserPermissionsInteractionUser',
        #'UserPermissionsJigsawProspectingUser',
        'UserPermissionsKnowledgeUser',
        'UserPermissionsLiveAgentUser',
        'UserPermissionsMarketingUser',
        'UserPermissionsMobileUser',
        'UserPermissionsOfflineUser',
        'UserPermissionsSFContentUser',
        'UserPermissionsSiteforceContributorUser',
        'UserPermissionsSiteforcePublisherUser',
        'UserPermissionsSupportUser',
        'UserPermissionsWorkDotComUserFeature',
        'UserPreferencesActivityRemindersPopup',
        'UserPreferencesApexPagesDeveloperMode',
        'UserPreferencesCacheDiagnostics',
        'UserPreferencesContentEmailAsAndWhen',
        'UserPreferencesContentNoEmail',
        'UserPreferencesDisableAllFeedsEmail',
        'UserPreferencesDisableBookmarkEmail',
        'UserPreferencesDisableChangeCommentEmail',
        'UserPreferencesDisableEndorsementEmail',
        'UserPreferencesDisableFeedbackEmail',
        'UserPreferencesDisableFileShareNotificationsForApi',
        'UserPreferencesDisableFollowersEmail',
        'UserPreferencesDisableLaterCommentEmail',
        'UserPreferencesDisableLikeEmail',
        'UserPreferencesDisableMentionsPostEmail',
        'UserPreferencesDisableMessageEmail',
        'UserPreferencesDisableProfilePostEmail',
        'UserPreferencesDisableRewardEmail',
        'UserPreferencesDisableSharePostEmail',
        'UserPreferencesDisableWorkEmail',
        'UserPreferencesDisCommentAfterLikeEmail',
        'UserPreferencesDisMentionsCommentEmail',
        'UserPreferencesDisProfPostCommentEmail',
        'UserPreferencesEnableAutoSubForFeeds',
        'UserPreferencesEventRemindersCheckboxDefault',
        'UserPreferencesHideBiggerPhotoCallout',
        'UserPreferencesHideChatterOnboardingSplash',
        'UserPreferencesHideCSNDesktopTask',
        'UserPreferencesHideCSNGetChatterMobileTask',
        'UserPreferencesHideEndUserOnboardingAssistantModal',
        'UserPreferencesHideLightningMigrationModal',
        'UserPreferencesHideS1BrowserUI',
        'UserPreferencesHideSecondChatterOnboardingSplash',
        'UserPreferencesHideSfxWelcomeMat',
        #'UserPreferencesJigsawListUser',
        'UserPreferencesLightningExperiencePreferred',
        'UserPreferencesPathAssistantCollapsed',
        'UserPreferencesPreviewLightning',
        'UserPreferencesReminderSoundOff',
        'UserPreferencesShowCityToExternalUsers',
        'UserPreferencesShowCityToGuestUsers',
        'UserPreferencesShowCountryToExternalUsers',
        'UserPreferencesShowCountryToGuestUsers',
        'UserPreferencesShowEmailToExternalUsers',
        'UserPreferencesShowEmailToGuestUsers',
        'UserPreferencesShowFaxToExternalUsers',
        'UserPreferencesShowFaxToGuestUsers',
        'UserPreferencesShowManagerToExternalUsers',
        'UserPreferencesShowManagerToGuestUsers',
        'UserPreferencesShowMobilePhoneToExternalUsers',
        'UserPreferencesShowMobilePhoneToGuestUsers',
        'UserPreferencesShowPostalCodeToExternalUsers',
        'UserPreferencesShowPostalCodeToGuestUsers',
        'UserPreferencesShowProfilePicToGuestUsers',
        'UserPreferencesShowStateToExternalUsers',
        'UserPreferencesShowStateToGuestUsers',
        'UserPreferencesShowStreetAddressToExternalUsers',
        'UserPreferencesShowStreetAddressToGuestUsers',
        'UserPreferencesShowTitleToExternalUsers',
        'UserPreferencesShowTitleToGuestUsers',
        'UserPreferencesShowWorkPhoneToExternalUsers',
        'UserPreferencesShowWorkPhoneToGuestUsers',
        'UserPreferencesSortFeedByComment',
        'UserPreferencesTaskRemindersCheckboxDefault',
        'EmailPreferencesAutoBcc',
        'EmailPreferencesAutoBccStayInTouch',
        'EmailPreferencesStayInTouchReminder',
        'UserPreferencesGlobalNavBarWTShown',
        'UserPreferencesGlobalNavGridMenuWTShown',
        'UserPreferencesCreateLEXAppsWTShown'
    ])