914 lines
37 KiB
JavaScript
914 lines
37 KiB
JavaScript
define([
|
||
'jquery',
|
||
'/customize/messages.js',
|
||
'/common/common-util.js',
|
||
'/common/visible.js',
|
||
'/bower_components/dragula.js/dist/dragula.min.js',
|
||
], function ($, Messages, Util, Visible, Dragula) {
|
||
/**
|
||
* jKanban
|
||
* Vanilla Javascript plugin for manage kanban boards
|
||
*
|
||
* @site: http://www.riccardotartaglia.it/jkanban/
|
||
* @author: Riccardo Tartaglia
|
||
*/
|
||
return function () {
|
||
var self = this;
|
||
this.element = '';
|
||
this.container = '';
|
||
this.boardContainer = [];
|
||
this.dragula = Dragula;
|
||
this.drake = '';
|
||
this.drakeBoard = '';
|
||
this.addItemButton = false;
|
||
this.cache = {};
|
||
var defaults = {
|
||
element: '',
|
||
gutter: '15px',
|
||
widthBoard: '250px',
|
||
responsive: 0, //'700',
|
||
responsivePercentage: false,
|
||
boards: {
|
||
data: {},
|
||
items: {},
|
||
list: []
|
||
}, // The realtime kanban
|
||
_boards: {}, // The displayed kanban. We need to remember the old columns when we redraw
|
||
getAvatar: function () {},
|
||
openLink: function () {},
|
||
getTags: function () {},
|
||
getTextColor: function () { return '#000'; },
|
||
cursors: {},
|
||
tags: [],
|
||
dragBoards: true,
|
||
addItemButton: false,
|
||
readOnly: false,
|
||
dragEl: function (/*el, source*/) {},
|
||
dragendEl: function (/*el*/) {},
|
||
dropEl: function (/*el, target, source, sibling*/) {},
|
||
dragcancelEl: function (/*el, boardId*/) {},
|
||
dragBoard: function (/*el, source*/) {},
|
||
dragendBoard: function (/*el*/) {},
|
||
dropBoard: function (/*el, target, source, sibling*/) {},
|
||
click: function (/*el*/) {},
|
||
boardTitleclick: function (/*el, boardId*/) {},
|
||
addItemClick: function (/*el, boardId*/) {},
|
||
renderMd: function (/*md*/) {},
|
||
applyHtml: function (/*html, node*/) {},
|
||
refresh: function () {},
|
||
onChange: function () {}
|
||
};
|
||
|
||
var __extendDefaults = function (source, properties) {
|
||
var property;
|
||
for (property in properties) {
|
||
if (properties.hasOwnProperty(property)) {
|
||
source[property] = properties[property];
|
||
}
|
||
}
|
||
return source;
|
||
};
|
||
|
||
|
||
if (arguments[0] && typeof arguments[0] === "object") {
|
||
this.options = __extendDefaults(defaults, arguments[0]);
|
||
}
|
||
|
||
var checkCache = function (boards) {
|
||
Object.keys(self.cache).forEach(function (id) {
|
||
if (boards.items[id]) { return; }
|
||
delete self.cache[id];
|
||
});
|
||
};
|
||
var removeUnusedTags = function (boards) {
|
||
var tags = self.options.getTags(boards);
|
||
var filter = self.options.tags || [];
|
||
var toClean = [];
|
||
filter.forEach(function (tag) {
|
||
if (tags.indexOf(tag) === -1) { toClean.push(tag); }
|
||
});
|
||
toClean.forEach(function (t) {
|
||
var idx = filter.indexOf(t);
|
||
if (idx === -1) { return; }
|
||
filter.splice(idx, 1);
|
||
});
|
||
// If all the tags have bene remove, make sure we show everything again
|
||
if (!filter.length) {
|
||
$('.kanban-item-hidden').removeClass('kanban-item-hidden');
|
||
}
|
||
};
|
||
|
||
// Private functions
|
||
|
||
function __setBoard() {
|
||
self.element = document.querySelector(self.options.element);
|
||
//create container
|
||
var boardContainerOuter = document.createElement('div');
|
||
boardContainerOuter.classList.add('kanban-container-outer');
|
||
var boardContainer = document.createElement('div');
|
||
boardContainer.classList.add('kanban-container');
|
||
boardContainerOuter.appendChild(boardContainer);
|
||
var addBoard = document.createElement('div');
|
||
addBoard.id = 'kanban-addboard';
|
||
addBoard.innerHTML = '<i class="fa fa-plus"></i>';
|
||
boardContainer.appendChild(addBoard);
|
||
var trash = self.trashContainer = document.createElement('div');
|
||
trash.setAttribute('id', 'kanban-trash');
|
||
trash.setAttribute('class', 'kanban-trash');
|
||
var trashBg = document.createElement('div');
|
||
var trashIcon = document.createElement('i');
|
||
trashIcon.setAttribute('class', 'fa fa-trash');
|
||
trash.appendChild(trashIcon);
|
||
trash.appendChild(trashBg);
|
||
self.boardContainer.push(trash);
|
||
|
||
self.container = boardContainer;
|
||
//add boards
|
||
self.addBoards();
|
||
//appends to container
|
||
self.element.appendChild(boardContainerOuter);
|
||
self.element.appendChild(trash);
|
||
|
||
// send event that board has changed
|
||
self.onChange();
|
||
}
|
||
|
||
function __onclickHandler(nodeItem) {
|
||
nodeItem.addEventListener('click', function (e) {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
self.options.click(this);
|
||
if (typeof (this.clickfn) === 'function') {
|
||
this.clickfn(this);
|
||
}
|
||
});
|
||
}
|
||
|
||
function __onboardTitleClickHandler(nodeItem) {
|
||
nodeItem.addEventListener('click', function (e) {
|
||
e.preventDefault();
|
||
self.options.boardTitleClick(this, e);
|
||
if (typeof (this.clickfn) === 'function') {
|
||
this.clickfn(this);
|
||
}
|
||
});
|
||
}
|
||
|
||
function __onAddItemClickHandler(nodeItem) {
|
||
nodeItem.addEventListener('click', function (e) {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
self.options.addItemClick(this);
|
||
if (typeof (this.clickfn) === 'function') {
|
||
this.clickfn(this);
|
||
}
|
||
});
|
||
}
|
||
|
||
function __findBoardJSON(id) {
|
||
return (self.options.boards.data || {})[id];
|
||
}
|
||
|
||
|
||
this.init = function () {
|
||
// set initial boards
|
||
__setBoard();
|
||
|
||
// Scroll on drag
|
||
var $el = $(self.element);
|
||
var leftRegion = $el.position().left + 10;
|
||
var rightRegion = $(window).width() - 10;
|
||
var activeBoard;
|
||
var $aB;
|
||
var setActiveDrag = function (board) {
|
||
activeBoard = undefined;
|
||
if (!board) { return; }
|
||
if (!board.classList.contains('kanban-drag')) { return; }
|
||
activeBoard = board;
|
||
$aB = $(activeBoard);
|
||
};
|
||
var mouseMoveState = false;
|
||
var mouseDown = function () {
|
||
mouseMoveState = true;
|
||
};
|
||
var mouseUp = function () {
|
||
mouseMoveState = false;
|
||
};
|
||
var onMouseMove = function (isItem) {
|
||
var to;
|
||
var f = function (e) {
|
||
if (!mouseMoveState) { return; }
|
||
if (e.which !== 1) { return; } // left click
|
||
var distance = 20;
|
||
var moved = false;
|
||
// If this is an item drag, check scroll
|
||
if (isItem && activeBoard) {
|
||
var rect = activeBoard.getBoundingClientRect();
|
||
if (e.pageX > rect.left && e.pageX < rect.right) {
|
||
if (e.pageY < (rect.top + 20)) {
|
||
distance *= -1;
|
||
$aB.scrollTop(distance + $aB.scrollTop()) ;
|
||
moved = true;
|
||
} else if (e.pageY > (rect.bottom - 20)) {
|
||
$aB.scrollTop(distance + $aB.scrollTop()) ;
|
||
moved = true;
|
||
}
|
||
}
|
||
}
|
||
// Itme or board: horizontal scroll if needed
|
||
if (e.pageX < leftRegion) {
|
||
distance *= -1;
|
||
$el.scrollLeft(distance + $el.scrollLeft()) ;
|
||
moved = true;
|
||
} else if (e.pageX >= rightRegion) {
|
||
$el.scrollLeft(distance + $el.scrollLeft()) ;
|
||
moved = true;
|
||
}
|
||
if (!moved) { return; }
|
||
clearTimeout(to);
|
||
to = setTimeout(function () {
|
||
if (!mouseMoveState) { return; }
|
||
f(e);
|
||
}, 100);
|
||
};
|
||
return f;
|
||
};
|
||
|
||
//set drag with dragula
|
||
if (window.innerWidth > self.options.responsive) {
|
||
|
||
//Init Drag Board
|
||
self.drakeBoard = self.dragula([self.container, self.trashContainer], {
|
||
moves: function (el, source, handle) {
|
||
if (self.options.readOnly) { return false; }
|
||
if (!self.options.dragBoards) { return false; }
|
||
return (handle.classList.contains('kanban-board-header') || handle.classList.contains('kanban-title-board'));
|
||
},
|
||
accepts: function (el, target, source, sibling) {
|
||
if (self.options.readOnly) { return false; }
|
||
if (sibling && sibling.getAttribute('id') === "kanban-addboard") { return false; }
|
||
return target.classList.contains('kanban-container') ||
|
||
target.classList.contains('kanban-trash');
|
||
},
|
||
revertOnSpill: true,
|
||
direction: 'horizontal',
|
||
})
|
||
.on('drag', function (el, source) {
|
||
el.classList.add('is-moving');
|
||
self.options.dragBoard(el, source);
|
||
if (typeof (el.dragfn) === 'function') {
|
||
el.dragfn(el, source);
|
||
}
|
||
$('.kanban-trash').addClass('kanban-trash-suggest');
|
||
mouseDown();
|
||
$(document).on('mousemove', onMouseMove());
|
||
})
|
||
.on('dragend', function (el) {
|
||
el.classList.remove('is-moving');
|
||
self.options.dragendBoard(el);
|
||
mouseUp();
|
||
$(document).off('mousemove');
|
||
$('.kanban-trash').removeClass('kanban-trash-suggest');
|
||
if (typeof (el.dragendfn) === 'function') {
|
||
el.dragendfn(el);
|
||
}
|
||
})
|
||
.on('over', function (el, target) {
|
||
if (!target.classList.contains('kanban-trash')) { return false; }
|
||
$('.kanban-trash').addClass('kanban-trash-active');
|
||
$('.kanban-trash').removeClass('kanban-trash-suggest');
|
||
})
|
||
.on('out', function (el, target) {
|
||
if (!target.classList.contains('kanban-trash')) { return false; }
|
||
$('.kanban-trash').removeClass('kanban-trash-active');
|
||
$('.kanban-trash').addClass('kanban-trash-suggest');
|
||
})
|
||
.on('drop', function (el, target, source, sibling) {
|
||
el.classList.remove('is-moving');
|
||
self.options.dropBoard(el, target, source, sibling);
|
||
if (typeof (el.dropfn) === 'function') {
|
||
el.dropfn(el, target, source, sibling);
|
||
}
|
||
|
||
var id = Number($(el).attr('data-id'));
|
||
var list = self.options.boards.list || [];
|
||
|
||
var index1 = list.indexOf(id);
|
||
if (index1 === -1) { return; }
|
||
|
||
// Move to trash?
|
||
if (target.classList.contains('kanban-trash')) {
|
||
list.splice(index1, 1);
|
||
if (list.indexOf(id) === -1) {
|
||
delete self.options.boards.data[id];
|
||
}
|
||
self.onChange();
|
||
return;
|
||
}
|
||
|
||
var index2;
|
||
var id2 = Number($(sibling).attr("data-id"));
|
||
if (sibling && id2) {
|
||
index2 = list.indexOf(id2);
|
||
}
|
||
// If we can't find the drop position, drop at the end
|
||
if (typeof(index2) === "undefined" || index2 === -1) {
|
||
index2 = list.length;
|
||
}
|
||
|
||
console.log("Switch " + index1 + " and " + index2);
|
||
if (index1 < index2) {
|
||
index2 = index2 - 1;
|
||
}
|
||
list.splice(index1, 1);
|
||
list.splice(index2, 0, id);
|
||
// send event that board has changed
|
||
self.onChange();
|
||
self.setBoards(self.options.boards);
|
||
});
|
||
|
||
//Init Drag Item
|
||
self.drake = self.dragula(self.boardContainer, {
|
||
moves: function (el) {
|
||
if (self.options.readOnly) { return false; }
|
||
if (el.classList.contains('new-item')) { return false; }
|
||
return el.classList.contains('kanban-item');
|
||
},
|
||
accepts: function () {
|
||
if (self.options.readOnly) { return false; }
|
||
return true;
|
||
},
|
||
revertOnSpill: true
|
||
})
|
||
.on('cancel', function() {
|
||
self.enableAllBoards();
|
||
})
|
||
.on('drag', function (el, source) {
|
||
// we need to calculate the position before starting to drag
|
||
self.dragItemPos = self.findElementPosition(el);
|
||
|
||
setActiveDrag();
|
||
el.classList.add('is-moving');
|
||
mouseDown();
|
||
$(document).on('mousemove', onMouseMove(el));
|
||
$('.kanban-trash').addClass('kanban-trash-suggest');
|
||
|
||
self.options.dragEl(el, source);
|
||
if (el !== null && typeof (el.dragfn) === 'function') {
|
||
el.dragfn(el, source);
|
||
}
|
||
})
|
||
.on('dragend', function (el) {
|
||
console.log("In dragend");
|
||
el.classList.remove('is-moving');
|
||
self.options.dragendEl(el);
|
||
$('.kanban-trash').removeClass('kanban-trash-suggest');
|
||
mouseUp();
|
||
$(document).off('mousemove');
|
||
if (el !== null && typeof (el.dragendfn) === 'function') {
|
||
el.dragendfn(el);
|
||
}
|
||
})
|
||
.on('cancel', function (el, container, source) {
|
||
console.log("In cancel");
|
||
el.classList.remove('is-moving');
|
||
var boardId = $(source).closest('kanban-board').data('id');
|
||
self.options.dragcancelEl(el, boardId);
|
||
})
|
||
.on('over', function (el, target) {
|
||
setActiveDrag(target);
|
||
if (!target.classList.contains('kanban-trash')) { return false; }
|
||
target.classList.remove('kanban-trash-suggest');
|
||
target.classList.add('kanban-trash-active');
|
||
|
||
})
|
||
.on('out', function (el, target) {
|
||
setActiveDrag();
|
||
if (!target.classList.contains('kanban-trash')) { return false; }
|
||
target.classList.remove('kanban-trash-active');
|
||
target.classList.add('kanban-trash-suggest');
|
||
|
||
})
|
||
.on('drop', function(el, target, source, sibling) {
|
||
self.enableAllBoards();
|
||
el.classList.remove('is-moving');
|
||
|
||
console.log("In drop");
|
||
|
||
var id1 = Number($(el).attr('data-eid'));
|
||
var boardId = Number($(source).closest('.kanban-board').data('id'));
|
||
|
||
// Move to trash?
|
||
if (target.classList.contains('kanban-trash')) {
|
||
self.moveItem(boardId, id1);
|
||
self.onChange();
|
||
return;
|
||
}
|
||
|
||
// Find the new board
|
||
var targetId = Number($(target).closest('.kanban-board').data('id'));
|
||
if (!targetId) { return; }
|
||
var board2 = __findBoardJSON(targetId);
|
||
var id2 = $(sibling).attr('data-eid');
|
||
if (id2) { id2 = Number(id2); }
|
||
var pos2 = id2 ? board2.item.indexOf(id2) : board2.item.length;
|
||
if (pos2 === -1) { pos2 = board2.item.length; }
|
||
|
||
// Remove the "move" effect
|
||
if (el !== null) {
|
||
el.classList.remove('is-moving');
|
||
}
|
||
|
||
// Move the item
|
||
self.moveItem(boardId, id1, board2, pos2);
|
||
|
||
// send event that board has changed
|
||
self.onChange();
|
||
self.setBoards(self.options.boards);
|
||
});
|
||
}
|
||
};
|
||
|
||
var findItem = function (eid) {
|
||
var boards = self.options.boards;
|
||
var list = boards.list || [];
|
||
var res = [];
|
||
list.forEach(function (id) {
|
||
var b = boards.data[id];
|
||
if (!b) { return; }
|
||
var items = b.item || [];
|
||
var idx = items.indexOf(eid);
|
||
if (idx === -1) { return; }
|
||
// This board contains our item...
|
||
res.push({
|
||
board: b,
|
||
pos: idx
|
||
});
|
||
});
|
||
return res;
|
||
};
|
||
this.checkItem = function (eid) {
|
||
var boards = self.options.boards;
|
||
var data = boards.data || {};
|
||
var exists = Object.keys(data).some(function (id) {
|
||
return (data[id].item || []).indexOf(Number(eid)) !== -1;
|
||
});
|
||
return exists;
|
||
};
|
||
this.moveItem = function (source, eid, board, pos) {
|
||
var boards = self.options.boards;
|
||
var same = -1;
|
||
if (source && boards.data[source]) {
|
||
// Remove from this board only
|
||
var l = boards.data[source].item;
|
||
var idx = l.indexOf(Number(eid));
|
||
if (idx !== -1) { l.splice(idx, 1); }
|
||
if (boards.data[source] === board) { same = idx; }
|
||
} else {
|
||
// Remove the item from all its board
|
||
var from = findItem(eid);
|
||
from.forEach(function (obj) {
|
||
obj.board.item.splice(obj.pos, 1);
|
||
if (obj.board === board) { same = obj.pos; }
|
||
});
|
||
}
|
||
// If it's a deletion and not a duplicate, remove the item data
|
||
if (!board) {
|
||
if (!self.checkItem(eid)) {
|
||
delete boards.items[eid];
|
||
delete self.cache[eid];
|
||
removeUnusedTags(boards);
|
||
self.options.refresh();
|
||
}
|
||
return;
|
||
}
|
||
// If the item already exists in the target board, abort (duplicate)
|
||
if (board.item.indexOf(eid) !== -1) {
|
||
return;
|
||
}
|
||
// If it's moved to the same board at a bigger index, decrement the index by one
|
||
// (we just removed one element)
|
||
if (same !== -1 && same < pos) {
|
||
pos = pos - 1;
|
||
}
|
||
board.item.splice(pos, 0, eid);
|
||
};
|
||
|
||
this.enableAllBoards = function() {
|
||
var allB = document.querySelectorAll('.kanban-board');
|
||
if (allB.length > 0 && allB !== undefined) {
|
||
for (var i = 0; i < allB.length; i++) {
|
||
allB[i].classList.remove('disabled-board');
|
||
}
|
||
}
|
||
};
|
||
|
||
var getElementNode = function (element) {
|
||
var nodeItem = document.createElement('div');
|
||
nodeItem.classList.add('kanban-item');
|
||
nodeItem.dataset.eid = element.id;
|
||
if (element.color) {
|
||
if (/color/.test(element.color)) {
|
||
// Palette color
|
||
nodeItem.classList.add('cp-kanban-palette-'+element.color);
|
||
} else {
|
||
// Hex color code
|
||
var textColor = self.options.getTextColor(element.color);
|
||
nodeItem.setAttribute('style', 'background-color:#'+element.color+';color:'+textColor+';');
|
||
}
|
||
}
|
||
var nodeCursors = document.createElement('div');
|
||
nodeCursors.classList.add('cp-kanban-cursors');
|
||
Object.keys(self.options.cursors).forEach(function (id) {
|
||
var c = self.options.cursors[id];
|
||
if (Number(c.item) !== Number(element.id)) { return; }
|
||
var el = self.options.getAvatar(c);
|
||
nodeCursors.appendChild(el);
|
||
});
|
||
var nodeItemText = document.createElement('div');
|
||
nodeItemText.classList.add('kanban-item-text');
|
||
nodeItemText.dataset.eid = element.id;
|
||
nodeItemText.innerText = element.title;
|
||
nodeItem.appendChild(nodeItemText);
|
||
// Check if this card is filtered out
|
||
if (Array.isArray(self.options.tags) && self.options.tags.length) {
|
||
var hide;
|
||
if (self.options.tagsAnd) {
|
||
hide = !Array.isArray(element.tags) ||
|
||
!self.options.tags.every(function (tag) {
|
||
return element.tags.indexOf(tag) !== -1;
|
||
});
|
||
} else {
|
||
hide = !Array.isArray(element.tags) ||
|
||
!element.tags.some(function (tag) {
|
||
return self.options.tags.indexOf(tag) !== -1;
|
||
});
|
||
}
|
||
if (hide) {
|
||
nodeItem.classList.add('kanban-item-hidden');
|
||
}
|
||
}
|
||
if (element.body) {
|
||
var html;
|
||
if (self.cache[element.id] && self.cache[element.id].body === element.body) {
|
||
html = self.cache[element.id].html;
|
||
} else {
|
||
html = self.renderMd(element.body);
|
||
self.cache[element.id] = {
|
||
body: element.body,
|
||
html: html
|
||
};
|
||
}
|
||
var nodeBody = document.createElement('div');
|
||
nodeBody.setAttribute('id', 'kanban-body-' + element.id);
|
||
$(nodeBody).on('click', 'a', function (e) {
|
||
e.preventDefault();
|
||
var a = e.target;
|
||
if (!a.href) { return; }
|
||
var href = a.getAttribute('href');
|
||
self.options.openLink(href);
|
||
});
|
||
nodeBody.onclick = function (e) {
|
||
e.preventDefault();
|
||
};
|
||
//nodeBody.innerHTML = html;
|
||
self.applyHtml(html, nodeBody);
|
||
nodeBody.classList.add('kanban-item-body');
|
||
nodeItem.appendChild(nodeBody);
|
||
}
|
||
if (Array.isArray(element.tags)) {
|
||
var nodeTags = document.createElement('div');
|
||
nodeTags.classList.add('kanban-item-tags');
|
||
element.tags.forEach(function (_tag) {
|
||
var tag = document.createElement('span');
|
||
tag.innerText = _tag;
|
||
nodeTags.appendChild(tag);
|
||
});
|
||
nodeItem.appendChild(nodeTags);
|
||
}
|
||
nodeItem.appendChild(nodeCursors);
|
||
//add function
|
||
nodeItem.clickfn = element.click;
|
||
nodeItem.dragfn = element.drag;
|
||
nodeItem.dragendfn = element.dragend;
|
||
nodeItem.dropfn = element.drop;
|
||
__onclickHandler(nodeItemText);
|
||
return nodeItem;
|
||
};
|
||
|
||
this.addElement = function (boardID, element, before) {
|
||
|
||
// add Element to JSON
|
||
var boardJSON = __findBoardJSON(boardID);
|
||
|
||
if (before) {
|
||
boardJSON.item.unshift(element.id);
|
||
} else {
|
||
boardJSON.item.push(element.id);
|
||
}
|
||
self.options.boards.items = self.options.boards.items || {};
|
||
self.options.boards.items[element.id] = element;
|
||
|
||
var board = self.element.querySelector('[data-id="' + boardID + '"] .kanban-drag');
|
||
if (before) {
|
||
board.insertBefore(getElementNode(element), board.firstChild);
|
||
} else {
|
||
board.appendChild(getElementNode(element));
|
||
}
|
||
// send event that board has changed
|
||
self.onChange();
|
||
return self;
|
||
};
|
||
|
||
this.addForm = function (boardID, formItem, isTop) {
|
||
var board = self.element.querySelector('[data-id="' + boardID + '"] .kanban-drag');
|
||
if (isTop) {
|
||
board.insertBefore(formItem, board.firstChild);
|
||
} else {
|
||
board.appendChild(formItem);
|
||
}
|
||
return self;
|
||
};
|
||
|
||
var getBoardNode = function (board) {
|
||
var boards = self.options.boards;
|
||
var boardWidth = self.options.widthBoard;
|
||
//create node
|
||
var boardNode = document.createElement('div');
|
||
boardNode.dataset.id = board.id;
|
||
boardNode.classList.add('kanban-board');
|
||
var boardNodeInner = document.createElement('div');
|
||
boardNodeInner.classList.add('kanban-board-inner');
|
||
//set style
|
||
if (self.options.responsivePercentage) {
|
||
boardNode.style.width = boardWidth + '%';
|
||
} else {
|
||
boardNode.style.width = boardWidth;
|
||
}
|
||
boardNode.style.marginLeft = self.options.gutter;
|
||
boardNode.style.marginRight = self.options.gutter;
|
||
// header board
|
||
var headerBoard = document.createElement('header');
|
||
var allClasses = [];
|
||
if (board.class !== '' && board.class !== undefined) {
|
||
allClasses = board.class.split(",");
|
||
}
|
||
headerBoard.classList.add('kanban-board-header');
|
||
allClasses.map(function (value) {
|
||
headerBoard.classList.add(value);
|
||
});
|
||
if (board.color !== '' && board.color !== undefined) {
|
||
if (/color/.test(board.color)) {
|
||
// Palette color
|
||
headerBoard.classList.add('cp-kanban-palette-'+board.color);
|
||
boardNodeInner.classList.add('cp-kanban-palette-'+board.color);
|
||
} else if (!/^[0-9a-f]{6}$/.test(board.color)) {
|
||
// "string" color (red, blue, etc.)
|
||
headerBoard.classList.add("kanban-header-" + board.color);
|
||
} else {
|
||
// Hex color code
|
||
var textColor = self.options.getTextColor(board.color);
|
||
headerBoard.setAttribute('style', 'background-color:#'+board.color+';color:'+textColor+';');
|
||
}
|
||
}
|
||
|
||
var titleBoard = document.createElement('div');
|
||
titleBoard.classList.add('kanban-title-board');
|
||
titleBoard.innerText = board.title;
|
||
|
||
titleBoard.clickfn = board.boardTitleClick;
|
||
__onboardTitleClickHandler(titleBoard);
|
||
headerBoard.appendChild(titleBoard);
|
||
|
||
var nodeCursors = document.createElement('div');
|
||
nodeCursors.classList.add('cp-kanban-cursors');
|
||
Object.keys(self.options.cursors).forEach(function (id) {
|
||
var c = self.options.cursors[id];
|
||
if (Number(c.board) !== Number(board.id)) { return; }
|
||
var el = self.options.getAvatar(c);
|
||
nodeCursors.appendChild(el);
|
||
});
|
||
headerBoard.appendChild(nodeCursors);
|
||
|
||
//content board
|
||
var contentBoard = document.createElement('main');
|
||
contentBoard.classList.add('kanban-drag');
|
||
//add drag to array for dragula
|
||
self.boardContainer.push(contentBoard);
|
||
(board.item || []).forEach(function (itemkey) {
|
||
//create item
|
||
var itemKanban = boards.items[itemkey];
|
||
if (!itemKanban) {
|
||
var idx = board.item.indexOf(itemkey);
|
||
if (idx > -1) { board.item.splice(idx, 1); }
|
||
return;
|
||
}
|
||
var nodeItem = getElementNode(itemKanban);
|
||
contentBoard.appendChild(nodeItem);
|
||
});
|
||
|
||
//footer board
|
||
var footerBoard = document.createElement('footer');
|
||
footerBoard.classList.add('kanban-board-footer');
|
||
//add button
|
||
var addTopBoardItem = document.createElement('span');
|
||
addTopBoardItem.classList.add('kanban-title-button');
|
||
addTopBoardItem.setAttribute('data-top', "1");
|
||
addTopBoardItem.innerHTML = '<i class="cptools cptools-add-top">';
|
||
footerBoard.appendChild(addTopBoardItem);
|
||
__onAddItemClickHandler(addTopBoardItem);
|
||
var addBoardItem = document.createElement('span');
|
||
addBoardItem.classList.add('kanban-title-button');
|
||
addBoardItem.innerHTML = '<i class="cptools cptools-add-bottom">';
|
||
footerBoard.appendChild(addBoardItem);
|
||
__onAddItemClickHandler(addBoardItem);
|
||
|
||
//board assembly
|
||
boardNode.appendChild(boardNodeInner);
|
||
boardNodeInner.appendChild(headerBoard);
|
||
boardNodeInner.appendChild(contentBoard);
|
||
boardNodeInner.appendChild(footerBoard);
|
||
|
||
return boardNode;
|
||
};
|
||
this.addBoard = function (board) {
|
||
if (!board || !board.id) { return; }
|
||
// We need to store all the columns in _boards too because it's used to
|
||
// remember what columns were already displayed when we redraw (in order to
|
||
// preserve their scroll value)
|
||
var boards = self.options.boards;
|
||
boards.data = boards.data || {};
|
||
boards.list = boards.list || [];
|
||
var _boards = self.options._boards;
|
||
_boards.data = _boards.data || {};
|
||
_boards.list = _boards.list || [];
|
||
// If it already there, abort
|
||
boards.data[board.id] = board;
|
||
_boards.data[board.id] = board;
|
||
if (boards.list.indexOf(board.id) !== -1) { return; }
|
||
|
||
boards.list.push(board.id);
|
||
_boards.list.push(board.id);
|
||
var boardNode = getBoardNode(board);
|
||
self.container.appendChild(boardNode);
|
||
};
|
||
|
||
this.addBoards = function() {
|
||
//for on all the boards
|
||
var boards = self.options._boards;
|
||
boards.list = boards.list || [];
|
||
boards.data = boards.data || {};
|
||
var toRemove = [];
|
||
boards.list.forEach(function (boardkey) {
|
||
// single board
|
||
var board = boards.data[boardkey];
|
||
if (!board) {
|
||
toRemove.push(boardkey);
|
||
return;
|
||
}
|
||
|
||
var boardNode = getBoardNode(board);
|
||
|
||
//board add
|
||
self.container.appendChild(boardNode);
|
||
});
|
||
toRemove.forEach(function (id) {
|
||
var idx = boards.list.indexOf(id);
|
||
if (idx > -1) { boards.list.splice(idx, 1); }
|
||
});
|
||
|
||
// send event that board has changed
|
||
self.onChange();
|
||
|
||
return self;
|
||
};
|
||
|
||
var onVisibleHandler = false;
|
||
this.setBoards = function (boards) {
|
||
var scroll = {};
|
||
// Fix the tags
|
||
checkCache(boards);
|
||
removeUnusedTags(boards);
|
||
// Get horizontal scroll
|
||
var $el = $(self.element);
|
||
var scrollLeft = $el.scrollLeft();
|
||
// Get existing boards list
|
||
var list = Util.clone(this.options._boards.list);
|
||
|
||
// Update memory
|
||
this.options._boards = Util.clone(boards);
|
||
|
||
// If the tab is not focused but a handler already exists: abort
|
||
if (!Visible.currently() && onVisibleHandler) { return; }
|
||
|
||
var todoOnVisible = function () {
|
||
// Remove all boards
|
||
for (var i in list) {
|
||
var boardkey = list[i];
|
||
scroll[boardkey] = $('.kanban-board[data-id="'+boardkey+'"] .kanban-drag').scrollTop();
|
||
self.removeBoard(boardkey);
|
||
}
|
||
|
||
// Add all new boards
|
||
self.addBoards();
|
||
self.options.refresh();
|
||
// Preserve scroll
|
||
self.options._boards.list.forEach(function (id) {
|
||
if (!scroll[id]) { return; }
|
||
$('.kanban-board[data-id="'+id+'"] .kanban-drag').scrollTop(scroll[id]);
|
||
});
|
||
$el.scrollLeft(scrollLeft);
|
||
};
|
||
|
||
// If the tab is not focused, redraw on focus
|
||
if (!Visible.currently()) {
|
||
onVisibleHandler = true;
|
||
return void Visible.onChange(function (visible) {
|
||
if (!visible) { return; }
|
||
todoOnVisible();
|
||
onVisibleHandler = false;
|
||
}, true);
|
||
}
|
||
todoOnVisible();
|
||
};
|
||
|
||
this.findBoard = function (id) {
|
||
var el = self.element.querySelector('[data-id="' + id + '"]');
|
||
return el;
|
||
};
|
||
|
||
this.findElement = function (id) {
|
||
var el = self.element.querySelector('[data-eid="' + id + '"]');
|
||
return el;
|
||
};
|
||
|
||
this.findElementPosition = function (el) {
|
||
// we are looking at the element position in the child array
|
||
return $(el.parentNode.children).index(el);
|
||
};
|
||
|
||
this.getBoardElements = function (id) {
|
||
var board = self.element.querySelector('[data-id="' + id + '"] .kanban-drag');
|
||
return (board.childNodes);
|
||
};
|
||
|
||
this.removeElement = function (el) {
|
||
if (typeof (el) === 'string') {
|
||
el = self.element.querySelector('[data-eid="' + el + '"]');
|
||
}
|
||
el.remove();
|
||
|
||
// send event that board has changed
|
||
self.onChange();
|
||
|
||
return self;
|
||
};
|
||
|
||
this.removeBoard = function (board) {
|
||
var id;
|
||
if (typeof (board) === 'string' || typeof (board) === "number") {
|
||
id = board;
|
||
board = self.element.querySelector('[data-id="' + board + '"]');
|
||
} else if (board) {
|
||
id = board.id;
|
||
}
|
||
if (board) {
|
||
board.remove();
|
||
|
||
// send event that board has changed
|
||
self.onChange();
|
||
}
|
||
|
||
// Remove duplicates
|
||
if (id) { $(self.element).find('.kanban-board[data-id="' + board + '"]').remove(); }
|
||
|
||
return self;
|
||
};
|
||
|
||
this.applyHtml = function (html, node) {
|
||
return self.options.applyHtml(html, node);
|
||
};
|
||
this.renderMd = function (md) {
|
||
return self.options.renderMd(md);
|
||
};
|
||
this.onChange = function () {
|
||
self.options.onChange();
|
||
};
|
||
|
||
this.getBoardsJSON = function () {
|
||
return self.options.boards;
|
||
};
|
||
|
||
this.getBoardJSON = function (id) {
|
||
return __findBoardJSON(id);
|
||
};
|
||
this.getItemJSON = function (id) {
|
||
return (self.options.boards.items || {})[id];
|
||
};
|
||
|
||
|
||
//init plugin
|
||
this.init();
|
||
};
|
||
});
|