How to Create a Task with an Attached File

from b24pysdk import BitrixWebhook, Client
        
        token = BitrixWebhook(
            domain="your-domain.bitrix24.com",
            webhook_token="user_id/webhook_key",
        )
        client = Client(token)
        
        result = client.disk.folder.uploadfile(
            bitrix_id=1739,
            data={
                "NAME": "ava555.jpg",
            },
            file_content=[
                "avatar.jpg",
                "/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAQDAwQDAwQEAwQ///+dAYq6YFKoAv/AFnAa6ArKv8AAtFJVppxCEAulxQ2DWgfMR//2Q==",
            ],
        ).response.result
        

require_once 'vendor/autoload.php';
        
        use Bitrix24\SDK\Services\ServiceBuilderFactory;
        use Symfony\Component\EventDispatcher\EventDispatcher;
        
        $serviceBuilder = (new ServiceBuilderFactory(new EventDispatcher(), $log))
            ->initFromWebhook('https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/');
        
        $result = $serviceBuilder->getDiskScope()->folder()->uploadFile(
            1739,
            ['NAME' => 'ava555.jpg'],
            [
                'avatar.jpg',
                '/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAQDAwQDAwQEAwQ///+dAYq6YFKoAv/AFnAa6ArKv8AAtFJVppxCEAulxQ2DWgfMR//2Q=='
            ]
        );
        
        echo '<PRE>';
        print_r($result->getFile());
        echo '</PRE>';
        

// fileContent is the Bitrix24 file transport: an array with two elements,
        // [file name, Base64 content]. The request body is already JSON, so a regular
        // []string is serialized exactly as the method expects: no multipart or manual
        // URL encoding is required. Base64 increases the data size by about one third,
        // so use this path for small files.
        res, err := core.Call(ctx, "disk.folder.uploadFile", b24.Params{
            "id":          folderID,
            "data":        b24.Params{"NAME": "report.txt"},
            "fileContent": []string{"report.txt", base64.StdEncoding.EncodeToString(content)},
            // Rerunning the example should not fail because of matching names.
            "generateUniqueName": true,
        })
        if err != nil {
            return fmt.Errorf("disk.folder.uploadFile: %w", err)
        }
        
        var file struct {
            // ID is the Drive object identifier accepted by fields of the File (Drive) type.
            ID b24.ID `json:"ID"`
            // FILE_ID is the internal file identifier. If it is passed to the task field,
            // the file will either not be attached or a different file will be attached.
            FileID b24.ID `json:"FILE_ID"`
            Name   string `json:"NAME"`
        }
        if err := json.Unmarshal(res.Result, &file); err != nil {
            return fmt.Errorf("decode uploaded file: %w", err)
        }
        

result = client.tasks.task.add(
            fields={
                "TITLE": "task for test",
                "RESPONSIBLE_ID": 1,
                "UF_TASK_WEBDAV_FILES": [
                    "n6687",
                ],
            }
        ).response.result
        

$result = $serviceBuilder->core->call(
            'tasks.task.add',
            [
                'fields' => [
                    'TITLE' => 'task for test',
                    'RESPONSIBLE_ID' => 1,
                    'UF_TASK_WEBDAV_FILES' => [
                        'n6687'
                    ]
                ]
            ]
        )->getResponseData()->getResult();
        
        echo '<PRE>';
        print_r($result);
        echo '</PRE>';
        

// The "n" prefix before the Drive object identifier means "attach this existing
        // object". The method will not accept a bare number. The field is always an
        // array, even when there is only one file.
        res, err = core.Call(ctx, "tasks.task.add", b24.Params{
            "fields": b24.Params{
                "TITLE":                "Task with file (b24gosdk)",
                "RESPONSIBLE_ID":       userID,
                "UF_TASK_WEBDAV_FILES": []string{"n" + strconv.FormatInt(int64(file.ID), 10)},
            },
        })
        if err != nil {
            return fmt.Errorf("tasks.task.add: %w", err)
        }
        
        // tasks.* wraps the response in a task object, unlike crm.*.add, which returns
        // a bare identifier. The identifier is returned as a string ("3711"): b24.ID
        // handles both formats, while a regular int does not.
        var out struct {
            Task struct {
                ID    b24.ID `json:"id"`
                Title string `json:"title"`
            } `json:"task"`
        }
        if err := json.Unmarshal(res.Result, &out); err != nil {
            return fmt.Errorf("decode created task: %w", err)
        }
        

task = client.tasks.task.get(
            bitrix_id=3711,
            select=["ID", "TITLE", "UF_TASK_WEBDAV_FILES"],
        ).response.result["task"]
        
        attachment_id = task["ufTaskWebdavFiles"][0]
        
        file = token.call_method(
            "disk.attachedObject.get",
            {
                "id": attachment_id,
            },
        )["result"]
        
        print(file)
        

$task = $serviceBuilder->core->call(
            'tasks.task.get',
            [
                'taskId' => 3711,
                'select' => ['ID', 'TITLE', 'UF_TASK_WEBDAV_FILES']
            ]
        )->getResponseData()->getResult()['task'];
        
        $attachmentId = $task['ufTaskWebdavFiles'][0];
        
        $file = $serviceBuilder->core->call(
            'disk.attachedObject.get',
            [
                'id' => $attachmentId
            ]
        )->getResponseData()->getResult();
        
        print_r($file);
        

res, err = core.Call(ctx, "tasks.task.get", b24.Params{
            "taskId": out.Task.ID,
            "select": []string{"ID", "TITLE", "UF_TASK_WEBDAV_FILES"},
        })
        if err != nil {
            return fmt.Errorf("tasks.task.get: %w", err)
        }
        
        var taskCheck struct {
            Task struct {
                ID                b24.ID   `json:"id"`
                Title             string   `json:"title"`
                UfTaskWebdavFiles []b24.ID `json:"ufTaskWebdavFiles"`
            } `json:"task"`
        }
        if err := json.Unmarshal(res.Result, &taskCheck); err != nil {
            return fmt.Errorf("decode task: %w", err)
        }
        if len(taskCheck.Task.UfTaskWebdavFiles) == 0 {
            return fmt.Errorf("the task has no attached files")
        }
        
        res, err = core.Call(ctx, "disk.attachedObject.get", b24.Params{
            "id": taskCheck.Task.UfTaskWebdavFiles[0],
        })
        if err != nil {
            return fmt.Errorf("disk.attachedObject.get: %w", err)
        }
        
        var attachment struct {
            ID         b24.ID `json:"ID"`
            ObjectID   b24.ID `json:"OBJECT_ID"`
            EntityType string `json:"ENTITY_TYPE"`
            EntityID   b24.ID `json:"ENTITY_ID"`
            Name       string `json:"NAME"`
        }
        if err := json.Unmarshal(res.Result, &attachment); err != nil {
            return fmt.Errorf("decode attached file: %w", err)
        }