سرویس غرفه، کاربر و محصول (مرکزی)

from basalam_sdk import BasalamClient, PersonalToken
 
auth = PersonalToken(
    token="your_access_token",
    refresh_token="your_refresh_token"
)
client = BasalamClient(auth=auth)

from basalam_sdk.core.models import CreateVendorSchema
 
async def create_vendor_example():
    vendor = await client.create_vendor(
        user_id=123,
        request=CreateVendorSchema(
            title="My Store",
            identifier="store123",
            category_type=1,
            city=1,
            summary="A great store for all your needs"
        )
    )
 
    return vendor

from basalam_sdk.core.models import UpdateVendorSchema
 
async def update_vendor_example():
    updated_vendor = await client.update_vendor(
        vendor_id=456,
        request=UpdateVendorSchema(
            title="Updated Store Name",
            summary="Updated description",
        )
    )
 
    return updated_vendor

async def get_vendor_example():
    vendor = await client.get_vendor(
        vendor_id=456,
        prefer="return=minimal"
    )
 
    return vendor

async def get_default_shipping_methods_example():
    shipping_methods = await client.get_default_shipping_methods()
 
    return shipping_methods

async def get_shipping_methods_example():
    shipping_methods = await client.get_shipping_methods()
 
    return shipping_methods

async def get_working_shipping_methods_example():
    working_methods = await client.get_working_shipping_methods(
        vendor_id=456
    )
 
    return working_methods

[
  ShippingMethodResponse(
    id=6124304, method=ShippingMethodInfo(name='سفارشی', value=3197, description=None),
    base_cost=460000, additional_cost=105000, is_private=False, additional_dimensions_cost=None, vendor_id=None, deleted_at=None
  ), 
  ShippingMethodResponse(
    id=6124301, method=ShippingMethodInfo(name='پیشتاز', value=3198, description=None),
    base_cost=570000, additional_cost=120000, is_private=False, additional_dimensions_cost=None, vendor_id=None, deleted_at=None
  ), 
  ShippingMethodResponse(
    id=6124305, method=ShippingMethodInfo(name='پیک', value=3259, description=None), 
    base_cost=320000, additional_cost=35000, is_private=False, additional_dimensions_cost=None, vendor_id=None, deleted_at=None
  )
]

from basalam_sdk.core.models import UpdateShippingMethodSchema
 
async def update_shipping_methods_example():
    updated_methods = await client.update_shipping_methods(
        vendor_id=456,
        request=UpdateShippingMethodSchema(
            shipping_methods=[
                {
                    "method_id": 3198,
                    "is_customized": True,
                    "base_cost": 50000
                }
            ]
        )
    )
 
    return updated_methods

from basalam_sdk.core.models import GetVendorProductsSchema, ProductStatusInputEnum
 
async def get_vendor_products_example():
    products = await client.get_vendor_products(
        vendor_id=456,
        query_params=GetVendorProductsSchema(
            statuses=[ProductStatusInputEnum.PUBLISHED],
            page=1,
            per_page=10
        )
    )
 
    return products

from basalam_sdk.core.models import UpdateVendorStatusSchema
 
async def update_vendor_status_example():
    status_update = await client.update_vendor_status(
        vendor_id=456,
        request=UpdateVendorStatusSchema(
            status=VendorStatusInputEnum.SEMI_ACTIVE,
            description="Vendor is Semi Active"
        )
    )
 
    return status_update

from basalam_sdk.core.models import ChangeVendorMobileRequestSchema
async def create_vendor_mobile_change_request_example():
    result = await client.create_vendor_mobile_change_request(
        vendor_id=456,
        request=ChangeVendorMobileRequestSchema(
            mobile="09123456789"
        )
    )
 
    return result

from basalam_sdk.core.models import ChangeVendorMobileConfirmSchema
 
async def create_vendor_mobile_change_confirmation_example():
    result = await client.create_vendor_mobile_change_confirmation(
        vendor_id=456,
        request=ChangeVendorMobileConfirmSchema(
            mobile="09123456789",
            verification_code=123456
        )
    )
 
    return result

from basalam_sdk.core.models import ProductRequestSchema, ProductStatusInputEnum, UnitTypeInputEnum
import io
 
async def create_product_example():
    try:
    with open("test1.png", "rb") as photo1, \
         open("test2.png", "rb") as photo2:
        request = ProductRequestSchema(
            name="Product 01",
            description="The material of this product is very high quality and made of silk.",
            category_id=238,
            primary_price=100000,
            weight=300,
            package_weight=500,
            stock=10,
            status=ProductStatusInputEnum.PUBLISHED,
            unit_quantity= 10,
            unit_type= UnitTypeInputEnum.NUMERIC
        )
        product = await client.core.create_product(456, request, photo_files=[photo1,photo2])
 
    return product

from basalam_sdk.core.models import BatchUpdateProductsRequest, UpdateProductRequestItem
 
async def update_bulk_products_example():
    updated_products = await client.core.update_bulk_products(
        vendor_id=456,
        request=BatchUpdateProductsRequest(
            data=[
                UpdateProductRequestItem(
                    id=1,
                    name="Updated Product 01",
                    stock=25
                ),
                UpdateProductRequestItem(
                    id=1,
                    stock=5,
                    primary_price=21000
                )
            ]
        )
    )
 
    return updated_products

from basalam_sdk.core.models import ProductRequestSchema
 
import io
async def update_product_example():
    updated_product = await client.update_product(
        product_id=789,
        request=ProductRequestSchema(
            status=3790,
            product_attribute = [
              {
                "attribute_id": 219,
                "value": "Suitable for formal ceremonies",
              },
              {
                "attribute_id": 221,
                "value": "Silk",
              },
              {
                "attribute_id": 222,
                "value": "Burgundy, Black, Turquoise",
              },
              {
                "attribute_id": 1319,
                "value": "Due to its sensitivity, this fabric should be hand washed gently with cold water.",
              }
            ]
        )
    )
 
    return updated_product

async def get_product_example():
    product = await client.get_product(
        product_id=24835037,
        prefer="return=minimal"
    )
 
    return product

from basalam_sdk.core.models import GetProductsQuerySchema
 
async def get_products_example():
    products = await client.get_products(
        query_params=GetProductsQuerySchema(
            page=1,
            per_page=20,
            sort="price:asc"
        )
    )
 
    return products

from basalam_sdk.core.models import (
    BulkProductsUpdateRequestSchema,
    ProductFilterSchema,
    BulkActionItem,
    RangeFilterItem,
    ProductBulkActionTypeEnum,
    ProductBulkFieldInputEnum
)
 
async def create_products_bulk_action_request_example():
    bulk_request = await client.core.create_products_bulk_action_request(
        vendor_id=456,
        request=BulkProductsUpdateRequestSchema(
            product_filter=ProductFilterSchema(
                stock=RangeFilterItem(
                    start=1,
                    end=5
                )
            ),
            action=[
                BulkActionItem(
                    field=ProductBulkFieldInputEnum.STOCK,
                    action=ProductBulkActionTypeEnum.SET,
                    value=50
                )
            ]
        )
    )
 
    return bulk_request

from basalam_sdk.core.models import UpdateProductVariationSchema
 
async def update_product_variation_example():
    updated_variation = await client.update_product_variation(
        product_id=789,
        variation_id=6639697,
        request=UpdateProductVariationSchema(
            primary_price=150000,
            stock=100
        )
    )
 
    return updated_variation

async def get_products_bulk_action_requests_example():
    bulk_requests = await client.get_products_bulk_action_requests(
        vendor_id=456,
        page=1,
        per_page=30
    )
 
    return bulk_requests

async def get_products_bulk_action_requests_count_example():
    counts = await client.get_products_bulk_action_requests_count(
        vendor_id=456
    )
 
    return counts

async def get_products_unsuccessful_bulk_action_requests_example():
    unsuccessful_products = await client.get_products_unsuccessful_bulk_action_requests(
        request_id=123
    )
 
    return unsuccessful_products

async def get_product_shelves_example():
    shelves = await client.get_product_shelves(
        product_id=789
    )
 
    return shelves

from basalam_sdk.core.models import CreateDiscountRequestSchema, DiscountProductFilterSchema
 
async def create_discount_example():
    discount = await client.create_discount(
        vendor_id=456,
        request=CreateDiscountRequestSchema(
            product_filter=DiscountProductFilterSchema(
                product_ids=[25010883, 24835037],
            ),
        discount_percent=20,
        active_days=5
        )
    )
 
    return discount

from basalam_sdk.core.models import DeleteDiscountRequestSchema, DiscountProductFilterSchema
 
async def delete_discount_example():
    result = await client.create_discount(
        vendor_id=456,
        request=DeleteDiscountRequestSchema(
            product_filter=DiscountProductFilterSchema(
                product_ids=[25010883],
            )
        )
    )
 
    return result

async def get_current_user_example():
    user = await client.get_current_user()
 
    return user

async def create_user_mobile_confirmation_request_example():
    result = await client.create_user_mobile_confirmation_request(
        user_id=123
    )
 
    return result

from basalam_sdk.core.models import ConfirmCurrentUserMobileConfirmSchema
 
async def verify_user_mobile_confirmation_request_example():
    result = await client.verify_user_mobile_confirmation_request(
        user_id=123,
        request=ConfirmCurrentUserMobileConfirmSchema(
            verification_code=123456
        )
    )
 
    return result

from basalam_sdk.core.models import ChangeUserMobileRequestSchema
 
async def create_user_mobile_change_request_example():
    result = await client.create_user_mobile_change_request(
        user_id=123,
        request=ChangeUserMobileRequestSchema(
            mobile="09123456789"
        )
    )
 
    return result

from basalam_sdk.core.models import ChangeUserMobileConfirmSchema
 
async def verify_user_mobile_change_request_example():
    result = await client.verify_user_mobile_change_request(
        user_id=123,
        request=ChangeUserMobileConfirmSchema(
            mobile="09123456789",
            verification_code=123456
        )
    )
 
    return result

async def get_user_bank_accounts_example():
    bank_accounts = await client.get_user_bank_accounts(
        user_id=123
    )
 
    return bank_accounts

from basalam_sdk.core.models import UserCardsSchema
 
async def create_user_bank_account_example():
    bank_account = await client.create_user_bank_account(
        user_id=123,
        request=UserCardsSchema(
            card_number="1234567890123456"
        )
    )
 
    return bank_account

from basalam_sdk.core.models import UserCardsOtpSchema
 
async def verify_user_bank_account_otp_example():
    result = await client.verify_user_bank_account_otp(
        user_id=123,
        request=UserCardsOtpSchema(
            card_number="1234567890123456",
            otp_code="123456"
        )
    )
 
    return result

from basalam_sdk.core.models import UserVerifyBankInformationSchema
 
async def verify_user_bank_account_example():
    result = await client.verify_user_bank_account(
        user_id=123,
        request=UserVerifyBankInformationSchema(
            bank_information_id=1,
            national_code="1234567890",
            birthday="1990-01-01"
        )
    )
 
    return result

async def delete_user_bank_account_example():
    result = await client.delete_user_bank_account(
        user_id=123,
        bank_account_id=1
    )
 
    return result

from basalam_sdk.core.models import UpdateUserBankInformationSchema
 
async def update_user_bank_account_example():
    result = await client.update_user_bank_account(
        bank_account_id=1,
        request=UpdateUserBankInformationSchema(
            user_id=123
        )
    )
 
    return result

from basalam_sdk.core.models import UserVerificationSchema
 
async def update_user_verification_example():
    user = await client.update_user_verification(
        user_id=123,
        request=UserVerificationSchema(
            national_code="1234567890",
            birthday="1990-01-01"
        )
    )
 
    return user

async def get_category_attributes_example():
    attributes = await client.get_category_attributes(
        category_id=1066
    )
 
    return attributes

async def get_categories_example():
    categories = await client.get_categories()
 
    return categories

async def get_category_example():
    category = await client.get_category(
        category_id=1066
    )
 
    return category