en-US.js

export default {
  commons: {
    please_select_import_mode: 'Please select import mode',
    please_select_import_module: 'Please select import module',
    pass_rate: 'Pass rate',
    execution_times: 'Execution times',
    cover: 'Cover',
    module_title: 'Default module',
    not_cover: 'Not Cover',
    import: 'Import',
    import_success: 'Import success',
    import_mode: 'Import mode',
    import_module: 'Import module',
    import_user: 'Import user',
    export: 'Export',
    please_fill_in_the_template: 'Please fill in the template',
    cut_back_old_version: 'Cut back to old version',
    cut_back_new_version: 'Switch back to new version',
    comment: 'comment',
    examples: 'examples',
    help_documentation: 'Help documentation',
    confirm_delete: 'Whether to delete',
    delete_cancelled: 'Delete cancelled',
    option_cannot_spread_pages: 'This options not support spread pages.Do you want continue?',
    workspace: 'Workspace',
    organization: 'Organization',
    setting: 'Setting',
    project: 'Project',
    about_us: 'About Us',
    current_project: 'Current Project',
    name: 'Name',
    description: 'Description',
    annotation: 'Annotation',
    clear: 'Clear',
    save: 'Save',
    update: 'Update',
    save_success: 'Saved successfully',
    delete_success: 'Deleted successfully',
    modify_success: 'Modify Success',
    copy_success: 'Copy Success',
    delete_cancel: 'Deleted Cancel',
    confirm: 'Confirm',
    cancel: 'Cancel',
    prompt: 'Prompt',
    operating: 'Operating',
    input_limit: 'Within {0} and {1} characters',
    login: 'Sign In',
    welcome: 'One-stop open source continuous testing platform',
    username: 'Username',
    password: 'Password',
    input_username: 'Please enter username',
    input_password: 'Please enter password',
    test: 'Test',
    create_time: 'Created Time',
    update_time: 'Updated Time',
    add: 'Add',
    preview: 'Preview',
    member: 'Member',
    email: 'Email',
    phone: 'Phone',
    role: 'Role',
    personal_info: 'Personal Info',
    status: 'Status',
    show_all: 'Show All',
    show: 'Show',
    report: 'Report',
    user: 'User',
    system: 'System',
    personal_setting: 'Personal Setting',
    api_keys: 'API Keys',
    quota: 'Quota',
    test_resource_pool: 'Resource Pool',
    system_setting: 'Settings',
    api: 'API',
    performance: 'Performance',
    functional: 'Functional test',
    input_content: 'Please enter content',
    create: 'Create',
    edit: 'Edit',
    copy: 'Copy',
    refresh: 'Refresh',
    remark: 'Remark',
    delete: 'Delete',
    reduction: 'Reduction',
    not_filled: 'Not filled',
    please_select: 'Please select',
    search_by_name: 'Search by name',
    search_by_name_or_id: 'Search by ID/NAME',
    search_by_id_name_tag: 'Search by ID/NAME/TAG',
    personal_information: 'Personal Information',
    exit_system: 'Exit System',
    verification: 'Verification',
    system_parameter_setting: 'System Parameter Setting',
    connection_successful: 'Connection successful',
    connection_failed: 'Connection failed',
    save_failed: 'Saved failed',
    host_cannot_be_empty: 'Host cannot be empty',
    port_cannot_be_empty: 'Port cannot be empty',
    account_cannot_be_empty: 'Account cannot be empty',
    title: 'Title',
    custom: 'Custom',
    select_date: 'Select date',
    calendar_heatmap: 'Calendar Heatmap',
    months_1: 'Jan',
    months_2: 'Feb',
    months_3: 'Mar',
    months_4: 'Apr',
    months_5: 'May',
    months_6: 'Jun',
    months_7: 'Jul',
    months_8: 'Aug',
    months_9: 'Sep',
    months_10: 'Oct',
    months_11: 'Nov',
    months_12: 'Dec',
    weeks_0: 'Sun',
    weeks_1: 'Mon',
    weeks_2: 'Tues',
    weeks_3: 'Wed',
    weeks_4: 'Thur',
    weeks_5: 'Fri',
    weeks_6: 'Sat',
    test_unit: 'tests',
    remove: 'Remove',
    next_level: "Next level",
    remove_cancel: 'Remove Cancel',
    remove_success: 'Remove Success',
    tips: 'The authentication information has expired, please login again',
    not_performed_yet: 'Not performed yet',
    incorrect_input: 'Incorrect input',
    delete_confirm: 'Please enter the following to confirm deletion:',
    login_username: 'ID or email',
    input_login_username: 'Please input the user ID or email',
    input_name: 'Please enter name',
    please_save: 'Please save first',
    formatErr: 'Format Error',
    id: 'ID',
    cannot_be_null: 'not null ',
    required: "{0} is required",
    millisecond: 'ms',
    please_upload: 'Please upload file',
    please_fill_path: 'Please fill in the path',
    reference_documentation: "Reference documentation",
    already_exists: 'The name already exists',
    modifier: 'Modifier',
    validate: "Validate",
    batch_add: "Batch add",
    check_project_tip: "Create or select the project first",
    auth_redirect_tip: 'Jump to the authentication source page for authentication',
    tag_tip: "Enter Enter to Add Label",
    node_name_tip: "The name cannot contain'\\'",
    more_operator: "More operator",
    mock: "Mock settings",
    table: {
      select_tip: "Item {0} data is selected"
    },
    date: {
      select_date: 'Select date',
      start_date: 'Start date',
      end_date: 'End date',
      select_date_time: 'Select date and time',
      start_date_time: 'Start date and time',
      end_date_time: 'End date time',
      range_separator: "To",
      data_time_error: "Start date cannot be later than the end date",
    },
    trigger_mode: {
      name: "Trigger Mode",
      manual: "Manual trigger",
      schedule: "Scheduled Task",
      api: "API call",
      case: "Case"
    },
    adv_search: {
      title: 'Advanced Search',
      combine: 'Combined query',
      test: "Test",
      project: "Project",
      search: "Query",
      reset: "Reset",
      and: 'All',
      or: 'any one',
      operators: {
        is_empty: "Is empty",
        is_not_empty: "Is not empty",
        like: "Contains",
        not_like: "Not included",
        in: "Belong to",
        not_in: "Not belonging",
        gt: ">",
        ge: ">=",
        lt: "<",
        le: "<=",
        equals: "=",
        not_equals: "!=",
        between: "Between",
        current_user: "Current user"
      }
    },
    monitor: "monitor",
    all_label: {
      case: "all",
      review: "all"
    },
    image: 'Image',
    tag: 'Tag',
    module: {
      select_module: "Select module",
      default_module: "Default module",
    },
    report_statistics: {
      title: "Report Statistics",
      test_case_analysis: "Test case analysis",
      test_case_activity: "Test case activity",
      name: "Report",
      excel: "Excel",
      add_case: "Add case",
      change_case: "Change case",
      type: "Type",
      options: "Options",
      chart: "Chart",
      line: "Line",
      bar: "Bar",
      desc: "Desc",
      asc: "Asc",
    }
  },
  license: {
    title: 'Authorization management',
    corporation: 'corporation',
    time: 'Authorization time',
    product: 'product',
    edition: 'edition',
    licenseVersion: 'licenseVersion',
    count: 'count',
    valid_license: 'valid license',
    show_license: 'show license',
    valid_license_error: 'validate license error',
    status: 'valid state',
    valid: 'valid',
    invalid: 'invalid',
    expired: 'expired',
  },
  display: {
    title: 'Theme',
    logo: 'System LOGO',
    loginLogo: 'Login page upper left corner LOGO',
    loginImage: 'Picture on the right side of the login page',
    loginTitle: 'Login page prompt information',
    pageTitle: 'Page Title',
  },
  system_config: {
    base_config: 'Base Config',
    base: {
      url: 'Website URL',
      url_tip: 'example：http://localhost:8081',
      url_is_null: 'The current site URL cannot be empty'
    },
    prometheus_config: 'Prometheus Host',
    prometheus: {
      host: 'Prometheus Host',
      host_tip: 'example: http://ms-prometheus:9090',
      host_is_null: 'Prometheus Host cannot be empty'
    }
  },
  workspace: {
    create: 'Create Workspace',
    update: 'Update Workspace',
    delete: 'Delete Workspace',
    delete_confirm: 'Deleting the workspace will delete all resources (such as related projects, test cases, etc.) under the workspace. Are you sure you want to delete?',
    add: 'Add Workspace',
    input_name: 'Please enter a workspace name',
    search_by_name: 'Search by name',
    organization_name: 'Organization Name',
    please_choose_organization: 'Please Choose Organization',
    batch_choose_workspace: 'Please choose organizations',
    please_select_a_workspace_first: 'Please select a workspace first!',
    none: 'None Workspace',
    select: 'Select Workspace',
    special_characters_are_not_supported: 'Incorrect format (special characters are not supported and cannot end with \'-\')',

  },
  organization: {
    create: 'Create Organization',
    modify: 'Modify',
    delete: 'Delete Organization',
    delete_confirm: 'Deleting this organization will delete all resources (such as related workspaces, projects, test cases, etc.) under this organization. Are you sure you want to delete?',
    input_name: 'Please enter a organization name',
    select_organization: 'Please select organization',
    search_by_name: 'Search by name',
    special_characters_are_not_supported: 'Incorrect format (special characters are not supported and cannot end with \'-\')',
    none: 'None Organization',
    select: 'Select Organization',
    service_integration: 'Service integration',
    defect_manage: 'Project management platform',
    message_settings: 'Message settings',
    message: {
      jenkins_task_notification: 'Jenkins task notification',
      test_plan_task_notification: 'Test plan task notification',
      test_review_task_notice: 'Test review task notice',
      defect_task_notification: 'Defect task notification',
      create_new_notification: 'Create a new notification',
      mail_template_example: 'Mail template',
      robot_template: 'Robot template',
      select_events: 'Select event',
      select_receiving_method: 'Select receiving method',
      mail: 'mail',
      nail_robot: 'Nail robot',
      enterprise_wechat_robot: 'Enterprise wechat robot',
      lark: "Flying Book Robot",
      notes: '1. Nail and create a custom robot in the enterprise group, and then copy the webhook address on our platform;\n' +
        '\n' +
        '2. Robots are selected as swarm robots, and "custom keyword" is selected for security verification: "task notification";\n' +
        '\n' +
        '3. When selecting the receiver, it must be the person included in the group you created. The mobile phone number of the receiver is required and it is the mobile phone number used by the nailing enterprise,',
      message: 'Event, receiver and receiving method are required\n' +
        '\n',
      message_webhook: 'Webhook is required when the receiving mode is nail or enterprise robot or lark',
      template: "Template"
    },
    integration: {
      select_defect_platform: 'Please select the defect management platform to be integrated:',
      basic_auth_info: 'Basic Auth account information:',
      api_account: 'API account',
      api_password: 'API password',
      app_name: 'APP name',
      app_key: 'APP key',
      account: 'Account',
      password: 'Password',
      jira_url: 'JIRA url',
      jira_issuetype: 'JIRA issue type',
      jira_storytype: 'JIRA story type',
      input_api_account: 'please enter account',
      input_api_password: 'Please enter password',
      input_jira_url: 'Please enter Jira address, for example: https://metersphere.atlassian.net/',
      input_jira_issuetype: 'Please enter the issue type',
      input_jira_storytype: 'Please enter the story type',
      zentao_url: 'Zentao url',
      input_zentao_url: 'Please enter Zentao address, for example: http://xx.xx.xx.xx/zentao/',
      use_tip: 'Usage guidelines:',
      use_tip_tapd: 'Basic Auth account information is queried in "Company Management-Security and Integration-Open Platform"',
      use_tip_jira: 'Jira software server authentication information is account password, Jira software cloud authentication information is account + token (account settings-security-create API token)',
      use_tip_zentao: 'The account password is a Zentao account with corresponding permissions, and the account needs to have super model calling interface permissions',
      use_tip_two: 'After saving the Basic Auth account information, you need to manually associate the ID/key in the MeterSphere project',
      link_the_project_now: 'Link the project now',
      cancel_edit: 'Cancel edit',
      cancel_integration: 'Cancel integration',
      cancel_confirm: 'Confirm cancellation of integration ',
      successful_operation: 'Successful operation',
      not_integrated: 'The platform is not integrated',
      choose_platform: 'Please choose an integrated platform',
      verified: 'Verified'
    }
  },
  project: {
    name: 'Project name',
    recent: 'Recent Projects',
    create: 'Create Project',
    edit: 'Edit Project',
    delete: 'Delete project',
    delete_confirm: 'Deleting this project will delete all test resources under this project. Are you sure you want to delete?',
    delete_tip: 'Deleting this project will delete all test resources under this project. Are you sure you want to delete?',
    file_delete_tip: 'Deleting this project file: {0}？',
    search_by_name: 'Search by name',
    search_by_name_jar: 'Search by name/jar',
    input_name: 'Please enter a workspace name',
    owning_workspace: 'Owning Workspace',
    please_choose_workspace: 'Please select Workspace',
    special_characters_are_not_supported: 'Incorrect format (special characters are not supported and cannot end with \'-\')',
    tapd_id: 'TAPD Project ID',
    jira_key: 'JIRA Project key',
    zentao_id: 'Zentao Project ID',
    manager: 'Manager',
    no_data: 'No Data',
    select: 'Select',
    repeatable: 'Interface definition URL repeatable',
    upload_file_again: 'Upload again'
  },
  member: {
    create: 'Create',
    modify: 'Modify',
    delete_confirm: 'Are you sure you want to delete this Member?',
    please_choose_member: 'Please Choose Member',
    search_by_name: 'Search by name',
    modify_personal_info: 'Modify Personal Information',
    edit_password: 'Edit Password',
    edit_information: 'Edit Information',
    input_name: 'Please enter a user name',
    input_email: 'Please enter a email',
    special_characters_are_not_supported: 'Special characters are not supported',
    mobile_number_format_is_incorrect: 'Mobile number format is incorrect',
    email_format_is_incorrect: 'Email format is incorrect',
    password_format_is_incorrect: 'Valid password: 8-30 digits, English upper and lower case letters + numbers + special characters (optional)',
    old_password: 'Old Password',
    new_password: 'New Password',
    repeat_password: 'Repeat',
    inconsistent_passwords: 'The two passwords entered are inconsistent',
    remove_member: 'Are you sure you want to remove this member',
    org_remove_member: 'Removing the user from the organization will also remove permissions from all workspaces under the organization. Are you sure you want to remove the member ?',
    input_id_or_email: 'Please enter user ID, or user Email',
    no_such_user: 'Without this user information, please enter the correct user ID or user Email!',
  },
  user: {
    create: 'Create',
    modify: 'Modify',
    input_name: 'Please enter a user name',
    input_id: 'Please enter a ID',
    input_email: 'Please enter a email',
    input_password: 'Please enter a password',
    input_phone: 'Please enter phone number',
    special_characters_are_not_supported: 'Special characters are not supported',
    mobile_number_format_is_incorrect: 'Mobile number format is incorrect',
    email_format_is_incorrect: 'Email format is incorrect',
    delete_confirm: 'Are you sure you want to delete this User?',
    apikey_delete_confirm: 'Are you sure you want to delete this API Key?',
    input_id_placeholder: 'Please enter ID (Chinese characters are not supported)',
    source: 'Source',
    button: {
      add_workspace_batch: 'Batch add user to workspace',
      add_user_role_batch: 'Batch add user role',
    }
  },
  role: {
    please_choose_role: 'Please Choose Role',
    admin: 'Admin',
    org_admin: 'Org_Admin',
    org_member: 'Org Member',
    test_manager: 'Test Manager',
    test_user: 'Test User',
    test_viewer: 'Read-only User',
    add: 'Add Role',
  },
  report: {
    api_test_report: 'Api Test Report',
    load_test_report: 'Load Test Report',
    test_plan_report: 'Test Plan Report',
    recent: 'My recent Report',
    search_by_name: 'Search by Name',
    test_name: 'Test',
    test_overview: 'Test Overview',
    test_request_statistics: 'Test Request Statistics',
    test_error_log: 'Test Error Log',
    test_log_details: 'Test Log Details',
    test_monitor_details: 'Test Monitor Details',
    test_details: 'Test Details',
    test_duration: 'Current Execution Time：{0} minutes {1} seconds',
    test_start_time: 'Start Execution Time',
    test_end_time: 'Plan End Time',
    test_stop_now: 'Test Stop Now',
    test_stop_now_confirm: 'Are you sure you want to stop the current test immediately?',
    test_rerun_confirm: 'Are you sure you want to rerun the current test immediately?',
    test_stop_success: 'Test stop successfully',
    downloadJtl: 'Download JTL',
    test_execute_again: 'Test Execute Again',
    export: 'Export',
    export_to_ms_format: 'Export to MeterSphere format',
    export_to_swagger3_format: 'Export to Swagger3.0 format',
    compare: 'Compare',
    generation_error: 'Report generation error, unable to view, please check log details!',
    being_generated: 'Report is being generated...',
    delete_confirm: 'Confirm delete: ',
    start_status: 'The test is in the beginning state, we will automatically display it on the page after we generate the report!',
    run_status: 'The test is running, please check the report later！',
    user_name: 'Creator',
    project_name: 'Project Name',
    force_stop_tips: '<strong>Terminating</strong> the servers will immediately kill the servers and the JTL files will be lost.',
    stop_tips: 'A <strong>Graceful shutdown</strong> will archive the JTL files and then stop the servers.',
    force_stop_btn: 'Terminating',
    stop_btn: 'Graceful shutdown',
    not_exist: "Test report does not exist",
    batch_delete: "Delete reports in bulk",
    delete_batch_confirm: 'Confirm batch delete report',
    response_time: 'Response Time(s)',
    max_users: 'VUs'
  },
  load_test: {
    concurrency_thread_group: 'Concurrent read group',
    thread_group: 'ThreadGroup',
    completed_test_report: 'Completed test report',
    test: 'Test',
    name: 'Test Name',
    same_project_test: 'Only tests within the same project can be run',
    run: 'One click operation',
    operating: 'Operating',
    pressure_prediction_chart: 'Pressure Prediction Chart',
    recent: 'My recent Tests',
    search_by_name: 'Search by name',
    project_name: 'Project',
    delete_confirm: 'Are you sure want to delete test: ',
    input_name: 'Please enter name',
    select_project: 'Please select project',
    save_and_run: 'Save and execute',
    basic_config: 'Scene Configuration',
    pressure_config: 'Pressure configuration',
    advanced_config: 'Advanced Configuration',
    runtime_config: 'Runtime Configuration',
    is_running: 'Test is running! ',
    test_name_is_null: 'Test name cannot be empty! ',
    project_is_null: 'Project cannot be empty! ',
    jmx_is_null: 'Must contain a JMX file, and can only contain a JMX file!',
    file_name: 'File name',
    file_size: 'File size',
    file_type: 'File Type',
    file_status: 'File Status',
    last_modify_time: 'Modify time',
    upload_tips: 'Drag files here, or <em> click to upload </em>',
    upload_type: 'Only JMX/CSV/JAR files can be uploaded',
    related_file_not_found: "No related test file found!",
    delete_file_confirm: 'Confirm delete file:',
    file_size_limit: "The number of files exceeds the limit！",
    delete_file: "The file already exists, please delete the file with the same name first!",
    thread_num: 'Concurrent users:',
    input_thread_num: 'Please enter the number of threads',
    duration: 'Duration time',
    granularity: 'Aggregation time (seconds)',
    input_duration: 'Please enter a duration',
    rps_limit: 'RPS Limit:',
    input_rps_limit: 'Please enter a limit',
    ramp_up_time_within: 'In',
    ramp_up_time_minutes: 'seconds, separate',
    ramp_up_time_seconds: 'seconds add concurrent users',
    iterate_num: 'Iterations: ',
    by_iteration: 'By iterations',
    by_duration: 'By duration',
    ramp_up_time_times: 'add concurrent users',
    advanced_config_error: 'Advanced configuration verification failed',
    domain_bind: 'Domain bind',
    domain: 'Domain',
    enable: 'Enable',
    ip: 'IP',
    input_ip: 'Please enter the correct IP address！',
    input_domain: 'Please enter the correct domain！',
    params: 'Parameters',
    param_name: 'Name',
    param_value: 'Value',
    domain_is_duplicate: 'Domain is duplicated',
    param_is_duplicate: 'Parameter name is duplicate',
    domain_ip_is_empty: 'Domain and IP cannot be empty',
    param_name_value_is_empty: 'Parameters cannot be empty',
    connect_timeout: 'Timeout to establish a connection',
    response_timeout: 'Timeout to response',
    custom_http_code: 'Custom HTTP response success status code',
    separated_by_commas: 'Separated by commas',
    serialize_threadgroups: 'Whether the scene is executed sequentially',
    autostop_threadgroups: 'Auto stop enable',
    reaches_duration: 'Delay',
    autostop_delay: 'seconds before stopping the test',
    create: 'Create Test',
    select_resource_pool: 'Please Select Resource Pool',
    resource_pool_is_null: 'Resource Pool is empty',
    download_log_file: 'Download',
    user_name: 'Creator',
    special_characters_are_not_supported: 'Test name does not support special characters',
    pressure_config_params_is_empty: 'Pressure configuration parameters cannot be empty!',
    schedule_tip: 'The interval must not be less than the pressure measuring time',
    delete_threadgroup_confirm: 'Confirm delete scenario: ',
    scenario_list: 'Scenario List',
    scenario_name: 'Scenario Name',
    upload_jmx: 'Upload JMX',
    exist_jmx: 'Existed Files',
    other_resource: 'Resource Files',
    upload_file: 'Upload Files',
    load_exist_file: 'Load Project Files',
    load_exist_jmx: 'Load Project JMX',
    threadgroup_at_least_one: 'At least one ThreadGroup is enabled',
    load_api_automation_jmx: 'Import API automation scenario',
    project_file_exist: "The file already exists in the project, please import it directly",
    project_file_update_type_error: 'Updated file types must be consistent',
    report: {
      diff: "Compare"
    },
  },
  api_test: {
    creator: "Creator",
    save_and_run: "Save and Run",
    run: "Run",
    running: "Running",
    reset: "Rest",
    select_all: "Select all",
    invert_select: "Invert select",
    select_or_invert: "Select all/Invert select",
    input_name: "Please enter the test name",
    select_project: "Please select project",
    variable_name: "Variable name",
    variable: "Variable",
    copied: "copied",
    key: "Key",
    value: "Value",
    create_performance_test: "Create Performance Test",
    export_config: "Export",
    enable_validate_tip: "No request available",
    copy: "Copy Test",
    jar_config: {
      title: "The Jar Package Management",
      jar_file: "Jar package",
      delete_tip: "The deletion takes effect after the service is restarted",
      file_exist: "The name already exists in the project",
      upload_limit_size: "Upload file size cannot exceed 30MB!",
    },
    batch_menus: {
      select_all_data: "Select all datas({0})",
      select_show_data: "Select show datas({0})",
    },
    mock: {
      create_error: "Api info is not saved",
      table: {
        name: "Name",
        tag: "Tag",
        creator: "Creator",
        status: "Status",
        update_time: "Update time"
      },
      expect_detail: "Expect",
      base_info: "Base info",
      req_param: "Request params",
      rsp_param: "Response Params",
      delete_mock_expect: "Confirm to delete this expect info ?",
    },
    definition: {
      api_title: "Api test",
      case_title: "Test Case",
      doc_title: "Document",
      api_name: "Api name",
      api_status: "Api status",
      api_type: "Api type",
      api_path: "Api path",
      api_principal: "Api principal",
      api_last_time: "Last update time",
      api_case_number: "Number use case",
      api_case_status: "Ise case status",
      api_case_passing_rate: "Use case pass rate",
      create_tip: "Note: Detailed interface information can be filled out on the edit page",
      api_import: "Api Import",
      check_select: "Please check the API",
      select_comp: {
        no_data: "No Data",
        add_data: "Add Data"
      },
      request: {
        grade_info: "Filter by rank",
        grade_order_asc: "from low to high by use case level",
        grade_order_desc: "from high to low by use case level",
        create_time_order_asc: "by creation time from front to back",
        create_time_order_desc: "from back to front by creation time",
        update_time_order_asc: "by update time from front to back",
        update_time_order_desc: "from back to front by update time",
        run_env: "Operating environment",
        select_case: "Search use cases",
        select_api: "Search api",
        case: "Case",
        title: "Create api",
        path_info: "Please enter the URL of the interface, such as /api/demo/#{id}, where id is the path parameter",
        path_all_info: "Please enter the complete test address",
        fast_debug: "Fast debug",
        close_all_label: "close all label",
        save_as: "Save as new interface",
        load_case: "Load use case",
        save_as_case: "Save as new use case",
        update_api: "Update interface",
        body_form_data: "form-data",
        body_x_www_from_urlencoded: "x-www-form-urlencoded",
        body_raw: "raw",
        body_binary: "binary",
        body_json: "json",
        body_xml: "xml",
        auth_config: "Authentication configuration",
        rest_param: "Rest parameter",
        query_param: "Query parameter",
        verification_method: "Verification method",
        verified: "verified",
        encryption: "encryption",
        req_param: "Request parameter",
        res_param: "Response content",
        batch_delete: "Batch deletion",
        delete_confirm: "Confirm deletion",
        delete_case_confirm: "Confirm case deletion",
        delete_confirm_step: "Confirm deletion step",
        assertions_rule: "Assertion rule",
        response_header: "Response header",
        response_body: "Response body",
        response_template: "Response template",
        console: "Console",
        status_code: "Status code",
        query_info: "Follow the address bar? The following parameters, such as updateapi?id=112",
        rest_info: "Slash/separated parameters in the address bar, such as updateapi/{id}",
        auth_config_info: "Request requires permission verification",
        pre_script: "Prescript",
        post_script: "Postscript",
        extract_param: "Extract parameters",
        add_module: "Add module",
        edit_api: "Edit Api",
        test_plan_select: "Please select test plan",
        create_info: 'Create',
        update_info: 'Update',
        batch_edit: "Batch edit",
        batch_move: "Batch move",
        path_valid_info: "The request path is invalid",
        other_config: "Other Config",
        message_template: "Message Template",
        tcp_parameter_tip: "The request parameters can be referenced in the request template ${XXX}",
        esb_table: {
          name: "name",
          type: "type",
          length: "length",
          required: "Required",
          desc: "Description",
          value: "Data",
          not_required: "Not required",
        },
        esb_copy_confirm: "Copy this node data struct",
        esb_title: "You can use ${name} or ${parent name.child name} to generate xml struct in report template",
      },
      document: {
        order: "Order",
        create_time_sort: "From back to front by create time",
        edit_time_positive_sequence: "From front to back by update time",
        edit_time_Reverse_order: "From back to front by update time",
        request_method: "Request method",
        request_interface: "Request interface",
        search_by_api_name: "Search by api name",
        request_info: "Request info",
        request_head: "Request head",
        request_param: "Param",
        request_body: "Request body",
        example_presentation: "Example presentation",
        response_info: "Response info",
        response_head: "Response head",
        response_body: "Response body",
        response_code: "Response code",
        table_coloum: {
          name: "name",
          value: "value",
          is_required: "Is it required",
          desc: "Description",
          type: "Type",
          default_value: "Default value",
        },
        data_set: {
          all: "All",
          none: "None"
        },
      }
    },
    automation: {
      open_expansion: "One-click expansion",
      close_expansion: "One-click storage",
      constant: "constant",
      counter: "counter",
      random: "random",
      view_scene_variables: "View scene variables",
      open_scene: "Open scene",
      save_as_api: "Save as api",
      delete_step: "Delete step",
      reference_deleted_info: "Reference scene has been deleted",
      follow_people: "Follow people",
      create_tag: "Create tag",
      scenario_step: "Ccenario step",
      step_total: "Step total",
      scenario_total: "Scenario variable",
      api_list_import: "Api list import",
      external_import: "External import",
      wait_controller: "Wait controller",
      if_controller: "If controller",
      loop_controller: "Loop Controller",
      scenario_import: "Scenario import",
      customize_script: "Customize script",
      customize_req: "Customize req",
      reference_info: "Reference info",
      scenario_test: "Scenario test",
      scenario_list: "Scenario List",
      add_scenario: "Add scenario",
      scenario_name: "Scenario name",
      case_level: "Case level",
      tag: "Tag",
      creator: "Creator",
      update_time: "Update time",
      step: "Step",
      last_result: "Last result",
      passing_rate: "Passing rate",
      success: "Success",
      fail: "Fail",
      saved: "Saved",
      trash: "Trash",
      edit: "Edit",
      execute: "Execute",
      copy: "Copy",
      remove: "Remove",
      view_ref: "View ref",
      case_ref: "Case ref",
      schedule: "Scheduled Task",
      scenario_ref: "Scenario ref",
      plan_ref: "Plan ref",
      batch_add_plan: "Add plan",
      batch_execute: "Batch execute",
      scenario: {
        principal: "principal",
        select_principal: "Select principal",
        follow_people: "Follow people",
        select_table: "Select table",
        select_all: "Select all",
        check_case: "Please check the Scene Use Case"
      },
      report_name_info: 'Please enter the registration name',
      save_case_info: 'Please save the use case first',
      reference_deleted: 'Reference deleted',
      loop_name: "Loop",
      loop_content: "The default is on, when there is only one request in the loop, it can be turned on/off; when there is more than one request in the loop, it can only be turned on。",
      loop_return_val: "Define variable name",
      loop_input_val: "Variable prefix",
      loop_message: "There is more than one request in the current cycle and cannot be closed",
    },
    environment: {
      create: 'Create environment',
      name: "Environment Name",
      socket: "Socket",
      condition_enable: "Activation conditions",
      globalVariable: "Global Variable",
      environment_list: "Environment List",
      environment_config: "Environment Config",
      config_environment: "Config Environment",
      copy_environment: "copy environment",
      environment: "Environment",
      select_environment: "Please select environment",
      please_save_test: "Please Save Test First",
      common_config: "Common Config",
      http_config: "HTTP Config",
      database_config: "Database Config",
      tcp_config: "TCP Config",
      import: "Import Environment",
    },
    scenario: {
      scenario: "Scenario",
      dubbo: "Dubbo Config",
      config: "Scenario Config",
      input_name: "Please enter the scenario name",
      name: "Scenario Name",
      base_url: "Base URL",
      base_url_description: "Base URL as URL prefix for all requests",
      url_invalid: "Invalid URL",
      variables: "Variables",
      headers: "Headers",
      kv_description: "Variables are available for all requests",
      copy: "Copy scenario",
      delete: "Delete scenario",
      disable: "Disable",
      enable: "Enable",
      create_scenario: "Create scenario",
      select_scenario: "Select scenario",
      scenario_request: "Scenario/Request",
      enable_disable: "Enable/Disable",
      test_name: "Test Name",
      reference: "Reference",
      clone: "Copy",
      cant_reference: 'Historical test files, can be referenced after re-saving'
    },
    request: {
      debug: "Debug",
      copy: "Copy request",
      delete: "Delete request",
      input_name: "Please enter the request name",
      input_url: "Please enter the request URL",
      input_path: "Please enter the request path",
      name: "Name",
      content_type: "Content Type",
      method: "Method",
      url: "URL",
      path: "Path",
      address: "Address",
      refer_to_environment: "Use Environment",
      please_configure_socket_in_environment: "Please Configure Path In The Environment",
      please_configure_environment_in_scenario: "Please Configure Environment In The Scenario",
      please_add_environment_to_scenario: "Please Add The Environment Configuration To The Scenario First",
      url_description: "etc: https://fit2cloud.com",
      path_description: "etc：/login",
      parameters: "Query parameters",
      jmeter_func: "JMeter Functions",
      parameters_filter_example: "Example",
      parameters_filter_tips: "Only support MockJs function result preview",
      parameters_advance: "Advanced parameter settings",
      parameters_preview: "Preview",
      parameters_mock_filter_tips: "Please enter keywords to filter",
      parameters_pre_request: "Pre-request extraction",
      parameters_advance_mock: "Mock Data",
      parameters_advance_add_func: "Add Function",
      parameters_advance_add_func_limit: "Support up to 5 functions",
      parameters_advance_add_func_error: "Please select function first",
      parameters_advance_add_param_error: "Please enter function parameters",
      parameters_desc: "Parameters will be appended to the URL e.g. https://fit2cloud.com?Name=Value&Name2=Value2",
      headers: "Headers",
      body: "Body",
      body_kv: "Key Value",
      body_text: "Raw",
      timeout_config: "Timeout Config",
      connect_timeout: "Connect Timeout",
      response_timeout: "Response Timeout",
      follow_redirects: "Follow Redirects",
      do_multipart_post: "Use multipart/form-data for POST",
      body_upload_limit_size: "The file size does not exceed 500 MB",
      condition: "condition",
      condition_variable: "Variable, e.g: ${var}",
      wait: "wait",
      assertions: {
        label: "Assertion",
        text: "Text",
        regex: "Regex",
        response_time: "Response Time",
        select_type: "Choose type",
        select_subject: "Subject",
        select_condition: "Condition",
        contains: "Contains",
        not_contains: "Not contains",
        equals: "Equals",
        start_with: "Start with",
        end_with: "End With",
        value: "Value",
        expect: "Expect Value",
        expression: "Expression",
        response_in_time: "Response in time",
        ignore_status: "Ignore Status",
        add: "Add",
        script_name: "Script name",
        script: "Script",
        variable_name: "Variable name",
        set_failure_status: "Set failure status",
        set_failure_msg: "Set failure message",
        json_path_add: "Add JONPATH Assertions",
        json_path_err: "The response result is not in JSON format",
        json_path_suggest: "JSONPath Assertion Suggest",
        json_path_clear: "Clear JSONPath Assertion",
        debug_first: "First, debug to get the response",
        suggest_tip: "Click the note to add the JSONPath assertion",
      },
      extract: {
        label: "Extract from response",
        select_type: "Choose type",
        description: "Extract data from the response and store it in variables. Use the variables in subsequent requests.",
        regex: "Regex",
        multiple_matching: "Multiple matching",
        regex_expression: "Regular expression",
        json_path_expression: "JSONPath expression",
        xpath_expression: "XPath expression",
        suggest_tip: "Click the note to add the JSONPath extraction",
        json_path_suggest: "JSONPath Extraction Suggest",
        json_path_clear: "Clear JSONPath Extraction",
      },
      processor: {
        pre_exec_script: "PreProcessor",
        post_exec_script: "PostProcessor",
        code_template: "Code template",
        bean_shell_processor_tip: "Currently only BeanShell scripts are supported",
        code_template_get_variable: "Get Variable",
        code_template_set_variable: "Set Variable",
        code_template_get_global_variable: "Get Global Variable",
        code_template_set_global_variable: "Set Global variable",
        code_template_get_response_header: "Get Response Header",
        code_template_get_response_code: "Get Response Code",
        code_template_get_response_result: "Get Response Result",
        code_add_report_length: "Add report length to head",
        code_hide_report_length: "Hide report length"
      },
      dubbo: {
        protocol: "protocol",
        input_interface: "Please enter the interface",
        input_method: "Please enter the method",
        input_config_center: "Please enter the config center",
        get_provider_success: "get provider list to finish",
        input_registry_center: "Please enter the registry center",
        input_consumer_service: "Please enter the consumer & service",
        check_registry_center: "Can't get interface list, please check the registry center",
      },
      sql: {
        dataSource: "Data Source",
        sql_script: "Sql Script",
        timeout: "Timeout(ms)",
        database_driver: "Driver",
        database_url: "Database URL",
        username: "Username",
        password: "Password",
        pool_max: "Max Number of Configuration",
        query_timeout: "Max Wait(ms)",
        name_cannot_be_empty: "SQL request name cannot be empty",
        dataSource_cannot_be_empty: "SQL request datasource cannot be empty",
        result_variable: "Result variable",
        variable_names: "Variable names",
      },
      tcp: {
        server: "Server Name or IP",
        port: "Port Number",
        connect: "Connect(ms)",
        response: "Response(ms)",
        re_use_connection: "Re-use connection",
        no_delay: "Set NoDelay",
        close_connection: "Close connection",
        so_linger: "SO LINGER",
        eol_byte: "End of line byte value",
        request: "Text to Send",
        username: "Username",
        password: "Password",
        login: "Login Configuration",
        server_cannot_be_empty: "Server name or IP cannot be empty",
      },
    },
    api_import: {
      label: "Import",
      title: "API test import",
      data_format: "Data format",
      file_size_limit: "The file size does not exceed 20 M",
      tip: "Instructions",
      export_tip: "Export Tip",
      ms_tip: "Support for MeterSphere JSON format",
      ms_export_tip: "Export jSON-formatted files via MeterSphere website or browser plug-ins",
      har_export_tip: "Export HAR files by browser dev-tool",
      esb_export_tip: "Can not export esb files now",
      swagger_tip: "Swagger 2.0 and 3.0 json files are supported",
      har_tip: "Only HAR files are supported",
      esb_tip: "Only ESB xlsx files are supported",
      postman_tip: "Only Postman Collection V2.1 json files are supported",
      postman_export_tip: "Export the test collection by Postman",
      swagger_export_tip: "Export jSON-formatted files via Swagger website",
      jmeter_export_tip: "Generating JMX file through JMeter",
      jmeter_tip: "JMX files supporting JMeter 5.2",
      suffixFormatErr: "The file format does not meet the requirements",
      swagger_url_import: "Import using URL",
      timing_synchronization: "Timing synchronization",
      next_synchronization_time: "Next synchronization time",
      ms_env_import_file_limit: "It supports JSON format files exported through metersphere",
      file_exceed_limit: "The number of files exceeds the limit",
    },
    home_page: {
      unit_of_measurement: "",
      unit_of_count: "",
      unit_of_times: "times",
      formula: {
        completion: "finished api / all api * 100%",
        coverage: "apis whitch have test case / all apis * 100%",
        pass: "scenarios whitch final execute is sucess / all scenarios * 100%",
        success: "execute success count number / all execute count number * 100%",
        interface_coverage: "api whitch in scenario's step / all api * 100%",
        review: "reviewd cases / all cases * 100%",
        testplan_coverage: "relevance function cases / all function cases * 100%",
      },
      api_count_card: {
        title: "API count",
      },
      test_case_count_card: {
        title: "Api test case count",
      },
      test_scene_count_card: {
        title: "Scene test case count",
      },
      schedule_task_count_card: {
        title: "Schedule task count",
      },
      detail_card: {
        running: "Running",
        not_started: "Not started",
        finished: "Finished",
        uncoverage: "Uncoverage",
        coverage: "Coverage",
        unexecute: "Unexecute",
        execution_failed: "Execution failed",
        execution_pass: "Execution passed",
        failed: "Failure",
        success: "Success",
        rate: {
          completion: "Completion rate",
          coverage: "Coverage rate",
          pass: "Pass rate",
          success: "Success rate",
          interface_coverage: "Interface coverage",
        },
      },
      api_details_card: {
        title: "API",
        this_week_add: "This week add:",
      },
      test_case_details_card: {
        title: "Test case",
        this_week_add: "This week add:",
        this_week_execute: "Executed {0} this week",
        executed: "Executed {0} in history",
        this_week_add_sm: "This week add:",
        this_week_execute_sm: "Executed {0}<br/> this week",
        executed_sm: "Executed {0}<br/> in history",
      },
      test_scene_details_card: {
        title: "Scene",
        this_week_add: "This week add:",
        this_week_execute: "Executed {0} this week",
        executed: "Executed {0} in history",
        this_week_add_sm: "This week add:",
        this_week_execute_sm: "Executed {0}<br/> this week",
        executed_sm: "Executed {0}<br/> in history",
      },
      schedule_task_details_card: {
        title: "Schedule task",
        this_week_add: "Added {0} this week",
        this_week_execute: "Executed {0} this week",
        executed: "Executed {0} in history",
        this_week_add_sm: "Added {0}<br/> this week",
        this_week_execute_sm: "Executed {0}<br/> this week",
        executed_sm: "Executed {0}<br/> in history",
      },
      failed_case_list: {
        title: "Top 10 failure cases about test plan in the past 7 days",
        table_coloum: {
          index: "Ranking",
          case_name: "Case name",
          case_type: "Case Type",
          test_plan: "Test plan",
          failure_times: "Failure times",
        },
        table_value: {
          case_type: {
            api: "Api case",
            scene: "Scenario case",
            load: "Load case"
          }
        }
      },
      running_task_list: {
        title: "Running schedule task",
        table_coloum: {
          index: "Index",
          scenario: "Scene",
          task_type: "Task Type",
          run_rule: "Rule",
          task_status: "Status",
          next_execution_time: "Next Execution Time",
          create_user: "Creator",
          update_time: "Update time",
        },
        scenario_schedule: "Scenario",
        test_plan_schedule: "Test plan",
        swagger_schedule: "swagger",
        confirm: {
          close_title: "Do you want to close this scheduled task？",
        }
      }
    }
  },
  api_report: {
    title: "Report",
    request: "Request",
    request_body: "Body",
    request_headers: "Headers",
    request_cookie: "Cookie",
    response: "Response",
    delete_confirm: 'Confirm delete : ',
    delete_batch_confirm: 'Confirm batch delete report',
    scenario_name: "Scenario name",
    response_time: "Response time(ms)",
    latency: "Latency",
    start_time: "Start Time",
    request_size: "Request Size",
    response_size: "Response Size",
    response_code: "Response Code",
    response_message: "Response Message",
    error: "Error",
    assertions: "Assertions",
    assertions_pass: "Passed Assertions",
    assertions_name: "Assertion Name",
    assertions_error_message: "Error Message",
    assertions_is_success: "Fail/Success",
    result: "Result",
    success: "Success",
    fail: "Fail",
    total: "Total",
    test_name: "Test",
    request_result: "Result",
    sub_result: "Sub Result",
    detail: "Report detail",
    delete: "Delete report",
    batch_delete: "Delete reports in bulk",
    running: "The test is reporting",
    not_exist: "Test report does not exist",
  },
  api_monitor: {
    to: "to",
    start_time: "Start Time",
    end_time: "End Time",
    today: "Today",
    this_week: "This Week",
    this_mouth: "This Mouth",
    please_search: "Please Search",
    date: "Date"
  },
  test_track: {
    related_requirements: 'Related requirements',
    please_related_requirements: 'Please select the requirements to associate',
    please_select_the_test_to_associate: "Please select the test to associate",
    person_responsible: "Person Responsible",
    test_track: "Track",
    confirm: "Confirm",
    cancel: "Cancel",
    planning_execution: "Planning&Execution",
    project: "Project",
    save: "Save",
    return: "Return",
    length_less_than: "The length less than",
    recent_plan: "My recent plan",
    recent_case: "My recent case",
    recent_review: "My recent review",
    pass_rate: "Pass rate",
    execution_result: ": Please select the execution result",
    actual_result: ": The actual result is empty",
    cancel_relevance_success: "Unlinked successfully",
    switch_project: "Switch project",
    case: {
      list: "List",
      minder: "Minder",
      minder_create_tip: "failed, unable to create its parent module in minder",
      check_select: "Please check the case",
      export_all_cases: 'Are you sure you want to export all use cases?',
      input_test_case: 'Please enter the associated case name',
      test_name: 'TestName',
      other: '--Other--',
      test_case: "Case",
      move: "Move case",
      case_list: "Test case list",
      create_case: "Create case",
      edit_case: "Edit case",
      view_case: "Test case",
      no_project: "There is no project in this workspace, please create the project first",
      priority: "Priority",
      type: "Type",
      method: "Method",
      auto: "Auto",
      manual: "Manual",
      create: "Create test case",
      case_type: "Case Type",
      name: "Test case name",
      module: "Module",
      maintainer: "Maintainer",
      steps: "Steps",
      number: "Number",
      prerequisite: "Prerequisite",
      step_desc: "Case step",
      expected_results: "Expected results",
      input_name: "Please enter name",
      input_module: "Please select module",
      input_maintainer: "Please select maintainer",
      input_priority: "Please select priority",
      input_type: "Please select type",
      input_method: "Please select method",
      input_prerequisite: "Please select prerequisite",
      input_demand_name: "Please input demand id or name",
      delete_confirm: "Confirm delete test case",
      delete: "Delete case",
      save_create_continue: "Save and create continue",
      please_create_project: "No project available, please create the project first",
      create_module_first: "Please create module first",
      relate_test: "Relate test",
      relate_test_not_find: 'The associated test does not exist, please check the test case',
      other_relate_test_not_find: 'Associated test name, please go to the third party platform to execute',
      batch_handle: 'Batch processing (select {0} item)',
      batch_update: 'Update the attributes of {0} cases',
      select_catalog: 'Please select use case catalog',
      updated_attr_value: 'The updated attribute value',
      batch_operate: 'Batch operation',
      please_select_attr: 'Please select attributes',
      please_select_attr_value: 'Please select the value corresponding to the attribute',
      batch_edit_case: 'Batch editing',
      batch_move_case: 'Batch move',
      batch_delete_case: 'Batch delete',
      batch_unlink: 'Batch Unlink',
      project_name: "Project",
      status: 'Review Status',
      status_prepare: 'Not reviewed',
      status_pass: 'Pass',
      status_un_pass: 'UnPass',
      cancel_relevance_project: "Disassociating the project will also cancel the associated test cases under the project",
      img_loading_fail: "Image failed to load",
      pdf_loading_fail: "PDF loading failed",
      upload_tip: "Only jpg, jpeg, png, docx, doc, pdf, xlsx, txt files can be uploaded",
      attachment: "Attachment",
      upload_time: "Upload Time",
      import: {
        import: "Import test case",
        case_import: "Import test case",
        download_template: "Download template",
        click_upload: "Upload",
        upload_limit: "Only XLS/XLSX/XMIND files can be uploaded, and no more than 20M",
        upload_xmind_format: "Upload files can only be .xmind format",
        upload_xmind: "Only xmind files can be uploaded, and no more than 800",
        upload_limit_count: "Only one file can be uploaded at a time",
        upload_limit_format: "Upload files can only be XLS, XLSX format!",
        upload_limit_size: "Upload file size cannot exceed 20MB!",
        upload_limit_other_size: "Upload file size cannot exceed",
        success: "Import success！",
        importing: "Importing...",
        excel_title: "Excel ",
        xmind_title: "Xmind",
        import_desc: "Import instructions",
        import_file: "upload files",
      },
      export: {
        export: "Export cases"
      }
    },
    plan: {
      test_plan: "Plan",
      create_plan: "Create test plan",
      edit_plan: "Edit test plan",
      plan_name: "Test plan name",
      plan_project: "Project",
      related_project: "Related Project",
      related_tip: "After linking the project, you can add test cases under the linking project to the test plan list",
      plan_stage: "Stage",
      plan_status: "Status",
      smoke_test: "Smoke test",
      functional_test: "Functional test",
      integration_testing: "Integration test",
      system_test: "System test",
      regression_test: "Regression test",
      version_validation: "Version validation",
      plan_principal: "Principal",
      input_plan_name: "Please input plan name",
      input_plan_principal: "Please select principal",
      input_plan_project: "Please select project",
      input_related_project: "Please Related project",
      input_plan_stage: "Please select stage",
      plan_status_prepare: "Not started",
      plan_status_running: "Starting",
      plan_status_finished: "Finished",
      plan_status_completed: "Completed",
      plan_status_trash: "Trashed",
      planned_start_time: "Scheduled Start Time",
      planned_end_time: "Scheduled End Time",
      actual_start_time: "Actual Start Time",
      actual_end_time: "Actual End Time",
      plan_delete_confirm: "All use cases under this plan will be deleted,confirm delete test plan: ",
      plan_delete_tip: "The test plan is under way, please confirm and delete it!",
      plan_delete: "Delete test plan",
      api_case: "Api case",
      scenario_case: "Scenario case",
      load_case: {
        case: "Load Case",
        execution_status: "Execution status",
        report: "report",
        view_report: "View report",
        unlink_in_bulk: "Unlink in bulk",
        batch_exec_cases: "Batch execution use cases",
        exec: "Executing....",
        error: "Use case execution error, please debug this use case separately!",
        report_not_found: "Report does not exist",
      }
    },
    review: {
      test_review: "Test Review",
      create_review: "Create Review",
      edit_review: "Edit Review",
      review_name: "Name",
      reviewer: "Reviewer",
      review_project: "Project",
      review_creator: "Creator",
      review_status: "Status",
      related_project: "Related Project",
      related_tip: "After the project is associated, you can add test cases under the associated project to the review list",
      end_time: "EndTime",
      delete: "Delete",
      input_review_name: "Please enter the name of the review",
      input_review_project: "Please select the project",
      input_reviewer: "Please select reviewer",
      no_link_case: "No associated use cases!",
      pass: "pass",
      un_pass: "UnPass",
      comment: "Comment",
      my_review: "My Review",
      my_create: "My Create",
      reviewed_by_me: "Review By Me",
      creator: "Creator",
      done: "Commented use cases",
      result_distribution: "Result Distribution"
    },
    comment: {
      no_comment: "No Comment",
      send_comment: "Post a comment (Ctrl + Enter to send)",
      send: "Send",
      description_is_null: "Comment content cannot be empty!",
      send_success: "Comment successful!",
    },
    review_view: {
      review: "Review",
      all_case: "All case",
      start_review: "Start Review",
      relevance_case: "Relevance Case",
      last_page: "It's the end！",
      execute_result: "Result",
      cannot_edit: "Cannot edit this comment！",
      cannot_delete: "Cannot delete this comment！",
    },
    module: {
      search: "Search module",
      rename: "Rename",
      add_submodule: "Add submodule",
      add_module: "Add module",
      name: "Name",
      delete_confirm: "Confirm delete module:",
      delete_all_resource: "and all submodules and test cases under the module",
      module: "Module",
      title: "Title",
      describe: "Describe",
      status: "Status",
      current_owner: "Current Owner",
      creation_time: "Creation time",
      project_name: "Project"
    },
    home: {
      recent_test: "Recent test",
      my_plan: "My plan",
      test_rate: "Test rate",
      tested_case: "Tested case",
      review_progress: "Review progress"
    },
    plan_view: {
      plan: "Plan",
      relevance_test_case: "Relevance case",
      cancel_all_relevance: "Unlink all",
      executor: "Executor",
      execute_result: "Result",
      pass: "Pass",
      not_pass: "UnPass",
      failure: "Failure",
      blocking: "Blocking",
      skip: "Skip",
      actual_result: "Actual result",
      step_result: "Step result",
      my_case: "My case",
      all_case: "All case",
      pre_case: "The last case",
      next_case: "The next case",
      change_execution_results: "Change results",
      change_executor: "Change executor",
      select_executor: "Select executor",
      select_execute_result: "Select execute result",
      cancel_relevance: "Cancel relevance",
      confirm_cancel_relevance: "Confirm cancel relevance",
      select_manipulate: "Select the data you want to manipulate",
      select_template: "Select template",
      step: "Step",
      submit_issues: "Commit issues",
      operate_step: "Operate step",
      edit_component: "Edit component",
      base_info: "Base info",
      mock_info: "Mock info",
      test_result: "Test result",
      result_distribution: "Result distribution",
      custom_component: "Custom",
      create_report: "Create report",
      defect_list: "Defect list",
      view_report: "View report",
      component_library: "Component library",
      component_library_tip: "Drag and drop the component from the component library, add to the right, preview the report effect, only one can be added per system component.",
      delete_component_tip: "Please reserve at least one component",
      input_template_name: "Input template name",
      template_special_characters: 'Template name does not support special characters',
      case_count: "Case count",
      issues_count: "Issues count",
      result_statistics: "Result statistics",
      result_statistics_chart: "Result statistics chart",
      create_template: "Create template",
      report_template: "Report template",
      test_detail: "Test detail",
      failure_case: "Failure case",
      export_report: "Export Report",
      no_case_relevance: "No related use cases",
    },
    issue: {
      issue: "Issue",
      platform_tip: "Integrated defect management platform in the system setting-organization-service integration can automatically submit defects to the designated defect management platform",
      input_title: "Please enter title",
      id: "Issue ID",
      title: "Issue Title",
      description: "Issue Description",
      status: "Issue Status",
      platform: "Platform",
      operate: "Operate",
      close: "Close",
      delete: "Delete",
      title_description_required: "Title and description are required",
      close_success: "Closed successfully",
      preview: "Preview",
      please_choose_current_owner: "Please choose current owner",
      tapd_current_owner: "Tapd Current Owner",
      zentao_bug_build: "Zentao Impact version",
      zentao_bug_assigned: "Zentao handler",
    },
    report: {
      name: "Test Plan Report",
      list: {
        name: "name",
        test_plan: "Test plan",
        creator: "Creator",
        create_time: "Create Time",
        trigger_mode: "Trigger Mode",
        status: "Status",
        operation: "Operation",
      },
      trigger_mode: {
        manual: "Manual",
        automation: "Automation",
      },
    }
  },
  test_resource_pool: {
    type: 'type',
    enable_disable: 'Enable / disable',
    search_by_name: 'Search by name',
    create_resource_pool: 'Create resource pool',
    update_resource_pool: 'Create resource pool',
    select_pool_type: 'Select resource type',
    max_threads: 'Maximum concurrent number',
    input_pool_name: 'Please enter the resource pool name',
    pool_name_valid: 'Resource pool name does not support special characters',
    cannot_remove_all_node: 'Cannot delete all independent nodes',
    cannot_empty: 'Resource pool cannot be empty',
    fill_the_data: 'Please complete the data',
    delete_prompt: 'This operation will permanently delete the resource pool, continue?',
    update_prompt: '{0}  The other tests are using this resource pool. Disabling the monitoring part that may affect the report. Do you want to continue?',
    status_change_success: 'Successfully changed the status!',
    status_change_failed: 'Failed to change the status, resource pool is invalid!',
    check_in: 'Check in',
    node_selector_invalid: 'nodeSelector must be JSON',
    pod_thread_limit: 'Maximum number of threads per POD'
  },
  system_parameter_setting: {
    mailbox_service_settings: 'Mailbox Settings',
    ldap_setting: 'LDAP Setting',
    test_connection: 'Test connection',
    SMTP_host: 'SMTP host',
    SMTP_port: 'SMTP port',
    SMTP_account: 'SMTP account',
    SMTP_password: 'SMTP password',
    SSL: 'Turn on SSL (if the SMTP port is 465, you usually need to enable SSL)',
    TLS: 'Turn on TLS (if the SMTP port is 587, you usually need to enable TLS)',
    SMTP: 'Anonymous SMTP or not',
    host: 'Host number cannot be empty',
    port: 'Port cannot be empty',
    account: 'Account cannot be empty',
    test_recipients: 'Test recipients',
    tip: 'Tip: use as test mail recipient only',

  },
  i18n: {
    home: 'Home',
    definition: 'Api Definition',
    automation: 'Api Automation',
    report: 'Test report',
  },
  ldap: {
    url: 'LDAP URL',
    dn: 'Bind DN',
    password: 'Password',
    ou: 'User OU',
    filter: 'User Filter',
    mapping: 'LDAP Mapping',
    open: 'Enable LDAP Authentication',
    input_url: 'Please enter LDAP url',
    input_dn: 'Please enter DN',
    input_password: 'Please enter the password',
    input_ou: 'Please enter user OU',
    input_filter: 'Please enter a user filter',
    input_mapping: 'Please enter LDAP attribute mapping',
    input_username: 'please enter user name',
    input_url_placeholder: 'Please enter the LDAP address (eg ldap://localhost:389)',
    input_ou_placeholder: 'Enter user OU (use | to separate each OU)',
    input_filter_placeholder: 'Input filter [Possible options are cn or uid or sAMAccountName={0}, eg: (uid={0})]',
    input_mapping_placeholder: 'eg：{"username":"uid","name":"sn","email":"mail"}, The username mapping option may be cn or uid or sAMAccountName',
    test_connect: 'Test Connection',
    test_login: 'Test Login',
    edit: 'Edit',
    login_success: 'login success',
    url_cannot_be_empty: 'LDAP address cannot be empty',
    dn_cannot_be_empty: 'LDAP DN cannot be empty',
    ou_cannot_be_empty: 'LDAP OU cannot be empty',
    filter_cannot_be_empty: 'LDAP user filter cannot be empty',
    password_cannot_be_empty: 'LDAP password cannot be empty',
    mapping_cannot_be_empty: 'LDAP mapping cannot be empty',
  },
  schedule: {
    input_email: "Please input email account",
    event: "event",
    event_success: 'EXECUTE SUCCESSFUL',
    event_failed: 'EXECUTE FAILED',
    receiving_mode: "mailbox",
    receiver: "Receiver",
    operation: "operation",
    task_notification: "Task notification",
    not_set: "Not Set",
    next_execution_time: "Next Execution Time",
    edit_timer_task: "Edit Timer Task",
    test_name: 'Test Name',
    running_rule: 'Rule',
    job_status: 'Status',
    running_task: 'Running Task',
    please_input_cron_expression: "Please Input Cron Expression",
    generate_expression: "Generate Expression",
    cron_expression_format_error: "Cron Expression Format Error",
    cron_expression_interval_short_error: "Interval time shorter than 3 minutes, please avoid running tests that take too long",
    cron: {
      seconds: "Seconds",
      minutes: "Minutes",
      hours: "Hours",
      day: "Day",
      month: "Month",
      weeks: "Weeks",
      years: "Years",
      week: "Week",
      time_expression: "Time Expression",
      complete_expression: "Complete Expression",
      allowed_wildcards: "Allowed Wildcards[, - * /]",
      day_allowed_wildcards: "Allowed Wildcards[, - * / L M]",
      weeks_allowed_wildcards: "Allowed Wildcards[, - * / L M]",
      not_specify: "Not Specify",
      specify: "Specify",
      period: "Period",
      from: "From",
      every: "Every",
      day_unit: "Day Unit",
      start: "Start",
      execute_once: "Execute Once",
      last_working_day: "The Last Working Day",
      last_day_of_the_month: "The Last Day Of The Month",
      multi_select: "Multi Select",
      num: "Number",
      week_of_weeks: "Week Of Weeks",
      last_week_of_the_month: "The Last Week Of The Month",
      not_fill: "Not Fill",
      recent_run_time: "Recent 5th Runing Time",
      no_qualifying_results: "No Qualifying Results",
    }
  },
  quota: {
    default: {
      organization: "Organization Default Quota",
      workspace: "Workspace Default Quota",
    },
    api: "Number of interface tests",
    performance: "Number of performance tests",
    resource_pool: "Available test resource pool",
    max_threads: "Maximum Concurrency",
    duration: "Stress test duration(seconds)",
    use_default: "Use default quota",
    yes: "Yes",
    no: "No",
    edit: "Edit",
    list: "Quota List",
    modify: "Modify Quota",
    edit_quota_title: "{0} quota",
    workspace_quota_list: "Workspace quota list of {0}",
    unlimited: "Unlimited",
    clean: "Clean"
  },
  schema: {
    title: "Title",
    import_json: "Import JSON",
    base_setting: "Base Setting",
    all_setting: "Source Code",
    default: "Default",
    description: "Description",
    "adv_setting": "Advanced Settings",
    "add_child_node": "Add child node",
    add_sibling_node: "Add sibling nodes",
    add_node: "Add sibling/child nodes",
    remove_node: "Remove node",
    child_node: "Child node",
    sibling_node: "Sibling node",
    ok: "OK",
    cancel: "Cancel",
    minLength: "Min length",
    maxLength: "Max length",
    pattern: "MUST be a valid regular expression.",
    exclusiveMinimum: "Value strictly less than",
    exclusiveMaximum: "Value strictly more than",
    minimum: "Min",
    maximum: "Max",
    uniqueItems: "Unique Items",
    minItems: "MinItems",
    maxItems: "MaxItems",
    minProperties: "MinProperties",
    maxProperties: "MaxProperties",
    checked_all: "Checked All",
    valid_json: "Not valid json",
    enum: "Enum",
    enum_msg: "One value per line",
    enum_desc: "desc",
    enum_desc_msg: "enum description",
    required: "Required",
    mock: "mock",
    mockLink: "Help",
    format: "Format",
    nothing: "Nothing",
    preview: "Preview",
    add_custom: "Add Custom Prop"
  },
  loop: {
    loops_title: "loops",
    foreach: "ForEach",
    while: "While",
    loops: "loops",
    interval: "interval",
    proceed: "proceed",
    timeout: "timeout",
  },
  variables: {
    cvs_info: "Only CSV files can be uploaded",
    end: "end",
    start: "start",
    increment: "increment",
    counter_info: "000 produces at least three digits. user_ 000 in the form of user_ NNN",
    config: "configure",
    add_file: "Add file",
    delimiter: "Delimiter",
    format: "Output format",
  },
  auth_source: {
    delete_prompt: 'This operation will delete the authentication source, do you want to continue? ',
    title: 'Auth Source',
    auth_name_valid: 'Name does not support special characters',
  },
  module: {
    title: 'Module Management'
  },
  table: {
    header_display_field: 'Header display field',
    fields_to_be_selected: 'Fields to be selected',
    selected_fields: 'Selected fields'
  },
  run_mode: {
    title: "Mode",
    serial: "Serial",
    parallel: "Parallel",
    other_config: "Other config",
    idd_report: "Report",
    set_report: "Set report",
    report_name: "Report name",
  }
};