verdnatura/salix
verdnatura
/
salix
3
4
Fork 0
Code Issues Pull Requests 67 Releases Wiki Activity

Merge branch 'dev' into 2931-entry_summary_pagination
gitea/salix/pipeline/head This commit looks good Details

This commit is contained in:
Carlos Jimenez Ruiz 2021-06-14 10:07:22 +00:00
parent 7f69909bbd 05d7eb837d
commit 187aa8d318
29 changed files with 856 additions and 484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
e2e/helpers/selectors.js
View File

@ -888,7 +888,7 @@ export default {
},
workerCalendar: {
year: 'vn-worker-calendar vn-autocomplete[ng-model="$ctrl.year"]',
totalHolidaysUsed: 'vn-worker-calendar div.totalBox > div',
totalHolidaysUsed: 'vn-worker-calendar div.totalBox:first-child > div',
penultimateMondayOfJanuary: 'vn-worker-calendar vn-calendar:nth-child(2) section:nth-child(22) > div',
lastMondayOfMarch: 'vn-worker-calendar vn-calendar:nth-child(4) section:nth-child(29) > div',
fistMondayOfMay: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(8) > div',
@ -896,11 +896,11 @@ export default {
secondTuesdayOfMay: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(16) > div',
secondWednesdayOfMay: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(17) > div',
secondThursdayOfMay: 'vn-worker-calendar vn-calendar:nth-child(6) section:nth-child(18) > div',
holidays: 'vn-worker-calendar > vn-side-menu div:nth-child(3) > vn-chip:nth-child(1)',
absence: 'vn-worker-calendar > vn-side-menu div:nth-child(3) > vn-chip:nth-child(2)',
halfHoliday: 'vn-worker-calendar > vn-side-menu div:nth-child(3) > vn-chip:nth-child(3)',
furlough: 'vn-worker-calendar > vn-side-menu div:nth-child(3) > vn-chip:nth-child(4)',
halfFurlough: 'vn-worker-calendar > vn-side-menu div:nth-child(3) > vn-chip:nth-child(5)',
holidays: 'vn-worker-calendar > vn-side-menu [name="absenceTypes"] > vn-chip:nth-child(1)',
absence: 'vn-worker-calendar > vn-side-menu [name="absenceTypes"] > vn-chip:nth-child(2)',
halfHoliday: 'vn-worker-calendar > vn-side-menu [name="absenceTypes"] > vn-chip:nth-child(3)',
furlough: 'vn-worker-calendar > vn-side-menu [name="absenceTypes"] > vn-chip:nth-child(4)',
halfFurlough: 'vn-worker-calendar > vn-side-menu [name="absenceTypes"] > vn-chip:nth-child(5)',
},
invoiceOutIndex: {
topbarSearch: 'vn-searchbar',

2
front/core/components/autocomplete/index.js
View File

@ -11,7 +11,7 @@ import './style.scss';
* @property {String} valueField The data field name that should be used as value
* @property {Array} data Static data for the autocomplete
* @property {Object} intialData An initial data to avoid the server request used to get the selection
* @property {Boolean} multiple Wether to allow multiple selection
* @property {Boolean} multiple Whether to allow multiple selection
* @property {Object} selection Current object selected
*
* @event change Thrown when value is changed

2
front/core/components/popup/index.js
View File

@ -17,7 +17,7 @@ export default class Popup extends Component {
}
/**
* @type {Boolean} Wether to show or hide the popup.
* @type {Boolean} Whether to show or hide the popup.
*/
get shown() {
return this._shown;

2
front/core/components/table/style.scss
View File

@ -102,7 +102,7 @@ vn-table {
& > vn-one {
overflow: hidden;
text-overflow: ellipsis;
font-size: 0.75rem;
font-size: 1rem;
}
& > vn-one:nth-child(2) h3 {

3
loopback/locale/es.json
View File

@ -180,5 +180,6 @@
"This genus already exist": "Este genus ya existe",
"This specie already exist": "Esta especie ya existe",
"Client assignment has changed": "He cambiado el comercial ~*\"<{{previousWorkerName}}>\"*~ por *\"<{{currentWorkerName}}>\"* del cliente [{{clientName}} ({{clientId}})]({{{url}}})",
"None": "Ninguno"
"None": "Ninguno",
"The contract was not active during the selected date": "El contrato no estaba activo durante la fecha seleccionada"
}

16
modules/route/front/tickets/index.html
View File

@ -149,11 +149,13 @@
ng-model="ticket.checked">
</vn-check>
</vn-td>
<vn-td number>{{::ticket.id}}</vn-td>
<vn-td number>
<span
ng-click="::$ctrl.showClientDescriptor($event, ticket.clientFk)"
class="link">
<span class="link" ng-click="ticketDescriptor.show($event, ticket.id)">
{{::ticket.id}}
</span>
</vn-td>
<vn-td number>
<span class="link" ng-click="clientDescriptor.show($event, ticket.clientFk)">
{{::ticket.nickname}}
</span>
</vn-td>
@ -180,3 +182,9 @@
vn-bind="+"
fixed-bottom-right>
</vn-float-button>
<vn-ticket-descriptor-popover
vn-id="ticket-descriptor">
</vn-ticket-descriptor-popover>
<vn-client-descriptor-popover
vn-id="client-descriptor">
</vn-client-descriptor-popover>

2
modules/ticket/back/methods/ticket/summary.js
View File

@ -63,7 +63,7 @@ module.exports = Self => {
}, {
relation: 'address',
scope: {
fields: ['street', 'city', 'provinceFk', 'phone', 'mobile'],
fields: ['street', 'city', 'provinceFk', 'phone', 'mobile', 'postalCode'],
include: {
relation: 'province',
scope: {

3
modules/ticket/front/basic-data/step-one/locale/es.yml
View File

@ -2,4 +2,5 @@ No delivery zone available for this landing date: No hay una zona de reparto dis
No delivery zone available for this shipping date: No hay una zona de reparto disponible para la fecha de preparación seleccionada
No delivery zone available for this parameters: No hay una zona de reparto disponible con estos parámetros
Deleted: Eliminado
Zone: Zona
Zone: Zona
Edit address: Editar dirección

7
modules/ticket/front/summary/index.js
View File

@ -16,10 +16,11 @@ class Controller extends Summary {
get formattedAddress() {
if (!this.summary) return '';
let address = this.summary.address;
let province = address.province ? `(${address.province.name})` : '';
const address = this.summary.address;
const postcode = address.postalCode;
const province = address.province ? `(${address.province.name})` : '';
return `${address.street} - ${address.city} ${province}`;
return `${address.street} - ${postcode} - ${address.city} ${province}`;
}
loadData() {

5
modules/ticket/front/summary/index.spec.js
View File

@ -27,18 +27,19 @@ describe('Ticket', () => {
});
describe('formattedAddress()', () => {
it('should return a full fromatted address with city and province', () => {
it('should return the full fromatted address with city and province', () => {
controller.summary = {
address: {
province: {
name: 'Gotham'
},
street: '1007 Mountain Drive',
postalCode: 46060,
city: 'Gotham'
}
};
expect(controller.formattedAddress).toEqual('1007 Mountain Drive - Gotham (Gotham)');
expect(controller.formattedAddress).toEqual('1007 Mountain Drive - 46060 - Gotham (Gotham)');
});
});
});

158
modules/worker/back/methods/calendar/absences.js
View File

@ -2,32 +2,24 @@ const UserError = require('vn-loopback/util/user-error');
module.exports = Self => {
Self.remoteMethodCtx('absences', {
description: 'Returns an array of absences from an specified worker',
description: 'Returns an array of absences from an specified contract',
accepts: [{
arg: 'workerFk',
type: 'Number',
arg: 'businessFk',
type: 'number',
required: true,
},
{
arg: 'started',
type: 'Date',
required: true,
},
{
arg: 'ended',
type: 'Date',
arg: 'year',
type: 'date',
required: true,
}],
returns: [{
arg: 'calendar'
},
{
arg: 'absences',
type: 'Number'
type: 'number'
},
{
arg: 'holidays',
type: 'Number'
type: 'number'
}],
http: {
path: `/absences`,
@ -35,25 +27,42 @@ module.exports = Self => {
}
});
Self.absences = async(ctx, workerFk, yearStarted, yearEnded) => {
Self.absences = async(ctx, businessFk, year, options) => {
const models = Self.app.models;
const isSubordinate = await models.Worker.isSubordinate(ctx, workerFk);
if (!isSubordinate)
throw new UserError(`You don't have enough privileges`);
const started = new Date();
started.setFullYear(year);
started.setMonth(0);
started.setDate(1);
const calendar = {totalHolidays: 0, holidaysEnjoyed: 0};
const holidays = [];
const ended = new Date();
ended.setFullYear(year);
ended.setMonth(12);
ended.setDate(0);
// Get active contracts on current year
const year = yearStarted.getFullYear();
const contracts = await models.WorkerLabour.find({
let myOptions = {};
if (typeof options == 'object')
Object.assign(myOptions, options);
const contract = await models.WorkerLabour.findOne({
include: [{
relation: 'holidays',
scope: {
where: {year}
}
},
{
relation: 'absences',
scope: {
include: {
relation: 'absenceType',
},
where: {
dated: {between: [started, ended]}
}
}
},
{
relation: 'workCenter',
scope: {
@ -67,104 +76,39 @@ module.exports = Self => {
relation: 'type'
}],
where: {
dated: {between: [yearStarted, yearEnded]}
dated: {between: [started, ended]}
}
}
}
}
}],
where: {
and: [
{workerFk: workerFk},
{or: [{
ended: {gte: [yearStarted]}
}, {ended: null}]}
],
where: {businessFk}
}, myOptions);
}
});
if (!contract) return;
// Contracts ids
const contractsId = contracts.map(contract => {
return contract.businessFk;
});
// Get absences of year
let absences = await Self.find({
include: {
relation: 'absenceType'
},
where: {
businessFk: {inq: contractsId},
dated: {between: [yearStarted, yearEnded]}
}
});
let entitlementRate = 0;
absences.forEach(absence => {
const absenceType = absence.absenceType();
const isHoliday = absenceType.code === 'holiday';
const isHalfHoliday = absenceType.code === 'halfHoliday';
if (isHoliday)
calendar.holidaysEnjoyed += 1;
if (isHalfHoliday)
calendar.holidaysEnjoyed += 0.5;
entitlementRate += absenceType.holidayEntitlementRate;
const isSubordinate = await models.Worker.isSubordinate(ctx, contract.workerFk, myOptions);
if (!isSubordinate)
throw new UserError(`You don't have enough privileges`);
const absences = [];
for (let absence of contract.absences()) {
absence.dated = new Date(absence.dated);
absence.dated.setHours(0, 0, 0, 0);
});
// Get number of worked days
let workedDays = 0;
contracts.forEach(contract => {
const started = contract.started;
const ended = contract.ended;
const startedTime = started.getTime();
const endedTime = ended && ended.getTime() || yearEnded;
const dayTimestamp = 1000 * 60 * 60 * 24;
workedDays += Math.floor((endedTime - startedTime) / dayTimestamp);
if (workedDays > daysInYear())
workedDays = daysInYear();
// Workcenter holidays
let holidayList = contract.workCenter().holidays();
for (let day of holidayList) {
day.dated = new Date(day.dated);
day.dated.setHours(0, 0, 0, 0);
holidays.push(day);
}
});
const currentContract = contracts.find(contract => {
return contract.started <= new Date()
&& (contract.ended >= new Date() || contract.ended == null);
});
if (currentContract) {
const maxHolidays = currentContract.holidays() && currentContract.holidays().days;
calendar.totalHolidays = maxHolidays;
workedDays -= entitlementRate;
if (workedDays < daysInYear())
calendar.totalHolidays = Math.round(2 * maxHolidays * (workedDays) / daysInYear()) / 2;
absences.push(absence);
}
function daysInYear() {
const year = yearStarted.getFullYear();
// Workcenter holidays
const holidays = [];
const holidayList = contract.workCenter().holidays();
for (let day of holidayList) {
day.dated = new Date(day.dated);
day.dated.setHours(0, 0, 0, 0);
return isLeapYear(year) ? 366 : 365;
holidays.push(day);
}
return [calendar, absences, holidays];
return [absences, holidays];
};
function isLeapYear(year) {
return year % 400 === 0 || (year % 100 !== 0 && year % 4 === 0);
}
};

169
modules/worker/back/methods/calendar/specs/absences.spec.js
View File

@ -2,78 +2,56 @@ const app = require('vn-loopback/server/server');
describe('Worker absences()', () => {
it('should get the absence calendar for a full year contract', async() => {
let ctx = {req: {accessToken: {userId: 106}}};
let workerFk = 106;
const ctx = {req: {accessToken: {userId: 106}}};
const businessId = 106;
const started = new Date();
started.setHours(0, 0, 0, 0);
started.setMonth(0);
started.setDate(1);
const now = new Date();
const year = now.getFullYear();
const monthIndex = 11;
const ended = new Date();
ended.setHours(0, 0, 0, 0);
ended.setMonth(monthIndex + 1);
ended.setDate(0);
const [absences] = await app.models.Calendar.absences(ctx, businessId, year);
let result = await app.models.Calendar.absences(ctx, workerFk, started, ended);
let calendar = result[0];
let absences = result[1];
expect(calendar.totalHolidays).toEqual(27.5);
expect(calendar.holidaysEnjoyed).toEqual(5);
let firstType = absences[0].absenceType().name;
let sixthType = absences[5].absenceType().name;
const firstType = absences[0].absenceType().name;
const sixthType = absences[5].absenceType().name;
expect(firstType).toMatch(/(Holidays|Leave of absence)/);
expect(sixthType).toMatch(/(Holidays|Leave of absence)/);
});
it('should get the absence calendar for a permanent contract', async() => {
let workerFk = 106;
let worker = await app.models.WorkerLabour.findById(workerFk);
let endedDate = worker.ended;
const businessId = 106;
const ctx = {req: {accessToken: {userId: 9}}};
await app.models.WorkerLabour.rawSql(
`UPDATE postgresql.business SET date_end = ? WHERE business_id = ?`,
[null, worker.businessFk]
);
const now = new Date();
const year = now.getFullYear();
let ctx = {req: {accessToken: {userId: 9}}};
const tx = await app.models.Calendar.beginTransaction({});
const started = new Date();
started.setHours(0, 0, 0, 0);
started.setMonth(0);
started.setDate(1);
try {
const options = {transaction: tx};
const monthIndex = 11;
const ended = new Date();
ended.setHours(0, 0, 0, 0);
ended.setMonth(monthIndex + 1);
ended.setDate(0);
const worker = await app.models.WorkerLabour.findById(businessId, null, options);
let result = await app.models.Calendar.absences(ctx, workerFk, started, ended);
let calendar = result[0];
let absences = result[1];
await app.models.WorkerLabour.rawSql(
`UPDATE postgresql.business SET date_end = ? WHERE business_id = ?`,
[null, worker.businessFk], options);
expect(calendar.totalHolidays).toEqual(27.5);
expect(calendar.holidaysEnjoyed).toEqual(5);
const [absences] = await app.models.Calendar.absences(ctx, businessId, year, options);
let firstType = absences[0].absenceType().name;
let sixthType = absences[5].absenceType().name;
let firstType = absences[0].absenceType().name;
let sixthType = absences[5].absenceType().name;
expect(firstType).toMatch(/(Holidays|Leave of absence)/);
expect(sixthType).toMatch(/(Holidays|Leave of absence)/);
// restores the contract end date
await app.models.WorkerLabour.rawSql(
`UPDATE postgresql.business SET date_end = ? WHERE business_id = ?`,
[endedDate, worker.businessFk]
);
expect(firstType).toMatch(/(Holidays|Leave of absence)/);
expect(sixthType).toMatch(/(Holidays|Leave of absence)/);
await tx.rollback();
} catch (e) {
await tx.rollback();
throw e;
}
});
it('should give the same holidays as worked days since the holidays amount matches the amount of days in a year', async() => {
const businessId = 106;
const userId = 106;
const today = new Date();
// getting how many days in a year
@ -94,70 +72,47 @@ describe('Worker absences()', () => {
const daysInYear = Math.round((endedTime - startedTime) / dayTimestamp);
// sets the holidays per year to the amount of days in the current year
let holidaysConfig = await app.models.WorkCenterHoliday.findOne({
where: {
workCenterFk: 1,
year: today.getFullYear()
}});
const tx = await app.models.Calendar.beginTransaction({});
try {
const options = {transaction: tx};
let originalHolidaysValue = holidaysConfig.days;
// sets the holidays per year to the amount of days in the current year
const holidaysConfig = await app.models.WorkCenterHoliday.findOne({
where: {
workCenterFk: 1,
year: today.getFullYear()
}
}, options);
await holidaysConfig.updateAttribute('days', daysInYear);
await holidaysConfig.updateAttribute('days', daysInYear, options);
// normal test begins
const userId = 106;
const contract = await app.models.WorkerLabour.findById(userId);
const contractStartDate = contract.started;
// normal test begins
const contract = await app.models.WorkerLabour.findById(businessId, null, options);
const startingContract = new Date();
startingContract.setHours(0, 0, 0, 0);
startingContract.setMonth(today.getMonth());
startingContract.setDate(1);
const startingContract = new Date();
startingContract.setHours(0, 0, 0, 0);
startingContract.setMonth(today.getMonth());
startingContract.setDate(1);
await app.models.WorkerLabour.rawSql(
`UPDATE postgresql.business SET date_start = ?, date_end = ? WHERE business_id = ?`,
[startingContract, yearEnd, contract.businessFk]
);
await app.models.WorkerLabour.rawSql(
`UPDATE postgresql.business SET date_start = ?, date_end = ? WHERE business_id = ?`,
[startingContract, yearEnd, contract.businessFk], options
);
let ctx = {req: {accessToken: {userId: userId}}};
const ctx = {req: {accessToken: {userId: userId}}};
let result = await app.models.Calendar.absences(ctx, userId, yearStart, yearEnd);
let calendar = result[0];
let absences = result[1];
const [absences] = await app.models.Calendar.absences(ctx, businessId, currentYear);
let remainingDays = 0;
for (let i = today.getMonth(); i < 12; i++) {
today.setDate(1);
today.setMonth(i + 1);
today.setDate(0);
const firstType = absences[0].absenceType().name;
const sixthType = absences[5].absenceType().name;
remainingDays += today.getDate();
expect(firstType).toMatch(/(Holidays|Leave of absence)/);
expect(sixthType).toMatch(/(Holidays|Leave of absence)/);
await tx.rollback();
} catch (e) {
await tx.rollback();
throw e;
}
expect(calendar.totalHolidays).toEqual(remainingDays);
expect(calendar.holidaysEnjoyed).toEqual(5);
let firstType = absences[0].absenceType().name;
let sixthType = absences[5].absenceType().name;
expect(firstType).toMatch(/(Holidays|Leave of absence)/);
expect(sixthType).toMatch(/(Holidays|Leave of absence)/);
// resets the holidays per year with originalHolidaysValue and the contract starting date
await app.models.WorkCenterHoliday.updateAll(
{
workCenterFk: 1,
year: today.getFullYear()
},
{
days: originalHolidaysValue
}
);
await app.models.WorkerLabour.rawSql(
`UPDATE postgresql.business SET date_start = ? WHERE business_id = ?`,
[contractStartDate, contract.businessFk]
);
});
});

47
modules/worker/back/methods/worker/activeContract.js Normal file
View File

@ -0,0 +1,47 @@
const UserError = require('vn-loopback/util/user-error');
module.exports = Self => {
Self.remoteMethodCtx('activeContract', {
description: 'Returns an array of contracts from an specified worker',
accepts: [{
arg: 'id',
type: 'number',
required: true,
description: 'The worker id',
http: {source: 'path'}
}],
returns: {
type: ['object'],
root: true
},
http: {
path: `/:id/activeContract`,
verb: 'GET'
}
});
Self.activeContract = async(ctx, id) => {
const models = Self.app.models;
const isSubordinate = await models.Worker.isSubordinate(ctx, id);
if (!isSubordinate)
throw new UserError(`You don't have enough privileges`);
const now = new Date();
return models.WorkerLabour.findOne({
where: {
and: [
{workerFk: id},
{started: {lte: now}},
{
or: [
{ended: {gte: now}},
{ended: null}
]
}
]
}
});
};
};

43
modules/worker/back/methods/worker/contracts.js Normal file
View File

@ -0,0 +1,43 @@
const UserError = require('vn-loopback/util/user-error');
module.exports = Self => {
Self.remoteMethodCtx('contracts', {
description: 'Returns an array of contracts from an specified worker',
accepts: [{
arg: 'id',
type: 'number',
required: true,
description: 'The worker id',
http: {source: 'path'}
},
{
arg: 'filter',
type: 'Object',
description: 'Filter defining where and paginated data',
required: true
}],
returns: {
type: ['object'],
root: true
},
http: {
path: `/:id/contracts`,
verb: 'GET'
}
});
Self.contracts = async(ctx, id, filter) => {
const models = Self.app.models;
const isSubordinate = await models.Worker.isSubordinate(ctx, id);
if (!isSubordinate)
throw new UserError(`You don't have enough privileges`);
if (!filter.where) filter.where = {};
const where = filter.where;
where['workerFk'] = id;
return models.WorkerLabour.find(filter);
};
};

110
modules/worker/back/methods/worker/createAbsence.js
View File

@ -5,19 +5,24 @@ module.exports = Self => {
description: 'Creates a new worker absence',
accepts: [{
arg: 'id',
type: 'Number',
type: 'number',
description: 'The worker id',
http: {source: 'path'}
},
{
arg: 'businessFk',
type: 'number',
required: true
},
{
arg: 'absenceTypeId',
type: 'Number',
type: 'number',
required: true
},
{
arg: 'dated',
type: 'Date',
required: false
type: 'date',
required: true
}],
returns: {
type: 'Object',
@ -29,55 +34,70 @@ module.exports = Self => {
}
});
Self.createAbsence = async(ctx, id, absenceTypeId, dated) => {
Self.createAbsence = async(ctx, id, options) => {
const models = Self.app.models;
const $t = ctx.req.__; // $translate
const args = ctx.args;
const userId = ctx.req.accessToken.userId;
const isSubordinate = await models.Worker.isSubordinate(ctx, id);
const isTeamBoss = await models.Account.hasRole(userId, 'teamBoss');
if (!isSubordinate || (isSubordinate && userId == id && !isTeamBoss))
throw new UserError(`You don't have enough privileges`);
let tx;
let myOptions = {};
const labour = await models.WorkerLabour.findOne({
include: {relation: 'department'},
where: {
and: [
{workerFk: id},
{or: [{
ended: {gte: [dated]}
}, {ended: null}]}
]
}
});
if (typeof options == 'object')
Object.assign(myOptions, options);
const absence = await models.Calendar.create({
businessFk: labour.businessFk,
dayOffTypeFk: absenceTypeId,
dated: dated
});
const department = labour.department();
if (department && department.notificationEmail) {
const absenceType = await models.AbsenceType.findById(absenceTypeId);
const account = await models.Account.findById(userId);
const subordinated = await models.Account.findById(id);
const origin = ctx.req.headers.origin;
const body = $t('Created absence', {
author: account.nickname,
employee: subordinated.nickname,
absenceType: absenceType.name,
dated: formatDate(dated),
workerUrl: `${origin}/#!/worker/${id}/calendar`
});
await models.Mail.create({
subject: $t('Absence change notification on the labour calendar'),
body: body,
sender: department.notificationEmail
});
if (!myOptions.transaction) {
tx = await Self.beginTransaction({});
myOptions.transaction = tx;
}
return absence;
try {
const isSubordinate = await models.Worker.isSubordinate(ctx, id, myOptions);
const isTeamBoss = await models.Account.hasRole(userId, 'teamBoss', myOptions);
if (!isSubordinate || (isSubordinate && userId == id && !isTeamBoss))
throw new UserError(`You don't have enough privileges`);
const labour = await models.WorkerLabour.findById(args.businessFk, {
include: {relation: 'department'}
}, myOptions);
if (args.dated < labour.started || (labour.ended != null && args.dated > labour.ended))
throw new UserError(`The contract was not active during the selected date`);
const absence = await models.Calendar.create({
businessFk: labour.businessFk,
dayOffTypeFk: args.absenceTypeId,
dated: args.dated
}, myOptions);
const department = labour.department();
if (department && department.notificationEmail) {
const absenceType = await models.AbsenceType.findById(args.absenceTypeId, null, myOptions);
const account = await models.Account.findById(userId, null, myOptions);
const subordinated = await models.Account.findById(id, null, myOptions);
const origin = ctx.req.headers.origin;
const body = $t('Created absence', {
author: account.nickname,
employee: subordinated.nickname,
absenceType: absenceType.name,
dated: formatDate(args.dated),
workerUrl: `${origin}/#!/worker/${id}/calendar`
});
await models.Mail.create({
subject: $t('Absence change notification on the labour calendar'),
body: body,
sender: department.notificationEmail
}, myOptions);
}
if (tx) await tx.commit();
return absence;
} catch (e) {
if (tx) await tx.rollback();
throw e;
}
};
function formatDate(date) {

92
modules/worker/back/methods/worker/deleteAbsence.js
View File

@ -5,13 +5,13 @@ module.exports = Self => {
description: 'Deletes a worker absence',
accepts: [{
arg: 'id',
type: 'Number',
type: 'number',
description: 'The worker id',
http: {source: 'path'}
},
{
arg: 'absenceId',
type: 'Number',
type: 'number',
required: true
}],
returns: 'Object',
@ -21,47 +21,67 @@ module.exports = Self => {
}
});
Self.deleteAbsence = async(ctx, id, absenceId) => {
Self.deleteAbsence = async(ctx, id, options) => {
const models = Self.app.models;
const $t = ctx.req.__; // $translate
const args = ctx.args;
const userId = ctx.req.accessToken.userId;
const isSubordinate = await models.Worker.isSubordinate(ctx, id);
const isTeamBoss = await models.Account.hasRole(userId, 'teamBoss');
if (!isSubordinate || (isSubordinate && userId == id && !isTeamBoss))
throw new UserError(`You don't have enough privileges`);
let tx;
let myOptions = {};
const absence = await models.Calendar.findById(absenceId, {
include: {
relation: 'labour',
scope: {
include: {relation: 'department'}
}
}
});
const result = await absence.destroy();
const labour = absence.labour();
const department = labour && labour.department();
if (department && department.notificationEmail) {
const absenceType = await models.AbsenceType.findById(absence.dayOffTypeFk);
const account = await models.Account.findById(userId);
const subordinated = await models.Account.findById(labour.workerFk);
const origin = ctx.req.headers.origin;
const body = $t('Deleted absence', {
author: account.nickname,
employee: subordinated.nickname,
absenceType: absenceType.name,
dated: formatDate(absence.dated),
workerUrl: `${origin}/#!/worker/${id}/calendar`
});
await models.Mail.create({
subject: $t('Absence change notification on the labour calendar'),
body: body,
sender: department.notificationEmail
});
if (typeof options == 'object')
Object.assign(myOptions, options);
if (!myOptions.transaction) {
tx = await Self.beginTransaction({});
myOptions.transaction = tx;
}
return result;
try {
const isSubordinate = await models.Worker.isSubordinate(ctx, id, myOptions);
const isTeamBoss = await models.Account.hasRole(userId, 'teamBoss', myOptions);
if (!isSubordinate || (isSubordinate && userId == id && !isTeamBoss))
throw new UserError(`You don't have enough privileges`);
const absence = await models.Calendar.findById(args.absenceId, {
include: {
relation: 'labour',
scope: {
include: {relation: 'department'}
}
}
}, myOptions);
const result = await absence.destroy(myOptions);
const labour = absence.labour();
const department = labour && labour.department();
if (department && department.notificationEmail) {
const absenceType = await models.AbsenceType.findById(absence.dayOffTypeFk, null, myOptions);
const account = await models.Account.findById(userId, null, myOptions);
const subordinated = await models.Account.findById(labour.workerFk, null, myOptions);
const origin = ctx.req.headers.origin;
const body = $t('Deleted absence', {
author: account.nickname,
employee: subordinated.nickname,
absenceType: absenceType.name,
dated: formatDate(absence.dated),
workerUrl: `${origin}/#!/worker/${id}/calendar`
});
await models.Mail.create({
subject: $t('Absence change notification on the labour calendar'),
body: body,
sender: department.notificationEmail
}, myOptions);
}
if (tx) await tx.commit();
return result;
} catch (e) {
if (tx) await tx.rollback();
throw e;
}
};
function formatDate(date) {

176
modules/worker/back/methods/worker/holidays.js Normal file
View File

@ -0,0 +1,176 @@
const UserError = require('vn-loopback/util/user-error');
module.exports = Self => {
Self.remoteMethodCtx('holidays', {
description: 'Returns the holidays available whitin a contract or a year',
accepts: [{
arg: 'id',
type: 'number',
required: true,
description: 'The worker id',
http: {source: 'path'}
},
{
arg: 'year',
type: 'date',
required: true,
},
{
arg: 'businessFk',
type: 'number',
required: false
}],
returns: [{
type: 'object',
root: true
}],
http: {
path: `/:id/holidays`,
verb: 'GET'
}
});
Self.holidays = async(ctx, id, options) => {
const models = Self.app.models;
const args = ctx.args;
let myOptions = {};
if (typeof options == 'object')
Object.assign(myOptions, options);
const isSubordinate = await models.Worker.isSubordinate(ctx, id, myOptions);
if (!isSubordinate)
throw new UserError(`You don't have enough privileges`);
const started = new Date();
started.setFullYear(args.year);
started.setMonth(0);
started.setDate(1);
started.setHours(0, 0, 0, 0);
const ended = new Date();
ended.setFullYear(args.year);
ended.setMonth(12);
ended.setDate(0);
ended.setHours(23, 59, 59, 59);
const filter = {
include: [{
relation: 'holidays',
scope: {
where: {year: args.year}
}
},
{
relation: 'absences',
scope: {
include: {
relation: 'absenceType',
},
where: {
dated: {between: [started, ended]}
}
}
},
{
relation: 'workCenter',
scope: {
include: {
relation: 'holidays',
scope: {
include: [{
relation: 'detail'
},
{
relation: 'type'
}],
where: {
dated: {between: [started, ended]}
}
}
}
}
}],
where: {
and: [
{workerFk: id},
{
or: [
{started: {between: [started, ended]}},
{ended: {between: [started, ended]}},
{and: [{started: {lt: started}}, {ended: {gt: ended}}]},
{and: [{started: {lt: started}}, {ended: null}]}
]
}
],
}
};
if (args.businessFk)
filter.where.and.push({businessFk: args.businessFk});
const contracts = await models.WorkerLabour.find(filter, myOptions);
let totalHolidays = 0;
let holidaysEnjoyed = 0;
for (let contract of contracts) {
const contractStarted = contract.started;
contractStarted.setHours(0, 0, 0, 0);
const contractEnded = contract.ended;
if (contractEnded)
contractEnded.setHours(23, 59, 59, 59);
let startedTime;
if (contractStarted < started)
startedTime = started.getTime();
else startedTime = contractStarted.getTime();
let endedTime;
if (!contractEnded || (contractEnded && contractEnded > ended))
endedTime = ended.getTime();
else endedTime = contractEnded.getTime();
const dayTimestamp = 1000 * 60 * 60 * 24;
// Get number of worked days between dates
let workedDays = Math.floor((endedTime - startedTime) / dayTimestamp);
workedDays += 1; // 1 day inclusion
// Calculates absences
let entitlementRate = 0;
for (let absence of contract.absences()) {
const absenceType = absence.absenceType();
const isHoliday = absenceType.code === 'holiday';
const isHalfHoliday = absenceType.code === 'halfHoliday';
if (isHoliday) holidaysEnjoyed += 1;
if (isHalfHoliday) holidaysEnjoyed += 0.5;
entitlementRate += absenceType.holidayEntitlementRate;
}
workedDays -= entitlementRate;
// Max holidays for the selected year
const maxHolidays = contract.holidays() && contract.holidays().days;
if (workedDays < daysInYear())
totalHolidays += Math.round(2 * maxHolidays * (workedDays) / daysInYear()) / 2;
else totalHolidays = maxHolidays;
}
function daysInYear() {
const year = started.getFullYear();
return isLeapYear(year) ? 366 : 365;
}
return {totalHolidays, holidaysEnjoyed};
};
function isLeapYear(year) {
return year % 400 === 0 || (year % 100 !== 0 && year % 4 === 0);
}
};

11
modules/worker/back/methods/worker/isSubordinate.js
View File

@ -23,16 +23,21 @@ module.exports = Self => {
}
});
Self.isSubordinate = async(ctx, id) => {
Self.isSubordinate = async(ctx, id, options) => {
const models = Self.app.models;
const myUserId = ctx.req.accessToken.userId;
const mySubordinates = await Self.mySubordinates(ctx);
let myOptions = {};
if (typeof options == 'object')
Object.assign(myOptions, options);
const mySubordinates = await Self.mySubordinates(ctx, myOptions);
const isSubordinate = mySubordinates.find(subordinate => {
return subordinate.workerFk == id;
});
const isHr = await models.Account.hasRole(myUserId, 'hr');
const isHr = await models.Account.hasRole(myUserId, 'hr', myOptions);
if (isHr || isSubordinate)
return true;

9
modules/worker/back/methods/worker/mySubordinates.js
View File

@ -20,17 +20,22 @@ module.exports = Self => {
}
});
Self.mySubordinates = async ctx => {
Self.mySubordinates = async(ctx, options) => {
const conn = Self.dataSource.connector;
const userId = ctx.req.accessToken.userId;
const stmts = [];
let myOptions = {};
if (typeof options == 'object')
Object.assign(myOptions, options);
stmts.push(new ParameterizedSQL('CALL vn.subordinateGetList(?)', [userId]));
const queryIndex = stmts.push('SELECT * FROM tmp.subordinate') - 1;
stmts.push('DROP TEMPORARY TABLE tmp.subordinate');
const sql = ParameterizedSQL.join(stmts, ';');
const result = await conn.executeStmt(sql);
const result = await conn.executeStmt(sql, myOptions);
return result[queryIndex];
};

69
modules/worker/back/methods/worker/specs/createAbsence.spec.js
View File

@ -5,18 +5,34 @@ describe('Worker createAbsence()', () => {
const workerId = 18;
it('should return an error for a user without enough privileges', async() => {
const ctx = {req: {accessToken: {userId: 18}}};
const absenceTypeId = 1;
const dated = new Date();
const ctx = {
req: {accessToken: {userId: 18}},
args: {
businessFk: 18,
absenceTypeId: 1,
dated: new Date()
}
};
let error;
await app.models.Worker.createAbsence(ctx, workerId, absenceTypeId, dated).catch(e => {
error = e;
}).finally(() => {
expect(error.message).toEqual(`You don't have enough privileges`);
});
const tx = await app.models.Calendar.beginTransaction({});
expect(error).toBeDefined();
try {
const options = {transaction: tx};
let error;
await app.models.Worker.createAbsence(ctx, workerId, options).catch(e => {
error = e;
}).finally(() => {
expect(error.message).toEqual(`You don't have enough privileges`);
});
expect(error).toBeDefined();
await tx.rollback();
} catch (e) {
await tx.rollback();
throw e;
}
});
it('should create a new absence', async() => {
@ -24,7 +40,14 @@ describe('Worker createAbsence()', () => {
accessToken: {userId: 19},
headers: {origin: 'http://localhost'}
};
const ctx = {req: activeCtx};
const ctx = {
req: activeCtx,
args: {
businessFk: 18,
absenceTypeId: 1,
dated: new Date()
}
};
ctx.req.__ = value => {
return value;
};
@ -32,17 +55,23 @@ describe('Worker createAbsence()', () => {
active: activeCtx
});
const absenceTypeId = 1;
const dated = new Date();
const createdAbsence = await app.models.Worker.createAbsence(ctx, workerId, absenceTypeId, dated);
const tx = await app.models.Calendar.beginTransaction({});
const expectedBusinessId = 18;
const expectedAbsenceTypeId = 1;
try {
const options = {transaction: tx};
expect(createdAbsence.businessFk).toEqual(expectedBusinessId);
expect(createdAbsence.dayOffTypeFk).toEqual(expectedAbsenceTypeId);
const createdAbsence = await app.models.Worker.createAbsence(ctx, workerId, options);
// Restores
await app.models.Calendar.destroyById(createdAbsence.id);
const expectedBusinessId = 18;
const expectedAbsenceTypeId = 1;
expect(createdAbsence.businessFk).toEqual(expectedBusinessId);
expect(createdAbsence.dayOffTypeFk).toEqual(expectedAbsenceTypeId);
await tx.rollback();
} catch (e) {
await tx.rollback();
throw e;
}
});
});

67
modules/worker/back/methods/worker/specs/deleteAbsence.spec.js
View File

@ -12,45 +12,68 @@ describe('Worker deleteAbsence()', () => {
ctx.req.__ = value => {
return value;
};
let createdAbsence;
beforeEach(async() => {
spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
active: activeCtx
});
createdAbsence = await app.models.Calendar.create({
businessFk: businessId,
dayOffTypeFk: 1,
dated: new Date()
});
});
afterEach(async() => {
await app.models.Calendar.destroyById(createdAbsence.id);
});
it('should return an error for a user without enough privileges', async() => {
activeCtx.accessToken.userId = 106;
const tx = await app.models.Calendar.beginTransaction({});
let error;
await app.models.Worker.deleteAbsence(ctx, 18, createdAbsence.id).catch(e => {
error = e;
}).finally(() => {
expect(error.message).toEqual(`You don't have enough privileges`);
});
try {
const options = {transaction: tx};
const createdAbsence = await app.models.Calendar.create({
businessFk: businessId,
dayOffTypeFk: 1,
dated: new Date()
}, options);
expect(error).toBeDefined();
ctx.args = {absenceId: createdAbsence.id};
let error;
await app.models.Worker.deleteAbsence(ctx, workerId).catch(e => {
error = e;
}).finally(() => {
expect(error.message).toEqual(`You don't have enough privileges`);
});
expect(error).toBeDefined();
await tx.rollback();
} catch (e) {
await tx.rollback();
throw e;
}
});
it('should create a new absence', async() => {
it('should successfully delete an absence', async() => {
activeCtx.accessToken.userId = 19;
expect(createdAbsence.businessFk).toEqual(businessId);
const tx = await app.models.Calendar.beginTransaction({});
await app.models.Worker.deleteAbsence(ctx, workerId, createdAbsence.id);
try {
const options = {transaction: tx};
const createdAbsence = await app.models.Calendar.create({
businessFk: businessId,
dayOffTypeFk: 1,
dated: new Date()
}, options);
const deletedAbsence = await app.models.Calendar.findById(createdAbsence.id);
ctx.args = {absenceId: createdAbsence.id};
expect(deletedAbsence).toBeNull();
await app.models.Worker.deleteAbsence(ctx, workerId, options);
const deletedAbsence = await app.models.Calendar.findById(createdAbsence.id, null, options);
expect(deletedAbsence).toBeNull();
await tx.rollback();
} catch (e) {
await tx.rollback();
throw e;
}
});
});

30
modules/worker/back/methods/worker/specs/holidays.spec.js Normal file
View File

@ -0,0 +1,30 @@
const app = require('vn-loopback/server/server');
const LoopBackContext = require('loopback-context');
describe('Worker holidays()', () => {
const businessId = 106;
const workerId = 106;
const activeCtx = {
accessToken: {userId: workerId},
headers: {origin: 'http://localhost'}
};
const ctx = {req: activeCtx};
beforeEach(async() => {
spyOn(LoopBackContext, 'getCurrentContext').and.returnValue({
active: activeCtx
});
});
it('should get the absence calendar for a full year contract', async() => {
const now = new Date();
const year = now.getFullYear();
ctx.args = {businessFk: businessId, year: year};
const result = await app.models.Worker.holidays(ctx, workerId);
expect(result.totalHolidays).toEqual(27.5);
expect(result.holidaysEnjoyed).toEqual(5);
});
});

9
modules/worker/back/models/worker-labour.json
View File

@ -12,10 +12,10 @@
"type": "Number"
},
"started": {
"type": "Date"
"type": "date"
},
"ended": {
"type": "Date"
"type": "date"
}
},
"relations": {
@ -38,6 +38,11 @@
"type": "belongsTo",
"model": "WorkCenterHoliday",
"foreignKey": "workCenterFk"
},
"absences": {
"type": "hasMany",
"model": "Calendar",
"foreignKey": "businessFk"
}
}
}

3
modules/worker/back/models/worker.js
View File

@ -10,4 +10,7 @@ module.exports = Self => {
require('../methods/worker/active')(Self);
require('../methods/worker/activeWithRole')(Self);
require('../methods/worker/activeWithInheritedRole')(Self);
require('../methods/worker/contracts')(Self);
require('../methods/worker/holidays')(Self);
require('../methods/worker/activeContract')(Self);
};

34
modules/worker/front/calendar/index.html
View File

@ -22,13 +22,22 @@
</div>
<vn-side-menu side="right">
<div class="vn-pa-md">
<div class="totalBox" style="text-align: center;">
<h6 translate>Holidays</h6>
<div class="totalBox vn-mb-sm" style="text-align: center;">
<h6>{{'Contract' | translate}} ID: {{$ctrl.businessId}}</h6>
<div>
{{'Used' | translate}} {{$ctrl.calendar.holidaysEnjoyed}}
{{'of' | translate}} {{$ctrl.calendar.totalHolidays || 0}} {{'days' | translate}}
{{'Used' | translate}} {{$ctrl.contractHolidays.holidaysEnjoyed}}
{{'of' | translate}} {{$ctrl.contractHolidays.totalHolidays || 0}} {{'days' | translate}}
</div>
</div>
<div class="totalBox" style="text-align: center;">
<h6>{{'Year' | translate}} {{$ctrl.year}}</h6>
<div>
{{'Used' | translate}} {{$ctrl.yearHolidays.holidaysEnjoyed}}
{{'of' | translate}} {{$ctrl.yearHolidays.totalHolidays || 0}} {{'days' | translate}}
</div>
</div>
<div class="vn-pt-md">
<vn-autocomplete label="Year"
data="$ctrl.yearFilter"
@ -37,8 +46,23 @@
value-field="year"
order="DESC">
</vn-autocomplete>
<vn-autocomplete label="Contract"
url="Workers/{{$ctrl.$params.id}}/contracts"
fields="['started', 'ended']"
ng-model="$ctrl.businessId"
search-function="{businessFk: $search}"
value-field="businessFk"
order="businessFk DESC"
limit="5">
<tpl-item>
<div>ID: {{businessFk}}</div>
<div class="text-caption text-secondary">
{{started | date: 'dd/MM/yyyy'}} - {{ended ? (ended | date: 'dd/MM/yyyy') : 'Indef.'}}
</div>
</tpl-item>
</vn-autocomplete>
</div>
<div class="input vn-py-md" style="overflow: hidden;">
<div name="absenceTypes" class="input vn-py-md" style="overflow: hidden;">
<vn-chip ng-repeat="absenceType in absenceTypes" ng-class="::{'selectable': $ctrl.isSubordinate}"
ng-click="$ctrl.pick(absenceType)">
<vn-avatar

94
modules/worker/front/calendar/index.js
View File

@ -20,7 +20,24 @@ class Controller extends Section {
this.date = newYear;
this.refresh().then(() => this.repaint());
this.refresh()
.then(() => this.repaint())
.then(() => this.getContractHolidays())
.then(() => this.getYearHolidays());
}
get businessId() {
return this._businessId;
}
set businessId(value) {
this._businessId = value;
if (value) {
this.refresh()
.then(() => this.repaint())
.then(() => this.getContractHolidays())
.then(() => this.getYearHolidays());
}
}
get date() {
@ -31,16 +48,6 @@ class Controller extends Section {
this._date = value;
value.setHours(0, 0, 0, 0);
const started = new Date(value.getTime());
started.setMonth(0);
started.setDate(1);
this.started = started;
const ended = new Date(value.getTime());
ended.setMonth(12);
ended.setDate(0);
this.ended = ended;
this.months = new Array(12);
for (let i = 0; i < this.months.length; i++) {
@ -59,26 +66,51 @@ class Controller extends Section {
this._worker = value;
if (value) {
this.refresh().then(() => this.repaint());
this.getIsSubordinate();
this.getActiveContract();
}
}
buildYearFilter() {
const currentYear = new Date().getFullYear();
const minRange = currentYear - 5;
const now = new Date();
now.setFullYear(now.getFullYear() + 1);
const maxYear = now.getFullYear();
const minRange = maxYear - 5;
const years = [];
for (let i = currentYear; i > minRange; i--)
for (let i = maxYear; i > minRange; i--)
years.push({year: i});
this.yearFilter = years;
}
getIsSubordinate() {
this.$http.get(`Workers/${this.worker.id}/isSubordinate`).then(res =>
this.isSubordinate = res.data
);
this.$http.get(`Workers/${this.worker.id}/isSubordinate`)
.then(res => this.isSubordinate = res.data);
}
getActiveContract() {
this.$http.get(`Workers/${this.worker.id}/activeContract`)
.then(res => this.businessId = res.data.businessFk);
}
getContractHolidays() {
this.getHolidays({
businessFk: this.businessId,
year: this.year
}, data => this.contractHolidays = data);
}
getYearHolidays() {
this.getHolidays({
year: this.year
}, data => this.yearHolidays = data);
}
getHolidays(params, cb) {
this.$http.get(`Workers/${this.worker.id}/holidays`, {params})
.then(res => cb(res.data));
}
onData(data) {
@ -155,9 +187,6 @@ class Controller extends Section {
if (!this.absenceType)
return this.vnApp.showMessage(this.$t('Choose an absence type from the right menu'));
if (this.year != new Date().getFullYear())
return this.vnApp.showMessage(this.$t('You can just add absences within the current year'));
const day = $days[0];
const stamp = day.getTime();
const event = this.events[stamp];
@ -176,7 +205,8 @@ class Controller extends Section {
const absenceType = this.absenceType;
const params = {
dated: dated,
absenceTypeId: absenceType.id
absenceTypeId: absenceType.id,
businessFk: this.businessId
};
const path = `Workers/${this.$params.id}/createAbsence`;
@ -190,7 +220,10 @@ class Controller extends Section {
};
this.repaintCanceller(() =>
this.refresh().then(calendar.repaint())
this.refresh()
.then(calendar.repaint())
.then(() => this.getContractHolidays())
.then(() => this.getYearHolidays())
);
});
}
@ -208,7 +241,10 @@ class Controller extends Section {
event.type = absenceType.code;
this.repaintCanceller(() =>
this.refresh().then(calendar.repaint())
this.refresh()
.then(calendar.repaint())
.then(() => this.getContractHolidays())
.then(() => this.getYearHolidays())
);
});
}
@ -220,7 +256,10 @@ class Controller extends Section {
delete this.events[day.getTime()];
this.repaintCanceller(() =>
this.refresh().then(calendar.repaint())
this.refresh()
.then(calendar.repaint())
.then(() => this.getContractHolidays())
.then(() => this.getYearHolidays())
);
});
}
@ -237,9 +276,8 @@ class Controller extends Section {
refresh() {
const params = {
workerFk: this.worker.id,
started: this.started,
ended: this.ended
businessFk: this.businessId,
year: this.year
};
return this.$http.get(`Calendars/absences`, {params})
.then(res => this.onData(res.data));

133
modules/worker/front/calendar/index.spec.js
View File

@ -41,35 +41,31 @@ describe('Worker', () => {
});
});
describe('started property', () => {
it(`should return first day and month of current year`, () => {
let started = new Date(year, 0, 1);
describe('businessId() setter', () => {
it(`should set the contract id and then call to the refresh method`, () => {
jest.spyOn(controller, 'refresh').mockReturnValue(Promise.resolve());
expect(controller.started).toEqual(started);
});
});
controller.businessId = 106;
describe('ended property', () => {
it(`should return last day and month of current year`, () => {
let ended = new Date(year, 11, 31);
expect(controller.ended).toEqual(ended);
expect(controller.refresh).toHaveBeenCalledWith();
});
});
describe('months property', () => {
it(`should return an array of twelve months length`, () => {
const started = new Date(year, 0, 1);
const ended = new Date(year, 11, 1);
expect(controller.months.length).toEqual(12);
expect(controller.months[0]).toEqual(controller.started);
expect(controller.months[0]).toEqual(started);
expect(controller.months[11]).toEqual(ended);
});
});
describe('worker() setter', () => {
it(`should perform a get query and set the reponse data on the model`, () => {
jest.spyOn(controller, 'getIsSubordinate').mockReturnValue(true);
controller.getIsSubordinate = jest.fn();
controller.getActiveContract = jest.fn();
let today = new Date();
let tomorrow = new Date(today.getTime());
@ -78,49 +74,60 @@ describe('Worker', () => {
let yesterday = new Date(today.getTime());
yesterday.setDate(yesterday.getDate() - 1);
$httpBackend.whenRoute('GET', 'Calendars/absences')
.respond({
holidays: [
{dated: today, detail: {name: 'New year'}},
{dated: tomorrow, detail: {name: 'Easter'}}
],
absences: [
{dated: today, absenceType: {name: 'Holiday', rgb: '#aaa'}},
{dated: yesterday, absenceType: {name: 'Leave', rgb: '#bbb'}}
]
});
controller.worker = {id: 107};
expect(controller.getIsSubordinate).toHaveBeenCalledWith();
expect(controller.getActiveContract).toHaveBeenCalledWith();
});
});
describe('getIsSubordinate()', () => {
it(`should return whether the worker is a subordinate`, () => {
$httpBackend.expect('GET', `Workers/106/isSubordinate`).respond(true);
controller.getIsSubordinate();
$httpBackend.flush();
let events = controller.events;
expect(controller.isSubordinate).toBe(true);
});
});
expect(events[today.getTime()].name).toEqual('New year, Holiday');
expect(events[tomorrow.getTime()].name).toEqual('Easter');
expect(events[yesterday.getTime()].name).toEqual('Leave');
expect(events[yesterday.getTime()].color).toEqual('#bbb');
expect(controller.getIsSubordinate).toHaveBeenCalledWith();
describe('getActiveContract()', () => {
it(`should return the current contract and then set the businessId property`, () => {
jest.spyOn(controller, 'refresh').mockReturnValue(Promise.resolve());
$httpBackend.expect('GET', `Workers/106/activeContract`).respond({businessFk: 106});
controller.getActiveContract();
$httpBackend.flush();
expect(controller.businessId).toEqual(106);
});
});
describe('getContractHolidays()', () => {
it(`should return the worker holidays amount and then set the contractHolidays property`, () => {
const today = new Date();
const year = today.getFullYear();
const serializedParams = $httpParamSerializer({year});
$httpBackend.expect('GET', `Workers/106/holidays?${serializedParams}`).respond({totalHolidays: 28});
controller.getContractHolidays();
$httpBackend.flush();
expect(controller.contractHolidays).toEqual({totalHolidays: 28});
});
});
describe('formatDay()', () => {
it(`should set the day element style`, () => {
jest.spyOn(controller, 'getIsSubordinate').mockReturnThis();
const today = new Date();
let today = new Date();
controller.events[today.getTime()] = {
name: 'Holiday',
color: '#000'
};
$httpBackend.whenRoute('GET', 'Calendars/absences')
.respond({
absences: [
{dated: today, absenceType: {name: 'Holiday', rgb: '#000'}}
]
});
controller.worker = {id: 1};
$httpBackend.flush();
let dayElement = angular.element('<div><section></section></div>')[0];
let dayNumber = dayElement.firstElementChild;
const dayElement = angular.element('<div><section></section></div>')[0];
const dayNumber = dayElement.firstElementChild;
controller.formatDay(today, dayElement);
@ -160,28 +167,6 @@ describe('Worker', () => {
expect(controller.vnApp.showMessage).toHaveBeenCalledWith('Choose an absence type from the right menu');
});
it(`should show an snackbar message if the selected day is not within the current year`, () => {
jest.spyOn(controller.vnApp, 'showMessage').mockReturnThis();
const selectedDay = new Date();
const $event = {
target: {
closest: () => {
return {$ctrl: {}};
}
}
};
const $days = [selectedDay];
const pastYear = new Date();
pastYear.setFullYear(pastYear.getFullYear() - 1);
controller.date = pastYear;
controller.absenceType = {id: 1};
controller.onSelection($event, $days);
expect(controller.vnApp.showMessage).toHaveBeenCalledWith('You can just add absences within the current year');
});
it(`should call to the create() method`, () => {
jest.spyOn(controller, 'create').mockReturnThis();
@ -342,20 +327,8 @@ describe('Worker', () => {
it(`should make a HTTP GET query and then call to the onData() method`, () => {
jest.spyOn(controller, 'onData').mockReturnThis();
const dated = controller.date;
const started = new Date(dated.getTime());
started.setMonth(0);
started.setDate(1);
const ended = new Date(dated.getTime());
ended.setMonth(12);
ended.setDate(0);
controller.started = started;
controller.ended = ended;
const expecteResponse = [{id: 1}];
const expectedParams = {workerFk: 106, started: started, ended: ended};
const expectedParams = {year: year};
const serializedParams = $httpParamSerializer(expectedParams);
$httpBackend.expect('GET', `Calendars/absences?${serializedParams}`).respond(200, expecteResponse);
controller.refresh();

2
modules/worker/front/calendar/locale/es.yml
View File

@ -1,5 +1,5 @@
Calendar: Calendario
Holidays: Vacaciones
Contract: Contrato
Festive: Festivo
Used: Utilizados
Year: Año

30
modules/worker/front/time-control/index.js
View File

@ -13,6 +13,19 @@ class Controller extends Section {
this.date = new Date();
}
get worker() {
return this._worker;
}
set worker(value) {
this._worker = value;
if (value) {
this.getActiveContract()
.then(() => this.getAbsences());
}
}
/**
* The current selected date
*/
@ -70,6 +83,11 @@ class Controller extends Section {
}
}
getActiveContract() {
return this.$http.get(`Workers/${this.worker.id}/activeContract`)
.then(res => this.businessId = res.data.businessFk);
}
fetchHours() {
const params = {workerFk: this.$params.id};
const filter = {
@ -80,7 +98,6 @@ class Controller extends Section {
};
this.$.model.applyFilter(filter, params).then(() => {
this.getWorkedHours(this.started, this.ended);
this.getAbsences();
});
}
@ -89,10 +106,10 @@ class Controller extends Section {
}
getAbsences() {
const fullYear = this.started.getFullYear();
let params = {
workerFk: this.$params.id,
started: this.started,
ended: this.ended
businessFk: this.businessId,
year: fullYear
};
return this.$http.get(`Calendars/absences`, {params})
@ -257,5 +274,8 @@ Controller.$inject = ['$element', '$scope', 'vnWeekDays'];
ngModule.vnComponent('vnWorkerTimeControl', {
template: require('./index.html'),
controller: Controller
controller: Controller,
bindings: {
worker: '<'
}
});