763 lines
16 KiB
Go
763 lines
16 KiB
Go
package bitrix
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"crypto/hmac"
|
||
"crypto/sha256"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"fmt"
|
||
"io"
|
||
"net/http"
|
||
"net/url"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
)
|
||
|
||
type Service struct {
|
||
bitrixWebhookURL string
|
||
loadBalancerURL string
|
||
client *http.Client
|
||
retries int
|
||
backoff time.Duration
|
||
apiKeyPrivate string
|
||
apiKeyPublic string
|
||
}
|
||
|
||
type BitrixPayload struct {
|
||
Url string `json:"url"`
|
||
Method string `json:"method"`
|
||
Body interface{} `json:"body"`
|
||
}
|
||
|
||
func NewService(bitrixWebhookURL string, loadBalancerURL string, apiKeyPrivate string, apiKeyPublic string) *Service {
|
||
return &Service{
|
||
bitrixWebhookURL: bitrixWebhookURL,
|
||
loadBalancerURL: loadBalancerURL,
|
||
client: &http.Client{
|
||
Timeout: 15 * time.Minute,
|
||
},
|
||
retries: 1,
|
||
backoff: 1 * time.Second,
|
||
apiKeyPrivate: apiKeyPrivate,
|
||
apiKeyPublic: apiKeyPublic,
|
||
}
|
||
}
|
||
|
||
type bitrixError struct {
|
||
Error string `json:"error"`
|
||
ErrorDescription string `json:"error_description"`
|
||
}
|
||
|
||
func generateSignature(timestamp string, apiKeyPrivate string, apiKeyPublic string) string {
|
||
message := fmt.Sprintf("%s:%s", apiKeyPublic, timestamp)
|
||
|
||
h := hmac.New(sha256.New, []byte(apiKeyPrivate))
|
||
h.Write([]byte(message))
|
||
|
||
return hex.EncodeToString(h.Sum(nil))
|
||
}
|
||
|
||
func (s *Service) call(
|
||
ctx context.Context,
|
||
method string,
|
||
payload interface{},
|
||
result interface{},
|
||
) error {
|
||
|
||
bitrixWebhookURL := fmt.Sprintf("%s%s.json", s.bitrixWebhookURL, method)
|
||
|
||
packagedBitrixPayload := BitrixPayload{
|
||
Url: bitrixWebhookURL,
|
||
Method: "POST",
|
||
Body: payload,
|
||
}
|
||
body, err := json.Marshal(packagedBitrixPayload)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
var lastErr error
|
||
|
||
req, err := http.NewRequestWithContext(
|
||
ctx,
|
||
http.MethodPost,
|
||
s.loadBalancerURL,
|
||
bytes.NewBuffer(body),
|
||
)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
timestamp := fmt.Sprintf("%d", time.Now().Unix())
|
||
|
||
req.Header.Set("Content-Type", "application/json")
|
||
req.Header.Set("X-Timestamp", timestamp)
|
||
req.Header.Set("X-Signature", generateSignature(timestamp, s.apiKeyPrivate, s.apiKeyPublic))
|
||
|
||
resp, err := s.client.Do(req)
|
||
if err != nil {
|
||
lastErr = err
|
||
} else {
|
||
func() {
|
||
defer resp.Body.Close()
|
||
|
||
respBody, err := io.ReadAll(resp.Body)
|
||
if err != nil {
|
||
lastErr = err
|
||
return
|
||
}
|
||
|
||
if resp.StatusCode >= 500 {
|
||
lastErr = fmt.Errorf("server error: %s", resp.Status)
|
||
return
|
||
}
|
||
|
||
respBody = bytes.TrimSpace(respBody)
|
||
if len(respBody) == 0 {
|
||
lastErr = nil
|
||
return
|
||
}
|
||
|
||
var wrapper struct {
|
||
Body struct {
|
||
Result json.RawMessage `json:"result"`
|
||
Error string `json:"error"`
|
||
ErrorDescription string `json:"error_description"`
|
||
} `json:"body"`
|
||
}
|
||
|
||
if err := json.Unmarshal(respBody, &wrapper); err != nil {
|
||
lastErr = err
|
||
return
|
||
}
|
||
|
||
if wrapper.Body.Error != "" {
|
||
lastErr = fmt.Errorf("%s: %s", wrapper.Body.Error, wrapper.Body.ErrorDescription)
|
||
return
|
||
}
|
||
|
||
if result != nil {
|
||
raw := bytes.TrimSpace(wrapper.Body.Result)
|
||
|
||
if bytes.Equal(raw, []byte("[]")) {
|
||
lastErr = nil
|
||
return
|
||
}
|
||
|
||
if len(raw) == 0 || bytes.Equal(raw, []byte("null")) {
|
||
lastErr = nil
|
||
return
|
||
}
|
||
|
||
if err := json.Unmarshal(wrapper.Body.Result, result); err != nil {
|
||
lastErr = err
|
||
return
|
||
}
|
||
}
|
||
|
||
lastErr = nil
|
||
}()
|
||
|
||
if lastErr == nil {
|
||
return nil
|
||
}
|
||
}
|
||
return fmt.Errorf("bitrix call failed: %w", lastErr)
|
||
}
|
||
|
||
func (s *Service) GetTaskUsers(
|
||
ctx context.Context,
|
||
taskID int,
|
||
) (int, []int, error) {
|
||
payload := map[string]interface{}{
|
||
"taskId": taskID,
|
||
"select": []string{"CHANGED_BY", "AUDITORS"},
|
||
}
|
||
|
||
var resp struct {
|
||
Task struct {
|
||
ChangedBy string `json:"changedBy"`
|
||
Auditors []string `json:"auditors"`
|
||
} `json:"task"`
|
||
}
|
||
|
||
err := s.call(ctx, "tasks.task.get", payload, &resp)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
|
||
changedBy, err := strconv.Atoi(resp.Task.ChangedBy)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
|
||
auditors := make([]int, len(resp.Task.Auditors))
|
||
for i, idStr := range resp.Task.Auditors {
|
||
id, err := strconv.Atoi(idStr)
|
||
if err != nil {
|
||
return 0, nil, err
|
||
}
|
||
auditors[i] = id
|
||
}
|
||
|
||
return changedBy, auditors, nil
|
||
}
|
||
|
||
func (s *Service) SetTaskAuditors(
|
||
ctx context.Context,
|
||
taskID int,
|
||
auditors []int,
|
||
) error {
|
||
auditorsStr := make([]string, len(auditors))
|
||
for i, id := range auditors {
|
||
auditorsStr[i] = strconv.Itoa(id)
|
||
}
|
||
|
||
payload := map[string]interface{}{
|
||
"taskId": taskID,
|
||
"fields": map[string]interface{}{
|
||
"AUDITORS": auditorsStr,
|
||
},
|
||
}
|
||
|
||
var resp struct {
|
||
Result interface{} `json:"result"`
|
||
}
|
||
|
||
return s.call(ctx, "tasks.task.update", payload, &resp)
|
||
}
|
||
|
||
func (s *Service) SyncTaskCompletion(ctx context.Context, taskID int) error {
|
||
|
||
type taskInfo struct {
|
||
Status int `json:"status,string"`
|
||
IsCopyString string `json:"ufAuto682289870673"`
|
||
CopyID int `json:"ufAuto889836441236,string"`
|
||
ParentID int `json:"parentId,string"`
|
||
TaskControl string `json:"taskControl"`
|
||
}
|
||
|
||
getPayload := map[string]interface{}{
|
||
"taskId": taskID,
|
||
"select": []string{
|
||
"STATUS",
|
||
"UF_AUTO_889836441236",
|
||
"UF_AUTO_682289870673",
|
||
"PARENT_ID",
|
||
"TASK_CONTROL",
|
||
},
|
||
}
|
||
|
||
var getResp struct {
|
||
Task taskInfo `json:"task"`
|
||
}
|
||
|
||
if err := s.call(ctx, "tasks.task.get", getPayload, &getResp); err != nil {
|
||
return err
|
||
}
|
||
|
||
current := getResp.Task
|
||
if current.Status == 5 {
|
||
err := s.CompleteSubtasks(ctx, taskID)
|
||
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) SetTaskControl(ctx context.Context, taskID int, control bool) error {
|
||
controlStr := "N"
|
||
if control {
|
||
controlStr = "Y"
|
||
}
|
||
payload := map[string]interface{}{
|
||
"taskId": taskID,
|
||
"fields": map[string]interface{}{
|
||
"TASK_CONTROL": controlStr,
|
||
},
|
||
}
|
||
|
||
var resp struct {
|
||
Result interface{} `json:"result"`
|
||
}
|
||
|
||
return s.call(ctx, "tasks.task.update", payload, &resp)
|
||
}
|
||
|
||
type taskInfo struct {
|
||
ResponsibleID int `json:"responsibleId,string"`
|
||
ChangedBy int `json:"changedBy,string"`
|
||
TaskName string `json:"title"`
|
||
}
|
||
|
||
func (s *Service) GetTaskInfo(
|
||
ctx context.Context,
|
||
taskID int,
|
||
) (*taskInfo, error) {
|
||
// --- 1. Получаем задачу ---
|
||
|
||
getTaskPayload := map[string]interface{}{
|
||
"taskId": taskID,
|
||
"select": []string{
|
||
"RESPONSIBLE_ID",
|
||
"CHANGED_BY",
|
||
"TITLE",
|
||
},
|
||
}
|
||
|
||
var taskResp struct {
|
||
Task taskInfo `json:"task"`
|
||
}
|
||
|
||
if err := s.call(ctx, "tasks.task.get", getTaskPayload, &taskResp); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &taskResp.Task, nil
|
||
}
|
||
|
||
func (s *Service) IsSelfRequest(
|
||
changedBy int,
|
||
excludedUserID int,
|
||
) bool {
|
||
return changedBy == excludedUserID
|
||
}
|
||
|
||
func (s *Service) ValidateTaskUserDeps(
|
||
ctx context.Context,
|
||
responsibleID int,
|
||
allowedDepartmentIDs []int,
|
||
) (bool, []int, error) {
|
||
// --- 3. Получаем отделы исполнителя ---
|
||
getUserPayload := map[string]interface{}{
|
||
"filter": map[string]interface{}{
|
||
"ID": responsibleID,
|
||
},
|
||
"select": []string{"UF_DEPARTMENT"},
|
||
}
|
||
|
||
var users []struct {
|
||
Departments []int `json:"UF_DEPARTMENT"`
|
||
}
|
||
|
||
if err := s.call(ctx, "user.get", getUserPayload, &users); err != nil {
|
||
return false, []int{}, err
|
||
}
|
||
|
||
if len(users) == 0 {
|
||
return false, []int{}, nil
|
||
}
|
||
|
||
userDepartments := users[0].Departments
|
||
|
||
// --- 4. Проверяем пересечение отделов ---
|
||
deptSet := make(map[int]struct{}, len(allowedDepartmentIDs))
|
||
for _, id := range allowedDepartmentIDs {
|
||
deptSet[id] = struct{}{}
|
||
}
|
||
|
||
for _, userDept := range userDepartments {
|
||
if _, ok := deptSet[userDept]; ok {
|
||
return true, userDepartments, nil
|
||
}
|
||
}
|
||
|
||
return false, []int{}, nil
|
||
}
|
||
|
||
type TaskTag struct {
|
||
ID int `json:"id"`
|
||
Title string `json:"title"`
|
||
}
|
||
|
||
type TaskTags map[string]TaskTag
|
||
|
||
func (t *TaskTags) UnmarshalJSON(data []byte) error {
|
||
|
||
// Если пришёл пустой массив
|
||
if string(data) == "[]" {
|
||
*t = make(TaskTags)
|
||
return nil
|
||
}
|
||
|
||
// Если пришёл null
|
||
if string(data) == "null" {
|
||
*t = make(TaskTags)
|
||
return nil
|
||
}
|
||
|
||
// Пробуем распарсить как объект
|
||
var obj map[string]TaskTag
|
||
if err := json.Unmarshal(data, &obj); err == nil {
|
||
*t = obj
|
||
return nil
|
||
}
|
||
|
||
return fmt.Errorf("unsupported tags format: %s", string(data))
|
||
}
|
||
|
||
type CRMTags []string
|
||
|
||
func (c *CRMTags) UnmarshalJSON(data []byte) error {
|
||
|
||
// null → пустой слайс
|
||
if string(data) == "null" {
|
||
*c = []string{}
|
||
return nil
|
||
}
|
||
|
||
// Пробуем распарсить как массив строк
|
||
var arr []string
|
||
if err := json.Unmarshal(data, &arr); err == nil {
|
||
*c = arr
|
||
return nil
|
||
}
|
||
|
||
// Если приходит одиночная строка (редкий кейс)
|
||
var s string
|
||
if err := json.Unmarshal(data, &s); err == nil {
|
||
*c = []string{s}
|
||
return nil
|
||
}
|
||
|
||
return fmt.Errorf("unsupported ufCrmTask format: %s", string(data))
|
||
}
|
||
|
||
type TaskDetails struct {
|
||
ID int `json:"id,string"`
|
||
ParentID int `json:"parentId,string"`
|
||
IsCopy *string `json:"ufAuto682289870673"`
|
||
CopyID *string `json:"ufAuto889836441236"`
|
||
ResponsibleID int `json:"responsibleId,string"`
|
||
CreatorID int `json:"createdBy,string"`
|
||
Title string `json:"title"`
|
||
Deadline *string `json:"deadline"`
|
||
CRMElements CRMTags `json:"ufCrmTask"`
|
||
Description string `json:"description"`
|
||
RequiresAcceptance string `json:"allowChangeDeadline"`
|
||
ProjectID int `json:"groupId,string"`
|
||
Tags TaskTags `json:"tags"`
|
||
}
|
||
|
||
type taskWrapper struct {
|
||
Task TaskOrArray `json:"task"`
|
||
}
|
||
|
||
type TaskOrArray struct {
|
||
Task *TaskDetails
|
||
}
|
||
|
||
func (t *TaskOrArray) UnmarshalJSON(data []byte) error {
|
||
if len(data) == 0 || string(data) == "null" {
|
||
t.Task = nil
|
||
return nil
|
||
}
|
||
|
||
if data[0] == '[' {
|
||
var arr []TaskDetails
|
||
if err := json.Unmarshal(data, &arr); err != nil {
|
||
return err
|
||
}
|
||
if len(arr) > 0 {
|
||
t.Task = &arr[0]
|
||
} else {
|
||
t.Task = nil
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// объект
|
||
var obj TaskDetails
|
||
if err := json.Unmarshal(data, &obj); err != nil {
|
||
return err
|
||
}
|
||
t.Task = &obj
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) GetTaskDetails(ctx context.Context, taskID int) (*TaskDetails, error) {
|
||
|
||
payload := map[string]interface{}{
|
||
"taskId": taskID,
|
||
"select": []string{
|
||
"ID",
|
||
"UF_AUTO_682289870673",
|
||
"UF_AUTO_889836441236",
|
||
"RESPONSIBLE_ID",
|
||
"CREATED_BY",
|
||
"TITLE",
|
||
"DEADLINE",
|
||
"UF_CRM_TASK",
|
||
"DESCRIPTION",
|
||
"ALLOW_CHANGE_DEADLINE",
|
||
"GROUP_ID",
|
||
"TAGS",
|
||
"PARENT_ID",
|
||
},
|
||
}
|
||
|
||
var resp taskWrapper
|
||
|
||
if err := s.call(ctx, "tasks.task.get", payload, &resp); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return resp.Task.Task, nil
|
||
}
|
||
|
||
func extractTagTitles(tags map[string]TaskTag) []string {
|
||
if tags == nil {
|
||
return []string{}
|
||
}
|
||
|
||
result := make([]string, 0, len(tags))
|
||
for _, tag := range tags {
|
||
result = append(result, tag.Title)
|
||
}
|
||
return result
|
||
}
|
||
|
||
func buildAddCopyCommand(task TaskDetails, auditorIDs []int, CRMElementNames []string) string {
|
||
const taskDescriptionTemplate = `Эта задача является дублем задачи, которую тебе поставил руководитель. Она нужна, чтобы ты мог планировать свой день (изначально крайний срок выбирает постановщик, но именно в этой задаче крайний срок выбирается автоматически сегодня, а ты можешь менять его, используя это поле крайнего срока как дату ближайшего контакта с этой задачей. Не забывай при этом выполнять её в срок, который тебе назначил руководитель.`
|
||
|
||
values := url.Values{}
|
||
|
||
values.Set("fields[TITLE]", "Копия "+task.Title)
|
||
values.Set(
|
||
"fields[DESCRIPTION]",
|
||
taskDescriptionTemplate+"\n\n"+task.Description,
|
||
)
|
||
values.Set("fields[RESPONSIBLE_ID]", strconv.Itoa(task.ResponsibleID))
|
||
values.Set("fields[CREATED_BY]", strconv.Itoa(task.ResponsibleID))
|
||
values.Set("fields[GROUP_ID]", strconv.Itoa(task.ProjectID))
|
||
values.Set("fields[PARENT_ID]", strconv.Itoa(task.ID))
|
||
values.Set("fields[DEADLINE]", time.Now().Format(time.RFC3339))
|
||
|
||
values.Set("fields[ALLOW_CHANGE_DEADLINE]", "Y")
|
||
values.Set("fields[UF_AUTO_682289870673]", "Y") // Копия задачи = да
|
||
values.Set("fields[TASK_CONTROL]", "N")
|
||
values.Set("fields[MATCH_WORK_TIME]", "N")
|
||
|
||
// Наблюдатели
|
||
for i, id := range auditorIDs {
|
||
values.Set(
|
||
fmt.Sprintf("fields[AUDITORS][%d]", i),
|
||
strconv.Itoa(id),
|
||
)
|
||
}
|
||
|
||
// for i, crm := range task.CRMElements {
|
||
// values.Set(
|
||
// fmt.Sprintf("fields[UF_CRM_TASK][%d]", i),
|
||
// crm,
|
||
// )
|
||
// }
|
||
|
||
i := 0
|
||
for _, tag := range task.Tags {
|
||
values.Set(
|
||
fmt.Sprintf("fields[TAGS][%d]", i),
|
||
tag.Title,
|
||
)
|
||
i++
|
||
}
|
||
|
||
for _, crmName := range CRMElementNames {
|
||
values.Set(
|
||
fmt.Sprintf("fields[TAGS][%d]", i),
|
||
crmName,
|
||
)
|
||
i++
|
||
}
|
||
|
||
return "tasks.task.add?" + values.Encode()
|
||
}
|
||
|
||
func (s *Service) CreateTaskCopyAtomic(
|
||
ctx context.Context,
|
||
task TaskDetails,
|
||
auditorIDs []int,
|
||
CRMElementNames []string,
|
||
) error {
|
||
|
||
addCmd := buildAddCopyCommand(task, auditorIDs, CRMElementNames)
|
||
|
||
updateCmd := fmt.Sprintf(
|
||
"tasks.task.update?taskId=%d&fields[UF_AUTO_889836441236]=$result[add_copy][task][id]",
|
||
task.ID,
|
||
)
|
||
|
||
batchPayload := map[string]interface{}{
|
||
"cmd": map[string]string{
|
||
"add_copy": addCmd,
|
||
"link_original": updateCmd,
|
||
},
|
||
}
|
||
|
||
if err := s.call(ctx, "batch", batchPayload, nil); err != nil {
|
||
return err
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) GetCRMElementTitles(
|
||
ctx context.Context,
|
||
crmIDs []string,
|
||
) ([]string, error) {
|
||
|
||
if len(crmIDs) == 0 {
|
||
return nil, nil
|
||
}
|
||
|
||
cmd := make(map[string]string)
|
||
|
||
index := 0
|
||
|
||
for _, crm := range crmIDs {
|
||
|
||
parts := strings.SplitN(crm, "_", 2)
|
||
if len(parts) != 2 {
|
||
continue
|
||
}
|
||
|
||
prefix := parts[0]
|
||
id := parts[1]
|
||
|
||
var method string
|
||
|
||
switch prefix {
|
||
case "D":
|
||
method = "crm.deal.get"
|
||
case "L":
|
||
method = "crm.lead.get"
|
||
case "C":
|
||
method = "crm.contact.get"
|
||
case "CO":
|
||
method = "crm.company.get"
|
||
default:
|
||
continue
|
||
}
|
||
|
||
cmdName := fmt.Sprintf("crm_%d", index)
|
||
cmd[cmdName] = fmt.Sprintf("%s?id=%s", method, id)
|
||
|
||
index++
|
||
}
|
||
|
||
if len(cmd) == 0 {
|
||
return nil, nil
|
||
}
|
||
|
||
payload := map[string]interface{}{
|
||
"cmd": cmd,
|
||
}
|
||
|
||
var batchResult struct {
|
||
Result map[string]json.RawMessage `json:"result"`
|
||
ResultError json.RawMessage `json:"result_error"`
|
||
}
|
||
|
||
if err := s.call(ctx, "batch", payload, &batchResult); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if len(batchResult.ResultError) > 0 {
|
||
|
||
// Проверяем, это массив?
|
||
var arr []interface{}
|
||
if err := json.Unmarshal(batchResult.ResultError, &arr); err == nil {
|
||
if len(arr) > 0 {
|
||
return nil, fmt.Errorf("batch error: %+v", arr)
|
||
}
|
||
} else {
|
||
// иначе это объект
|
||
var obj map[string]interface{}
|
||
if err := json.Unmarshal(batchResult.ResultError, &obj); err == nil {
|
||
if len(obj) > 0 {
|
||
return nil, fmt.Errorf("batch error: %+v", obj)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
titles := make([]string, 0, len(batchResult.Result))
|
||
|
||
for key := range cmd {
|
||
|
||
var raw map[string]interface{}
|
||
|
||
if err := json.Unmarshal(batchResult.Result[key], &raw); err != nil {
|
||
continue
|
||
}
|
||
|
||
// Возможные варианты структуры ответа
|
||
// Сделка/лид -> TITLE
|
||
// Контакт -> NAME + LAST_NAME
|
||
// Компания -> TITLE
|
||
|
||
if title, ok := raw["TITLE"].(string); ok && title != "" {
|
||
titles = append(titles, title)
|
||
continue
|
||
}
|
||
|
||
name, _ := raw["NAME"].(string)
|
||
lastName, _ := raw["LAST_NAME"].(string)
|
||
|
||
fullName := strings.TrimSpace(name + " " + lastName)
|
||
if fullName != "" {
|
||
titles = append(titles, fullName)
|
||
}
|
||
}
|
||
|
||
return titles, nil
|
||
}
|
||
|
||
type taskListResponse struct {
|
||
Tasks []struct {
|
||
ID int `json:"id,string"`
|
||
} `json:"tasks"`
|
||
}
|
||
|
||
func (s *Service) CompleteSubtasks(ctx context.Context, taskID int) error {
|
||
// Получаем список подзадач
|
||
var resp taskListResponse
|
||
|
||
err := s.call(
|
||
ctx,
|
||
"tasks.task.list",
|
||
map[string]interface{}{
|
||
"filter": map[string]interface{}{
|
||
"PARENT_ID": taskID,
|
||
},
|
||
"select": []string{"ID"},
|
||
},
|
||
&resp,
|
||
)
|
||
if err != nil {
|
||
return fmt.Errorf("get subtasks: %w", err)
|
||
}
|
||
|
||
// Завершаем каждую подзадачу
|
||
for _, task := range resp.Tasks {
|
||
if err := s.call(
|
||
ctx,
|
||
"tasks.task.complete",
|
||
map[string]interface{}{
|
||
"taskId": task.ID,
|
||
},
|
||
nil,
|
||
); err != nil {
|
||
return fmt.Errorf("complete subtask %d: %w", task.ID, err)
|
||
}
|
||
}
|
||
|
||
return nil
|
||
}
|