Question

我很难制定逻辑来完善我的调度系统。

案例：

我有以下房间的时间表：

07:00-15:00
从上面的房间时间表中我已经有下面的预订列表：


08:00-10:00

10:00-11:00

12:00-15:00
我想要的结果是：


07:00-08:00->可用

08:00-10:00->已预订

10:00-11:00->已预订

11:00-12:00->可用

12:00-15:00->已预订

以前有没有人遇到过这样的案件？任何想法或建议，表示赞赏。谢谢。

Answer 1

我想这很大程度上取决于您的预订数据的当前结构，但是我的第一个想法是组装一系列时间段并相应地进行标记。

例如，如果您最短的预订时间是1小时，那么一天中有8个疗程：

[0,0,0,0,0,0,0,0]

应用当前的预订将导致：

[0,1,1,1,0,1,1,1]

生成可用性列表时，您将连接连续值。

Answer 2

这将为您提供从roomAvailable的开始到结束的可用插槽。我在可能的地方添加了评论。

var roomAvailable = {
  start: "07:00",
  end: "15:00"
}
// gets numeric value of time
var getValue = function(time) {
  var arr = time.split(":");
  var val = arr[0] * 60 + arr[1] * 1;
  return val;
}
//converts to readable time string
var toTimeString = function(val) {
  var hr = Math.floor(val / 60);
  var min = val % 60;
  if (hr < 10) hr = "0" + hr;
  if (min < 10) min = "0" + min;
  return hr + ":" + min;
}

var booked = [{
    start: "08:00",
    end: "10:30"
  },
  {
    start: "10:40",
    end: "11:00"
  },
  {
    start: "12:00",
    end: "15:00"
  }
];

var printSlot = function(a, b) {
  console.log(toTimeString(a) + " - " + toTimeString(b));
}

var getAvailableSlots = function(roomAvailable, booked) {
  //sort booked slots by start time [Optional]
  var bookedSorted = booked.sort(function(a, b) {
    var x = getValue(a.start);
    var y = getValue(b.start);

    if (x < y) {
      return -1;
    }
    if (x > y) {
      return 1;
    }
    return 0;
  });

  var bookingStart = getValue(roomAvailable.start);
  var bookingEnd = getValue(roomAvailable.end);
  //now start from bookingStart
  var oStart = bookingStart;
  var i = 0;
  while (oStart < bookingEnd) {
    if (i < booked.length) {
      if (oStart < getValue(booked[i].start)) {
        printSlot(oStart, getValue(booked[i].start));
      }
      //has to be equal 
      oStart = getValue(booked[i].end);
      i++;
    } else {
      //left out time..
      if (oStart < bookingEnd) {
        printSlot(oStart, bookingEnd);
      }
    }
  }

};

getAvailableSlots(roomAvailable, booked);

Answer 3

我返回结果，实现@lecstor的想法，

完整的源代码：

exports.exprocedure = function(req,res){
var minT = 7;
var maxT = 15;
var arraySession = [];

//Booked Time
//08:00 - 10:00
//10:00 - 11:00
//12:00 - 15:00
var arrayBookingPerTrans    = [{start:8,finish:10},{start:10,finish:11},{start:12,finish:15}];
var arrayBookPerHour        = [];
var avSession               = [];

//split session
for(var i = minT; i < maxT; i++)
{
    arraySession.push({
        start:i,
        finish:i+1
    });
}
console.log("Session :");
console.log(arraySession);

//split booked time
for(var a=0;a<arrayBookingPerTrans.length;a++)
{
    for(var j = arrayBookingPerTrans[a].start; j < arrayBookingPerTrans[a].finish; j++)
    {
        arrayBookPerHour.push({
            start:j,
            finish:j+1,
            Trans:a
        })
    }
}
console.log("Booking Per Hour :");
console.log(arrayBookPerHour);

//filter to find available time
var avSession  = arraySession.filter(function(array_el){
    return arrayBookPerHour.filter(function(anotherOne_el)
    {
        return anotherOne_el.start == array_el.start;
    }).length == 0
});

console.log("Available :");
console.log(avSession);

//push available time and booked time in an array
var allArray = [];
var sum = avSession.length + arrayBookingPerTrans.length;
for(var i=0;i<avSession.length;i++)
{
    allArray.push({
        start  : avSession[i].start,
        finish : avSession[i].finish,
        state  : 'Available'
    });
}

for(var i=0;i<arrayBookingPerTrans.length;i++)
{
    allArray.push({
        start  : arrayBookingPerTrans[i].start,
        finish : arrayBookingPerTrans[i].finish,
        state  : 'Booked'
    });
}

//sorting 
function compare(a, b) {
    const startA = a.start
    const startB = b.start

    let comparison = 0;
    if (startA > startB) {
      comparison = 1;
    } else if (startA < startB) {
      comparison = -1;
    }
    return comparison;
}

  console.log("RESULT SORTING");
  console.log(allArray.sort(compare));

res.json({ 
    result      :'success',
    content     : allArray 
});}

结果：

Available Time :
[ { start: 7, finish: 8 }, { start: 11, finish: 12 } ]

RESULT SORTING : 
[{start: 7, finish: 8, state: 'Available' },
{ start: 8, finish: 10, state: 'Booked' },
{ start: 10, finish: 11, state: 'Booked' },
{ start: 11, finish: 12, state: 'Available' },
{ start: 12, finish: 15, state: 'Booked' } ]

根据以下情况，使用javascript

3 个答案: