编辑代码

/**
* 创建人：吴东欣
* 时间：2021-10-16
* 需求描述：排课校验 
* 
* 2022-5-10保存前对明细里的日期和排课日期里的日期做对比
* 2022-6-19保存前对排课明细里的排课日期与讲师请假日期做对比
* 2022-6-28保存前对排课期数做校验，判断是否超过了排课期数
**/

if(true){
  String record_type=context.data.record_type as String 
  if(record_type=="default__c"){
    context.data.owner=["1291"] as List
  }
  
  
}




List scheduleDetails = context.details["object_3s7hD__c"] as List;  //排课明细
boolean isok=false;
String number1 = "";
String number2 = "";
String number3 = "";
String number4 = "";
String number5 = "";
String number6 = "";
String teacher = "";

scheduleDetails.each{
  item ->
  String classroom = item["field_2HQd3__c"] as String;    //获取“教室”
  List teacherx = item["field_HLros__c"] as List;    //获取“讲师”
  if(teacherx != null){
    teacher = teacherx[0];
  }
  DateTime startTime = item["field_57T2e__c"] as DateTime;    //获取“开始时间”
  DateTime endTime = item["field_9o2QQ__c"] as DateTime;    //获取“结束时间”
  log.info("教室：" + classroom);
  log.info("讲师：" + teacher);
  log.info("开始时间：" + startTime + "、" + "结束时间：" + endTime);
  
  /*
  以下条件判断冲突
  1.教室相同、历史数据开始时间 ≤ 申请数据的开始时间 ≤ 历史数据的结束时间
  2.教室相同、历史数据开始时间 ≤ 申请数据的结束时间 ≤ 历史数据的结束时间
  3.教室相同、历史数据开始时间 ≥ 申请数据的开始时间、历史数据的结束时间 ≤ 申请数据的结束时间
  4.讲师相同、历史数据开始时间 ≤ 申请数据的开始时间 ≤ 历史数据的结束时间
  5.讲师相同、历史数据开始时间 ≤ 申请数据的结束时间 ≤ 历史数据的结束时间
  6.讲师相同、历史数据开始时间 ≥ 申请数据的开始时间、历史数据的结束时间 ≤ 申请数据的结束时间
  */
  
  //1.教室相同、历史数据开始时间 ≤ 申请数据的开始时间 ≤ 历史数据的结束时间
  def ret1 = Fx.object.find("object_3s7hD__c",[["field_2HQd3__c":classroom],["field_57T2e__c":Operator.LTE(startTime)],["field_9o2QQ__c":Operator.GTE(startTime)]],10,0)
  if( ret1[0] ){
    log.info("教室相同判断类1查询出错，原因：" + ret1[2])
  }else{
    log.info("教室相同判断类1找到数据：" + ret1[1])
  }
  
  if(ret1[1]["dataList"] != [] && classroom !="62f1cc38736b6f000163f8ea"){
    number1 = number1 + ret1[1]["dataList"]["name"] as String;
    log.info("重复的历史数据：" + number1)
  }
  
  if(ret1[1]["size"] == 0 || classroom =="62f1cc38736b6f000163f8ea"){
    log.info("通过")
  }else{
    isok=true;
  }
  
  //2.教室相同、历史数据开始时间 ≤ 申请数据的结束时间 ≤ 历史数据的结束时间
  def ret2 = Fx.object.find("object_3s7hD__c",[["field_2HQd3__c":classroom],["field_57T2e__c":Operator.LTE(endTime)],["field_9o2QQ__c":Operator.GTE(endTime)]],10,0)
  if( ret2[0] ){
    log.info("教室相同判断类2查询出错，原因：" + ret2[2])
  }else{
    log.info("教室相同判断类2找到数据：" + ret2[1])
  }
  
  if(ret2[1]["dataList"] != [] && classroom !="62f1cc38736b6f000163f8ea"){
    number2 = number2 + ret2[1]["dataList"]["name"] as String;
    log.info("重复的历史数据：" + number2)
  }
  
  if(ret2[1]["size"] == 0 || classroom =="62f1cc38736b6f000163f8ea"){
    log.info("通过")
  }else{
    isok=true;
  }
  
  //3.教室相同、历史数据开始时间 ≥ 申请数据的开始时间、历史数据的结束时间 ≤ 申请数据的结束时间
  def ret3 = Fx.object.find("object_3s7hD__c",[["field_2HQd3__c":classroom],["field_57T2e__c":Operator.GTE(startTime)],["field_9o2QQ__c":Operator.LTE(endTime)]],10,0)
  if( ret3[0] ){
    log.info("教室相同判断类3查询出错，原因：" + ret3[2])
  }else{
    log.info("教室相同判断类3找到数据：" + ret3[1])
  }
  
  if(ret3[1]["dataList"] != [] && classroom !="62f1cc38736b6f000163f8ea"){
    number3 = number3 + ret3[1]["dataList"]["name"] as String;
    log.info("重复的历史数据：" + number3)
  }
  
  if(ret3[1]["size"] == 0 || classroom =="62f1cc38736b6f000163f8ea"){
    log.info("通过")
  }else{
    isok=true;
  }
  
  //4.讲师相同、历史数据开始时间 ≤ 申请数据的开始时间 ≤ 历史数据的结束时间
  def rgt1 = Fx.object.find("object_3s7hD__c",[["field_HLros__c":teacher],["field_57T2e__c":Operator.LTE(startTime)],["field_9o2QQ__c":Operator.GTE(startTime)]],10,0)
  if(rgt1[0]){
    log.info("讲师相同判断类1查询出错，原因：" + rgt1[2])
  }else{
    log.info("讲师相同判断类1找到数据: " + rgt1[1])
  }
  
  if(rgt1[1]["dataList"] != []){
    number4 = number4 + rgt1[1]["dataList"]["name"] as String;
    log.info("重复的历史数据：" + number4)
  }
  
  if(rgt1[1]["size"] == 0){
    log.info("通过")
  }else{
    isok=true;
  }
  
  //5.讲师相同、历史数据开始时间 ≤ 申请数据的结束时间 ≤ 历史数据的结束时间
  def rgt2 = Fx.object.find("object_3s7hD__c",[["field_HLros__c":teacher],["field_57T2e__c":Operator.LTE(endTime)],["field_9o2QQ__c":Operator.GTE(endTime)]],10,0)
  if( rgt2[0] ){
    log.info("讲师相同判断类2查询出错，原因：" + rgt2[2])
  }else{
    log.info("讲师相同判断类2找到数据：" + rgt2[1])
  }
  
  if(rgt2[1]["dataList"] != []){
    number5 = number5 + rgt2[1]["dataList"]["name"] as String;
    log.info("重复的历史数据：" + number5)
  }
  
  if(rgt2[1]["size"] == 0){
    log.info("通过")
  }else{
    isok=true;
  }
  
  //6.讲师相同、历史数据开始时间 ≥ 申请数据的开始时间、历史数据的结束时间 ≤ 申请数据的结束时间
  def rgt3 = Fx.object.find("object_3s7hD__c",[["field_HLros__c":teacher],["field_57T2e__c":Operator.GTE(startTime)],["field_9o2QQ__c":Operator.LTE(endTime)]],10,0)
  if( rgt3[0] ){
    log.info("讲师相同判断类3查询出错，原因：" + rgt3[2])
  }else{
    log.info("讲师相同判断类3找到数据：" + rgt3[1])
  }
  
  if(rgt3[1]["dataList"] != []){
    number6 = number6 + rgt3[1]["dataList"]["name"] as String;
    log.info("重复的历史数据：" + number6)
  }
  
  if(rgt3[1]["size"] == 0){
    log.info("通过")
  }else{
    isok=true;
  }
}

if(isok){
    //return ["error":true, "errorMessage":"与排课明细编号为：" + number1 + number2 + number3 + number4 + number5 + number6 + "有冲突", "block":true ]
  return ["error":true, "errorMessage":"教室上课时间有冲突，请检查排课使用的教室是否正确", "block":true ]
}

String record_type = context.data.record_type as String 
  String flag = '0'  //判断是否要阻断
  String making_people = context.userId as String
  def(boolean errorP, List dataP, String messageP) = Fx.auth.user.getRolesByUsers(1, [making_people])
  if (errorP) {
    log.info("error: " + messageP)
  } else {
    log.info(dataP)
    dataP.find{i ->
      Map tmp_people = i as Map
        if(tmp_people.containsValue("61302c0bbc2704167c5e2628")||tmp_people.containsValue("61302c370c2ec51a396f1f2c")||tmp_people.containsValue("61302c43a6b9516fc5930d79" )){   //如果是教研员
        flag = '2'
        log.info("教务员/大项目专员/大项目经理在操作该页面！")
        return true
      }else{
        flag = '1'
        log.info("校长在操作该页面")
      }
      if(tmp_people.containsValue("627db5503e048974906fd874")){
        flag = '1'
        log.info("受控的角色操作了页面")
        return true
      }
  }
  }
//2022-5-10保存前对明细里的日期和排课日期里的日期做对比，保持排课日期的值和明细里的值相同
List details = context.details["object_3s7hD__c"] as  List  //排课明细
  // log.info(details)
  List details_date = []
  details.each{i ->   //从排课明细中取出日期
    Map details_tmp = i as Map
    details_date.add(details_tmp.field_dX12n__c)
  }
  log.info("从排课明细中取出日期："+details_date)
  details_date = Fx.utils.listUnique(details_date)  //去重
  log.info("去重（从排课明细中取出）的日期："+details_date)
  String details_date_str = ''
  details_date.eachWithIndex{ item,int index ->
    String tmp = item as String
    if( index == 0 ){
      details_date_str = tmp
    }else{
      details_date_str+=","+tmp
    }
   
  }
  log.info("排课明细里的日期提取为字符串："+details_date_str)
context.data.field_44c1g__c = details_date_str
context.data.field_jjtcI__c =  details_date.size()  //排课天数
// if( record_type == 'default__c' || record_type == 'record_Penno__c'){
if( record_type == 'default__c' ){
  //2022-6-19保存前对排课明细里的排课日期与讲师请假日期做对比
  String rule = context.data.field_2d5dZ__c
  String teacher_id = context.data.field_0jhWj__c as String
  Map keyValue = [
    "teacherID":teacher_id,
    "hasBeenDate ":details_date_str,
    "rule":rule
  ]
  def (error1,result1,errorMessage1)  = Fx.function.executeFunc("func_jz713__c",keyValue)
  if( error1 ){
    log.info("查找讲师不能上课日期失败："+errorMessage1)
  }else{
    List date_str_list = (result1 as Map).date as List
    log.info("讲师不能上课日期："+date_str_list)
    List intersect_list = []
    date_str_list.each{i ->
      if( details_date_str.contains(i as String) ){
        log.info(i as String)
        intersect_list.add(i as String)
      }
    }
  log.info("交集日期："+intersect_list)
    if(intersect_list!=null&&intersect_list.size()>0){
      intersect_list = Fx.utils.listUnique(intersect_list)
      // if( flag !='2' ){  //教研只提醒
        return ["error":true, "errorMessage":"讲师在"+intersect_list+"请假/已有排课，请修改排课明细的日期！", "block":true ]
      // }else{
      // 不阻断
      //  return ["error":false, "errorMessage":"讲师在"+intersect_list+"请假/已有排课，请修改排课明细的日期！", "block":true ]
      // }
    }
    
    
  }
  /*******************************判断该校区是否有期数限制***************************************/
  
  String course = context.data.field_tP1kG__c as String   //课程id
  String course_r = context.data.field_l16Z4__c //课程名称
  String school = context.data.field_cAn5H__c as String //上课校区
  String school_level = context.data.field_Pzj6M__c as String
  String isX = 'N'
  APIResult ret = Fx.object.findOne("ProductObj", //查询客户对象
            FQLAttribute.builder()
                .columns(["_id", "name","field_B5b0b__c"]) //返回的数据id
                .queryTemplate( QueryTemplate.AND(["_id": QueryOperator.EQ(course)] ))
                .build(),
            SelectAttribute.builder()
                .needInvalid(true)
                .build());
  if(ret.isError()){
    log.info(ret.message());
  }else{
    log.info(ret.data)
    if( ((ret.data as Map).field_B5b0b__c as String )=='Z3tuqWYM8'){
      isX = 'Y'
    }
  }
  if( school_level!=null &&school_level == "A+" ){
    school_level =  "AA"
  }
  log.info("校区等级："+school_level)
  def (Boolean error,QueryResult data,String errorMessage) =
  Fx.object.find("object_tcZ0f__c",[["field_S3bYK__c":rule],["field_SN6AR__c": Operator.EQ(school_level)]],10,0);
  if( error ){
    log.info("查找课程期数失败："+errorMessage)
  }else{
    log.info("查找对应校区等级的课程期数："+data.total)
    if( data.total>0 ){
      log.info("有对应的课程期数限制："+data)
      Map tmp = data.dataList[0] as Map
      BigDecimal dz_quota = tmp.field_51I61__c as BigDecimal  //可排期数
      BigDecimal others_quota = tmp.field_J2ql9__c as BigDecimal  //可排期数
    log.info("当众讲话可排期数："+dz_quota+"   其他可排："+others_quota)
      //查找已创建的排课列表
      def (Boolean error12,QueryResult data12,String errorMessage12) =
      Fx.object.find("object_G2aY4__c",[["field_2d5dZ__c":rule],["field_cAn5H__c": Operator.EQ(school)],["_id":Operator.NE(context.data._id as String)],["field_tP1kG__c":Operator.EQ(course)]],10,0);
      if( error12 ){
        log.info("查找课程期数失败："+errorMessage12)
      }else{
        log.info("查找已排课表："+data12)
          if( course == "612d9a2a2a65980001f062bf" &&  (data12.total as BigDecimal)>= dz_quota ){
            log.info("当众讲话已达规则下可排课额度")

              return ["error":true, "errorMessage":"您校区的《当众讲话》已达本月的排课次数上限，不允许再排课!", "block":true ]
            // }
          
          }else if(course != "612d9a2a2a65980001f062bf" && isX =='Y' &&  (data12.total as BigDecimal)>= others_quota){
            log.info("已达规则下可排课额度")

              return ["error":true, "errorMessage":"您校区的《其他小课》已达本月的排课次数上限，不允许再排课!", "block":true ]
            // }
          }else{
            log.info("没有已排课表")
          }
      }
    }else{
      log.info("没有对应的课程期数限制")
    }
  }
  /*******************************END判断该校区是否有期数限制***************************************/
  
  /********************************改周五六日同城********************************************/
    Boolean isSameCity = false
  APIResult retRule = Fx.object.find("object_317OI__c", //查询客户对象
            FQLAttribute.builder()
                .columns(["_id", "field_23Kq4__c"]) //返回的数据id
                .queryTemplate( QueryTemplate.AND(["_id": QueryOperator.EQ(rule)] ))
                .build(),
            SelectAttribute.builder()
                .needInvalid(false) //是否需要返回作废数据
                .build());
  if(retRule.isError()){
      log.info(retRule.message());
  }else{
    log.info(retRule.data)
    if( (retRule.data as QueryResult).size>0 ){
      isSameCity = ((retRule.data as QueryResult).dataList[0] as Map).field_23Kq4__c as Boolean
    }
  }
  if(details_date !=null && details_date!=[]&& teacher_id!=null && teacher_id!='627caeca72b3950001377d94'&&isSameCity){
  List days_flag = []
  int days_count = 0
  List date_list = details_date
  date_list.each{i ->
    Date tmp_date = Date.of(i as String)
    if( (tmp_date.dayOfWeek as int) == 5){
      days_flag.add(["50":tmp_date])
      days_count+=1
    }else if((tmp_date.dayOfWeek as int) == 6){
      days_flag.add(["60":tmp_date])
      days_count+=1
    }else if((tmp_date.dayOfWeek as int) == 7){
      days_flag.add(["70":tmp_date])
      days_count+=1
    }
  }
  List find_days = []
  if( days_count!=0||days_count!=3 ){
    if( days_count == 1 ){
      log.info("选了三天中的一天")
      int dayOfWeek_tmp_int = 0
      List dayOfWeek_tmp = []
      days_flag.each{i ->
        dayOfWeek_tmp.add(((i as Map).keys() as List)[0] )
      }
      
      dayOfWeek_tmp.each{i1 ->    //找最大的日期是周几
        if( (i1 as int)>dayOfWeek_tmp_int ){
          dayOfWeek_tmp_int = i1 as int
        }
      }
      switch(dayOfWeek_tmp_int){
        case 50: 
          List dayOfWeek_date_list = days_flag.collect{x ->x["50"]} as List
          find_days.add((dayOfWeek_date_list[0] as Date)+1.days)
          find_days.add((dayOfWeek_date_list[0] as Date)+2.days)
          break;
        case 60: 
          List dayOfWeek_date_list = days_flag.collect{x ->x["60"]}
          find_days.add((dayOfWeek_date_list[0] as Date)+1.days)
          find_days.add((dayOfWeek_date_list[0] as Date)-1.days)
          break;
        case 70: 
          List dayOfWeek_date_list = days_flag.collect{x ->x["70"]}
          find_days.add((dayOfWeek_date_list[0] as Date)-1.days)
          find_days.add((dayOfWeek_date_list[0] as Date)-2.days)
          break;
        default:  break;

      }
      
    }
    if( days_count == 2 ){
      log.info("选了三天中的两天")
      List dayOfWeek_tmp = []
      days_flag.each{i ->
        dayOfWeek_tmp.add(((i as Map).keys() as List)[0] )
      }
      int dayOfWeek_tmp_int = 0
      dayOfWeek_tmp.each{i1 ->    //找最大的日期是周几
        dayOfWeek_tmp_int += (i1 as int)
      }
      switch(dayOfWeek_tmp_int){
        case 110:   //说明选的是周五周六
          List dayOfWeek_date_list = days_flag.collect{x ->x["60"]}
          log.info("110时取出的日期："+dayOfWeek_date_list)
          //因为collect取出来的日期是【null,2022-09-03】这样的格式，如果直接读取会报错，必须要找到非空的元素
          dayOfWeek_date_list.find{ i2 ->
            if( (i2 as Date)!=null ){//非空，则读取元素
              find_days.add(((i2 as Date)+1.days).toTimestamp() as long)  //找周日的日期
              return true
            }
          }
          break;
        case 120: //说明选的是周五周日
          List dayOfWeek_date_list = days_flag.collect{x ->x["50"]}
          log.info("120时取出的日期："+dayOfWeek_date_list)
          //因为collect取出来的日期是【null,2022-09-03】这样的格式，如果直接读取会报错，必须要找到非空的元素
          dayOfWeek_date_list.find{ i2 ->
            if( (i2 as Date)!=null ){//非空，则读取元素
              find_days.add(((i2 as Date)+1.days).toTimestamp() as long) //找周六的日期
              return true
            }
          }
          break;
        case 130: //说明选的是周日周六
          List dayOfWeek_date_list = days_flag.collect{x ->x["60"]}
          log.info("130时取出的日期："+dayOfWeek_date_list)
          //因为collect取出来的日期是【null,2022-09-03】这样的格式，如果直接读取会报错，必须要找到非空的元素
          dayOfWeek_date_list.find{ i2 ->
            if( (i2 as Date)!=null ){//非空，则读取元素
                find_days.add(((i2 as Date)-1.days).toTimestamp() as long) //找周五的日期
                return true
            }
          }
          break;
        default:  break;

      }       
    }
    log.info("需要查找的日期："+find_days+'讲师：'+teacher_id)
    if(find_days!=null&&find_days!=[]&&find_days.size()>0){
        APIResult ret0 = Fx.object.find("object_3s7hD__c", //查询排课明细对象
            FQLAttribute.builder()
                .columns(["field_4sD21__c","name"]) //返回的数据id
                .queryTemplate( QueryTemplate.AND(["field_HLros__c": QueryOperator.EQ(teacher_id)],["field_dX12n__c":Operator.IN(find_days)] ))
                .build(),
            SelectAttribute.builder()
                .needInvalid(false) //是否需要返回作废数据
                .build());
        if(ret0.isError()){
            log.info(ret0.message());
        }else{
          log.info("周五周六周日的排课明细"+ret0.data)
          QueryResult qr = ret0.data as QueryResult
          String city_standard = ''
          if( qr.size>0 ){
            APIResult ret1 = Fx.object.findOne("object_2bwgw__c", //查询本次排课中的校区对象
                FQLAttribute.builder()
                    .columns(["field_kx487__c"]) //返回的数据id
                    .queryTemplate( QueryTemplate.AND(["_id": QueryOperator.EQ(school)] ))
                    .build(),
                SelectAttribute.builder()
                    .needInvalid(false) //是否需要返回作废数据
                    .build());
            if(ret1.isError()){
                log.info(ret1.message());
            }else{
              log.info("校区"+school+"的城市为："+ret1.data)
              city_standard = (ret1.data as Map).field_kx487__c  as String 
            }
            List pk_dayOfWeek = (qr.dataList as List)
            String flag_1 = 'Y'
            List campus_dayOfWeek = pk_dayOfWeek.collect{x ->x["field_4sD21__c"]} as List
            campus_dayOfWeek.find{i2 ->
              APIResult ret2 = Fx.object.findOne("object_2bwgw__c", //查询周五六日校区对象
                  FQLAttribute.builder()
                      .columns(["name","field_kx487__c"]) //返回的数据id
                      .queryTemplate( QueryTemplate.AND(["_id": QueryOperator.EQ(i2 as String)] ))
                      .build(),
                  SelectAttribute.builder()
                      .needInvalid(false) //是否需要返回作废数据
                      .build());
              if(ret2.isError()){
                  log.info(ret2.message());
              }else{
                log.info("周五六日排课校区的城市为："+ret2.data)
                String city= (ret2.data as Map)."field_kx487__c" as String
                log.info("city:"+city+"  city_standard:"+city_standard)
                if( city!=null && city!=''&& !city.contains(city_standard)){
                  if((city.contains('484')&&city_standard.contains('479'))||(city.contains('479')&&city_standard.contains('484'))){
                    log.info("广佛")
                  }else{
                    flag_1 = 'N'
                      return true
                  }
                  }else{
                    log.info("城市为空或城市相等！")
                }
              }
    
            }
            if( flag_1 == 'N' ){
          //  return ["error":true, "errorMessage":"该老师在周五/六/日已有其他城市的排课！请修改排课日期!", "block":true ]
            }
               
            // }
          }else{
            log.info("周五六日暂时无多个城市的情况")
          }
        }
    }
    }else{
      log.info("没有选到周五周六日")
    }
  
  }

  
}else{
  log.info("不对日期做校验")
}

String fl = context.data.field_Gsdg5__c // 教研课程分类
String type = context.data.record_type //业务类型


if( type == "record_Penno__c" && fl == "服务大课" ){
  return ["error":true, "errorMessage":"请选择业务类型：小课、沙龙、服务大课排课!", "block":true ]
}

// 排课验证擅长课程

String skjs = context.data.field_9mq1d__c  //讲师姓名
log.info(skjs)

String pkmc = context.data.field_tP1kG__c //排课课程名称

log.info("排课课程名称："+pkmc)

//查询讲师信息表
def js = Fx.object.find("object_q4TS1__c",[["name":skjs]],10, 0)
if(js[0]){
  log.info("查询失败，原因："+ js[2])
}else{
//  log.info("查询到的列表数据："+ js[1])
}


List jsids1 = js[1]["dataList"]["_id"] as List //ID
String jsids = jsids1[0] as String

log.info("讲师ID："+jsids)



//查询擅长课程
def sckc = Fx.object.find("object_QKrk8__c",[["field_NwaBP__c":jsids]],50, 0)
if(sckc[0]){
  log.info("查询失败，原因："+ sckc[2])
}else{
//  log.info("查询到的列表数据："+ sckc[1])
}

String record = context.data.record_type //业务类型

String RS = context.data.field_oVkl9__c //讲师确认到课人数


List A = sckc[1]["dataList"] as List
List jssckc = []
A.each{
  itemA ->
    String kcmc = itemA["field_r0j45__c"]
    jssckc.add(kcmc)
}
log.info("取出擅长课程："+jssckc)

Boolean a = jssckc.containsAll(pkmc)

log.info(a)

if( a == false && jsids != "627caeca72b3950001377d94" && record == "default__c" && RS == null ){
  return ["error":true, "errorMessage":"该老师擅长课程没有这门课，请检查该老师的擅长课程!", "block":true ]
}


//排课验证距离

//查找距离表 是否符合授课范围 Y=是 N= 否
String JiaoShi=context.data.field_McOk7__c as String 
def jl = Fx.object.find("object_01jMZ__c",[["field_a6sO9__c":jsids,"field_1zrM6__c":JiaoShi]],100, 0)
if(jl[0]){
  log.info("查询失败，原因："+ jl[2])
}else{
//  log.info("查询到的列表数据："+ jl[1])
}

List jsjl1 = jl[1]["dataList"]["field_87mAQ__c"] as List //ID
String jsjl = jsjl1[0] as String

log.info("授课范围："+jsjl)



if( jsjl != "Y" && jsids != "627caeca72b3950001377d94" && record == "default__c" && RS == null ){
  return ["error":true, "errorMessage":"该老师授课距离不够，请检查该老师的授课距离!", "block":true ]  
}