Add Calendar Event for Client Management

from b24pysdk import BitrixWebhook, Client
        
        
        client = Client(
            BitrixWebhook(
                domain="your-domain.bitrix24.com",
                webhook_token="user_id/webhook_key",
            )
        )
        
        contact_id = 1
        result_contact = client.crm.contact.get(
            bitrix_id=contact_id,
        ).response.result
        

// composer require bitrix24/b24phpsdk:"^3.0"
        require_once 'vendor/autoload.php';
        
        use Bitrix24\SDK\Services\ServiceBuilderFactory;
        use Symfony\Component\EventDispatcher\EventDispatcher;
        use Psr\Log\NullLogger;
        
        $sb = (new ServiceBuilderFactory(new EventDispatcher(), new NullLogger()))
            ->initFromWebhook('https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/');
        
        $contactID = 1;
        $resultContact = $sb->getCRMScope()->contact()->get($contactID)->contact();
        

// core, ctx, and contactID are declared in the full example below
        res, err := core.Call(ctx, "crm.contact.get",
        	b24.Params{"id": contactID}, b24.WithIdempotent())
        if err != nil {
        	return fmt.Errorf("crm.contact.get: %w", err)
        }
        
        // The phone and the responsible person are needed from the response. PHONE is a multifield: a list of
        // objects, even when there is a single number, and it arrives only if the contact
        // has any phone numbers at all.
        var contact struct {
        	ID           b24.ID `json:"ID"`
        	Name         string `json:"NAME"`
        	LastName     string `json:"LAST_NAME"`
        	AssignedByID b24.ID `json:"ASSIGNED_BY_ID"`
        	Phone        []struct {
        		ID        b24.ID `json:"ID"`
        		Value     string `json:"VALUE"`
        		ValueType string `json:"VALUE_TYPE"`
        	} `json:"PHONE"`
        }
        if err := json.Unmarshal(res.Result, &contact); err != nil {
        	return fmt.Errorf("parse contact: %w", err)
        }
        if len(contact.Phone) == 0 {
        	return fmt.Errorf("contact %d has no phone number", contactID)
        }
        

contact_phone = result_contact["PHONE"][0]
        
        response = client.crm.activity.add(
            fields={
                "SUBJECT": "calendar title",
                "DESCRIPTION": "calendar body",
                "DESCRIPTION_TYPE": 3,
                "OWNER_ID": contact_id,
                "OWNER_TYPE_ID": 3,
                "TYPE_ID": 1,
                "COMMUNICATIONS": [
                    {
                        "VALUE": contact_phone["VALUE"],
                        "ENTITY_ID": contact_id,
                        "ENTITY_TYPE_ID": 3,
                    }
                ],
                "START_TIME": "2025-05-20T14:00:00",
                "END_TIME": "2025-05-20T15:00:00",
                "RESPONSIBLE_ID": result_contact["ASSIGNED_BY_ID"],
            }
        ).response
        

$phones = $resultContact->PHONE;
        $contactPhone = reset($phones);
        
        $result = $sb->getCRMScope()->activity()->add(
            [
                "SUBJECT" => "calendar title",
                "DESCRIPTION" => "calendar body",
                "DESCRIPTION_TYPE" => 3,
                "OWNER_ID" => $contactID,
                "OWNER_TYPE_ID" => 3,
                "TYPE_ID" => 1,
                "COMMUNICATIONS" => [
                    [
                        'VALUE' => $contactPhone->VALUE,
                        'ENTITY_ID' => $contactID,
                        'ENTITY_TYPE_ID' => 3
                    ]
                ],
                "START_TIME" => "2025-05-20T14:00:00",
                "END_TIME" => "2025-05-20T15:00:00",
                "RESPONSIBLE_ID" => $resultContact->ASSIGNED_BY_ID,
            ]
        );
        

// core, ctx, and contact are declared in the full example below.
        // The start and end times are in ISO 8601 format. Here it is a one-hour meeting,
        // tomorrow at the same time.
        start := time.Now().Add(24 * time.Hour)
        
        res, err = core.Call(ctx, "crm.activity.add", b24.Params{
        	"fields": b24.Params{
        		"SUBJECT":     "calendar title",
        		"DESCRIPTION": "calendar body",
        		// 1 — plain text, 2 — HTML, 3 — BB code.
        		"DESCRIPTION_TYPE": 3,
        		"OWNER_ID":         contact.ID,
        		"OWNER_TYPE_ID":    entityTypeContact,
        		// 1 — a meeting; crm.enum.activitytype returns the full list of activity types.
        		"TYPE_ID": 1,
        		// COMMUNICATIONS links the activity to the client's contact details:
        		// the value is taken from the PHONE multifield retrieved in step 1.
        		"COMMUNICATIONS": []b24.Params{{
        			"VALUE":          contact.Phone[0].Value,
        			"ENTITY_ID":      contact.ID,
        			"ENTITY_TYPE_ID": entityTypeContact,
        		}},
        		"START_TIME":     start.Format(time.RFC3339),
        		"END_TIME":       start.Add(time.Hour).Format(time.RFC3339),
        		"RESPONSIBLE_ID": contact.AssignedByID,
        	},
        })
        if err != nil {
        	return fmt.Errorf("crm.activity.add: %w", err)
        }
        
        // There is no wrapper: result is the ID of the created activity itself.
        var activityID b24.ID
        if err := json.Unmarshal(res.Result, &activityID); err != nil {
        	return fmt.Errorf("parse event ID: %w", err)
        }
        

activities = client.crm.activity.list(
            filter={
                "OWNER_TYPE_ID": 3,
                "OWNER_ID": contact_id,
            },
            select=["*", "COMMUNICATIONS"],
            order={"ID": "DESC"},
        ).response.result
        

// crm.activity.list has no wrapper in the SDK — we call the method directly
        $activities = $sb->core->call(
            'crm.activity.list',
            [
                'filter' => [
                    'OWNER_TYPE_ID' => 3,
                    'OWNER_ID' => $contactID,
                ],
                'select' => ['*', 'COMMUNICATIONS'],
                'order' => ['ID' => 'DESC'],
            ]
        )->getResponseData()->getResult();
        

from datetime import datetime, timedelta
        
        from b24pysdk import BitrixWebhook, Client
        from b24pysdk.errors import BitrixAPIError
        
        client = Client(
            BitrixWebhook(
                domain="your-domain.bitrix24.com",
                webhook_token="user_id/webhook_key",
            )
        )
        
        contact_id = 1
        result_activity = None
        
        try:
            contact = client.crm.contact.get(bitrix_id=contact_id).response.result
        
            if contact.get("ASSIGNED_BY_ID") and contact.get("PHONE"):
                contact_phone = contact["PHONE"][0]
                staff_id = contact["ASSIGNED_BY_ID"]
                now = datetime.now()
                result_activity = client.crm.activity.add(
                    fields={
                        "SUBJECT": "calendar title",
                        "DESCRIPTION": "calendar body",
                        "DESCRIPTION_TYPE": 3,
                        "OWNER_ID": contact_id,
                        "OWNER_TYPE_ID": 3,
                        "TYPE_ID": 1,
                        "COMMUNICATIONS": [
                            {
                                "VALUE": contact_phone["VALUE"],
                                "ENTITY_ID": contact_id,
                                "ENTITY_TYPE_ID": 3,
                            }
                        ],
                        "START_TIME": now.isoformat(timespec="seconds"),
                        "END_TIME": (now + timedelta(hours=1)).isoformat(timespec="seconds"),
                        "RESPONSIBLE_ID": staff_id,
                    }
                ).response
        except BitrixAPIError as error:
            print({"message": f"Activity not added: {error}"})
        else:
            if result_activity and result_activity.result:
                print({"message": "Activity add"})
            else:
                print({"message": "Activity not added"})
        

<?php
        // composer require bitrix24/b24phpsdk:"^3.0"
        require_once 'vendor/autoload.php';
        
        use Bitrix24\SDK\Services\ServiceBuilderFactory;
        use Symfony\Component\EventDispatcher\EventDispatcher;
        use Psr\Log\NullLogger;
        
        $sb = (new ServiceBuilderFactory(new EventDispatcher(), new NullLogger()))
            ->initFromWebhook('https://your-domain.bitrix24.com/rest/USER_ID/TOKEN/');
        
        $contactID = 1;
        try {
            $resultContact = $sb->getCRMScope()->contact()->get($contactID)->contact();
            $resultActivity = null;
            if (!empty($resultContact->ASSIGNED_BY_ID) && !empty($resultContact->PHONE))
            {
                $phones = $resultContact->PHONE;
                $contactPhone = reset($phones);
                $staffID = $resultContact->ASSIGNED_BY_ID;
                $resultActivity = $sb->getCRMScope()->activity()->add(
                    [
                        "SUBJECT" => "calendar title",
                        "DESCRIPTION" => "calendar body",
                        "DESCRIPTION_TYPE" => 3,// text type (crm.enum.contenttype): plain, HTML, BB-code
                        "OWNER_ID" => $contactID,
                        "OWNER_TYPE_ID" => 3, // crm.enum.ownertype
                        "TYPE_ID" => 1, // crm.enum.activitytype
                        "COMMUNICATIONS" => [
                            [
                                'VALUE' => $contactPhone->VALUE,
                                'ENTITY_ID' => $contactID,
                                'ENTITY_TYPE_ID' => 3// crm.enum.ownertype
                            ]
                        ],
                        "START_TIME" => date("Y-m-d H:i:s", time()),
                        "END_TIME" => date("Y-m-d H:i:s", time() + 3600),
                        "RESPONSIBLE_ID" => $staffID,
                    ]
                )->getId();
            }
            if (!empty($resultActivity))
            {
                echo json_encode(['message' => 'Activity add']);
            }
            else
            {
                echo json_encode(['message' => 'Activity not added']);
            }
        } catch (\Throwable $e) {
            echo json_encode(['message' => 'Activity not added: ' . $e->getMessage()]);
        }
        

// Setup in an empty directory — go get will not work without go mod init:
        //
        //	go mod init example && go get github.com/bitrix24/b24gosdk
        //
        // Run:
        //
        //	export B24_WEBHOOK_URL='https://your-portal.bitrix24.com/rest/1/token/' && go run .
        //
        // The example is self-contained: it creates a contact with a phone number, reads its data,
        // creates a calendar event linked to this contact and cleans up after itself.
        // It runs on any portal, nothing needs to be edited.
        package main
        
        import (
        	"context"
        	"encoding/json"
        	"fmt"
        	"log"
        	"os"
        	"time"
        
        	b24 "github.com/bitrix24/b24gosdk"
        )
        
        // entityTypeContact is the ID of the "contact" object type from crm.enum.ownertype.
        const entityTypeContact = 3
        
        func main() {
        	if err := run(context.Background()); err != nil {
        		log.Fatal(err)
        	}
        }
        
        func run(ctx context.Context) error {
        	// The webhook path is a secret, so it comes from the environment, not from the code.
        	core := b24.NewClient(os.Getenv("B24_WEBHOOK_URL")).Core()
        
        	// --- setup: our own contact with a phone number
        
        	contactID, err := addContact(ctx, core)
        	if err != nil {
        		return err
        	}
        	defer del(ctx, core, "crm.contact.delete", b24.Params{"id": contactID})
        
        	// --- step 1: the client data
        	res, err := core.Call(ctx, "crm.contact.get",
        		b24.Params{"id": contactID}, b24.WithIdempotent())
        	if err != nil {
        		return fmt.Errorf("crm.contact.get: %w", err)
        	}
        
        	// The phone and the responsible person are needed from the response. PHONE is a multifield: a list of
        	// objects, even when there is a single number, and it arrives only if the contact
        	// has any phone numbers at all.
        	var contact struct {
        		ID           b24.ID `json:"ID"`
        		Name         string `json:"NAME"`
        		LastName     string `json:"LAST_NAME"`
        		AssignedByID b24.ID `json:"ASSIGNED_BY_ID"`
        		Phone        []struct {
        			ID        b24.ID `json:"ID"`
        			Value     string `json:"VALUE"`
        			ValueType string `json:"VALUE_TYPE"`
        		} `json:"PHONE"`
        	}
        	if err := json.Unmarshal(res.Result, &contact); err != nil {
        		return fmt.Errorf("parse contact: %w", err)
        	}
        	if len(contact.Phone) == 0 {
        		return fmt.Errorf("contact %d has no phone number", contactID)
        	}
        	fmt.Printf("contact %d %s %s, phone %s, responsible %d\n",
        		contact.ID, contact.Name, contact.LastName, contact.Phone[0].Value, contact.AssignedByID)
        
        	// --- step 2: the calendar event
        	// The start and end times are in ISO 8601 format. Here it is a one-hour meeting,
        	// tomorrow at the same time.
        	start := time.Now().Add(24 * time.Hour)
        
        	res, err = core.Call(ctx, "crm.activity.add", b24.Params{
        		"fields": b24.Params{
        			"SUBJECT":     "calendar title",
        			"DESCRIPTION": "calendar body",
        			// 1 — plain text, 2 — HTML, 3 — BB code.
        			"DESCRIPTION_TYPE": 3,
        			"OWNER_ID":         contact.ID,
        			"OWNER_TYPE_ID":    entityTypeContact,
        			// 1 — a meeting; crm.enum.activitytype returns the full list.
        			"TYPE_ID": 1,
        			// COMMUNICATIONS links the activity to the client's contact details:
        			// the value is taken from the PHONE multifield retrieved in step 1.
        			"COMMUNICATIONS": []b24.Params{{
        				"VALUE":          contact.Phone[0].Value,
        				"ENTITY_ID":      contact.ID,
        				"ENTITY_TYPE_ID": entityTypeContact,
        			}},
        			"START_TIME":     start.Format(time.RFC3339),
        			"END_TIME":       start.Add(time.Hour).Format(time.RFC3339),
        			"RESPONSIBLE_ID": contact.AssignedByID,
        		},
        	})
        	if err != nil {
        		return fmt.Errorf("crm.activity.add: %w", err)
        	}
        
        	// There is no wrapper: result is the ID of the created activity itself.
        	var activityID b24.ID
        	if err := json.Unmarshal(res.Result, &activityID); err != nil {
        		return fmt.Errorf("parse event ID: %w", err)
        	}
        	defer del(ctx, core, "crm.activity.delete", b24.Params{"id": activityID})
        
        	fmt.Printf("event %d created for %s\n", activityID, start.Format("02.01.2006 15:04"))
        	return nil
        }
        
        // --- helpers: data setup and cleanup
        
        // addContact creates a contact with a phone number: the page takes a ready-made contact with
        // ID 1, but on someone else's portal that is a different person or nobody.
        func addContact(ctx context.Context, core *b24.Core) (b24.ID, error) {
        	res, err := core.Call(ctx, "crm.contact.add", b24.Params{
        		"fields": b24.Params{
        			"NAME":      "Klaus",
        			"LAST_NAME": "Müller",
        			// A multifield: a row without an ID ADDS a value. MultifieldAdd
        			// assembles it for you, so you do not get lost in the keys.
        			"PHONE": []map[string]any{
        				b24.MultifieldAdd("+49 800 100-10-20", "MOBILE"),
        			},
        		},
        	})
        	if err != nil {
        		return 0, fmt.Errorf("crm.contact.add: %w", err)
        	}
        	var id b24.ID
        	return id, json.Unmarshal(res.Result, &id)
        }
        
        // del removes what was created. A cleanup error is printed but not returned: it must not
        // mask the real error of the scenario.
        func del(ctx context.Context, core *b24.Core, method string, params b24.Params) {
        	if _, err := core.Call(ctx, method, params); err != nil {
        		fmt.Fprintf(os.Stderr, "cleanup, %s: %v