对账单修改

.editorconfig

@@ -0,0 +1,442 @@
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+max_line_length = 1000
+tab_width = 4
+ij_continuation_indent_size = 8
+ij_formatter_off_tag = @formatter:off
+ij_formatter_on_tag = @formatter:on
+ij_formatter_tags_enabled = true
+ij_smart_tabs = false
+ij_visual_guides =
+ij_wrap_on_typing = false
+
+[*.java]
+ij_java_align_consecutive_assignments = false
+ij_java_align_consecutive_variable_declarations = false
+ij_java_align_group_field_declarations = false
+ij_java_align_multiline_annotation_parameters = false
+ij_java_align_multiline_array_initializer_expression = false
+ij_java_align_multiline_assignment = false
+ij_java_align_multiline_binary_operation = false
+ij_java_align_multiline_chained_methods = false
+ij_java_align_multiline_deconstruction_list_components = true
+ij_java_align_multiline_extends_list = false
+ij_java_align_multiline_for = true
+ij_java_align_multiline_method_parentheses = false
+ij_java_align_multiline_parameters = true
+ij_java_align_multiline_parameters_in_calls = false
+ij_java_align_multiline_parenthesized_expression = false
+ij_java_align_multiline_records = true
+ij_java_align_multiline_resources = true
+ij_java_align_multiline_ternary_operation = false
+ij_java_align_multiline_text_blocks = false
+ij_java_align_multiline_throws_list = false
+ij_java_align_subsequent_simple_methods = false
+ij_java_align_throws_keyword = false
+ij_java_align_types_in_multi_catch = true
+ij_java_annotation_new_line_in_record_component = false
+ij_java_annotation_parameter_wrap = off
+ij_java_array_initializer_new_line_after_left_brace = false
+ij_java_array_initializer_right_brace_on_new_line = false
+ij_java_array_initializer_wrap = off
+ij_java_assert_statement_colon_on_next_line = false
+ij_java_assert_statement_wrap = off
+ij_java_assignment_wrap = off
+ij_java_binary_operation_sign_on_next_line = false
+ij_java_binary_operation_wrap = off
+ij_java_blank_lines_after_anonymous_class_header = 0
+ij_java_blank_lines_after_class_header = 0
+ij_java_blank_lines_after_imports = 1
+ij_java_blank_lines_after_package = 1
+ij_java_blank_lines_around_class = 1
+ij_java_blank_lines_around_field = 0
+ij_java_blank_lines_around_field_in_interface = 0
+ij_java_blank_lines_around_field_with_annotations = 0
+ij_java_blank_lines_around_initializer = 1
+ij_java_blank_lines_around_method = 1
+ij_java_blank_lines_around_method_in_interface = 1
+ij_java_blank_lines_before_class_end = 0
+ij_java_blank_lines_before_imports = 1
+ij_java_blank_lines_before_method_body = 0
+ij_java_blank_lines_before_package = 0
+ij_java_blank_lines_between_record_components = 0
+ij_java_block_brace_style = end_of_line
+ij_java_block_comment_add_space = true
+ij_java_block_comment_at_first_column = false
+ij_java_builder_methods =
+ij_java_call_parameters_new_line_after_left_paren = false
+ij_java_call_parameters_right_paren_on_new_line = false
+ij_java_call_parameters_wrap = off
+ij_java_case_statement_on_separate_line = true
+ij_java_catch_on_new_line = false
+ij_java_class_annotation_wrap = split_into_lines
+ij_java_class_brace_style = end_of_line
+ij_java_class_count_to_use_import_on_demand = 5
+ij_java_class_names_in_javadoc = 1
+ij_java_deconstruction_list_wrap = normal
+ij_java_delete_unused_module_imports = false
+ij_java_do_not_indent_top_level_class_members = false
+ij_java_do_not_wrap_after_single_annotation = false
+ij_java_do_not_wrap_after_single_annotation_in_parameter = false
+ij_java_do_while_brace_force = never
+ij_java_doc_add_blank_line_after_description = true
+ij_java_doc_add_blank_line_after_param_comments = false
+ij_java_doc_add_blank_line_after_return = false
+ij_java_doc_add_p_tag_on_empty_lines = true
+ij_java_doc_align_exception_comments = true
+ij_java_doc_align_param_comments = true
+ij_java_doc_do_not_wrap_if_one_line = false
+ij_java_doc_enable_formatting = true
+ij_java_doc_enable_leading_asterisks = true
+ij_java_doc_indent_on_continuation = false
+ij_java_doc_keep_empty_lines = true
+ij_java_doc_keep_empty_parameter_tag = true
+ij_java_doc_keep_empty_return_tag = true
+ij_java_doc_keep_empty_throws_tag = true
+ij_java_doc_keep_invalid_tags = true
+ij_java_doc_param_description_on_new_line = false
+ij_java_doc_preserve_line_breaks = false
+ij_java_doc_use_throws_not_exception_tag = true
+ij_java_else_on_new_line = false
+ij_java_entity_dd_prefix =
+ij_java_entity_dd_suffix = EJB
+ij_java_entity_eb_prefix =
+ij_java_entity_eb_suffix = Bean
+ij_java_entity_hi_prefix =
+ij_java_entity_hi_suffix = Home
+ij_java_entity_lhi_prefix = Local
+ij_java_entity_lhi_suffix = Home
+ij_java_entity_li_prefix = Local
+ij_java_entity_li_suffix =
+ij_java_entity_pk_class = java.lang.String
+ij_java_entity_ri_prefix =
+ij_java_entity_ri_suffix =
+ij_java_entity_vo_prefix =
+ij_java_entity_vo_suffix = VO
+ij_java_enum_constants_wrap = off
+ij_java_enum_field_annotation_wrap = off
+ij_java_extends_keyword_wrap = off
+ij_java_extends_list_wrap = off
+ij_java_field_annotation_wrap = split_into_lines
+ij_java_field_name_prefix =
+ij_java_field_name_suffix =
+ij_java_filter_class_prefix =
+ij_java_filter_class_suffix =
+ij_java_filter_dd_prefix =
+ij_java_filter_dd_suffix =
+ij_java_finally_on_new_line = false
+ij_java_for_brace_force = never
+ij_java_for_statement_new_line_after_left_paren = false
+ij_java_for_statement_right_paren_on_new_line = false
+ij_java_for_statement_wrap = off
+ij_java_generate_final_locals = false
+ij_java_generate_final_parameters = false
+ij_java_generate_use_type_annotation_before_type = true
+ij_java_if_brace_force = never
+ij_java_imports_layout = *, |, javax.**, java.**, |, $*
+ij_java_indent_case_from_switch = true
+ij_java_insert_inner_class_imports = false
+ij_java_insert_override_annotation = true
+ij_java_keep_blank_lines_before_right_brace = 2
+ij_java_keep_blank_lines_between_package_declaration_and_header = 2
+ij_java_keep_blank_lines_in_code = 2
+ij_java_keep_blank_lines_in_declarations = 2
+ij_java_keep_builder_methods_indents = false
+ij_java_keep_control_statement_in_one_line = true
+ij_java_keep_first_column_comment = true
+ij_java_keep_indents_on_empty_lines = false
+ij_java_keep_line_breaks = true
+ij_java_keep_multiple_expressions_in_one_line = false
+ij_java_keep_simple_blocks_in_one_line = false
+ij_java_keep_simple_classes_in_one_line = false
+ij_java_keep_simple_lambdas_in_one_line = false
+ij_java_keep_simple_methods_in_one_line = false
+ij_java_label_indent_absolute = false
+ij_java_label_indent_size = 0
+ij_java_lambda_brace_style = end_of_line
+ij_java_layout_on_demand_import_from_same_package_first = true
+ij_java_layout_static_imports_separately = true
+ij_java_line_comment_add_space = true
+ij_java_line_comment_add_space_on_reformat = true
+ij_java_line_comment_at_first_column = false
+ij_java_listener_class_prefix =
+ij_java_listener_class_suffix =
+ij_java_local_variable_name_prefix =
+ij_java_local_variable_name_suffix =
+ij_java_message_dd_prefix =
+ij_java_message_dd_suffix = EJB
+ij_java_message_eb_prefix =
+ij_java_message_eb_suffix = Bean
+ij_java_method_annotation_wrap = split_into_lines
+ij_java_method_brace_style = end_of_line
+ij_java_method_call_chain_wrap = off
+ij_java_method_parameters_new_line_after_left_paren = false
+ij_java_method_parameters_right_paren_on_new_line = false
+ij_java_method_parameters_wrap = off
+ij_java_modifier_list_wrap = false
+ij_java_multi_catch_types_wrap = normal
+ij_java_names_count_to_use_import_on_demand = 3
+ij_java_new_line_after_lparen_in_annotation = false
+ij_java_new_line_after_lparen_in_deconstruction_pattern = true
+ij_java_new_line_after_lparen_in_record_header = false
+ij_java_new_line_when_body_is_presented = false
+ij_java_packages_to_use_import_on_demand = java.awt.*, javax.swing.*
+ij_java_parameter_annotation_wrap = off
+ij_java_parameter_name_prefix =
+ij_java_parameter_name_suffix =
+ij_java_parentheses_expression_new_line_after_left_paren = false
+ij_java_parentheses_expression_right_paren_on_new_line = false
+ij_java_place_assignment_sign_on_next_line = false
+ij_java_prefer_longer_names = true
+ij_java_prefer_parameters_wrap = false
+ij_java_preserve_module_imports = true
+ij_java_record_components_wrap = normal
+ij_java_repeat_annotations =
+ij_java_repeat_synchronized = true
+ij_java_replace_instanceof_and_cast = false
+ij_java_replace_null_check = true
+ij_java_replace_sum_lambda_with_method_ref = true
+ij_java_resource_list_new_line_after_left_paren = false
+ij_java_resource_list_right_paren_on_new_line = false
+ij_java_resource_list_wrap = off
+ij_java_rparen_on_new_line_in_annotation = false
+ij_java_rparen_on_new_line_in_deconstruction_pattern = true
+ij_java_rparen_on_new_line_in_record_header = false
+ij_java_servlet_class_prefix =
+ij_java_servlet_class_suffix =
+ij_java_servlet_dd_prefix =
+ij_java_servlet_dd_suffix =
+ij_java_session_dd_prefix =
+ij_java_session_dd_suffix = EJB
+ij_java_session_eb_prefix =
+ij_java_session_eb_suffix = Bean
+ij_java_session_hi_prefix =
+ij_java_session_hi_suffix = Home
+ij_java_session_lhi_prefix = Local
+ij_java_session_lhi_suffix = Home
+ij_java_session_li_prefix = Local
+ij_java_session_li_suffix =
+ij_java_session_ri_prefix =
+ij_java_session_ri_suffix =
+ij_java_session_si_prefix =
+ij_java_session_si_suffix = Service
+ij_java_space_after_closing_angle_bracket_in_type_argument = false
+ij_java_space_after_colon = true
+ij_java_space_after_comma = true
+ij_java_space_after_comma_in_type_arguments = true
+ij_java_space_after_for_semicolon = true
+ij_java_space_after_quest = true
+ij_java_space_after_type_cast = true
+ij_java_space_before_annotation_array_initializer_left_brace = false
+ij_java_space_before_annotation_parameter_list = false
+ij_java_space_before_array_initializer_left_brace = false
+ij_java_space_before_catch_keyword = true
+ij_java_space_before_catch_left_brace = true
+ij_java_space_before_catch_parentheses = true
+ij_java_space_before_class_left_brace = true
+ij_java_space_before_colon = true
+ij_java_space_before_colon_in_foreach = true
+ij_java_space_before_comma = false
+ij_java_space_before_deconstruction_list = false
+ij_java_space_before_do_left_brace = true
+ij_java_space_before_else_keyword = true
+ij_java_space_before_else_left_brace = true
+ij_java_space_before_finally_keyword = true
+ij_java_space_before_finally_left_brace = true
+ij_java_space_before_for_left_brace = true
+ij_java_space_before_for_parentheses = true
+ij_java_space_before_for_semicolon = false
+ij_java_space_before_if_left_brace = true
+ij_java_space_before_if_parentheses = true
+ij_java_space_before_method_call_parentheses = false
+ij_java_space_before_method_left_brace = true
+ij_java_space_before_method_parentheses = false
+ij_java_space_before_opening_angle_bracket_in_type_parameter = false
+ij_java_space_before_quest = true
+ij_java_space_before_switch_left_brace = true
+ij_java_space_before_switch_parentheses = true
+ij_java_space_before_synchronized_left_brace = true
+ij_java_space_before_synchronized_parentheses = true
+ij_java_space_before_try_left_brace = true
+ij_java_space_before_try_parentheses = true
+ij_java_space_before_type_parameter_list = false
+ij_java_space_before_while_keyword = true
+ij_java_space_before_while_left_brace = true
+ij_java_space_before_while_parentheses = true
+ij_java_space_inside_one_line_enum_braces = false
+ij_java_space_within_empty_array_initializer_braces = false
+ij_java_space_within_empty_method_call_parentheses = false
+ij_java_space_within_empty_method_parentheses = false
+ij_java_spaces_around_additive_operators = true
+ij_java_spaces_around_annotation_eq = true
+ij_java_spaces_around_assignment_operators = true
+ij_java_spaces_around_bitwise_operators = true
+ij_java_spaces_around_equality_operators = true
+ij_java_spaces_around_lambda_arrow = true
+ij_java_spaces_around_logical_operators = true
+ij_java_spaces_around_method_ref_dbl_colon = false
+ij_java_spaces_around_multiplicative_operators = true
+ij_java_spaces_around_relational_operators = true
+ij_java_spaces_around_shift_operators = true
+ij_java_spaces_around_type_bounds_in_type_parameters = true
+ij_java_spaces_around_unary_operator = false
+ij_java_spaces_inside_block_braces_when_body_is_present = false
+ij_java_spaces_within_angle_brackets = false
+ij_java_spaces_within_annotation_parentheses = false
+ij_java_spaces_within_array_initializer_braces = false
+ij_java_spaces_within_braces = false
+ij_java_spaces_within_brackets = false
+ij_java_spaces_within_cast_parentheses = false
+ij_java_spaces_within_catch_parentheses = false
+ij_java_spaces_within_deconstruction_list = false
+ij_java_spaces_within_for_parentheses = false
+ij_java_spaces_within_if_parentheses = false
+ij_java_spaces_within_method_call_parentheses = false
+ij_java_spaces_within_method_parentheses = false
+ij_java_spaces_within_parentheses = false
+ij_java_spaces_within_record_header = false
+ij_java_spaces_within_switch_parentheses = false
+ij_java_spaces_within_synchronized_parentheses = false
+ij_java_spaces_within_try_parentheses = false
+ij_java_spaces_within_while_parentheses = false
+ij_java_special_else_if_treatment = true
+ij_java_static_field_name_prefix =
+ij_java_static_field_name_suffix =
+ij_java_subclass_name_prefix =
+ij_java_subclass_name_suffix = Impl
+ij_java_switch_expressions_wrap = normal
+ij_java_ternary_operation_signs_on_next_line = false
+ij_java_ternary_operation_wrap = off
+ij_java_test_name_prefix =
+ij_java_test_name_suffix = Test
+ij_java_throws_keyword_wrap = off
+ij_java_throws_list_wrap = off
+ij_java_use_external_annotations = false
+ij_java_use_fq_class_names = false
+ij_java_use_relative_indents = false
+ij_java_use_single_class_imports = true
+ij_java_variable_annotation_wrap = off
+ij_java_visibility = public
+ij_java_while_brace_force = never
+ij_java_while_on_new_line = false
+ij_java_wrap_comments = false
+ij_java_wrap_first_method_in_call_chain = false
+ij_java_wrap_long_lines = false
+ij_java_wrap_semicolon_after_call_chain = false
+
+[.editorconfig]
+ij_editorconfig_align_group_field_declarations = false
+ij_editorconfig_space_after_colon = false
+ij_editorconfig_space_after_comma = true
+ij_editorconfig_space_before_colon = false
+ij_editorconfig_space_before_comma = false
+ij_editorconfig_spaces_around_assignment_operators = true
+
+[{*.ant,*.fxml,*.jhm,*.jnlp,*.jrxml,*.pom,*.rng,*.tld,*.wadl,*.wsdl,*.xml,*.xsd,*.xsl,*.xslt,*.xul}]
+ij_xml_align_attributes = true
+ij_xml_align_text = false
+ij_xml_attribute_wrap = normal
+ij_xml_block_comment_add_space = true
+ij_xml_block_comment_at_first_column = false
+ij_xml_keep_blank_lines = 2
+ij_xml_keep_indents_on_empty_lines = false
+ij_xml_keep_line_breaks = true
+ij_xml_keep_line_breaks_in_text = true
+ij_xml_keep_whitespaces = false
+ij_xml_keep_whitespaces_around_cdata = preserve
+ij_xml_keep_whitespaces_inside_cdata = false
+ij_xml_line_comment_at_first_column = false
+ij_xml_space_after_tag_name = false
+ij_xml_space_around_equals_in_attribute = false
+ij_xml_space_inside_empty_tag = false
+ij_xml_text_wrap = normal
+
+[{*.har,*.jsb2,*.jsb3,*.json,*.jsonc,*.postman_collection,*.postman_collection.json,*.postman_environment,*.postman_environment.json,.babelrc,.eslintrc,.prettierrc,.stylelintrc,.ws-context,jest.config}]
+indent_size = 2
+ij_json_array_wrapping = split_into_lines
+ij_json_keep_blank_lines_in_code = 0
+ij_json_keep_indents_on_empty_lines = false
+ij_json_keep_line_breaks = true
+ij_json_keep_trailing_comma = false
+ij_json_object_wrapping = split_into_lines
+ij_json_property_alignment = do_not_align
+ij_json_space_after_colon = true
+ij_json_space_after_comma = true
+ij_json_space_before_colon = false
+ij_json_space_before_comma = false
+ij_json_spaces_within_braces = false
+ij_json_spaces_within_brackets = false
+ij_json_wrap_long_lines = false
+
+[{*.htm,*.html,*.sht,*.shtm,*.shtml}]
+ij_html_add_new_line_before_tags = body, div, p, form, h1, h2, h3
+ij_html_align_attributes = true
+ij_html_align_text = false
+ij_html_attribute_wrap = normal
+ij_html_block_comment_add_space = false
+ij_html_block_comment_at_first_column = true
+ij_html_do_not_align_children_of_min_lines = 0
+ij_html_do_not_break_if_inline_tags = title, h1, h2, h3, h4, h5, h6, p
+ij_html_do_not_indent_children_of_tags = html, body, thead, tbody, tfoot
+ij_html_enforce_quotes = false
+ij_html_inline_tags = a, abbr, acronym, b, basefont, bdo, big, br, cite, cite, code, dfn, em, font, i, img, input, kbd, label, q, s, samp, select, small, span, strike, strong, sub, sup, textarea, tt, u, var
+ij_html_keep_blank_lines = 2
+ij_html_keep_indents_on_empty_lines = false
+ij_html_keep_line_breaks = true
+ij_html_keep_line_breaks_in_text = true
+ij_html_keep_whitespaces = false
+ij_html_keep_whitespaces_inside = span, pre, textarea
+ij_html_line_comment_at_first_column = true
+ij_html_new_line_after_last_attribute = never
+ij_html_new_line_before_first_attribute = never
+ij_html_quote_style = double
+ij_html_remove_new_line_before_tags = br
+ij_html_space_after_tag_name = false
+ij_html_space_around_equality_in_attribute = false
+ij_html_space_inside_empty_tag = false
+ij_html_text_wrap = normal
+
+[{*.http,*.rest}]
+ij_continuation_indent_size = 4
+ij_http-request_call_parameters_wrap = normal
+ij_http-request_method_parameters_wrap = split_into_lines
+ij_http-request_space_before_comma = true
+ij_http-request_spaces_around_assignment_operators = true
+
+[{*.markdown,*.md}]
+ij_markdown_force_one_space_after_blockquote_symbol = true
+ij_markdown_force_one_space_after_header_symbol = true
+ij_markdown_force_one_space_after_list_bullet = true
+ij_markdown_force_one_space_between_words = true
+ij_markdown_format_tables = true
+ij_markdown_insert_quote_arrows_on_wrap = true
+ij_markdown_keep_indents_on_empty_lines = false
+ij_markdown_keep_line_breaks_inside_text_blocks = true
+ij_markdown_max_lines_around_block_elements = 1
+ij_markdown_max_lines_around_header = 1
+ij_markdown_max_lines_between_paragraphs = 1
+ij_markdown_min_lines_around_block_elements = 1
+ij_markdown_min_lines_around_header = 1
+ij_markdown_min_lines_between_paragraphs = 1
+ij_markdown_wrap_text_if_long = true
+ij_markdown_wrap_text_inside_blockquotes = true
+
+[{*.yaml,*.yml}]
+indent_size = 2
+ij_yaml_align_values_properties = do_not_align
+ij_yaml_autoinsert_sequence_marker = true
+ij_yaml_block_mapping_on_new_line = false
+ij_yaml_indent_sequence_value = true
+ij_yaml_keep_indents_on_empty_lines = false
+ij_yaml_keep_line_breaks = true
+ij_yaml_line_comment_add_space = false
+ij_yaml_line_comment_add_space_on_reformat = false
+ij_yaml_line_comment_at_first_column = true
+ij_yaml_sequence_on_new_line = false
+ij_yaml_space_before_colon = false
+ij_yaml_spaces_within_braces = true
+ij_yaml_spaces_within_brackets = true

njzscloud-common/njzscloud-common-security/src/main/java/com/njzscloud/common/security/handler/AccessDeniedExceptionHandler.java

@@ -44,7 +44,7 @@ public class AccessDeniedExceptionHandler implements AccessDeniedHandler {
             response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
         } else {
             log.error("暂无权限: {}", request.getRequestURI(), accessDeniedException);
-            r = R.failed(ExceptionMsg.CLI_ERR_MSG, accessDeniedException.getMessage());
+            r = R.failed(ExceptionMsg.CLI_ERR_MSG, "暂无权限");
             response.setStatus(HttpServletResponse.SC_FORBIDDEN);
         }
         ServletUtil.write(response, Jackson.toJsonStr(r), Mime.u8Val(Mime.JSON));

njzscloud-svr/pom.xml

@@ -125,6 +125,11 @@
             <artifactId>aspectjweaver</artifactId>
             <version>1.9.7</version>
         </dependency>
+        <dependency>
+            <groupId>com.volcengine</groupId>
+            <artifactId>volcengine-java-sdk-ark-runtime</artifactId>
+            <version>LATEST</version>
+        </dependency>
 
     </dependencies>
 

njzscloud-svr/src/main/java/com/njzscloud/supervisory/biz/pojo/result/SearchCompanyResult.java

@@ -147,4 +147,10 @@ public class SearchCompanyResult {
 
     private BigDecimal money;
 
+    private String idcard;
+    private String idcardStartTime;
+    private String idcardEndTime;
+    private String idcardFront;
+    private String idcardBack;
+
 }

njzscloud-svr/src/main/java/com/njzscloud/supervisory/bs/service/SupervisionStatisticsService.java

@@ -96,12 +96,23 @@ public class SupervisionStatisticsService {
                     double warnRate = todayTotalCount == 0 ? 0 : todayWarnCount / todayTotalCount * 100;
                     double incWarnRate = yesterdayWarnCount == 0 ? 0 : (todayWarnCount - yesterdayWarnCount) / yesterdayWarnCount * 100;
 
+
+                    Double yesterdayTotalCount = MapUtil.getDouble(dataStatistics, "yesterdayTotalCount", 0.0);
+                    double incDayCountRate = yesterdayTotalCount == 0 ? 0 : (todayTotalCount - yesterdayTotalCount) / yesterdayTotalCount * 100;
+
+                    Double currentMonthTotalCount = MapUtil.getDouble(dataStatistics, "currentMonthTotalCount", 0.0);
+                    Double lastMonthTotalCount = MapUtil.getDouble(dataStatistics, "lastMonthTotalCount", 0.0);
+                    double incMonthCountRate = lastMonthTotalCount == 0 ? 0 : (currentMonthTotalCount - lastMonthTotalCount) / lastMonthTotalCount * 100;
+
+
                     dataStatistics.put("dayRate", NumberUtil.decimalFormat("#.##", dayRate));
                     dataStatistics.put("monthRate", NumberUtil.decimalFormat("#.##", monthRate));
                     dataStatistics.put("finishRate", NumberUtil.decimalFormat("#.##", todayFinishRate));
                     dataStatistics.put("incFinishRate", NumberUtil.decimalFormat("#.##", incFinishRate));
                     dataStatistics.put("warnRate", NumberUtil.decimalFormat("#.##", warnRate));
                     dataStatistics.put("incWarnRate", NumberUtil.decimalFormat("#.##", incWarnRate));
+                    dataStatistics.put("incDayCountRate", NumberUtil.decimalFormat("#.##", incDayCountRate));
+                    dataStatistics.put("incMonthCountRate", NumberUtil.decimalFormat("#.##", incMonthCountRate));
                     return dataStatistics;
                 })
                 .exceptionally(ex -> {

njzscloud-svr/src/main/java/com/njzscloud/supervisory/customer/pojo/result/SearchCompanyResult.java

@@ -102,4 +102,11 @@ public class SearchCompanyResult {
      * 审核备注
      */
     private String auditMemo;
+
+
+    private String idcard;
+    private String idcardStartTime;
+    private String idcardEndTime;
+    private String idcardFront;
+    private String idcardBack;
 }

njzscloud-svr/src/main/java/com/njzscloud/supervisory/customer/pojo/result/SearchCustomerResult.java

@@ -61,4 +61,6 @@ public class SearchCustomerResult {
     private SearchCompanyResult company;
 
     private String settlementWay;
+
+
 }

njzscloud-svr/src/main/java/com/njzscloud/supervisory/doubao/API文档.md

@@ -0,0 +1,520 @@
+# 豆包垃圾分析接口文档
+
+## 接口概述
+
+本接口基于火山引擎豆包AI模型，提供垃圾车辆图片分析功能。通过上传多张垃圾车辆图片，AI会自动识别车棚状态、垃圾类型、轻物质和重物质占比等信息。
+
+**接口路径：** `/douBao/analyzeGarbage`  
+**请求方式：** `POST`  
+**Content-Type：** `application/json`
+
+---
+
+## 请求参数
+
+### 请求体（GarbageAnalysisParam）
+
+| 参数名 | 类型 | 必填 | 说明 |
+|--------|------|------|------|
+| imageUrls | List<String> | 是 | 图片URL列表，支持多张图片，至少需要一张 |
+| orderSn | String | 否 | 订单号，用于关联订单信息 |
+| remark | String | 否 | 备注信息，可提供额外的分析上下文 |
+
+### 参数说明
+
+- **imageUrls**：图片URL列表，支持HTTP/HTTPS协议的图片链接。建议使用可公开访问的图片URL。
+- **orderSn**：订单号，用于在分析结果中关联订单信息，便于后续查询和追踪。
+- **remark**：备注信息，可以包含订单相关的额外信息，如装货地点、卸货地点等，有助于AI更准确地进行分析。
+
+---
+
+## 响应结果
+
+### 响应体（GarbageAnalysisResult）
+
+| 字段名 | 类型 | 说明 |
+|--------|------|------|
+| isShedOpened | Boolean | 车棚是否完全打开。true表示已打开，false表示未打开 |
+| details | String | 明细信息，车厢内包含的物品列表。格式：物品1(数量描述),物品2(数量描述)，例如：石块(多),木材(少) |
+| lightMaterialPercentage | BigDecimal | 轻物质占比（百分比，0-100） |
+| heavyMaterialPercentage | BigDecimal | 重物质占比（百分比，0-100） |
+| garbageType | String | 垃圾类型，可能的值：拆除垃圾、装修垃圾、抛货 |
+| judgmentBasis | String | 判断依据，说明AI判断垃圾类型的原因 |
+| analysisTime | Long | 分析时间戳（毫秒） |
+| rawResponse | String | AI原始响应内容，用于调试和问题排查 |
+| garbageTypes | List<GarbageTypeInfo> | 垃圾类型分析列表（保留字段，用于兼容） |
+| totalWeight | BigDecimal | 总重量（单位：千克）（保留字段，用于兼容） |
+
+### GarbageTypeInfo 对象结构（保留字段）
+
+| 字段名 | 类型 | 说明 |
+|--------|------|------|
+| typeName | String | 垃圾类型名称 |
+| category | String | 具体垃圾种类 |
+| judgmentBasis | String | 判断依据 |
+| percentage | BigDecimal | 占比（百分比，0-100） |
+| weight | BigDecimal | 估算重量（单位：千克） |
+
+---
+
+## 请求示例
+
+### 场景一：最小参数（仅图片URL）
+
+**适用场景：** 快速测试，仅提供必要的图片URL
+
+```json
+{
+  "imageUrls": [
+    "https://example.com/garbage-truck-1.jpg"
+  ]
+}
+```
+
+**cURL 命令：**
+```bash
+curl -X POST "http://localhost:8080/douBao/analyzeGarbage" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "imageUrls": [
+      "https://example.com/garbage-truck-1.jpg"
+    ]
+  }'
+```
+
+---
+
+### 场景二：单张图片 + 订单号
+
+**适用场景：** 关联订单信息
+
+```json
+{
+  "imageUrls": [
+    "https://example.com/garbage-truck-1.jpg"
+  ],
+  "orderSn": "ORD20240101001"
+}
+```
+
+**cURL 命令：**
+```bash
+curl -X POST "http://localhost:8080/douBao/analyzeGarbage" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "imageUrls": [
+      "https://example.com/garbage-truck-1.jpg"
+    ],
+    "orderSn": "ORD20240101001"
+  }'
+```
+
+---
+
+### 场景三：多张图片（推荐）
+
+**适用场景：** 从不同角度拍摄，提高分析准确性
+
+```json
+{
+  "imageUrls": [
+    "https://example.com/garbage-truck-front.jpg",
+    "https://example.com/garbage-truck-side.jpg",
+    "https://example.com/garbage-truck-back.jpg"
+  ],
+  "orderSn": "ORD20240101001",
+  "remark": "装货地点：南京市建邺区，卸货地点：南京市江宁区"
+}
+```
+
+**cURL 命令：**
+```bash
+curl -X POST "http://localhost:8080/douBao/analyzeGarbage" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "imageUrls": [
+      "https://example.com/garbage-truck-front.jpg",
+      "https://example.com/garbage-truck-side.jpg",
+      "https://example.com/garbage-truck-back.jpg"
+    ],
+    "orderSn": "ORD20240101001",
+    "remark": "装货地点：南京市建邺区，卸货地点：南京市江宁区"
+  }'
+```
+
+---
+
+### 场景四：完整参数示例
+
+**适用场景：** 生产环境，包含所有可选信息
+
+```json
+{
+  "imageUrls": [
+    "https://cdn.example.com/orders/2024/01/01/truck-front-001.jpg",
+    "https://cdn.example.com/orders/2024/01/01/truck-side-001.jpg"
+  ],
+  "orderSn": "ORD20240101001",
+  "remark": "订单编号：ORD20240101001；装货地点：南京市建邺区奥体中心；卸货地点：南京市江宁区垃圾处理厂；装货时间：2024-01-01 10:00:00"
+}
+```
+
+**cURL 命令：**
+```bash
+curl -X POST "http://localhost:8080/douBao/analyzeGarbage" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "imageUrls": [
+      "https://cdn.example.com/orders/2024/01/01/truck-front-001.jpg",
+      "https://cdn.example.com/orders/2024/01/01/truck-side-001.jpg"
+    ],
+    "orderSn": "ORD20240101001",
+    "remark": "订单编号：ORD20240101001；装货地点：南京市建邺区奥体中心；卸货地点：南京市江宁区垃圾处理厂；装货时间：2024-01-01 10:00:00"
+  }'
+```
+
+---
+
+### Java 示例
+
+#### 方式一：使用链式调用（推荐）
+
+```java
+import com.njzscloud.supervisory.doubao.param.GarbageAnalysisParam;
+import com.njzscloud.supervisory.doubao.result.GarbageAnalysisResult;
+import com.njzscloud.common.core.utils.R;
+import java.util.Arrays;
+
+// 最小参数
+GarbageAnalysisParam param1 = new GarbageAnalysisParam()
+    .setImageUrls(Arrays.asList("https://example.com/garbage-truck-1.jpg"));
+
+// 完整参数
+GarbageAnalysisParam param2 = new GarbageAnalysisParam()
+    .setImageUrls(Arrays.asList(
+        "https://example.com/garbage-truck-front.jpg",
+        "https://example.com/garbage-truck-side.jpg"
+    ))
+    .setOrderSn("ORD20240101001")
+    .setRemark("装货地点：南京市建邺区，卸货地点：南京市江宁区");
+
+R<GarbageAnalysisResult> result = douBaoController.analyzeGarbage(param2);
+if (result.getCode() == 200) {
+    GarbageAnalysisResult data = result.getData();
+    System.out.println("车棚状态：" + (data.getIsShedOpened() ? "已打开" : "未打开"));
+    System.out.println("垃圾类型：" + data.getGarbageType());
+    System.out.println("轻物质占比：" + data.getLightMaterialPercentage() + "%");
+    System.out.println("重物质占比：" + data.getHeavyMaterialPercentage() + "%");
+}
+```
+
+#### 方式二：传统方式
+
+```java
+GarbageAnalysisParam param = new GarbageAnalysisParam();
+param.setImageUrls(Arrays.asList(
+    "https://example.com/garbage-truck-1.jpg",
+    "https://example.com/garbage-truck-2.jpg"
+));
+param.setOrderSn("ORD20240101001");
+param.setRemark("装货地点：南京市建邺区，卸货地点：南京市江宁区");
+
+R<GarbageAnalysisResult> result = douBaoController.analyzeGarbage(param);
+```
+
+---
+
+### JavaScript/Axios 示例
+
+```javascript
+// 使用 fetch
+fetch('http://localhost:8080/douBao/analyzeGarbage', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    imageUrls: [
+      'https://example.com/garbage-truck-1.jpg',
+      'https://example.com/garbage-truck-2.jpg'
+    ],
+    orderSn: 'ORD20240101001',
+    remark: '装货地点：南京市建邺区，卸货地点：南京市江宁区'
+  })
+})
+.then(response => response.json())
+.then(data => {
+  if (data.code === 200) {
+    console.log('分析成功：', data.data);
+    console.log('车棚状态：', data.data.isShedOpened ? '已打开' : '未打开');
+    console.log('垃圾类型：', data.data.garbageType);
+  } else {
+    console.error('分析失败：', data.msg);
+  }
+})
+.catch(error => console.error('请求错误：', error));
+
+// 使用 axios
+import axios from 'axios';
+
+const analyzeGarbage = async () => {
+  try {
+    const response = await axios.post('http://localhost:8080/douBao/analyzeGarbage', {
+      imageUrls: [
+        'https://example.com/garbage-truck-1.jpg',
+        'https://example.com/garbage-truck-2.jpg'
+      ],
+      orderSn: 'ORD20240101001',
+      remark: '装货地点：南京市建邺区，卸货地点：南京市江宁区'
+    });
+    
+    if (response.data.code === 200) {
+      console.log('分析结果：', response.data.data);
+    }
+  } catch (error) {
+    console.error('请求失败：', error);
+  }
+};
+```
+
+---
+
+### Postman/Apifox 测试配置
+
+#### 请求配置
+- **请求方式：** `POST`
+- **请求URL：** `http://localhost:8080/douBao/analyzeGarbage`
+- **Headers：**
+  - `Content-Type: application/json`
+
+#### Body（raw JSON）示例
+
+**示例1：最小参数**
+```json
+{
+  "imageUrls": [
+    "https://example.com/garbage-truck-1.jpg"
+  ]
+}
+```
+
+**示例2：完整参数**
+```json
+{
+  "imageUrls": [
+    "https://example.com/garbage-truck-front.jpg",
+    "https://example.com/garbage-truck-side.jpg",
+    "https://example.com/garbage-truck-back.jpg"
+  ],
+  "orderSn": "ORD20240101001",
+  "remark": "装货地点：南京市建邺区奥体中心；卸货地点：南京市江宁区垃圾处理厂"
+}
+```
+
+---
+
+### Python 示例
+
+```python
+import requests
+import json
+
+url = "http://localhost:8080/douBao/analyzeGarbage"
+
+# 最小参数
+payload1 = {
+    "imageUrls": [
+        "https://example.com/garbage-truck-1.jpg"
+    ]
+}
+
+# 完整参数
+payload2 = {
+    "imageUrls": [
+        "https://example.com/garbage-truck-front.jpg",
+        "https://example.com/garbage-truck-side.jpg"
+    ],
+    "orderSn": "ORD20240101001",
+    "remark": "装货地点：南京市建邺区，卸货地点：南京市江宁区"
+}
+
+headers = {
+    "Content-Type": "application/json"
+}
+
+response = requests.post(url, headers=headers, data=json.dumps(payload2))
+result = response.json()
+
+if result.get("code") == 200:
+    data = result.get("data")
+    print(f"车棚状态：{'已打开' if data.get('isShedOpened') else '未打开'}")
+    print(f"垃圾类型：{data.get('garbageType')}")
+    print(f"轻物质占比：{data.get('lightMaterialPercentage')}%")
+    print(f"重物质占比：{data.get('heavyMaterialPercentage')}%")
+else:
+    print(f"分析失败：{result.get('msg')}")
+```
+
+---
+
+### 测试图片URL说明
+
+**注意：** 实际测试时，请替换为真实可访问的图片URL。图片URL需要满足以下条件：
+
+1. **可公开访问**：图片URL必须可以通过HTTP/HTTPS协议直接访问
+2. **支持格式**：建议使用 JPG、PNG 等常见图片格式
+3. **图片质量**：建议图片清晰，能够清楚看到车辆和垃圾内容
+4. **推荐来源**：
+   - OSS对象存储（如阿里云OSS、腾讯云COS等）
+   - CDN加速域名
+   - 公网可访问的图片服务器
+
+**测试用占位图片（仅供参考，实际使用时请替换）：**
+```
+https://via.placeholder.com/800x600.jpg?text=Garbage+Truck+Front
+https://via.placeholder.com/800x600.jpg?text=Garbage+Truck+Side
+```
+
+---
+
+### 本地开发环境测试
+
+如果是在本地开发环境测试，请确保：
+
+1. **服务已启动**：确保Spring Boot应用已启动
+2. **端口正确**：默认端口通常是 `8080`，请根据实际配置调整
+3. **跨域配置**：如果前端调用，可能需要配置CORS
+4. **完整URL示例**：
+   - 本地：`http://localhost:8080/douBao/analyzeGarbage`
+   - 开发环境：`http://dev.example.com:8080/douBao/analyzeGarbage`
+   - 生产环境：`https://api.example.com/douBao/analyzeGarbage`
+
+---
+
+## 响应示例
+
+### 成功响应（车棚已打开）
+
+```json
+{
+  "code": 200,
+  "msg": "操作成功",
+  "data": {
+    "isShedOpened": true,
+    "details": "石块(多),木材(少)",
+    "lightMaterialPercentage": 10.00,
+    "heavyMaterialPercentage": 90.00,
+    "garbageType": "拆除垃圾",
+    "judgmentBasis": "车厢内主要为石块,这类垃圾多来自建筑物拆除等工程",
+    "analysisTime": 1704067200000,
+    "rawResponse": "明细:石块(多),木材(少);轻物质:10%;重物质:90%;垃圾类型:拆除垃圾;判断依据:车厢内主要为石块,这类垃圾多来自建筑物拆除等工程",
+    "garbageTypes": null,
+    "totalWeight": null
+  }
+}
+```
+
+### 成功响应（车棚未打开）
+
+```json
+{
+  "code": 200,
+  "msg": "操作成功",
+  "data": {
+    "isShedOpened": false,
+    "details": "未打开车棚",
+    "lightMaterialPercentage": null,
+    "heavyMaterialPercentage": null,
+    "garbageType": null,
+    "judgmentBasis": null,
+    "analysisTime": 1704067200000,
+    "rawResponse": "未打开车棚",
+    "garbageTypes": null,
+    "totalWeight": null
+  }
+}
+```
+
+### 错误响应
+
+```json
+{
+  "code": 500,
+  "msg": "垃圾分析失败：垃圾分析参数不能为空，且必须包含至少一张图片URL",
+  "data": null
+}
+```
+
+---
+
+## 错误码说明
+
+| 错误码 | 说明 |
+|--------|------|
+| 200 | 请求成功 |
+| 400 | 请求参数错误（如：图片URL列表为空） |
+| 500 | 服务器内部错误（如：AI服务调用失败、解析失败等） |
+
+---
+
+## 业务逻辑说明
+
+### 分析流程
+
+1. **车棚状态检测**：AI首先判断车棚是否完全打开
+   - 如果车棚未完全打开，直接返回"未打开车棚"，不进行后续分析
+   - 如果车棚已打开，继续执行垃圾分析
+
+2. **垃圾识别**（仅当车棚已打开时）：
+   - 识别车厢内包含的物品类型和数量
+   - 如果有多辆车，只分析画面中间的车辆
+   - 分析轻物质和重物质的占比（百分比，0-100，两者之和应为100%）
+   - 判断垃圾类型：拆除垃圾、装修垃圾或抛货
+   - 提供判断依据说明
+
+### 垃圾类型说明
+
+- **拆除垃圾**：主要来自建筑物拆除等工程，通常包含大量石块、混凝土块等重物质
+- **装修垃圾**：主要来自室内装修，通常包含白色板材、泡沫、木棍等轻物质
+- **抛货**：其他类型的垃圾
+
+---
+
+## 注意事项
+
+1. **图片要求**：
+   - 图片URL必须可公开访问
+   - 支持HTTP/HTTPS协议
+   - 建议图片清晰，能够清楚看到车辆和垃圾内容
+   - 支持多张图片，建议从不同角度拍摄
+
+2. **性能考虑**：
+   - AI分析需要一定时间，建议设置合理的超时时间
+   - 图片数量越多，分析时间可能越长
+
+3. **数据准确性**：
+   - AI分析结果仅供参考，建议结合人工审核
+   - 如果分析结果不准确，可以通过 `rawResponse` 字段查看AI原始响应进行排查
+
+4. **字段说明**：
+   - `garbageTypes` 和 `totalWeight` 为保留字段，当前版本可能为null
+   - `isShedOpened` 为false时，其他分析字段（如 `garbageType`、`lightMaterialPercentage` 等）可能为null
+
+5. **格式要求**：
+   - AI返回的格式为固定格式，解析失败时会记录警告日志
+   - 如果解析结果不完整，建议查看 `rawResponse` 字段获取原始响应
+
+---
+
+## 更新日志
+
+| 版本 | 日期 | 更新内容 |
+|------|------|----------|
+| 1.0.0 | 2024-01-01 | 初始版本，支持垃圾车辆图片分析功能 |
+
+---
+
+## 联系方式
+
+如有问题或建议，请联系开发团队。
+

njzscloud-svr/src/main/java/com/njzscloud/supervisory/doubao/config/DouBaoConfiguration.java

@@ -0,0 +1,48 @@
+package com.njzscloud.supervisory.doubao.config;
+
+import com.volcengine.ark.runtime.service.ArkService;
+import lombok.RequiredArgsConstructor;
+import okhttp3.ConnectionPool;
+import okhttp3.Dispatcher;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.util.StringUtils;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 火山引擎豆包配置类
+ */
+@Configuration
+@RequiredArgsConstructor
+@EnableConfigurationProperties(DouBaoProperties.class)
+public class DouBaoConfiguration {
+
+    private final DouBaoProperties properties;
+
+    @Bean(destroyMethod = "shutdownExecutor")
+    @ConditionalOnMissingBean
+    public ArkService arkService() {
+        String apiKey = properties.getApiKey();
+        if (!StringUtils.hasText(apiKey)) {
+            throw new IllegalStateException("豆包API Key未配置，请设置环境变量 ARK_API_KEY 或在配置文件中设置 doubao.api-key");
+        }
+        
+        ConnectionPool connectionPool = new ConnectionPool(
+                properties.getConnectionPoolSize(), 
+                properties.getConnectionKeepAliveSeconds(), 
+                TimeUnit.SECONDS
+        );
+        Dispatcher dispatcher = new Dispatcher();
+        
+        return ArkService.builder()
+                .dispatcher(dispatcher)
+                .connectionPool(connectionPool)
+                .baseUrl(properties.getBaseUrl())
+                .apiKey(apiKey)
+                .build();
+    }
+}
+

njzscloud-svr/src/main/java/com/njzscloud/supervisory/doubao/config/DouBaoProperties.java

@@ -0,0 +1,52 @@
+package com.njzscloud.supervisory.doubao.config;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * 火山引擎豆包配置
+ */
+@Getter
+@Setter
+@ToString
+@Accessors(chain = true)
+@ConfigurationProperties(prefix = "doubao")
+public class DouBaoProperties {
+    
+    /**
+     * API Key，优先从环境变量 ARK_API_KEY 获取，如果环境变量不存在则使用配置值
+     */
+    private String apiKey;
+    
+    /**
+     * 基础URL，默认为 https://ark.cn-beijing.volces.com/api/v3
+     */
+    private String baseUrl = "https://ark.cn-beijing.volces.com/api/v3";
+    
+    /**
+     * 模型ID，默认为 doubao-seed-1-6-vision-250815
+     */
+    private String model = "doubao-seed-1-6-vision-250815";
+    
+    /**
+     * 连接池大小，默认5
+     */
+    private Integer connectionPoolSize = 5;
+    
+    /**
+     * 连接保持时间（秒），默认1
+     */
+    private Long connectionKeepAliveSeconds = 1L;
+    
+    /**
+     * 获取API Key，优先从环境变量获取
+     */
+    public String getApiKey() {
+        String envApiKey = System.getenv("ARK_API_KEY");
+        return envApiKey != null ? envApiKey : apiKey;
+    }
+}
+

njzscloud-svr/src/main/java/com/njzscloud/supervisory/doubao/controller/DouBaoController.java

@@ -0,0 +1,31 @@
+package com.njzscloud.supervisory.doubao.controller;
+
+import com.njzscloud.common.core.utils.R;
+import com.njzscloud.supervisory.doubao.param.GarbageAnalysisParam;
+import com.njzscloud.supervisory.doubao.result.GarbageAnalysisResult;
+import com.njzscloud.supervisory.doubao.sevice.DouBaoService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 豆包
+ * 使用豆包官方SDK的生产级实现
+ */
+@Slf4j
+@RestController
+@RequestMapping("/douBao")
+@RequiredArgsConstructor
+public class DouBaoController {
+
+    private final DouBaoService douBaoService;
+
+    @PostMapping("/analyzeGarbage")
+    public R<GarbageAnalysisResult> analyzeGarbage(@RequestBody GarbageAnalysisParam param) {
+        return R.success(douBaoService.analyzeGarbage(param));
+    }
+
+}

njzscloud-svr/src/main/java/com/njzscloud/supervisory/doubao/param/GarbageAnalysisParam.java

@@ -0,0 +1,34 @@
+package com.njzscloud.supervisory.doubao.param;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+
+import java.util.List;
+
+/**
+ * 垃圾分析请求参数
+ */
+@Getter
+@Setter
+@ToString
+@Accessors(chain = true)
+public class GarbageAnalysisParam {
+
+    /**
+     * 图片URL列表（支持多张图片）
+     */
+    private List<String> imageUrls;
+
+    /**
+     * 订单号（可选）
+     */
+    private String orderSn;
+
+    /**
+     * 备注信息（可选）
+     */
+    private String remark;
+}
+

njzscloud-svr/src/main/java/com/njzscloud/supervisory/doubao/result/GarbageAnalysisResult.java

@@ -0,0 +1,105 @@
+package com.njzscloud.supervisory.doubao.result;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+
+import java.math.BigDecimal;
+import java.util.List;
+
+/**
+ * 垃圾分析结果
+ */
+@Getter
+@Setter
+@ToString
+@Accessors(chain = true)
+public class GarbageAnalysisResult {
+
+    /**
+     * 车棚是否完全打开
+     */
+    private Boolean isShedOpened;
+
+    /**
+     * 明细：车厢内包含的物品列表，格式：物品1(数量描述),物品2(数量描述)
+     * 例如：石块(多),木材(少)
+     */
+    private String details;
+
+    /**
+     * 轻物质占比（百分比，0-100）
+     */
+    private BigDecimal lightMaterialPercentage;
+
+    /**
+     * 重物质占比（百分比，0-100）
+     */
+    private BigDecimal heavyMaterialPercentage;
+
+    /**
+     * 垃圾类型：拆除垃圾、装修垃圾、抛货
+     */
+    private String garbageType;
+
+    /**
+     * 判断依据：说明判断垃圾类型的原因
+     */
+    private String judgmentBasis;
+
+    /**
+     * 分析时间戳
+     */
+    private Long analysisTime;
+
+    /**
+     * 原始响应内容
+     */
+    private String rawResponse;
+
+    /**
+     * 垃圾类型分析列表（保留用于兼容）
+     */
+    private List<GarbageTypeInfo> garbageTypes;
+
+    /**
+     * 总重量（单位：千克）（保留用于兼容）
+     */
+    private BigDecimal totalWeight;
+
+    /**
+     * 垃圾类型信息（保留用于兼容）
+     */
+    @Getter
+    @Setter
+    @ToString
+    @Accessors(chain = true)
+    public static class GarbageTypeInfo {
+        /**
+         * 垃圾类型名称（如：可回收垃圾、有害垃圾、厨余垃圾、其他垃圾等）
+         */
+        private String typeName;
+
+        /**
+         * 具体垃圾种类（如：塑料瓶、废纸、电池等）
+         */
+        private String category;
+
+        /**
+         * 判断依据（AI识别该垃圾类型的理由）
+         */
+        private String judgmentBasis;
+
+        /**
+         * 占比（百分比，0-100）
+         */
+        private BigDecimal percentage;
+
+        /**
+         * 估算重量（单位：千克）
+         */
+        private BigDecimal weight;
+    }
+}
+

njzscloud-svr/src/main/java/com/njzscloud/supervisory/doubao/sevice/DouBaoService.java

@@ -0,0 +1,18 @@
+package com.njzscloud.supervisory.doubao.sevice;
+
+import com.njzscloud.supervisory.doubao.param.GarbageAnalysisParam;
+import com.njzscloud.supervisory.doubao.result.GarbageAnalysisResult;
+
+/**
+ * 火山引擎豆包服务接口
+ */
+public interface DouBaoService {
+
+    /**
+     * 垃圾分析 - 分析多张图片中的垃圾类型、占比和重量
+     *
+     * @param param 垃圾分析请求参数，包含多张图片URL
+     * @return 垃圾分析结果，包含垃圾类型、判断依据、占比、重量等信息
+     */
+    GarbageAnalysisResult analyzeGarbage(GarbageAnalysisParam param);
+}

njzscloud-svr/src/main/java/com/njzscloud/supervisory/doubao/sevice/impl/DouBaoServiceImpl.java

@@ -0,0 +1,242 @@
+package com.njzscloud.supervisory.doubao.sevice.impl;
+
+import com.njzscloud.supervisory.doubao.config.DouBaoProperties;
+import com.njzscloud.supervisory.doubao.param.GarbageAnalysisParam;
+import com.njzscloud.supervisory.doubao.result.GarbageAnalysisResult;
+import com.njzscloud.supervisory.doubao.sevice.DouBaoService;
+import com.volcengine.ark.runtime.model.completion.chat.ChatCompletionContentPart;
+import com.volcengine.ark.runtime.model.completion.chat.ChatCompletionRequest;
+import com.volcengine.ark.runtime.model.completion.chat.ChatMessage;
+import com.volcengine.ark.runtime.model.completion.chat.ChatMessageRole;
+import com.volcengine.ark.runtime.service.ArkService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * 火山引擎豆包服务实现类
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class DouBaoServiceImpl implements DouBaoService {
+
+    private final ArkService arkService;
+    private final DouBaoProperties douBaoProperties;
+
+    /**
+     * 垃圾分析 - 分析多张图片中的垃圾类型、占比和重量
+     *
+     * @param param 垃圾分析请求参数，包含多张图片URL
+     * @return 垃圾分析结果，包含垃圾类型、判断依据、占比、重量等信息
+     */
+    @Override
+    public GarbageAnalysisResult analyzeGarbage(GarbageAnalysisParam param) {
+        try {
+            log.info("开始调用火山引擎豆包API进行垃圾分析，订单号：{}，图片数量：{}",
+                    param != null ? param.getOrderSn() : "未知",
+                    param != null && param.getImageUrls() != null ? param.getImageUrls().size() : 0);
+
+            // 参数校验
+            if (param == null || CollectionUtils.isEmpty(param.getImageUrls())) {
+                throw new IllegalArgumentException("垃圾分析参数不能为空，且必须包含至少一张图片URL");
+            }
+
+            // 构建消息列表
+            final List<ChatMessage> messages = new ArrayList<>();
+            final List<ChatCompletionContentPart> multiParts = new ArrayList<>();
+
+            // 添加所有图片URL
+            for (String imageUrl : param.getImageUrls()) {
+                if (StringUtils.hasText(imageUrl)) {
+                    multiParts.add(ChatCompletionContentPart.builder()
+                            .type("image_url")
+                            .imageUrl(new ChatCompletionContentPart.ChatCompletionContentPartImageURL(imageUrl))
+                            .build());
+                }
+            }
+
+            // 添加文本提示词，要求返回JSON格式
+            String textPrompt = buildGarbageAnalysisPrompt(param);
+            multiParts.add(ChatCompletionContentPart.builder()
+                    .type("text")
+                    .text(textPrompt)
+                    .build());
+
+            // 构建用户消息
+            final ChatMessage userMessage = ChatMessage.builder()
+                    .role(ChatMessageRole.USER)
+                    .multiContent(multiParts)
+                    .build();
+            messages.add(userMessage);
+
+            // 构建请求
+            ChatCompletionRequest chatCompletionRequest = ChatCompletionRequest.builder()
+                    .model(douBaoProperties.getModel())
+                    .messages(messages)
+                    .build();
+
+            // 调用API并获取响应
+            String response = arkService.createChatCompletion(chatCompletionRequest)
+                    .getChoices()
+                    .stream()
+                    .map(choice -> String.valueOf(choice.getMessage().getContent()))
+                    .collect(Collectors.joining("\n"));
+
+            log.info("火山引擎豆包API调用成功，原始响应内容：{}", response);
+
+            // 解析响应并转换为结果对象
+            GarbageAnalysisResult result = parseGarbageAnalysisResponse(response);
+            result.setRawResponse(response);
+            result.setAnalysisTime(System.currentTimeMillis());
+
+            log.info("垃圾分析完成，车棚状态：{}，垃圾类型：{}，轻物质占比：{}%，重物质占比：{}%",
+                    result.getIsShedOpened() != null && result.getIsShedOpened() ? "已打开" : "未打开",
+                    result.getGarbageType(),
+                    result.getLightMaterialPercentage(),
+                    result.getHeavyMaterialPercentage());
+
+            return result;
+
+        } catch (Exception e) {
+            log.error("调用火山引擎豆包API进行垃圾分析失败，订单号：{}",
+                    param != null ? param.getOrderSn() : "未知", e);
+            throw new RuntimeException("垃圾分析失败：" + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * 构建垃圾分析提示词
+     * 要求AI返回指定格式的文本
+     */
+    private String buildGarbageAnalysisPrompt(GarbageAnalysisParam param) {
+        StringBuilder prompt = new StringBuilder();
+        prompt.append("请仔细分析这些图片中的垃圾内容。\n\n");
+
+        // 添加订单信息（如果有）
+        if (StringUtils.hasText(param.getOrderSn())) {
+            prompt.append("订单号：").append(param.getOrderSn()).append("\n");
+        }
+        if (StringUtils.hasText(param.getRemark())) {
+            prompt.append("备注：").append(param.getRemark()).append("\n");
+        }
+
+        prompt.append("\n请按照以下要求进行分析：\n");
+        prompt.append("1. 首先判断图片中是否有垃圾运输车辆：\n");
+        prompt.append("   - 如果图片中没有车辆（直接是垃圾堆、垃圾场等场景），请直接跳到第3步分析垃圾内容\n");
+        prompt.append("   - 如果图片中有车辆，请继续第2步判断车棚状态\n");
+        prompt.append("2. 如果图片中有车辆，判断车棚是否完全打开：\n");
+        prompt.append("   - 如果车棚没有完全打开，无法看到车厢内的垃圾内容，直接回答：未打开车棚\n");
+        prompt.append("   - 如果车棚完全打开，可以看到车厢内的垃圾，请继续第3步分析\n");
+        prompt.append("3. 分析垃圾内容（适用于：无车辆的场景，或有车辆且车棚已打开的场景）：\n");
+        prompt.append("   - 识别垃圾中包含哪几种物品（如果有多辆车，只分析画面中间的车辆或主要垃圾堆）\n");
+        prompt.append("   - 说明哪种物品占比最多\n");
+        prompt.append("   - 给出轻物质和重物质的大概占比（使用百分比数值，0-100）\n");
+        prompt.append("   - 判断垃圾类型：拆除垃圾、装修垃圾或抛货\n");
+        prompt.append("   - 说明判断垃圾类型的原因\n\n");
+
+        prompt.append("请严格按照以下格式返回结果，不要添加任何其他文字说明：\n");
+        prompt.append("如果图片中有车辆且车棚未打开，直接回答：未打开车棚\n");
+        prompt.append("如果图片中没有车辆，或者有车辆且车棚已打开，按照以下格式回答：\n");
+        prompt.append("明细:物品1(数量描述),物品2(数量描述);轻物质:x%;重物质:x%;垃圾类型:x;判断依据:x\n\n");
+        prompt.append("格式说明：\n");
+        prompt.append("- 明细：列出垃圾中包含的所有物品，用逗号分隔，每个物品后标注数量（多、少、较多、较少等）\n");
+        prompt.append("- 轻物质：轻物质的占比百分比（0-100）\n");
+        prompt.append("- 重物质：重物质的占比百分比（0-100），轻物质和重物质占比之和应为100%\n");
+        prompt.append("- 垃圾类型：拆除垃圾、装修垃圾或抛货\n");
+        prompt.append("- 判断依据：详细说明为什么判断为该垃圾类型\n\n");
+        prompt.append("示例：\n");
+        prompt.append("明细:石块(多);轻物质:0%;重物质:100%;垃圾类型:拆除垃圾;判断依据:主要为石块,这类垃圾多来自建筑物拆除等工程\n");
+        prompt.append("明细:白色板材(多),白色泡沫(少),木棍(少);轻物质:90%;重物质:10%;垃圾类型:装修垃圾;判断依据:主要是白色板材、泡沫等装修常见废弃物\n");
+        prompt.append("明细:纸箱(多),塑料瓶(少),泡沫箱(少);轻物质:95%;重物质:5%;垃圾类型:抛货;判断依据:主要是轻质包装材料,属于抛货类垃圾\n\n");
+        prompt.append("注意：必须严格按照上述格式返回，不要添加任何其他文字说明。");
+
+        return prompt.toString();
+    }
+
+    /**
+     * 解析垃圾分析响应
+     * 从AI响应中提取信息并转换为结果对象
+     * 格式：明细:xx(x),xx(x);轻物质:x%;重物质:x%;垃圾类型:x;判断依据:x
+     * 或者：未打开车棚
+     */
+    private GarbageAnalysisResult parseGarbageAnalysisResponse(String response) {
+        if (!StringUtils.hasText(response)) {
+            throw new RuntimeException("AI响应为空，无法解析");
+        }
+
+        try {
+            GarbageAnalysisResult result = new GarbageAnalysisResult();
+            String trimmed = response.trim();
+
+            // 检查是否是"未打开车棚"的情况
+            if (trimmed.contains("未打开车棚")) {
+                result.setIsShedOpened(false);
+                result.setDetails("未打开车棚");
+                result.setLightMaterialPercentage(BigDecimal.ZERO);
+                result.setHeavyMaterialPercentage(BigDecimal.ZERO);
+                result.setGarbageType("无");
+                result.setJudgmentBasis("车棚未完全打开，无法进行分析");
+                return result;
+            }
+
+            // 车棚已打开，解析详细格式
+            result.setIsShedOpened(true);
+
+            // 提取明细
+            Pattern detailsPattern = Pattern.compile("明细[:：]([^;]+)");
+            Matcher detailsMatcher = detailsPattern.matcher(trimmed);
+            if (detailsMatcher.find()) {
+                result.setDetails(detailsMatcher.group(1).trim());
+            }
+
+            // 提取轻物质占比
+            Pattern lightPattern = Pattern.compile("轻物质[:：](\\d+(?:\\.\\d+)?)%");
+            Matcher lightMatcher = lightPattern.matcher(trimmed);
+            if (lightMatcher.find()) {
+                result.setLightMaterialPercentage(new BigDecimal(lightMatcher.group(1)));
+            }
+
+            // 提取重物质占比
+            Pattern heavyPattern = Pattern.compile("重物质[:：](\\d+(?:\\.\\d+)?)%");
+            Matcher heavyMatcher = heavyPattern.matcher(trimmed);
+            if (heavyMatcher.find()) {
+                result.setHeavyMaterialPercentage(new BigDecimal(heavyMatcher.group(1)));
+            }
+
+            // 提取垃圾类型
+            Pattern typePattern = Pattern.compile("垃圾类型[:：]([^;]+)");
+            Matcher typeMatcher = typePattern.matcher(trimmed);
+            if (typeMatcher.find()) {
+                result.setGarbageType(typeMatcher.group(1).trim());
+            }
+
+            // 提取判断依据
+            Pattern basisPattern = Pattern.compile("判断依据[:：](.+)");
+            Matcher basisMatcher = basisPattern.matcher(trimmed);
+            if (basisMatcher.find()) {
+                result.setJudgmentBasis(basisMatcher.group(1).trim());
+            }
+
+            // 验证必要字段
+            if (result.getDetails() == null || result.getGarbageType() == null) {
+                log.warn("解析结果不完整，响应内容：{}", response);
+            }
+
+            return result;
+
+        } catch (Exception e) {
+            log.error("解析垃圾分析响应失败，响应内容：{}", response, e);
+            throw new RuntimeException("解析AI响应失败：" + e.getMessage(), e);
+        }
+    }
+}

njzscloud-svr/src/main/java/com/njzscloud/supervisory/expense/contant/StationsScope.java

@@ -0,0 +1,19 @@
+package com.njzscloud.supervisory.expense.contant;
+
+import com.njzscloud.common.core.ienum.DictStr;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+/**
+ * 字典代码：stations_scope
+ * 字典名称：站点范围
+ */
+@Getter
+@RequiredArgsConstructor
+public enum StationsScope implements DictStr {
+    ALL("all", "所有站点"),
+    STATIONS("stations", "指定站点"),
+    ;
+    private final String val;
+    private final String txt;
+}

njzscloud-svr/src/main/java/com/njzscloud/supervisory/expense/pojo/entity/ExpenseItemsConfigEntity.java

@@ -5,6 +5,7 @@ import com.njzscloud.common.mp.support.handler.j.JsonTypeHandler;
 import com.njzscloud.supervisory.biz.constant.BizObj;
 import com.njzscloud.supervisory.expense.contant.GoodsScope;
 import com.njzscloud.supervisory.expense.contant.Scope;
+import com.njzscloud.supervisory.expense.contant.StationsScope;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
@@ -92,6 +93,17 @@ public class ExpenseItemsConfigEntity {
     @TableField(typeHandler = JsonTypeHandler.class)
     private List<String> goodsIds;
 
+    /**
+     * 站点范围;字典代码：station_scope all -->所有站点  stations -->指定站点
+     */
+    private StationsScope stationScope;
+
+    /**
+     * 站点ids
+     */
+    @TableField(typeHandler = JsonTypeHandler.class)
+    private List<String> stationIds;
+
     /**
      * 计费类型 fixed -> 固定计费 elasticity -> 弹性计费
      */

njzscloud-svr/src/main/java/com/njzscloud/supervisory/hsoa/Hsoa.java

@@ -91,4 +91,16 @@ public class Hsoa {
             wlock.unlock();
         }
     }
+
+    public static void relogin() {
+        try {
+            wlock.lock();
+            log.info("重置登录TOKEN");
+            refTnt = "";
+            tnt = "";
+            login();
+        } finally {
+            wlock.unlock();
+        }
+    }
 }

njzscloud-svr/src/main/java/com/njzscloud/supervisory/hsoa/HsoaProperties.java

@@ -15,5 +15,5 @@ public class HsoaProperties {
     private String baseUrl;
     private String username;
     private String password;
-    private int expire = 72 * 24 * 3600;
+    private int expire = 3 * 3600;
 }

njzscloud-svr/src/main/java/com/njzscloud/supervisory/money/pojo/entity/MoneyChangeDetailEntity.java

@@ -109,6 +109,9 @@ public class MoneyChangeDetailEntity {
     @TableField(exist = false)
     private String nickname;
 
+    @TableField(exist = false)
+    private String sn;
+
     /**
      * 开始时间（用于时间范围查询）
      */

njzscloud-svr/src/main/java/com/njzscloud/supervisory/money/pojo/result/MoneyBillResult.java

@@ -23,7 +23,10 @@ public class MoneyBillResult {
     private Long orderId;
     private BigDecimal discountMoney;
     private BigDecimal settleMoney;
-    private Integer quantity;
+    /**
+     * 净重
+     */
+    private Integer settleWeight;
     /**
      * 开始时间（用于时间范围查询）
      */

njzscloud-svr/src/main/java/com/njzscloud/supervisory/money/quartz/MoneyBillQuartz.java

@@ -24,7 +24,7 @@ public class MoneyBillQuartz {
 
     private final MoneyBillMapper moneyBillMapper;
 
-//    @Scheduled(cron = "0 0/1 * * * ?")//每1分钟一次
+   // @Scheduled(cron = "0 0/1 * * * ?")//每1分钟一次
     @Scheduled(cron = "0 0 1 27 * ?")//每月27号凌晨1点执行
     public void syncAssetsDiscover() {
         generateMoneyBill();
@@ -89,20 +89,15 @@ public class MoneyBillQuartz {
                             .count();
                     entity.setOrderCount((int) orderCount);
 
-                    // 2. 总质量：quantity求和，条件是计费策略不等于"车"
+                    // 2. 车数=订单数
+                    entity.setCarCount((int) orderCount);
+
+                    // 3. 总质量
                     int totalWeight = itemGroupResults.stream()
-                            .filter(result -> !MoneyStrategy.Che.getVal().equals(result.getMoneyStrategy()))
+                            .mapToInt(MoneyBillResult::getSettleWeight)
-                            .mapToInt(MoneyBillResult::getQuantity)
                             .sum();
                     entity.setTotalWeight(totalWeight);
 
-                    // 3. 车数：quantity求和，条件是计费策略等于"车"
-                    int totalCars = itemGroupResults.stream()
-                            .filter(result -> MoneyStrategy.Che.getVal().equals(result.getMoneyStrategy()))
-                            .mapToInt(MoneyBillResult::getQuantity)
-                            .sum();
-                    entity.setCarCount(totalCars);
-
                     // 4. 优惠金额：discountMoney求和，可能是负数
                     BigDecimal totalDiscountMoney = itemGroupResults.stream()
                             .map(MoneyBillResult::getDiscountMoney)
@@ -121,7 +116,7 @@ public class MoneyBillQuartz {
                     entity.setGoodsName(firstResult.getExpenseItemName());
                     entityList.add(entity);
                     log.info("生成账单实体: transCompanyId={}, originExpenseItemId={}, 订单数={}, 总质量={}, 车数={}, 优惠金额={}, 账单金额={}",
-                            transCompanyId, originExpenseItemId, orderCount, totalWeight, totalCars, totalDiscountMoney, totalSettleMoney);
+                            transCompanyId, originExpenseItemId, orderCount, totalWeight, orderCount, totalDiscountMoney, totalSettleMoney);
                 }
             }
             // 账单入库

njzscloud-svr/src/main/java/com/njzscloud/supervisory/money/service/MoneyBillService.java

@@ -117,19 +117,14 @@ public class MoneyBillService extends ServiceImpl<MoneyBillMapper, MoneyBillEnti
                     .count();
             entity.setOrderCount((int) orderCount);
 
-            // 2. 总质量：quantity求和，条件是计费策略不等于"车"
+            // 2. 总质量
             int totalWeight = billResults.stream()
-                    .filter(result -> !MoneyStrategy.Che.getVal().equals(result.getMoneyStrategy()))
+                    .mapToInt(MoneyBillResult::getSettleWeight)
-                    .mapToInt(MoneyBillResult::getQuantity)
                     .sum();
             entity.setTotalWeight(totalWeight);
 
-            // 3. 车数：quantity求和，条件是计费策略等于"车"
+            // 3. 车数 = 订单数
-            int totalCars = billResults.stream()
+            entity.setCarCount((int) orderCount);
-                    .filter(result -> MoneyStrategy.Che.getVal().equals(result.getMoneyStrategy()))
-                    .mapToInt(MoneyBillResult::getQuantity)
-                    .sum();
-            entity.setCarCount(totalCars);
 
             // 4. 优惠金额：discountMoney求和，可能是负数
             BigDecimal totalDiscountMoney = billResults.stream()

njzscloud-svr/src/main/java/com/njzscloud/supervisory/order/controller/OrderInfoController.java

@@ -261,6 +261,17 @@ public class OrderInfoController {
         orderInfoService.export(response, param);
     }
 
+    /**
+     * 转办
+     * @param orderId 订单Id
+     */
+    @GetMapping("/forwarded")
+    public R<?> forwarded(@RequestParam("orderId") Long orderId, @RequestParam("area") String area,
+                          @RequestParam("areaName") String areaName) {
+        orderInfoService.forwarded(orderId, area, areaName);
+        return R.success();
+    }
+
     /**
      * 改价
      */

njzscloud-svr/src/main/java/com/njzscloud/supervisory/order/pojo/entity/OrderExpenseItemsEntity.java

@@ -5,6 +5,7 @@ import com.njzscloud.common.mp.support.handler.j.JsonTypeHandler;
 import com.njzscloud.supervisory.biz.constant.BizObj;
 import com.njzscloud.supervisory.expense.contant.GoodsScope;
 import com.njzscloud.supervisory.expense.contant.Scope;
+import com.njzscloud.supervisory.expense.contant.StationsScope;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
@@ -97,6 +98,17 @@ public class OrderExpenseItemsEntity {
     @TableField(typeHandler = JsonTypeHandler.class)
     private List<String> goodsIds;
 
+    /**
+     * 站点范围;字典代码：station_scope all -->所有站点  stations -->指定站点
+     */
+    private StationsScope stationScope;
+
+    /**
+     * 站点ids
+     */
+    @TableField(typeHandler = JsonTypeHandler.class)
+    private List<String> stationIds;
+
     /**
      * 计费类型 fixed -> 固定计费 elasticity -> 弹性计费
      */

njzscloud-svr/src/main/java/com/njzscloud/supervisory/order/pojo/param/OrderPagingSearchParam.java

@@ -2,6 +2,7 @@ package com.njzscloud.supervisory.order.pojo.param;
 
 import com.njzscloud.supervisory.biz.constant.AuditStatus;
 import com.njzscloud.supervisory.order.contant.CheckStatus;
+import com.njzscloud.supervisory.order.contant.OrderCategory;
 import com.njzscloud.supervisory.order.contant.OrderViewType;
 import lombok.Getter;
 import lombok.Setter;
@@ -20,6 +21,10 @@ public class OrderPagingSearchParam {
      */
     private AuditStatus auditStatus;
 
+    /**
+     * 订单类型; 字典代码：order_category
+     */
+    private OrderCategory orderCategory;
     /**
      * 订单状态; 字典代码：order_status
      */
@@ -45,6 +50,7 @@ public class OrderPagingSearchParam {
      * 订单编号
      */
     private String sn;
+    private String area;
 
     /**
      * 车牌号

njzscloud-svr/src/main/java/com/njzscloud/supervisory/order/pojo/result/OrderPagingResult.java

@@ -38,6 +38,15 @@ public class OrderPagingResult {
      * 订单 Id
      */
     private Long id;
+    /**
+     * 对方站点 Id; 短驳单有值
+     */
+    private Long targetStationId;
+
+    /**
+     * 对方订单 Id; 短驳单有值
+     */
+    private Long targetOrderId;
     /**
      * 准运证编号
      */

njzscloud-svr/src/main/java/com/njzscloud/supervisory/order/service/OrderCarInOutService.java

@@ -72,6 +72,8 @@ public class OrderCarInOutService extends ServiceImpl<OrderCarInOutMapper, Order
      */
     @Transactional(rollbackFor = Exception.class)
     public long truckComing(TruckComingOrderParam truckComingOrderParam, OrderCategory orderCategory) {
+        Integer weight = truckComingOrderParam.getWeight();
+        Assert.isTrue(weight != null && weight > 0, () -> Exceptions.clierr("磅重错误"));
         Integer roughWeight = null;
         Integer tareWeight = null;
         if (orderCategory == OrderCategory.DuanBoChu) {
@@ -94,24 +96,27 @@ public class OrderCarInOutService extends ServiceImpl<OrderCarInOutMapper, Order
      */
     @Transactional(rollbackFor = Exception.class)
     public Integer truckOut(Long carInOutId, TruckLeavingOrderParam truckLeavingOrderParam, OrderCategory orderCategory, Long truckId) {
+        Integer weight = truckLeavingOrderParam.getWeight();
+        Assert.isTrue(weight != null && weight > 0, () -> Exceptions.clierr("磅重错误"));
+
         OrderCarInOutEntity orderCarInOutEntity = this.getById(carInOutId);
         Integer roughWeight = null;
         Integer tareWeight = null;
         Integer settleWeight = null;
-        Integer roughWeight__ = orderCarInOutEntity.getRoughWeight();
+        /*Integer roughWeight__ = orderCarInOutEntity.getRoughWeight();
-        if (roughWeight__ == null) {
+         if (roughWeight__ == null) {
             BizTruckEntity bizTruckEntity = bizTruckService.getById(truckId);
             Integer truckTareWeight = bizTruckEntity.getTareWeight();
             Assert.notNull(truckTareWeight, () -> Exceptions.exception("{} 车辆暂无皮重", bizTruckEntity.getLicensePlate()));
             orderCarInOutEntity.setRoughWeight(truckTareWeight);
             roughWeight__ = truckTareWeight;
-        }
+        } */
         if (orderCategory == OrderCategory.DuanBoChu) {
-            roughWeight = truckLeavingOrderParam.getWeight();
+            roughWeight = weight;
-            settleWeight = roughWeight - roughWeight__;
+            settleWeight = roughWeight - orderCarInOutEntity.getTareWeight();
         } else {
-            tareWeight = truckLeavingOrderParam.getWeight();
+            tareWeight = weight;
-            settleWeight = roughWeight__ - tareWeight;
+            settleWeight = orderCarInOutEntity.getRoughWeight() - tareWeight;
         }
         Integer roughWeight_ = roughWeight;
         Integer tareWeight_ = tareWeight;

njzscloud-svr/src/main/java/com/njzscloud/supervisory/order/service/OrderInfoService.java

@@ -34,10 +34,7 @@ import com.njzscloud.supervisory.constant.Constant;
 import com.njzscloud.supervisory.device.pojo.entity.DeviceLocalizerEntity;
 import com.njzscloud.supervisory.discount.pojo.DiscountManageEntity;
 import com.njzscloud.supervisory.discount.service.DiscountManageService;
-import com.njzscloud.supervisory.expense.contant.BillingType;
+import com.njzscloud.supervisory.expense.contant.*;
-import com.njzscloud.supervisory.expense.contant.ExpenseItemCategory;
-import com.njzscloud.supervisory.expense.contant.GoodsScope;
-import com.njzscloud.supervisory.expense.contant.Scope;
 import com.njzscloud.supervisory.expense.pojo.entity.ExpenseItemsConfigEntity;
 import com.njzscloud.supervisory.expense.service.ExpenseItemsConfigService;
 import com.njzscloud.supervisory.goods.contant.MoneyStrategy;
@@ -140,8 +137,10 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
 
         Long orderGoodsId = orderGoodsService.add(goodsId, null);
 
+        orderSn = orderSn == null ? SnUtil.next() : orderSn;
+        OrderCategory orderCategory = addOrderInfoParam.getOrderCategory();
         OrderInfoEntity orderInfoEntity = BeanUtil.copyProperties(addOrderInfoParam, OrderInfoEntity.class)
-                .setSn(orderSn == null ? SnUtil.next() : orderSn)
+                .setSn(orderCategory == OrderCategory.DuanBoChu ? orderSn + "-1" : orderSn)
                 .setCargoPlaceId(cargoPlaceId)
                 .setUserId(userId)
                 .setOrderStatus(orderStatus)
@@ -154,13 +153,14 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
         settleForTransCompany(this.getById(orderInfoEntity.getId()), entity);
 
         Long orderId = orderInfoEntity.getId();
-        OrderCategory orderCategory = addOrderInfoParam.getOrderCategory();
         if (orderCategory == OrderCategory.DuanBoChu) {
+            Long stationId = addOrderInfoParam.getStationId();
+            Long targetStationId = addOrderInfoParam.getTargetStationId();
             this.add(addOrderInfoParam.setOrderCategory(OrderCategory.DuanBoRu)
                             .setTargetOrderId(orderId)
-                            .setTargetStationId(addOrderInfoParam.getStationId())
+                            .setTargetStationId(stationId)
-                            .setStationId(addOrderInfoParam.getTargetStationId()),
+                            .setStationId(targetStationId),
-                    null);
+                    orderSn + "-2");
 
         } else if (orderCategory == OrderCategory.DuanBoRu) {
             this.updateById(new OrderInfoEntity().setId(addOrderInfoParam.getTargetOrderId())
@@ -226,6 +226,8 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
         Long goodsId = orderPagingSearchParam.getGoodsId();
         Page<OrderPagingResult> page = pageParam.toPage();
         Long stationId = orderPagingSearchParam.getStationId();
+        String area = orderPagingSearchParam.getArea();
+        OrderCategory orderCategory = orderPagingSearchParam.getOrderCategory();
         QueryWrapper<OrderPagingResult> ew = Wrappers.<OrderPagingResult>query()
                 .eq(stationId != null && stationId > 0, "a.station_id", stationId)
                 .like(StrUtil.isNotBlank(sn), "a.sn", sn)
@@ -234,8 +236,10 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 .like(StrUtil.isNotBlank(phone), "a.phone", phone)
                 .ge(startTime != null, "a.create_time", startTime)
                 .le(endTime != null, "a.create_time", endTime)
+                .eq(orderCategory != null, "a.order_category", orderCategory)
                 .eq(null != transCompanyId, "a.trans_company_id", transCompanyId)
                 .eq("a.deleted", 0)
+                .eq(StrUtil.isNotBlank(area), "b.area", area)
                 .eq(null != goodsId, "c.origin_goods_id", goodsId);
         OrderViewType type = orderPagingSearchParam.getType();
         Assert.notNull(type, () -> Exceptions.clierr("订单类型不能为空"));
@@ -272,12 +276,14 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
         BizObj bizObj = userDetail.getBizObj();
         if (BizObj.isTrans(bizObj)) {
             ew
+                    .in("a.order_category", OrderCategory.PuTong, OrderCategory.DuanBoChu)
                     .in("a.order_status", OrderStatus.DaiPaiDan, OrderStatus.DaiJieDan)
                     .eq("g.user_id", userId);
             return;
         }
         if (BizObj.isDriver(bizObj)) {
             ew
+                    .in("a.order_category", OrderCategory.PuTong, OrderCategory.DuanBoChu)
                     .eq("a.order_status", OrderStatus.DaiJieDan)
                     .eq("f.user_id", userId);
             return;
@@ -473,9 +479,13 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                         .isNull(BizAuditConfigEntity::getAreaRole).isNull(BizAuditConfigEntity::getCityRole))
                 .stream().map(BizAuditConfigEntity::getArea).distinct().collect(Collectors.toList());
 
+        if (CollUtil.isEmpty(areaList) && CollUtil.isEmpty(cityList) && CollUtil.isEmpty(cityAreaList)) {
+            return PageResult.of(pageParam.toPage());
+        }
+
         Page<OrderPagingResult> page = pageParam.toPage();
         page.addOrder(OrderItem.desc("a.create_time"));
-        QueryWrapper<OrderPagingResult> ew = Wrappers.<OrderPagingResult>query();
+        QueryWrapper<OrderPagingResult> ew = Wrappers.query();
         AuditStatus auditStatus = orderPagingSearchParam.getAuditStatus();
         if (Boolean.TRUE.equals(orderPagingSearchParam.getIsCertificatePaging())) {
             ew.isNotNull("a.certificate_sn");
@@ -494,6 +504,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 .like(StrUtil.isNotBlank(licensePlate), "e.license_plate", licensePlate)
                 .ge(startTime != null, "e.create_time", startTime)
                 .le(endTime != null, "e.create_time", endTime)
+                .in("a.order_category", OrderCategory.PuTong, OrderCategory.DuanBoChu)
         ;
 
         if (auditStatus != null) {
@@ -501,7 +512,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 ew
                         .eq("a.order_status", OrderStatus.YiJieDan)
                         .and(it ->
-                                it.in(CollUtil.isNotEmpty(areaList), "b.area", areaList).eq("a.audit_status", AuditStatus.QuDaiShenHe)
+                                it.or(CollUtil.isNotEmpty(areaList), it0 -> it0.in("b.area", areaList).eq("a.audit_status", AuditStatus.QuDaiShenHe))
                                         .or(CollUtil.isNotEmpty(cityList), it1 -> it1.in("b.area", cityList).eq("a.audit_status", AuditStatus.ShiDaiShenHe))
                                         .or(CollUtil.isNotEmpty(cityAreaList), it2 -> it2.in("b.area", cityAreaList).eq("a.audit_status", AuditStatus.DaiShenHe))
                         )
@@ -510,7 +521,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 ew
                         .in("a.order_status", OrderStatus.YiJieDan, OrderStatus.QingYunZhong, OrderStatus.YiJinChang, OrderStatus.YiChuChang, OrderStatus.YiWanCheng)
                         .and(it ->
-                                it.in(CollUtil.isNotEmpty(areaList), "b.area", areaList).eq("a.audit_status", AuditStatus.ShiDaiShenHe)
+                                it.or(CollUtil.isNotEmpty(areaList), it0 -> it0.in("b.area", areaList).eq("a.audit_status", AuditStatus.ShiDaiShenHe))
                                         .or(CollUtil.isNotEmpty(cityList), it1 -> it1.in("b.area", cityList).eq("a.audit_status", AuditStatus.TongGuo))
                                         .or(CollUtil.isNotEmpty(cityAreaList), it2 -> it2.in("b.area", cityAreaList).eq("a.audit_status", AuditStatus.TongGuo))
                         );
@@ -518,25 +529,26 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 ew
                         .in("a.order_status", OrderStatus.YiJieDan, OrderStatus.QingYunZhong, OrderStatus.YiJinChang, OrderStatus.YiChuChang, OrderStatus.YiWanCheng)
                         .and(it ->
-                                it.in(CollUtil.isNotEmpty(areaList), "b.area", areaList).eq("a.audit_status", AuditStatus.BoHui)
+                                it.or(CollUtil.isNotEmpty(areaList), it0 -> it0.in("b.area", areaList).eq("a.audit_status", AuditStatus.BoHui))
                                         .or(CollUtil.isNotEmpty(cityList), it1 -> it1.in("b.area", cityList).eq("a.audit_status", AuditStatus.BoHui))
                                         .or(CollUtil.isNotEmpty(cityAreaList), it2 -> it2.in("b.area", cityAreaList).eq("a.audit_status", AuditStatus.BoHui))
                         );
             }
         } else {
             String auditType = orderPagingSearchParam.getAuditType();
+            // 1-->待审核
             if ("1".equals(auditType)) {
                 ew.eq("a.order_status", OrderStatus.YiJieDan)
                         .and(it ->
-                                it.in(CollUtil.isNotEmpty(areaList), "b.area", areaList).in("a.audit_status", AuditStatus.QuDaiShenHe, AuditStatus.ShiDaiShenHe)
+                                it.or(CollUtil.isNotEmpty(areaList), it0 -> it0.in("b.area", areaList).in("a.audit_status", AuditStatus.QuDaiShenHe, AuditStatus.ShiDaiShenHe))
                                         .or(CollUtil.isNotEmpty(cityList), it1 -> it1.in("b.area", cityList).eq("a.audit_status", AuditStatus.ShiDaiShenHe))
                                         .or(CollUtil.isNotEmpty(cityAreaList), it2 -> it2.in("b.area", cityAreaList).eq("a.audit_status", AuditStatus.DaiShenHe))
                         );
-            } else if ("2".equals(auditType)) {
+            } else if ("2".equals(auditType)) { // 2-->已审核
                 ew
                         .in("a.order_status", OrderStatus.YiJieDan, OrderStatus.QingYunZhong, OrderStatus.YiJinChang, OrderStatus.YiChuChang, OrderStatus.YiWanCheng)
                         .and(it ->
-                                it.in(CollUtil.isNotEmpty(areaList), "b.area", areaList).eq("a.audit_status", AuditStatus.ShiDaiShenHe)
+                                it.or(CollUtil.isNotEmpty(areaList), it0 -> it0.in("b.area", areaList).eq("a.audit_status", AuditStatus.ShiDaiShenHe))
                                         .or(CollUtil.isNotEmpty(cityList), it1 -> it1.in("b.area", cityList).in("a.audit_status", AuditStatus.TongGuo, AuditStatus.BoHui))
                                         .or(CollUtil.isNotEmpty(cityAreaList), it2 -> it2.in("b.area", cityAreaList).in("a.audit_status", AuditStatus.TongGuo, AuditStatus.BoHui))
                         );
@@ -544,7 +556,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 ew
                         .in("a.order_status", OrderStatus.YiJieDan, OrderStatus.QingYunZhong, OrderStatus.YiJinChang, OrderStatus.YiChuChang, OrderStatus.YiWanCheng)
                         .and(it ->
-                                it.in(CollUtil.isNotEmpty(areaList), "b.area", areaList)
+                                it.or(CollUtil.isNotEmpty(areaList), it0 -> it0.in("b.area", areaList))
                                         .or(CollUtil.isNotEmpty(cityList), it1 -> it1.in("b.area", cityList))
                                         .or(CollUtil.isNotEmpty(cityAreaList), it2 -> it2.in("b.area", cityAreaList)))
                 ;
@@ -570,6 +582,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
         Set<String> roles = SecurityUtil.loginUser().getRoles();
         BizAuditConfigEntity config = bizAuditConfigService.getOne(Wrappers.<BizAuditConfigEntity>query()
                 .eq("area", detail.getArea()));
+        Assert.notNull(config, () -> Exceptions.exception("您没有权限审核该订单"));
         String areaRole = config.getAreaRole();
         String cityRole = config.getCityRole();
         if (!roles.contains(areaRole) && !roles.contains(cityRole)) {
@@ -612,6 +625,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
             certificateSn = SnUtil.next(CERTIFICATE_SN_CODE);
             checkStatus = CheckStatus.WeiKanLiao;
         }
+
         this.updateById(new OrderInfoEntity()
                 .setId(detail.getId())
                 .setAuditStatus(auditStatus)
@@ -624,6 +638,8 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 .setCheckStatus(checkStatus)
                 .setAuditMemo(auditOrderParam.getAuditMemo())
         );
+        OrderCategory orderCategory = detail.getOrderCategory();
+        if (orderCategory == OrderCategory.DuanBoRu) return;
         // auditStatus为市待审核状态通知市，通过状态通知司机
         try {
             TemplateMessageParam param = new TemplateMessageParam();
@@ -712,6 +728,15 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
         }
         baseMapper.busyDriver(driverId, Boolean.TRUE);
 
+        OrderCategory orderCategory = orderInfo.getOrderCategory();
+        if (orderCategory == OrderCategory.DuanBoChu) {
+            this.updateById(new OrderInfoEntity()
+                    .setId(orderInfo.getTargetOrderId())
+                    .setDriverId(driverId)
+                    .setAssignmentDriverTime(LocalDateTime.now())
+                    .setOrderStatus(OrderStatus.DaiJieDan));
+        }
+
         this.updateById(new OrderInfoEntity()
                 .setId(orderInfo.getId())
                 .setDriverId(driverId)
@@ -821,13 +846,17 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 param.setSn(orderInfo.getSn());
                 OrderGoodsEntity entity = orderGoodsService.getById(orderInfo.getGoodsId());
                 param.setGoodsName(entity.getGoodsName());
-                BizTruckEntity truckEntity = bizTruckService.getById(orderInfo.getTruckId());
+                BizTruckEntity truckEntity = bizTruckService.getById(truckId);
                 param.setLicensePlate(truckEntity.getLicensePlate());
                 for (SysUserRoleEntity userRoleEntity : userIds) {
-                    UserEntity userEntity = userService.getById(userRoleEntity.getUserId());
+                    UserEntity userEntity = userService.getById(orderInfo.getUserId());
-                    param.setUserId(userRoleEntity.getUserId());
+                    if (null != userEntity) {
-                    param.setCfCompanyName(userEntity.getNickname());
+                        param.setUserId(userRoleEntity.getUserId());
-                    wechatTemplateMessageService.sendTemplateMessage(param);
+                        param.setCfCompanyName(userEntity.getNickname());
+                        wechatTemplateMessageService.sendTemplateMessage(param);
+                    } else {
+                        log.info("未查到用户信息：" + userRoleEntity.getUserId());
+                    }
                 }
             }
         } catch (Exception e) {
@@ -1125,12 +1154,16 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
 
         OrderCategory orderCategory = orderInfoEntity.getOrderCategory();
         long carInOutId = orderCarInOutService.truckComing(truckComingOrderParam, orderCategory);
-
+        CheckStatus checkStatus = null;
+        if (orderInfoEntity.getOrderCategory() == OrderCategory.DuanBoChu) {
+            checkStatus = CheckStatus.YiKanLiao;
+        }
         this.updateById(new OrderInfoEntity()
                 .setAutoOrder(3 ^ i)
                 .setId(orderInfoEntity.getId())
                 .setCarInOutId(carInOutId)
                 .setOrderStatus(OrderStatus.YiJinChang)
+                .setCheckStatus(checkStatus)
         );
 
         CompletableFuture.runAsync(() -> {
@@ -1156,7 +1189,8 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
      */
     @Transactional(rollbackFor = Exception.class)
     public boolean truckLeaving(TruckLeavingOrderParam truckLeavingOrderParam, int i) {
-        OrderInfoEntity orderInfoEntity = this.getById(truckLeavingOrderParam.getOrderId());
+        Long orderId = truckLeavingOrderParam.getOrderId();
+        OrderInfoEntity orderInfoEntity = this.getById(orderId);
         Long truckId = orderInfoEntity.getTruckId();
         try {
             Assert.notNull(orderInfoEntity, () -> Exceptions.clierr("订单不存在"));
@@ -1174,11 +1208,9 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
             if (MoneyWay.OUT.getVal().equals(entity.getMoneyWay())) {
                 // 计算费用，出厂付费可能需要称重，需要更新付费项
                 updateOrderItems(orderInfoEntity.getId(), orderInfoEntity.getTransCompanyId(), settleWeight, Boolean.FALSE);
-                orderInfoEntity = this.getById(truckLeavingOrderParam.getOrderId());
+                orderInfoEntity = this.getById(orderId);
             }
 
-            baseMapper.busyDriver(orderInfoEntity.getDriverId(), Boolean.FALSE);
-            baseMapper.busyTruck(orderInfoEntity.getTruckId(), Boolean.FALSE);
             PaymentStatus paymentStatus = orderInfoEntity.getPaymentStatus();
 
             OrderStatus newOrderStatus = paymentStatus == PaymentStatus.WeiZhiFu ? OrderStatus.YiChuChang : OrderStatus.YiWanCheng;
@@ -1187,6 +1219,41 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                     .setId(orderInfoEntity.getId())
                     .setOrderStatus(newOrderStatus)
             );
+
+            if (orderInfoEntity.getOrderCategory() == OrderCategory.DuanBoChu) {
+                Long targetOrderId = orderInfoEntity.getTargetOrderId();
+
+                this.updateById(new OrderInfoEntity()
+                        .setId(targetOrderId)
+                        // 接单
+                        .setDriverConfirmTime(orderInfoEntity.getDriverConfirmTime())
+                        .setTruckId(truckId)
+
+                        // 审核
+                        .setAuditStatus(orderInfoEntity.getAuditStatus())
+                        .setQuAuditUserId(orderInfoEntity.getQuAuditUserId())
+                        .setShiAuditUserId(orderInfoEntity.getShiAuditUserId())
+                        .setQuAuditPicture(orderInfoEntity.getQuAuditPicture())
+                        .setShiAuditPicture(orderInfoEntity.getShiAuditPicture())
+                        .setCertificateSn(orderInfoEntity.getCertificateSn())
+                        .setAuditTime(orderInfoEntity.getAuditTime())
+                        .setCheckStatus(CheckStatus.WeiKanLiao)
+                        .setAuditMemo(orderInfoEntity.getAuditMemo())
+                        // 开始清运
+                        .setCargoPhoto(orderInfoEntity.getCargoPhoto())
+                        .setOrderStatus(OrderStatus.QingYunZhong)
+                        .setTransTime(orderInfoEntity.getTransTime())
+                );
+                if (MoneyWay.IN.getVal().equals(entity.getMoneyWay())) {
+                    // 入场付费无称重，不需要更新付费项
+                    // 处理公司支付
+                    handleCompanyPay(this.getById(targetOrderId), Boolean.TRUE, new BigDecimal("0"), Boolean.FALSE);
+                }
+            } else {
+                baseMapper.busyDriver(orderInfoEntity.getDriverId(), Boolean.FALSE);
+                baseMapper.busyTruck(orderInfoEntity.getTruckId(), Boolean.FALSE);
+            }
+
             // 计算本单净重（或结算重量），作为结算时的数量依据
 
             OrderInfoEntity orderInfoEntity_ = orderInfoEntity;
@@ -1214,10 +1281,12 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
             }
 
         } finally {
-            // 关闭 GPS
+            if (orderInfoEntity.getOrderCategory() != OrderCategory.DuanBoChu) {
-            BizTruckEntity truckInfo = baseMapper.getTruckInfo(truckId);
+                // 关闭 GPS
-            String gpsId = truckInfo.getGps();
+                BizTruckEntity truckInfo = baseMapper.getTruckInfo(truckId);
-            stopTrack(gpsId);
+                String gpsId = truckInfo.getGps();
+                stopTrack(gpsId);
+            }
         }
         return false;
     }
@@ -1270,8 +1339,9 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
 
     /**
      * 计算付费项的优惠金额
+     *
      * @param companyId 清运公司id
-     * @param item 付费项实体
+     * @param item      付费项实体
      * @return 总金额
      */
     private BigDecimal calculateItemDiscountMoney(Long companyId, OrderExpenseItemsEntity item) {
@@ -1284,7 +1354,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 return discountMoney;
             }
             goodsId = entity.getOriginGoodsId();
-        } else if (ExpenseItemCategory.QingYunFuWuFei.getVal().equals(item.getExpenseItemCategory())){
+        } else if (ExpenseItemCategory.QingYunFuWuFei.getVal().equals(item.getExpenseItemCategory())) {
             itemId = item.getOriginExpenseItemId();
         }
         List<DiscountManageEntity> discountList = discountManageService.list(Wrappers.lambdaQuery(DiscountManageEntity.class)
@@ -1293,7 +1363,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 .eq(null != itemId, DiscountManageEntity::getExpenseId, itemId)
                 .eq(DiscountManageEntity::getDeleted, Boolean.FALSE));
         if (null != discountList && discountList.size() > 0) {
-            for (DiscountManageEntity discount: discountList) {
+            for (DiscountManageEntity discount : discountList) {
                 if (DiscountType.DISCOUNT.getVal().equals(discount.getType())) {
                     discountMoney = discountMoney.subtract(discount.getMoney());
                 } else if (DiscountType.RAISE.getVal().equals(discount.getType())) {
@@ -1439,29 +1509,42 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
 
         Long transCompanyId = orderInfoEntity.getTransCompanyId();
         Long goodsId = orderGoods.getOriginGoodsId();
+        Long stationId = orderInfoEntity.getStationId();
         List<OrderExpenseItemsEntity> extraItems = configs.stream()
                 .filter(cfg -> {
                     Scope scope = cfg.getScope();
                     GoodsScope goodsScope = cfg.getGoodsScope();
+                    StationsScope stationsScope = cfg.getStationScope();
                     List<String> companyIds = cfg.getCompanyIds();
                     List<String> goodsIds = cfg.getGoodsIds();
-                    boolean isComTrue = companyIds != null && transCompanyId != null && companyIds.contains(String.valueOf(transCompanyId));
+                    List<String> stationsIds = cfg.getStationIds();
-                    boolean isGoodsTrue = goodsIds != null && goodsId != null && goodsIds.contains(String.valueOf(goodsId));
+
-                    if (scope == Scope.ALL && goodsScope == GoodsScope.ALL) return true;
+                    // 判断客户范围
-                    if (scope == Scope.ALL && goodsScope == GoodsScope.GOODS) {
+                    boolean isComTrue;
-                        return isGoodsTrue;
+                    if (scope == Scope.ALL) {
+                        isComTrue = true; // 所有客户都匹配
+                    } else {
+                        isComTrue = companyIds != null && transCompanyId != null && companyIds.contains(String.valueOf(transCompanyId));
                     }
-                    /*if (scope == Scope.CUSTOMER_TYPE) {
+
-                        BizObj bizObj = cfg.getBizObj();
+                    // 判断产品范围
-                        return bizObj == BizObj.QiYe || bizObj == BizObj.GeTi;
+                    boolean isGoodsTrue;
-                    }*/
+                    if (goodsScope == GoodsScope.ALL) {
-                    if (scope == Scope.CUSTOMER && goodsScope == GoodsScope.ALL) {
+                        isGoodsTrue = true; // 所有产品都匹配
-                        return isComTrue;
+                    } else {
+                        isGoodsTrue = goodsIds != null && goodsId != null && goodsIds.contains(String.valueOf(goodsId));
                     }
-                    if (scope == Scope.CUSTOMER && goodsScope == GoodsScope.GOODS) {
+
-                        return isComTrue && isGoodsTrue;
+                    // 判断站点范围
+                    boolean isStationsTrue;
+                    if (stationsScope == StationsScope.ALL) {
+                        isStationsTrue = true; // 所有站点都匹配
+                    } else {
+                        isStationsTrue = stationsIds != null && stationId != null && stationsIds.contains(String.valueOf(stationId));
                     }
-                    return false;
+
+                    // 只有当三个条件都为true时，才返回true
+                    return isComTrue && isGoodsTrue && isStationsTrue;
                 })
                 // 复制配置为订单付费项（数量口径与产品一致：按车=1，否则=settleWeight）
                 .map(cfg -> new OrderExpenseItemsEntity()
@@ -1592,7 +1675,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
             orderSn = SnUtil.next();
         }
         for (int i = 0; i < truckCount; i++) {
-            add(addOrderInfoParam, orderSn == null ? null : orderSn + "-" + (i + 1));
+            add(addOrderInfoParam, orderSn == null ? null : (orderSn + "-" + (i + 1)));
         }
     }
 
@@ -1635,7 +1718,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                         .equals(result.getId())).collect(Collectors.toList());
                 List<String> detailList = new ArrayList<>();
                 if (details.size() > 0) {
-                    for (OrderExportDetailResult detailResult: details) {
+                    for (OrderExportDetailResult detailResult : details) {
                         detailList.add(detailResult.getExpenseItemName() + detailResult.getSettleMoney() + "元");
                     }
                     map.put("明细", JSONObject.toJSONString(detailList));
@@ -1693,7 +1776,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                 truckLocationTrackService.save(entity);
                 try {
                     String transCompanyName = orderDetail.getTransCompanyName();
-                    HsoaResult<?> result = Hsoa.pushVehicleTrajectory(new PushVehicleTrajectoryParam()
+                    PushVehicleTrajectoryParam param = new PushVehicleTrajectoryParam()
                             .setCompanyName(transCompanyName)
                             .setTransportLicense(orderDetail.getCertificateSn())
                             .setPlateNumber(licensePlate)
@@ -1709,9 +1792,10 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
                             .setLiftStatus("0")
                             .setAccStatus(1)
                             .setGpsTime(time)
-                            .setLocationMode("WGS84")
+                            .setLocationMode("WGS84");
-                    );
+                    HsoaResult<?> result = Hsoa.pushVehicleTrajectory(param);
                     if (result == null || !result.isSuccess()) {
+                        Hsoa.relogin();
                         log.error("推送定位数据失败，数据Id：{}", entity.getId());
                     }
                 } catch (Exception e) {
@@ -1838,25 +1922,42 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
 
             Long transCompanyId = order.getTransCompanyId();
             Long goodsId = entity.getOriginGoodsId();
+            Long stationId = order.getStationId();
             List<OrderExpenseItemsEntity> extraItems = configs.stream()
                     .filter(cfg -> {
                         Scope scope = cfg.getScope();
                         GoodsScope goodsScope = cfg.getGoodsScope();
+                        StationsScope stationsScope = cfg.getStationScope();
                         List<String> companyIds = cfg.getCompanyIds();
                         List<String> goodsIds = cfg.getGoodsIds();
-                        boolean isComTrue = companyIds != null && transCompanyId != null && companyIds.contains(String.valueOf(transCompanyId));
+                        List<String> stationsIds = cfg.getStationIds();
-                        boolean isGoodsTrue = goodsIds != null && goodsId != null && goodsIds.contains(String.valueOf(goodsId));
+
-                        if (scope == Scope.ALL && goodsScope == GoodsScope.ALL) return true;
+                        // 判断客户范围
-                        if (scope == Scope.ALL && goodsScope == GoodsScope.GOODS) {
+                        boolean isComTrue;
-                            return isGoodsTrue;
+                        if (scope == Scope.ALL) {
+                            isComTrue = true; // 所有客户都匹配
+                        } else {
+                            isComTrue = companyIds != null && transCompanyId != null && companyIds.contains(String.valueOf(transCompanyId));
                         }
-                        if (scope == Scope.CUSTOMER && goodsScope == GoodsScope.ALL) {
+
-                            return isComTrue;
+                        // 判断产品范围
+                        boolean isGoodsTrue;
+                        if (goodsScope == GoodsScope.ALL) {
+                            isGoodsTrue = true; // 所有产品都匹配
+                        } else {
+                            isGoodsTrue = goodsIds != null && goodsId != null && goodsIds.contains(String.valueOf(goodsId));
                         }
-                        if (scope == Scope.CUSTOMER && goodsScope == GoodsScope.GOODS) {
+
-                            return isComTrue && isGoodsTrue;
+                        // 判断站点范围
+                        boolean isStationsTrue;
+                        if (stationsScope == StationsScope.ALL) {
+                            isStationsTrue = true; // 所有站点都匹配
+                        } else {
+                            isStationsTrue = stationsIds != null && stationId != null && stationsIds.contains(String.valueOf(stationId));
                         }
-                        return false;
+
+                        // 只有当三个条件都为true时，才返回true
+                        return isComTrue && isGoodsTrue && isStationsTrue;
                     })
                     // 复制配置为订单付费项（数量口径与产品一致：按车=1，否则=settleWeight）
                     .map(cfg -> new OrderExpenseItemsEntity()
@@ -1919,7 +2020,7 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
             if (null != param.getServiceFeeList() && param.getServiceFeeList().size() > 0) {
                 List<OrderItemsParams> params = param.getServiceFeeList();
                 for (OrderItemsParams itemsParam : params) {
-                    OrderExpenseItemsEntity expenseItemsEntity =  orderExpenseItemsService.getById(itemsParam.getId());
+                    OrderExpenseItemsEntity expenseItemsEntity = orderExpenseItemsService.getById(itemsParam.getId());
                     if (null == expenseItemsEntity) {
                         throw Exceptions.clierr("服务费不存在，请检查参数");
                     }
@@ -1987,4 +2088,23 @@ public class OrderInfoService extends ServiceImpl<OrderInfoMapper, OrderInfoEnti
             // 如果金额相等，则不需要处理
         }
     }
+
+    public void forwarded(Long orderId, String area, String areaName) {
+        OrderInfoEntity order = this.getById(orderId);
+        Assert.notNull(order, () -> Exceptions.clierr("订单不存在"));
+        if (null != order.getCargoPlaceId()) {
+            OrderCargoPlaceEntity cargoPlaceEntity = orderCargoPlaceService.getById(order.getCargoPlaceId());
+            if (null != cargoPlaceEntity) {
+                OrderCargoPlaceEntity placeEntity = new OrderCargoPlaceEntity();
+                placeEntity.setId(cargoPlaceEntity.getId());
+                placeEntity.setArea(area);
+                placeEntity.setAreaName(areaName);
+                orderCargoPlaceService.updateById(placeEntity);
+            } else {
+                throw Exceptions.clierr("未查询到装货地址");
+            }
+        } else {
+            throw Exceptions.clierr("装货地址不存在");
+        }
+    }
 }

njzscloud-svr/src/main/java/com/njzscloud/supervisory/route/pojo/OrderRouteEntity.java

@@ -48,6 +48,9 @@ public class OrderRouteEntity {
      */
     private String name;
 
+    @TableField(exist = false)
+    private String projectName;
+
     /**
      * 起始地
      */

njzscloud-svr/src/main/java/com/njzscloud/supervisory/route/pojo/RouteEntity.java

@@ -43,6 +43,9 @@ public class RouteEntity {
      */
     private String name;
 
+    @TableField(exist = false)
+    private String projectName;
+
     /**
      * 起始地
      */

njzscloud-svr/src/main/java/com/njzscloud/supervisory/route/service/impl/OrderRouteServiceImpl.java

@@ -107,7 +107,8 @@ public class OrderRouteServiceImpl extends ServiceImpl<OrderRouteMapper, OrderRo
                 .like(StrUtil.isNotBlank(routeEntity.getName()), "a.name", routeEntity.getName())
                 .eq(null != routeEntity.getCompanyId(), "a.company_id", routeEntity.getCompanyId())
                 .eq(null != routeEntity.getStationId(), "a.station_id", routeEntity.getStationId())
-                .eq(null != routeEntity.getOrderId(), "a.order_id", routeEntity.getOrderId());
+                .eq(null != routeEntity.getOrderId(), "a.order_id", routeEntity.getOrderId())
+                .eq(null != routeEntity.getProjectId(), "a.project_id", routeEntity.getProjectId());
         IPage<OrderRouteEntity> page = orderRouteMapper.paging(pageParam.toPage(), ew);
         for (OrderRouteEntity entity : page.getRecords()) {
             List<OrderRouteDetailEntity> detailEntityList = orderRouteDetailService.list(Wrappers.lambdaQuery(OrderRouteDetailEntity.class)

njzscloud-svr/src/main/java/com/njzscloud/supervisory/route/service/impl/RouteServiceImpl.java

@@ -106,7 +106,8 @@ public class RouteServiceImpl extends ServiceImpl<RouteMapper, RouteEntity> impl
                 .eq("a.deleted", 0)
                 .like(StrUtil.isNotBlank(routeEntity.getName()), "a.name", routeEntity.getName())
                 .eq(null != routeEntity.getCompanyId(), "a.company_id", routeEntity.getCompanyId())
-                .eq(null != routeEntity.getStationId(), "a.station_id", routeEntity.getStationId());
+                .eq(null != routeEntity.getStationId(), "a.station_id", routeEntity.getStationId())
+                .eq(null != routeEntity.getProjectId(), "a.project_id", routeEntity.getProjectId());
         IPage<RouteEntity> page = routeMapper.paging(pageParam.toPage(), ew);
         for (RouteEntity entity : page.getRecords()) {
             List<RouteDetailEntity> detailEntityList = routeDetailService.list(Wrappers.lambdaQuery(RouteDetailEntity.class)

njzscloud-svr/src/main/java/com/njzscloud/supervisory/sys/stationletter/service/impl/StationLetterServiceImpl.java

@@ -10,6 +10,7 @@ import com.njzscloud.supervisory.biz.constant.BizObj;
 import com.njzscloud.supervisory.biz.pojo.entity.BizAuditConfigEntity;
 import com.njzscloud.supervisory.biz.service.BizAuditConfigService;
 import com.njzscloud.supervisory.order.contant.CheckStatus;
+import com.njzscloud.supervisory.order.contant.OrderCategory;
 import com.njzscloud.supervisory.order.contant.OrderStatus;
 import com.njzscloud.supervisory.order.pojo.result.OrderPagingResult;
 import com.njzscloud.supervisory.station.pojo.entity.StationManageEntity;
@@ -102,8 +103,9 @@ public class StationLetterServiceImpl implements StationLetterService {
         sjAudit.setAuditName("司机待接单");
         if (BizObj.isDriver(bizObj)) {
             QueryWrapper<OrderPagingResult> queryWrapper = Wrappers.query();
-            queryWrapper.eq("a.order_status", OrderStatus.DaiJieDan);
+            queryWrapper.eq("a.order_status", OrderStatus.DaiJieDan)
-            queryWrapper.eq("f.user_id", userId);
+                    .in("a.order_category", OrderCategory.DuanBoRu, OrderCategory.PuTong)
+                    .eq("f.user_id", userId);
             int sjOrderCount = stationLetterMapper.selectPendingOrderCount(queryWrapper);
             sjAudit.setCount(sjOrderCount);
         } else {
@@ -117,8 +119,9 @@ public class StationLetterServiceImpl implements StationLetterService {
         transAudit.setAuditName("清运公司待派单");
         if (BizObj.isTrans(bizObj)) {
             QueryWrapper<OrderPagingResult> queryWrapper = Wrappers.query();
-            queryWrapper.in("a.order_status", OrderStatus.DaiPaiDan, OrderStatus.DaiJieDan);
+            queryWrapper.in("a.order_status", OrderStatus.DaiPaiDan, OrderStatus.DaiJieDan)
-            queryWrapper.eq("g.user_id", userId);
+                    .in("a.order_category", OrderCategory.DuanBoRu, OrderCategory.PuTong)
+                    .eq("g.user_id", userId);
             int transOrderCount = stationLetterMapper.selectPendingOrderCount(queryWrapper);
             transAudit.setCount(transOrderCount);
         } else {
@@ -179,7 +182,8 @@ public class StationLetterServiceImpl implements StationLetterService {
             }
 
             // 构建查询条件
-            QueryWrapper<OrderPagingResult> queryWrapper = buildOrderQueryWrapper(auditAreaInfo);
+            QueryWrapper<OrderPagingResult> queryWrapper = buildOrderQueryWrapper(auditAreaInfo)
+                    .in("a.order_category", OrderCategory.DuanBoRu, OrderCategory.PuTong);
             int orderCount = stationLetterMapper.selectPendingOrderCount(queryWrapper);
             orderAudit.setCount(orderCount);
 
@@ -197,22 +201,22 @@ public class StationLetterServiceImpl implements StationLetterService {
     private AuditAreaInfo getAuditAreaInfoByRoles(Set<String> roles) {
         // 获取区级审核区域
         List<String> areaList = bizAuditConfigService.list(Wrappers.<BizAuditConfigEntity>lambdaQuery()
-                .in(BizAuditConfigEntity::getAreaRole, roles)).stream()
+                        .in(BizAuditConfigEntity::getAreaRole, roles)).stream()
                 .map(BizAuditConfigEntity::getArea)
                 .distinct()
                 .collect(Collectors.toList());
 
         // 获取市级审核区域
         List<String> cityList = bizAuditConfigService.list(Wrappers.<BizAuditConfigEntity>lambdaQuery()
-                .in(BizAuditConfigEntity::getCityRole, roles)).stream()
+                        .in(BizAuditConfigEntity::getCityRole, roles)).stream()
                 .map(BizAuditConfigEntity::getArea)
                 .distinct()
                 .collect(Collectors.toList());
 
         // 获取无角色限制的区域
         List<String> cityAreaList = bizAuditConfigService.list(Wrappers.<BizAuditConfigEntity>lambdaQuery()
-                .isNull(BizAuditConfigEntity::getAreaRole)
+                        .isNull(BizAuditConfigEntity::getAreaRole)
-                .isNull(BizAuditConfigEntity::getCityRole)).stream()
+                        .isNull(BizAuditConfigEntity::getCityRole)).stream()
                 .map(BizAuditConfigEntity::getArea)
                 .distinct()
                 .collect(Collectors.toList());

njzscloud-svr/src/main/java/com/njzscloud/supervisory/sys/user/service/UserService.java

@@ -187,21 +187,25 @@ public class UserService extends ServiceImpl<UserMapper, UserEntity> implements
         AddUserParam addUserParam = BeanUtil.copyProperties(userRegisterParam, AddUserParam.class);
         addUserParam.setAccount(BeanUtil.copyProperties(account, AddUserAccountParam.class));
         Long userId = this.add(addUserParam);
-        MoneyAccountEntity entity = new MoneyAccountEntity();
 //        if (bizObj == BizObj.GeRen) {
 //            entity.setUserId(userId);
 //            moneyAccountService.add(entity);
 //            return;
 //        }
-        UserRegisterParam.Company company = userRegisterParam.getCompany();
+        Long companyId = null;
-        Assert.notNull(company, "公司信息不能为空");
+        if (!bizObj.isWastePersonal()) {
+            UserRegisterParam.Company company = userRegisterParam.getCompany();
+            Assert.notNull(company, "公司信息不能为空");
+            AddBizCompanyParam addBizCompanyParam = BeanUtil
+                    .copyProperties(company, AddBizCompanyParam.class)
+                    .setUserId(userId);
+            companyId = bizCompanyService.add(addBizCompanyParam);
+        }
+
 
-        AddBizCompanyParam addBizCompanyParam = BeanUtil
-                .copyProperties(company, AddBizCompanyParam.class)
-                .setUserId(userId);
-        Long companyId = bizCompanyService.add(addBizCompanyParam);
         // 添加账户信息
         if (bizObj.isTrans()) {
+            MoneyAccountEntity entity = new MoneyAccountEntity();
             entity.setStationId(companyId);
             moneyAccountService.add(entity);
         }

njzscloud-svr/src/main/java/com/njzscloud/supervisory/wxPay/service/WechatTemplateMessageService.java

@@ -1,6 +1,5 @@
 package com.njzscloud.supervisory.wxPay.service;
 
-import com.njzscloud.supervisory.wxPay.dto.TemplateData;
 import com.njzscloud.supervisory.wxPay.param.TemplateMessageParam;
 import org.springframework.scheduling.annotation.Async;
 

njzscloud-svr/src/main/resources/application-dev.yml

@@ -32,14 +32,10 @@ spring:
       - /hsoa/push_order
 app:
   default-place:
-    province: 320000
+    province: 340000
-    city: 320100
+    city: 341100
-    province-name: 江苏省
+    province-name: 安徽省
-    city-name: 南京市
+    city-name: 滁州市
-#    province: 340000
-#    city: 341100
-#    province-name: 安徽省
-#    city-name: 滁州市
 
 oss:
   type: ali
@@ -84,6 +80,9 @@ wechat:
     notify-url: http://115.29.236.92:8082/payment/wechat/notify
     # 退款回调地址
     refund-notify-url: http://115.29.236.92:8082/payment/wechat/refundNotify
+doubao:
+  api-name: api-key-20250411103646
+  api-key: e0fc97bb-2bb6-4525-a79b-1e3555026821
 mqtt:
   enabled: true
   broker: tcp://139.224.54.144:1883

njzscloud-svr/src/main/resources/application-prod.yml

@@ -70,7 +70,9 @@ wechat:
     notify-url: http://139.224.32.69:80/api/payment/wechat/notify
     # 退款回调地址
     refund-notify-url: http://139.224.32.69:80/api/payment/wechat/refundNotify
-
+doubao:
+  api-name: api-key-20250411103646
+  api-key: e0fc97bb-2bb6-4525-a79b-1e3555026821
 mqtt:
   enabled: true
   broker: tcp://127.0.0.1:1883

njzscloud-svr/src/main/resources/mapper/biz/BizDriverMapper.xml

@@ -36,7 +36,10 @@
     <select id="driverCantDel" resultMap="driverCantDelMap">
         SELECT b.driver_name, a.sn, a.order_status
         FROM order_info a
-                 INNER JOIN biz_driver b ON b.id = a.driver_id AND b.deleted = 0
+        INNER JOIN biz_driver b ON b.id = a.driver_id AND b.deleted = 0
+        <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''">
+            ${ew.customSqlSegment}
+        </if>
     </select>
 
 </mapper>

njzscloud-svr/src/main/resources/mapper/bs/SupervisionStatisticsMapper.xml

@@ -161,7 +161,11 @@
                MAX(IF(t = 9, c, 0))  todayWarnCount,
                MAX(IF(t = 10, c, 0)) todayUnwarnCount,
                MAX(IF(t = 11, c, 0)) yesterdayWarnCount,
-               MAX(IF(t = 12, c, 0)) yesterdayUnwarnCount
+               MAX(IF(t = 12, c, 0)) yesterdayUnwarnCount,
+               MAX(IF(t = 13, c, 0)) todayTotalCount,
+               MAX(IF(t = 14, c, 0)) yesterdayTotalCount,
+               MAX(IF(t = 15, c, 0)) currentMonthTotalCount,
+               MAX(IF(t = 16, c, 0)) lastMonthTotalCount
         FROM (SELECT ROUND(SUM(b.settle_weight) / 1000, 2) c, 1 t
               FROM order_info a
                        INNER JOIN order_car_in_out b ON b.id = a.car_in_out_id
@@ -256,7 +260,31 @@
               WHERE a.deleted = 0
                 AND a.warn = 0
                 AND b.out_time >= DATE_SUB(CURDATE(), INTERVAL 1 DAY)
-                AND b.out_time <![CDATA[ < ]]> CURDATE()) tt
+                AND b.out_time <![CDATA[ < ]]> CURDATE()
+              UNION ALL
+              SELECT COUNT(*) c, 14 t
+              FROM order_info a
+                       INNER JOIN order_car_in_out b ON b.id = a.car_in_out_id
+              WHERE a.deleted = 0
+                AND a.order_status = 'YiWanCheng'
+                AND b.out_time >= DATE_SUB(CURDATE(), INTERVAL 1 DAY)
+                AND b.out_time <![CDATA[ < ]]> CURDATE()
+              UNION ALL
+              SELECT COUNT(*) c, 15 t
+              FROM order_info a
+                       INNER JOIN order_car_in_out b ON b.id = a.car_in_out_id
+              WHERE a.deleted = 0
+                AND a.order_status = 'YiWanCheng'
+                AND b.out_time >= DATE_FORMAT(NOW(), '%Y-%m-01 00:00:00')
+                AND b.out_time <![CDATA[ < ]]> DATE_ADD(DATE_FORMAT(NOW(), '%Y-%m-01'), INTERVAL 1 MONTH)
+              UNION ALL
+              SELECT COUNT(*) c, 16 t
+              FROM order_info a
+                       INNER JOIN order_car_in_out b ON b.id = a.car_in_out_id
+              WHERE a.deleted = 0
+                AND a.order_status = 'YiWanCheng'
+                AND b.out_time >= DATE_FORMAT(DATE_SUB(NOW(), INTERVAL 1 MONTH), '%Y-%m-01 00:00:00')
+                AND b.out_time <![CDATA[ < ]]> DATE_FORMAT(NOW(), '%Y-%m-01 00:00:00')) tt
     </select>
 
     <select id="warnTruck" resultType="java.util.Map">

njzscloud-svr/src/main/resources/mapper/customer/CustomerMapper.xml

@@ -7,6 +7,11 @@
         <id column="company_id" property="id"/>
         <result column="contacts_phone" property="phone"/>
         <result column="audit_status" property="auditStatus" typeHandler="com.njzscloud.common.mp.support.handler.e.EnumTypeHandlerDealer"/>
+        <result column="idcard" property="idcard"/>
+        <result column="idcard_Start_Time" property="idcardStartTime"/>
+        <result column="idcard_end_time" property="idcardEndTime"/>
+        <result column="idcard_front" property="idcardFront"/>
+        <result column="idcard_back" property="idcardBack"/>
     </resultMap>
     <resultMap id="SearchCustomerResultMap" autoMapping="true" type="com.njzscloud.supervisory.customer.pojo.result.SearchCustomerResult">
         <id column="id" property="id"/>
@@ -47,7 +52,12 @@
         c.phone contacts_phone,
         c.audit_status,
         c.audit_memo,
-        c.settlement_way
+        c.settlement_way,
+        c.idcard,
+        c.idcard_Start_Time,
+        c.idcard_end_time,
+        c.idcard_front,
+        c.idcard_back
         FROM sys_user a
         INNER JOIN sys_user_account b ON b.user_id = a.id AND b.deleted = 0
         LEFT JOIN biz_company c ON c.user_id = a.id AND c.station = 0 AND c.deleted = 0

njzscloud-svr/src/main/resources/mapper/money/MoneyBillMapper.xml

@@ -16,7 +16,7 @@
             mb.bill_period as billPeriod,
             mb.goods_id as goodsId,
             mb.order_count as orderCount,
-            mb.total_weight as totalWeight,
+            ROUND(mb.total_weight / 1000, 2 ) AS totalWeight,
             mb.discount_money as discountMoney,
             mb.total_money as totalMoney,
             mb.creator_id as creatorId,
@@ -75,12 +75,13 @@
             oei.order_id,
             oei.discount_money,
             oei.settle_money,
-            oei.quantity
+            ocio.settle_weight
         FROM
             order_expense_items oei
                 LEFT JOIN order_info oi ON oi.id = oei.order_id
                 LEFT JOIN biz_company bc ON oi.trans_company_id = bc.id
                 LEFT JOIN sys_user su ON bc.user_id = su.id
+                LEFT JOIN order_car_in_out ocio ON ocio.id = oi.car_in_out_id
         WHERE
             oi.order_status = 'YiWanCheng'
             <if test="entity.startTime != null">
@@ -97,4 +98,4 @@
             </if>
         order by oei.create_time desc
     </select>
-</mapper>
+</mapper>

njzscloud-svr/src/main/resources/mapper/money/MoneyChangeDetailMapper.xml

@@ -20,6 +20,7 @@
         mcd.create_time,
         mcd.modify_time,
         mcd.deleted,
+        oi.sn,
         CASE
         WHEN mcd.user_id IS NOT NULL THEN u.nickname
         WHEN mcd.company_id IS NOT NULL THEN bc.company_name
@@ -28,6 +29,7 @@
         FROM money_change_detail mcd
         LEFT JOIN sys_user u ON mcd.user_id = u.id
         LEFT JOIN biz_company bc ON mcd.company_id = bc.id
+        LEFT JOIN order_info oi on oi.id = mcd.order_id
         <where>
             <if test="entity.nickname != null and entity.nickname != ''">
                 AND (u.nickname LIKE CONCAT('%', #{entity.nickname}, '%') or

njzscloud-svr/src/main/resources/mapper/order/OrderInfoMapper.xml

@@ -5,6 +5,8 @@
 
     <sql id="base_select">
         SELECT a.id,
+               a.target_order_id,
+               a.target_station_id,
                g.settlement_way,
                CASE g.settlement_way
                    WHEN 'month' THEN '月结'

njzscloud-svr/src/main/resources/mapper/route/OrderRouteMapper.xml

@@ -16,10 +16,12 @@
         a.modify_time,
         a.deleted,
         b.company_name start_address,
-        c.station_name end_address
+        c.station_name end_address,
+        d.project_name
         FROM order_route a
         LEFT JOIN biz_company b ON b.id = a.company_id
         LEFT JOIN biz_company c ON c.id = a.station_id
+        LEFT JOIN biz_project d ON d.id = a.project_id
         <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''">
             ${ew.customSqlSegment}
         </if>
@@ -39,10 +41,12 @@
                a.modify_time,
                a.deleted,
                b.company_name start_address,
-               c.station_name end_address
+               c.station_name end_address,
+               d.project_name
         FROM order_route a
                  LEFT JOIN biz_company b ON b.id = a.company_id
                  LEFT JOIN biz_company c ON c.id = a.station_id
+                 LEFT JOIN biz_project d ON d.id = a.project_id
         WHERE a.id = #{id}
           AND a.deleted = 0
     </select>
@@ -60,10 +64,12 @@
                a.modify_time,
                a.deleted,
                b.company_name start_address,
-               c.station_name end_address
+               c.station_name end_address,
+               d.project_name
         FROM order_route a
                  LEFT JOIN biz_company b ON b.id = a.company_id
                  LEFT JOIN biz_company c ON c.id = a.station_id
+                 LEFT JOIN biz_project d ON d.id = a.project_id
         WHERE a.order_id = #{orderId}
           AND a.deleted = 0
     </select>

njzscloud-svr/src/main/resources/mapper/route/RouteMapper.xml

@@ -15,10 +15,12 @@
         a.modify_time,
         a.deleted,
         b.company_name start_address,
-        c.station_name end_address
+        c.station_name end_address,
+        d.project_name
         FROM biz_route a
         LEFT JOIN biz_company b ON b.id = a.company_id
         LEFT JOIN biz_company c ON c.id = a.station_id
+        LEFT JOIN biz_project d ON d.id = a.project_id
         <if test="ew.customSqlSegment != null and ew.customSqlSegment != ''">
             ${ew.customSqlSegment}
         </if>
@@ -37,10 +39,12 @@
                a.modify_time,
                a.deleted,
                b.company_name start_address,
-               c.station_name end_address
+               c.station_name end_address,
+               d.project_name
         FROM biz_route a
                  LEFT JOIN biz_company b ON b.id = a.company_id
                  LEFT JOIN biz_company c ON c.id = a.station_id
+                 LEFT JOIN biz_project d ON d.id = a.project_id
         WHERE a.id = #{id}
           AND a.deleted = 0
     </select>

njzscloud-svr/src/main/resources/mapper/sys/auth/AuthMapper.xml

@@ -104,7 +104,12 @@
             bc.phone,
             bc.audit_status,
             bc.audit_memo,
-            ma.money
+            ma.money,
+            bc.idcard,
+            bc.idcard_Start_Time,
+            bc.idcard_end_time,
+            bc.idcard_front,
+            bc.idcard_back
         FROM
             biz_company bc
             LEFT JOIN money_account ma ON bc.id = ma.station_id