Download Source Code

Download source code from your end users' connected SCM provider. The Unizo SDKs provide programmatic access to repositories, branches, and commits across all supported version control systems.

Prerequisites

Before you begin, ensure you have:

• Valid Unizo API Key
• Repository ID
• Integration ID
• Unizo SDK for your programming language

tip

Need to install an SDK? See our SDK installation guide to get started with your preferred programming language.

Download Repository

Retrieve a complete repository archive containing the default branch. Note, default branch is set by your end user in respective provider console.

Java

import com.unizo.scm.extension.DownloadResponse;
import com.unizo.scm.extension.ScmRepositoryApi;
import com.unizo.core.ApiClient;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.UUID;

public class RepositoryDownloadExample {
    public static void main(String[] args) throws Exception {
        // Configure API client with endpoint and authentication
        ApiClient client = new ApiClient();
        client.setBasePath("https://api.unizo.com");
        client.setBearerToken("your-api-key");

        ScmRepositoryApi api = new ScmRepositoryApi();

        // Set required parameters
        String organizationId = "your-organization-id";
        String repositoryId = "your-repository-id";
        UUID integrationId = UUID.fromString("your-integration-uuid");

        // Execute download request
        try (OutputStream output = new FileOutputStream("repository.zip")) {
            DownloadResponse response = api.download(
                organizationId,
                repositoryId,
                integrationId,
                output,
                client
            ).get();
            
            System.out.println("Download completed: " + response);
        }
    }
}

Python

import asyncio
from unizo_scm import ScmRepositoryApi, ApiClient

async def download_repository_example():
    # Configure API client with endpoint and authentication
    client = ApiClient(
        base_url="https://api.unizo.com",
        api_key="your-api-key"
    )
    
    api = ScmRepositoryApi(client)
    
    # Set required parameters
    organization_id = "your-organization-id"
    repository_id = "your-repository-id"
    integration_id = "your-integration-uuid"
    
    # Execute download request
    async with api.download(
        organization_id=organization_id,
        repository_id=repository_id,
        integration_id=integration_id
    ) as response:
        with open("repository.zip", "wb") as f:
            async for chunk in response.iter_content():
                f.write(chunk)
    
    print("Download completed")

# Run the download
asyncio.run(download_repository())

TypeScript

import { ScmRepositoryApi, Configuration } from '@unizo/scm-sdk';
import * as fs from 'fs';

async function downloadRepositoryExample() {
    // Configure API client with endpoint and authentication
    const config = new Configuration({
        basePath: 'https://api.unizo.com',
        apiKey: 'your-api-key'
    });
    
    const api = new ScmRepositoryApi(config);
    
    // Set required parameters
    const organizationId = 'your-organization-id';
    const repositoryId = 'your-repository-id';
    const integrationId = 'your-integration-uuid';
    
    // Execute download request
    const response = await api.download({
        organizationId,
        repositoryId,
        integrationId
    });
    
    // Save to file
    const writeStream = fs.createWriteStream('repository.zip');
    response.data.pipe(writeStream);
    
    writeStream.on('finish', () => {
        console.log('Download completed');
    });
}

downloadRepository().catch(console.error);

Go

package main

import (
    "context"
    "fmt"
    "io"
    "os"
    
    "github.com/unizo/go-scm-sdk/client"
    "github.com/unizo/go-scm-sdk/api"
)

func main() {
    // Configure API client with endpoint and authentication
    cfg := client.NewConfiguration()
    cfg.BasePath = "https://api.unizo.com"
    cfg.DefaultHeader["Authorization"] = "Bearer your-api-key"
    
    client := client.NewAPIClient(cfg)
    
    // Set required parameters
    organizationId := "your-organization-id"
    repositoryId := "your-repository-id"
    integrationId := "your-integration-uuid"
    
    // Execute download request
    response, _, err := client.ScmRepositoryApi.Download(
        context.Background(),
        organizationId,
        repositoryId,
        integrationId,
    )
    
    if err != nil {
        panic(err)
    }
    
    // Save to file
    file, err := os.Create("repository.zip")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    
    _, err = io.Copy(file, response)
    if err != nil {
        panic(err)
    }
    
    fmt.Println("Download completed")
}

Download Specific Branch

Retrieve source code from a specific branch. This method allows you to download any branch, including feature branches, release branches, or custom development branches.

Java

import com.unizo.scm.extension.DownloadResponse;
import com.unizo.scm.extension.ScmBranchApi;
import com.unizo.core.ApiClient;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.UUID;

public class BranchDownloadExample {
    public static void main(String[] args) throws Exception {
        // Configure API client with endpoint and authentication
        ApiClient client = new ApiClient();
        client.setBasePath("https://api.unizo.com");
        client.setBearerToken("your-api-key");

        ScmBranchApi api = new ScmBranchApi();

        // Set required parameters
        String organizationId = "your-organization-id";
        String repositoryId = "your-repository-id";
        String branchId = "main"; // or "develop", "feature/new-feature"
        UUID integrationId = UUID.fromString("your-integration-uuid");

        // Execute branch download
        try (OutputStream output = new FileOutputStream(branchId + ".zip")) {
            DownloadResponse response = api.download(
                organizationId,
                repositoryId,
                branchId,
                integrationId,
                output,
                client
            ).get();
            
            System.out.println("Branch downloaded: " + response);
        }
    }
}

Python

import asyncio
from unizo_scm import ScmBranchApi, ApiClient

async def download_branch_example():
    # Configure API client with endpoint and authentication
    client = ApiClient(
        base_url="https://api.unizo.com",
        api_key="your-api-key"
    )
    
    api = ScmBranchApi(client)
    
    # Set required parameters
    organization_id = "your-organization-id"
    repository_id = "your-repository-id"
    branch_id = "main"  # or "develop", "feature/new-feature"
    integration_id = "your-integration-uuid"
    
    # Execute branch download
    async with api.download(
        organization_id=organization_id,
        repository_id=repository_id,
        branch_id=branch_id,
        integration_id=integration_id
    ) as response:
        with open(f"{branch_id}.zip", "wb") as f:
            async for chunk in response.iter_content():
                f.write(chunk)
    
    print(f"Branch '{branch_id}' downloaded")

# Run the download
asyncio.run(download_branch())

TypeScript

import { ScmBranchApi, Configuration } from '@unizo/scm-sdk';
import * as fs from 'fs';

async function downloadBranchExample() {
    // Configure API client with endpoint and authentication
    const config = new Configuration({
        basePath: 'https://api.unizo.com',
        apiKey: 'your-api-key'
    });
    
    const api = new ScmBranchApi(config);
    
    // Set required parameters
    const organizationId = 'your-organization-id';
    const repositoryId = 'your-repository-id';
    const branchId = 'main'; // or 'develop', 'feature/new-feature'
    const integrationId = 'your-integration-uuid';
    
    // Execute branch download
    const response = await api.download({
        organizationId,
        repositoryId,
        branchId,
        integrationId
    });
    
    // Save to file
    const writeStream = fs.createWriteStream(`${branchId}.zip`);
    response.data.pipe(writeStream);
    
    writeStream.on('finish', () => {
        console.log(`Branch '${branchId}' downloaded`);
    });
}

downloadBranch().catch(console.error);

Go

package main

import (
    "context"
    "fmt"
    "io"
    "os"
    
    "github.com/unizo/go-scm-sdk/client"
    "github.com/unizo/go-scm-sdk/api"
)

func main() {
    // Configure API client with endpoint and authentication
    cfg := client.NewConfiguration()
    cfg.BasePath = "https://api.unizo.com"
    cfg.DefaultHeader["Authorization"] = "Bearer your-api-key"
    
    client := client.NewAPIClient(cfg)
    
    // Set required parameters
    organizationId := "your-organization-id"
    repositoryId := "your-repository-id"
    branchId := "main" // or "develop", "feature/new-feature"
    integrationId := "your-integration-uuid"
    
    // Execute branch download
    response, _, err := client.ScmBranchApi.Download(
        context.Background(),
        organizationId,
        repositoryId,
        branchId,
        integrationId,
    )
    
    if err != nil {
        panic(err)
    }
    
    // Save to file
    fileName := fmt.Sprintf("%s.zip", branchId)
    file, err := os.Create(fileName)
    if err != nil {
        panic(err)
    }
    defer file.Close()
    
    _, err = io.Copy(file, response)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Branch '%s' downloaded\n", branchId)
}

Download Specific Commit

Retrieve source code from a specific point in the repository's history. Use the commit SHA to download an exact snapshot of the codebase.

Java

import com.unizo.scm.extension.DownloadResponse;
import com.unizo.scm.extension.ScmCommitApi;
import com.unizo.core.ApiClient;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.UUID;

public class CommitDownloadExample {
    public static void main(String[] args) throws Exception {
        // Configure API client with endpoint and authentication
        ApiClient client = new ApiClient();
        client.setBasePath("https://api.unizo.com");
        client.setBearerToken("your-api-key");

        ScmCommitApi api = new ScmCommitApi();

        // Set required parameters
        String organizationId = "your-organization-id";
        String repositoryId = "your-repository-id";
        String commitId = "abc123def456"; // commit SHA
        UUID integrationId = UUID.fromString("your-integration-uuid");

        // Execute commit download
        try (OutputStream output = new FileOutputStream("commit-" + commitId + ".zip")) {
            DownloadResponse response = api.download(
                organizationId,
                repositoryId,
                commitId,
                integrationId,
                output,
                client
            ).get();
            
            System.out.println("Commit downloaded: " + response);
        }
    }
}

Python

import asyncio
from unizo_scm import ScmCommitApi, ApiClient

async def download_commit_example():
    # Configure API client with endpoint and authentication
    client = ApiClient(
        base_url="https://api.unizo.com",
        api_key="your-api-key"
    )
    
    api = ScmCommitApi(client)
    
    # Set required parameters
    organization_id = "your-organization-id"
    repository_id = "your-repository-id"
    commit_id = "abc123def456"  # commit SHA
    integration_id = "your-integration-uuid"
    
    # Execute commit download
    async with api.download(
        organization_id=organization_id,
        repository_id=repository_id,
        commit_id=commit_id,
        integration_id=integration_id
    ) as response:
        with open(f"commit-{commit_id}.zip", "wb") as f:
            async for chunk in response.iter_content():
                f.write(chunk)
    
    print(f"Commit '{commit_id}' downloaded")

# Run the download
asyncio.run(download_commit())

TypeScript

import { ScmCommitApi, Configuration } from '@unizo/scm-sdk';
import * as fs from 'fs';

async function downloadCommitExample() {
    // Configure API client with endpoint and authentication
    const config = new Configuration({
        basePath: 'https://api.unizo.com',
        apiKey: 'your-api-key'
    });
    
    const api = new ScmCommitApi(config);
    
    // Set required parameters
    const organizationId = 'your-organization-id';
    const repositoryId = 'your-repository-id';
    const commitId = 'abc123def456'; // commit SHA
    const integrationId = 'your-integration-uuid';
    
    // Execute commit download
    const response = await api.download({
        organizationId,
        repositoryId,
        commitId,
        integrationId
    });
    
    // Save to file
    const writeStream = fs.createWriteStream(`commit-${commitId}.zip`);
    response.data.pipe(writeStream);
    
    writeStream.on('finish', () => {
        console.log(`Commit '${commitId}' downloaded`);
    });
}

downloadCommit().catch(console.error);

Go

package main

import (
    "context"
    "fmt"
    "io"
    "os"
    
    "github.com/unizo/go-scm-sdk/client"
    "github.com/unizo/go-scm-sdk/api"
)

func main() {
    // Configure API client with endpoint and authentication
    cfg := client.NewConfiguration()
    cfg.BasePath = "https://api.unizo.com"
    cfg.DefaultHeader["Authorization"] = "Bearer your-api-key"
    
    client := client.NewAPIClient(cfg)
    
    // Set required parameters
    organizationId := "your-organization-id"
    repositoryId := "your-repository-id"
    commitId := "abc123def456" // commit SHA
    integrationId := "your-integration-uuid"
    
    // Execute commit download
    response, _, err := client.ScmCommitApi.Download(
        context.Background(),
        organizationId,
        repositoryId,
        commitId,
        integrationId,
    )
    
    if err != nil {
        panic(err)
    }
    
    // Save to file
    fileName := fmt.Sprintf("commit-%s.zip", commitId)
    file, err := os.Create(fileName)
    if err != nil {
        panic(err)
    }
    defer file.Close()
    
    _, err = io.Copy(file, response)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Commit '%s' downloaded\n", commitId)
}

Error Handling

Implement robust error handling to manage API responses and network failures. Each SDK provides specific exception types for different error scenarios.

Java

import com.unizo.core.ApiException;

try (OutputStream output = new FileOutputStream("repository.zip")) {
    api.download(orgId, repoId, integrationId, output, client).get();
} catch (ApiException e) {
    switch (e.getCode()) {
        case 401:
            System.err.println("Invalid API key");
            break;
        case 403:
            System.err.println("Insufficient permissions");
            break;
        case 404:
            System.err.println("Repository not found");
            break;
        default:
            System.err.println("Error: " + e.getMessage());
    }
}

Python

from unizo_scm.exceptions import ApiException

try:
    async with api.download(...) as response:
        # Download logic
        pass
except ApiException as e:
    if e.status_code == 401:
        print("Invalid API key")
    elif e.status_code == 403:
        print("Insufficient permissions")
    elif e.status_code == 404:
        print("Repository not found")
    else:
        print(f"Error: {e.message}")

TypeScript

try {
    const response = await api.download({ ... });
    // Download logic
} catch (error) {
    if (error.response?.status === 401) {
        console.error('Invalid API key');
    } else if (error.response?.status === 403) {
        console.error('Insufficient permissions');
    } else if (error.response?.status === 404) {
        console.error('Repository not found');
    } else {
        console.error('Error:', error.message);
    }
}

Go

response, httpResp, err := client.ScmRepositoryApi.Download(...)
if err != nil {
    if httpResp != nil {
        switch httpResp.StatusCode {
        case 401:
            fmt.Println("Invalid API key")
        case 403:
            fmt.Println("Insufficient permissions")
        case 404:
            fmt.Println("Repository not found")
        default:
            fmt.Printf("Error: %v\n", err)
        }
    }
    return
}

API Response Codes

Status Code	Description	Solution
401	Authentication failed	Verify your API key
403	Access denied	Check repository permissions
404	Resource not found	Verify repository/branch/commit exists
429	Rate limit exceeded	Implement retry logic with backoff
500	Server error	Retry request or contact support