点击此处--->   群内免费提供SAP练习系统（在群公告中）

加入QQ群：457200227（SAP S4 HANA技术交流） 群内免费提供SAP练习系统（在群公告中）

打包com.company.aifunctionalbot.javamodule;

 
//导入com.fasterxml.jackson.databind.PropertyName;
 导入com.google.gson.Gson；
 导入com.google.gson.annotations.Expose;
 导入com.google.gson.annotations.SerializedName;
//导入com.sap.cloud.sdk.s4hana.datamodel.odata.namespaces.productmaster.OperationalAcctgDocItemCube;
 导入com.sap.cloud.sdk.s4hana.datamodel.odata.namespaces.productmaster.ProductFluentHelper;
 导入com.sap.cloud.sdk.s4hana.datamodel.odata.namespaces.productmaster.Product;
 导入com.sap.cloud.sdk.s4hana.datamodel.odata.services.ProductMasterService;
 导入com.sap.cloud.sdk.s4hana.datamodel.odata.services.DefaultProductMasterService;
 导入org.slf4j.Logger;

 导入javax.servlet.ServletException;
 导入javax.servlet.annotation.WebServlet;
 导入javax.servlet.http.HttpServlet;
 导入javax.servlet.http.HttpServletRequest;
 导入javax.servlet.http.HttpServletResponse;
 导入java.io.BufferedReader;
 导入java.io.IOException;
 导入java.util.List;

 导入com.sap.cloud.sdk.cloudplatform.logging.CloudLoggerFactory;
 导入com.sap.cloud.sdk.odatav2.connectivity.ODataException;

 @WebServlet（"/img/hello"）
 公共类HelloServlet扩展HttpServlet {

     私有静态最终长serialVersionUID = 1L;
     私有静态最终Logger logger = CloudLoggerFactory.getLogger（Product.class）;

     @Override
     受保护的void doGet（最终HttpServletRequest请求，最终HttpServletResponse响应）
             引发ServletException，IOException {
             System.out.println（" Message"）;
         尝试{
        
             列表<产品> productResult =
                     新的DefaultProductMasterService（）。getAllProduct（）。select（Product.PRODUCT_TYPE，
                             产品。PRODUCT_GROUP，
                             产品（PRODUCT。）
                             .filter（Product.IS_RELEVANT_FOR_HZDS_SUBSTANCES.eq（false））
                             。执行（）;

             response.setContentType（" application/json"）;
             response.getWriter（）。write（new Gson（）。toJson（productResult））;

         } catch（final ODataException e）{
             logger.error（e.getMessage（），e）;
             response.setStatus（HttpServletResponse.SC_INTERNAL_SERVER_ERROR）;
             response.getWriter（）。write（e.getMessage（））;
         }
     }

     @Override
     受保护的void doPost（最终HttpServletRequest请求，最终HttpServletResponse响应）抛出ServletException，IOException {
         BufferedReader reader = request.getReader（）;
         Gson gson =新的Gson（）;
         RecastData myData = gson.fromJson（阅读器，RecastData.class）;

         尝试{
             实体实体= myData.getNlp（）。getEntities（）;
             字符串property_name;

             TextResponse textResponse = new TextResponse（）;

             if（entities.getPropertyName（）== null）{
                 textResponse.setContent（"嗯，我无法识别此客户"）;
             }其他{
                property_name =实体.getPropertyName（）。get（0）.getValue（）;
                 列表<产品> productResult =
                         新的DefaultProductMasterService（）。getAllProduct（）。select（
                                 产品。PRODUCT_TYPE，
                                 产品。PRODUCT_GROUP）
                                 .filter（Product.PRODUCT.eq（property_name））
                                 。执行（）;

                 如果（productResult.size（）> 0）{
                     产品oneDoc = productResult.get（0）;
                     textResponse.setContent（"有未清除的文档。例如文档" + oneDoc.getProductGroup（）+"与公司" + oneDoc.getProductType（））；
                 }其他{
                     textResponse.setContent（"没有未清除的文档！太好了"）;
                 }
             }

             ResponseWrapper responseWrapper =新的ResponseWrapper（textResponse）;
             response.setContentType（" application/json"）;
             response.getWriter（）。println（responseWrapper.getResponse（））;

         } catch（final ODataException e）{
             logger.error（e.getMessage（），e）;
             response.setContentType（" application/json"）;
             response.getWriter（）。write（e.getMessage（））;
         }
     }

     静态类RecastData {
         @SerializedName（" nlp"）
         @暴露
         私人Nlp nlp；

         公共Nlp getNlp（）{
             返回nlp;
         }
     }

     静态类Nlp {
         @SerializedName（"实体"）
         @暴露
         私人实体实体；

         公共实体getEntities（）{
             返回实体；
         }

         public void setEntities（实体实体）{
             this.entities =实体；
         }
     }

     静态类实体{
         @SerializedName（" product_name"）
         @暴露
         私有List  property_name = null;

         公共列表 getPropertyName（）{
             返回property_name;
         }

         公共无效setProduct（List  property_name）{
             this.property_name = property_name;
         }
    }

     静态类PropertyName {
         @SerializedName（" value"）
         @暴露
         私有字符串值；
         @SerializedName（" raw"）
         @暴露
         私有String raw;
         @SerializedName（"信心"）
         @暴露
         私有字符串置信度；

         公共字符串getValue（）{
             返回值
         }

         public void setValue（String value）{
             this.value =值;
         }

         公共字符串getRaw（）{
             退货
         }

         公共无效setRaw（原始字符串）{
             this.raw = raw;
         }

         公共字符串getConfidence（）{
             恢复信心；
         }

         公共无效setConfidence（字符串的置信度）{
             this.confidence =信心；
         }
     }

     静态类TextResponse {
         字符串类型="文本"；
         字符串内容；

         公共字符串getResponse（）{
             Gson gson =新的Gson（）;
             返回gson.toJson（this）;
         }

         public void setContent（String content）{
             this.content =内容；
         }
     }

     静态类ResponseWrapper {
         TextResponse []答复；
         对话对话；

         公共ResponseWrapper（TextResponse回复）{
             this.replies = new TextResponse [] {replies};
             this.conversation =新会话（新Memory（））;
         }

         公共字符串getResponse（）{
             Gson gson =新的Gson（）;
             返回gson.toJson（this）;
         }

         公共内存getMemory（）{
             返回对话.getMemory（）;
         }

         公共无效setMemory（内存内存）{
             this.conversation.setMemory（memory）;
         }

     }

     静态类Memory {
     }

     静态课程会话{
         内存内存；

         公众对话（记忆）{
             this.memory =内存；
         }

         公共内存getMemory（）{
             返回内存；
         }

         公共无效setMemory（内存内存）{
             this.memory =内存；
         }
     }

  

 }