leankit-client

const LeanKitClient = require( "leankit-client" );
const auth = {
    account: "account-name",    // change these properties to match your account
    email: "your@email.com",    // for token auth, see below
    password: "your-p@ssw0rd"
};
// create a client with the account credentials
const client = LeanKitClient( auth );
 
// use the client to get a list of boards
client.board.list().then( response => {
    console.log( response.data );
} );

const auth = {
    account: "account-name",
    token: "2a0ec41e4fca6a10727a33je4f409545870c0ce199fd8cde287a027acdf671d73da3f5af1ee983441d1993dc3a2181302690885c0b46692e39b6c9e29bd132eb"
}
const client = LeanKitClient( auth );

// start by requesting all the boards
client.board.list().then( res => {
    // get the first board's ID
    const boardId = res.data.boards[ 0 ].id;
 
    // request the full board by ID
    return client.board.get( boardId );
} ).then( boardRes => {
    // response from client.board.get()
    const board = boardRes.data;
    console.log( board );
} ).catch( err => {
    // any errors that occur will be caught here
    console.log( "Error:", err );
} );

const LeanKitClient = require( "leankit-client" );
 
const getBoardByTitle = async ( client, title ) => {
    try {
        // search boards by title
        const res = await client.board.list( { search: title } );
        if ( res.data.length === 0 ) {
            return { msg: `Cound not find board with the title: ${ title }` };
        }
        // get the board ID
        const boardId = res.data.boards[ 0 ].id;
        // retrieve the board by ID
        const boardRes = await client.board.get( boardId );
        return boardRes.data;
    } catch ( err ) {
        // any errors will be caught here.
        console.log( "Error:", err );
        return { msg: err.message };
    }
};
 
const main = async () => {
    const auth = {
        account: "account-name",
        email: "your@email.com",
        password: "your-p@ssw0rd"
    };
    const client = LeanKitClient( auth );
    const board = await getBoardByTitle( client, "Team Awesome" );
    console.log( board );
};
 
main().then( () => {
    // async functions automatically return a Promise
    console.log( "done" );
} );

const createCard = async ( client, boardId, cardTitle, cardDescription, cardTypeName, laneName ) => {
    try {
        // get the board for identifiers like card types, lanes, users, etc.
        const boardRes = await client.board.get( boardId );
        const board = boardRes.data;
        // find the card type by name
        const cardType = board.cardTypes.find( x => x.name === cardTypeName );
        // find the lane by name
        const lane = board.lanes.find( x => x.name === laneName );
        // create the card
        const cardCreateRes = await client.card.create( {
            boardId,
            title: cardTitle,
            description: cardDescription,
            typeId: cardType.id,
            laneId: lane.id
        } );
        // return the new card id
        return cardCreateRes.data;
    } catch ( err ) {
        console.log( err );
        return null;
    }
};

const updateCardTitle = async ( client, cardId, newTitle ) => {
    // replace the existing title
    const updateCardRes = await client.card.update( cardId, [ {
        op: "replace",
        path: "/title",
        value: newTitle
    } ] );
    // return the updated card object
    return updateCardRes.data;
};

const addTagToCard = async ( client, cardId, tag ) => {
    // replace the existing title
    const updateCardRes = await client.card.update( cardId, [ {
        op: "add",
        path: "/tags/-",
        value: tag
    } ] );
    // return the updated card object
    return updateCardRes.data;
};

const fs = require( "fs" );
const path = require( "path" );
 
const addAttachmentToCard = async ( client, cardId, filePath, description ) => {
    try {
        // create a readable stream of the given file
        const fileStream = fs.createReadStream( filePath );
        // get the base filename without the directory or path (e.g. 'QuarterlyResults.pdf')
        const fileName = path.basename( filePath );
        const fileData = {
            file: fileStream,
            name: fileName,
            description
        };
        const createRes = await client.card.attachment.create( cardId, fileData );
        return createRes.data;
    } catch ( err ) {
        console.log( err );
    }
};

const createNewBoardFromTemplate = async ( client, categoryName, templateName, newBoardTitle, description ) => {
    try {
        // get a list of all the templates
        const templateList = await client.template.list();
        // find the category by name
        const category = templateList.data.categories.find( x => x.name === categoryName );
        // find the template by name
        const template = category.find( x => x.name === templateName );
        // create the board
        const createBoard = await client.board.create( {
            templateId: template.id,
            title: newBoardTitle,
            description
        } );
        return createBoard.data;
    } catch ( err ) {
        console.log( err );
    }
};

const fs = require( "fs" );
 
const exportCardsByBoardId = async ( client, boardId, filePath ) => {
    try {
        const createTokenResponse = await client.reporting.auth.token();
        const token = createTokenResponse.data.token;
        const cardExportRes = await client.reporting.export.cards( {
            token,
            stream: fs.createWriteStream( filePath ),
            config: {
                format: "csv",        // optional format ( csv, tab, json )
                quotedString: false,  // optional, quotes will only be used when necessary
                boardId               // optional board id. If no boardId or boardId = 0, all cards will be returned
            }
        } );
        return cardExportRes.status === 200;
    } catch ( err ) {
        console.log( err );
    }
};

const LeanKitClient = require( "leankit-client" );
const auth = {
    account: "account-name",
    email: "your@email.com",
    password: "your-p@ssw0rd",
    config: {
        proxy: "http://localproxy.com"
    }
};
const client = LeanKitClient( auth );