Method: scheduling.solveShiftScheduling

Résolution d'un problème fixe de planification des quarts à partir du SolveShiftSchedulingRequest donné en affectant des employés à des quarts de sorte que les employés les préférences de planification sont maximisées et les cas de non-respect des contraintes de planification sont minimisés.

Requête HTTP

POST https://optimization.googleapis.com/v1/scheduling:solveShiftScheduling

L'URL utilise la syntaxe de transcodage gRPC.

Corps de la requête

Le corps de la requête contient des données présentant la structure suivante :

Représentation JSON 
{
  "requestId": string,
  "solveParameters": {
    object (SolveParameters)
  },
  "employees": [
    {
      object (Employee)
    }
  ],
  "shifts": [
    {
      object (Shift)
    }
  ],
  "coverageRequirements": [
    {
      object (CoverageRequirement)
    }
  ],
  "roleIds": [
    string
  ],
  "skillIds": [
    string
  ],
  "locationIds": [
    string
  ],
  "budgetRequirements": [
    {
      object (BudgetRequirement)
    }
  ],
  "assignmentsHint": [
    {
      object (ShiftAssignment)
    }
  ]
}
Champs
requestId

string

Problème ou identifiant de la demande.
solveParameters

object (SolveParameters)

Paramètres permettant de contrôler une seule solution du problème.
employees[]

object (Employee)

Tous les employés disponibles doivent être programmés.
shifts[]

object (Shift)

Toutes les périodes de travail constituent le planning.
coverageRequirements[]

object (CoverageRequirement)

Exigences de couverture pour l'ensemble de l'horizon de planification. Ceux-ci indiquent le nombre d'employés qui doivent assumer chaque rôle ou posséder une compétence particulière au cours d'une période donnée ou d'une liste d'ID d'équipes. Toutes les exigences de couverture doivent être spécifiées soit à l'aide de périodes, soit à l'aide d'une liste d'ID d'équipes, mais pas des deux. Les périodes (le cas échéant) correspondant aux exigences de couverture ne peuvent pas se chevaucher pour chaque emplacement. Le niveau de priorité par défaut pour chacune de ces contraintes est PRIORITY_MANDATORY pour les exigences de rôle et PRIORITY_LOW pour les compétences requises. Pour en savoir plus, consultez l'énumération Priority.
roleIds[]

string

Liste de tous les rôles possibles pour l'ensemble du personnel. Chaque employé doit avoir au moins un rôle auquel il peut être assigné pour un quart de travail. Un rôle fait référence à un poste spécifique attribué au cours d'une équipe (infirmière diplômée, chef exécutif, serveur, etc.). Lorsqu'un employé est affecté à un poste, il se voit également attribuer un rôle spécifique.
skillIds[]

string

Liste de toutes les compétences possibles pour l'ensemble du personnel. Une compétence fait référence à toute qualification supplémentaire qu'un employé peut avoir et qui ne concerne pas un emploi spécifique qui peut lui être attribué (certifications, langues parlées, etc.). Cette liste peut être vide. Lorsqu'un employé est affecté à un poste, il doit posséder toutes les compétences nécessaires pour ce poste.
locationIds[]

string

Liste de tous les lieux possibles pour l'ensemble des quarts de la planification. Cette liste peut être vide. Il peut s'avérer utile de spécifier des lieux différents lorsque, par exemple, un infirmier en chef souhaite réserver des horaires à plusieurs membres du personnel d'un hôpital ou, dans un autre exemple, un directeur d'hôtel qui souhaite planifier des employés dans plusieurs hôtels.
budgetRequirements[]

object (BudgetRequirement)

Spécification de budget pour le problème de planification. Le niveau de priorité par défaut pour chacune de ces exigences est PRIORITY_LOW. Pour en savoir plus, consultez l'énumération Priority.
assignmentsHint[]

object (ShiftAssignment)

Décalez les affectations à utiliser comme solution provisoire (c’est-à-dire une indice de solution) au problème de planification. Les indications d'attribution sont ignorées si l'attribution contredit un quart de travail non attribuable ou une demande de planification.

Corps de la réponse

Réponse pour l'API de planification du personnel. Pour chaque réponse, shiftAssignments sera vide si la valeur solutionStatus renvoyée est NOT_SOLVED_DEADLINE_EXCEEDED ou INFEASIBLE. Si la valeur solutionStatus renvoyée est OPTIMAL ou FEASIBLE, une attribution d'équipe valide est renvoyée dans shiftAssignments. Pour que l'attribution d'un ajustement soit valide, les propriétés suivantes sont conservées:

  1. Chaque identifiant d'employé est contenu dans l'ensemble d'employés indiqué dans la demande.
  2. Chaque ID de rôle attribué à l'employé est contenu dans l'ensemble des ID de rôle de l'employé en question.
  3. Chaque ID d'équipe est contenu dans l'ensemble des quarts fourni dans la requête.
  4. Chaque ID d'équipe n'est pas l'un des ID non attribuables pour l'employé donné.
  5. Un employé ne sera jamais affecté à deux quarts de travail qui se chevauchent.
  6. Pour la planification donnée, aucune des contraintes ni des requêtes avec le niveau de priorité PRIORITY_MANDATORY n'est enfreinte.

Si la requête aboutit, le corps de la réponse contient des données qui ont la structure suivante :

Représentation JSON 
{
  "requestId": string,
  "solutionStatus": enum (SolutionStatus),
  "shiftAssignments": [
    {
      object (ShiftAssignment)
    }
  ],
  "statusMessage": string
}
Champs
requestId

string

ID de la requête à laquelle cette réponse est associée.
solutionStatus

enum (SolutionStatus)

État de la solution renvoyée. Si la solution n'est ni FÉASIBLE, ni OPTIMALE, les autres champs de ce fichier proto peuvent être vides. Si l'état est NOT_SOLVED_DEADLINE_EXCEEDED, cela signifie que le délai a été atteint sans que nous ayons trouvé de solution réalisable ni déterminé si une solution est réalisable. Les requêtes peuvent être impossibles si les contraintes du niveau de priorité MANDATORY ne peuvent pas toutes être satisfaites.
shiftAssignments[]

object (ShiftAssignment)

Liste de toutes les attributions. Chaque ShiftAssignment spécifie un employé, le quart de travail auquel il est affecté et le rôle qu'il doit remplir pour ce poste.
statusMessage

string

Si solutionStatus n'est pas optimal, ce champ peut contenir des informations supplémentaires sur le résolveur.

SolveParameters

Paramètres qui contrôlent une seule solution du problème de planification des équipes.

Représentation JSON 
{
  "timeLimit": string
}
Champs
timeLimit

string (Duration format)

Temps maximal que le résolveur doit consacrer au problème. Si ce champ n'est pas spécifié, la valeur par défaut est de 1 minute.

Cette valeur n'est pas une limite stricte et ne tient pas compte des frais de communication. La latence attendue pour résoudre le problème peut dépasser légèrement cette valeur.

Durée en secondes avec neuf chiffres au maximum après la virgule et se terminant par "s". Exemple : "3.5s"

Employé

Un employé du personnel à planifier un rendez-vous.

Représentation JSON 
{
  "id": string,
  "roleIds": [
    string
  ],
  "skillIds": [
    string
  ],
  "shiftPreferences": [
    {
      object (ShiftPreference)
    }
  ],
  "schedulingConstraints": [
    {
      object (SchedulingConstraint)
    }
  ],
  "resourceConstraints": [
    {
      object (ResourceConstraint)
    }
  ],
  "shiftRequests": [
    {
      object (ShiftRequest)
    }
  ],
  "hourlyContract": {
    object (HourlyContract)
  }
}
Champs
id

string

Identifiant unique attribué à cet employé.
roleIds[]

string

ID de rôle que cet employé peut exécuter. Vous devez spécifier au moins un rôle. Lorsqu'un employé est affecté à un poste, il se voit également attribuer un seul rôle parmi cette liste. Différents rôles peuvent être attribués à l'employé au cours de la période de planification.
skillIds[]

string

ID de compétence de cet employé. Cette liste peut être vide. Lorsqu'un employé est affecté à un quart de travail, il utilise n'importe quel sous-ensemble des compétences listées ici pour couvrir les exigences en matière de compétences pendant toute la durée du poste assigné.
shiftPreferences[]

object (ShiftPreference)

Modifiez les préférences de cet employé. Les quarts spécifiés ici représentent des quarts auxquels l'employé préférerait être affecté pendant la période de planification. Les ID d'horaires spécifiés dans shiftPreferences doivent être uniques. Le résolveur tente de maximiser la somme des valeurs ShiftPreference.preference pour toutes les shiftPreferences satisfaites.
schedulingConstraints[]

object (SchedulingConstraint)

Liste des contraintes de planification pour cet employé. Le niveau de priorité par défaut pour chacune de ces contraintes est PRIORITY_MEDIUM. Pour en savoir plus, consultez l'énumération Priority.
resourceConstraints[]

object (ResourceConstraint)

Toutes les contraintes de planification supplémentaires non spécifiées dans schedulingConstraints peuvent être ajoutées ici à resourceConstraints. Un ResourceConstraint est une représentation plus abstraite permettant de limiter les ressources d'un employé. Le niveau de priorité par défaut pour chacune de ces contraintes est PRIORITY_MEDIUM. Pour en savoir plus, consultez l'énumération Priority.
shiftRequests[]

object (ShiftRequest)

Liste des demandes d'équipes de l'employé. Il est possible de demander à un employé d'être affecté ou non à des périodes de travail spécifiques. Toutes les attributions d'emploi du temps fixes pour l'employé peuvent être représentées par un élément ShiftRequest de priorité PRIORITY_MANDATORY. Un ID d'équipe peut apparaître dans une seule demande de planification pour cet employé. Le niveau de priorité par défaut pour chacune de ces requêtes est PRIORITY_LOW. Pour en savoir plus, consultez l'énumération Priority.
hourlyContract

object (HourlyContract)

Contrat qui spécifie le taux horaire normal et les heures supplémentaires pour l'employé.

ShiftPreference

Préférence numérique pour un ID d'ajustement particulier.

Représentation JSON 
{
  "shiftId": string,
  "preference": integer
}
Champs
shiftId

string

Identifiant Shift pour lequel la préférence est spécifiée.
preference

integer

Des valeurs de préférence plus élevées indiquent un changement plus souhaitable.

SchedulingConstraint

Contrainte de planification spécifique à un employé particulier. La contrainte spécifiée n'est appliquée que pendant l'intervalle [startDateTime, endDateTime) donné.

Représentation JSON 
{
  "priority": enum (Priority),
  "startDateTime": {
    object (DateTime)
  },
  "endDateTime": {
    object (DateTime)
  },

  // Union field type can be only one of the following:
  "minimumMinutes": integer,
  "maximumMinutes": integer,
  "minimumConsecutiveWorkDays": integer,
  "maximumConsecutiveWorkDays": integer,
  "minimumShiftCount": integer,
  "maximumShiftCount": integer,
  "minimumRestMinutes": integer
  // End of list of possible types for union field type.
}
Champs
priority

enum (Priority)

Niveau de priorité pour cette contrainte de planification. La priorité par défaut de toutes les contraintes de planification est PRIORITY_MEDIUM.
startDateTime

object (DateTime)

Heure de début à laquelle cette contrainte de planification s'applique (incluse).
endDateTime

object (DateTime)

Heure de fin d'application de cette contrainte de planification (exclue).
Champ d'union type. Type de contrainte spécifiée. Chaque contrainte n'est appliquée que pendant la période spécifiée ci-dessus. type ne peut être qu'un des éléments suivants :
minimumMinutes

integer

Durée minimale de travail (en minutes) de l'employé. Si l'employé est affecté à un quart de travail qui chevauche (entièrement ou partiellement) la fenêtre horaire, le nombre de minutes de chevauchement de la période de travail est inclus dans ce décompte.
maximumMinutes

integer

Durée maximale (en minutes) pendant laquelle l'employé peut travailler dans la fenêtre de temps. Si l'employé est affecté à un quart de travail qui chevauche (entièrement ou partiellement) la fenêtre horaire, le nombre de minutes de chevauchement de la période de travail est inclus dans ce décompte.
minimumConsecutiveWorkDays

integer

Nombre minimal de jours consécutifs pendant lesquels l'employé peut travailler. Un employé travaille un jour précis s'il est affecté à un quart de travail qui commence ce jour-là. Tout quart de travail auquel l'employé est attribué et qui commence dans la fenêtre de temps est inclus dans ce décompte.
maximumConsecutiveWorkDays

integer

Nombre maximal de jours consécutifs pendant lesquels l'employé peut travailler. Un employé travaille un jour précis s'il est affecté à un quart de travail qui commence ce jour-là. Tout quart de travail auquel l'employé est attribué et qui commence dans la fenêtre de temps est inclus dans ce décompte.
minimumShiftCount

integer

Nombre minimal d'heures de travail que l'employé peut effectuer. Tous les horaires auxquels l'employé est affecté et qui chevauchent entièrement la période est inclus dans ce décompte.
maximumShiftCount

integer

Nombre maximal d'heures de travail autorisées par l'employé. Tous les horaires auxquels l'employé est affecté et qui chevauchent entièrement la période est inclus dans ce décompte.
minimumRestMinutes

integer

Nombre minimal de minutes pendant lesquelles l'employé doit se reposer après la fin d'un quart de travail avant d'être affecté à un autre quart. Cette contrainte s'applique à chaque paire de quarts de travail entièrement incluse dans [startDateTime, endDateTime].

Priorité

Niveau de priorité de toute contrainte liée au planning d'un employé ou aux exigences de couverture. (par exemple, SchedulingConstraint, ResourceConstraint, ShiftRequest et CoverageRequirement). Comme il peut y avoir des contraintes contradictoires, il n'est pas toujours possible de satisfaire toutes les contraintes. Ainsi, chaque type de contrainte a une priorité (donnée par l'utilisateur ou par défaut) qui informe le résolveur de l'importance relative de toutes les contraintes données pour un calendrier complet.

Enums
PRIORITY_UNSPECIFIED Niveau de priorité inconnu.
PRIORITY_LOW Niveau de priorité le plus bas. Les contraintes avec cette priorité sont moins importantes que les autres. Ils sont les premiers à être considérés comme non conformes si aucune solution plausible n'est trouvée.
PRIORITY_MEDIUM Niveau de priorité moyen. Les contraintes avec cette priorité sont plus importantes que les contraintes de priorité PRIORITY_LOW, mais moins importantes que les contraintes de priorité PRIORITY_HIGH. Si aucune solution réalisable ne peut être trouvée après avoir assoupli toutes les contraintes avec la priorité PRIORITY_LOW, alors les contraintes de priorité PRIORITY_MEDIUM sont considérées comme la prochaine violation.
PRIORITY_HIGH Niveau de priorité le plus élevé. Les contraintes avec ce niveau de priorité sont les plus importantes. Ils sont les derniers à considérer comme non-respect des règles si aucune solution réalisable n'est trouvée après l'assouplissement des contraintes des niveaux de priorité inférieurs.
PRIORITY_MANDATORY Niveau de priorité qui représente un élément que le résolveur ne peut pas violer. Si le résolveur renvoie SolutionStatus.INFEASIBLE, cela peut être dû à un trop grand nombre de contraintes PRIORITY_MANDATORY.

ResourceConstraint

Contrainte générale qui limite la quantité d'une certaine "ressource" utilisés par un employé. Il s'agit d'une version abstraite de SchedulingConstraint, plus spécifique, et plus flexible pour l'utilisateur. De nombreuses contraintes de planification qui ne peuvent pas être spécifiées dans SchedulingConstraint.type peuvent être spécifiées à l'aide de ce message.

Représentation JSON 
{
  "priority": enum (Priority),
  "resourceUsages": {
    string: number,
    ...
  },
  "minimumResourceUsage": number,
  "maximumResourceUsage": number
}
Champs
priority

enum (Priority)

Niveau de priorité de cette contrainte de ressource. La priorité par défaut pour toutes les contraintes de ressources est PRIORITY_MEDIUM.
resourceUsages

map (key: string, value: number)

Quantité de ressources utilisée par les équipes. Par exemple, si cette contrainte s'applique aux heures minimum et maximum de travail d'un employé au cours d'une semaine spécifique, cette carte contiendra les quarts de travail qui se produisent au cours de cette semaine et la durée de chaque équipe en heures.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.
minimumResourceUsage

number

Utilisation minimale des ressources pour respecter une contrainte de ressource.
maximumResourceUsage

number

Utilisation maximale des ressources pour qu'une contrainte de ressource soit respectée.

ShiftRequest

Demande d'affectation ou de non-affectation à des équipes spécifiques d'un employé.

Représentation JSON 
{
  "priority": enum (Priority),
  "shiftIds": [
    string
  ],
  "type": enum (WorkStatus)
}
Champs
priority

enum (Priority)

Niveau de priorité de cette demande de planification. La priorité par défaut de toutes les requêtes de planification est PRIORITY_LOW.
shiftIds[]

string

ID des équipes de la requête de planification.
type

enum (WorkStatus)

Type de demande, par exemple, si la demande est attribuée ou non à l'ensemble d'équipes.

WorkStatus

Indique si un employé travaille ou non.

Enums
WORK_STATUS_UNSPECIFIED État professionnel inconnu.
STATUS_WORK Statut représentant un employé qui travaille.
STATUS_NOT_WORK Statut représentant un employé qui ne travaille pas.

HourlyContract

Spécifie un tarif horaire de base, des différentiels de taux et des multiplicateurs d'heures supplémentaires pour déterminer la rémunération d'un employé. Notez que les réglementations en fonction du pays peuvent nécessiter un calcul différent pour la rémunération des heures supplémentaires. Le résolveur évalue la rémunération des heures supplémentaires de façon à minimiser un indicateur du coût total ou à respecter un budget (voir BudgetRequirement). Il n'est pas destiné à être utilisé comme outil de calcul des salaires.

Représentation JSON 
{
  "baseHourlyRate": number,
  "hourlyRateShiftDifferentials": {
    string: number,
    ...
  },
  "overtimePeriods": [
    {
      object (OvertimePeriod)
    }
  ]
}
Champs
baseHourlyRate

number

Rémunération pour le travail effectué en dehors des heures supplémentaires. Si plusieurs taux s'appliquent à l'employé, des différentiels de taux sont appliqués par rapport à ce tarif horaire de base. En outre, s'il existe plusieurs tarifs, le tarif horaire de base doit être le plus faible de ces tarifs.
hourlyRateShiftDifferentials

map (key: string, value: number)

Différence de tarif horaire, payé en plus de baseHourlyRate. Par exemple, si le tarif horaire de base est de 30 $/h, "shift_1" est payé à un taux de 40 USD/h et « shift_2 » est payé au tarif de 45 $/h, alors la représentation proto est: baseHourlyRate: 30 hourlyRateShiftDifferentials {key: "shift_1" value: 10} hourlyRateShiftDifferentials {key: "shift_2" value: 15}.

Objet contenant une liste de paires "key": value. Exemple : { "name": "wrench", "mass": "1.3kg", "count": "3" }.
overtimePeriods[]

object (OvertimePeriod)

Liste de toutes les périodes pour lesquelles des heures supplémentaires doivent être calculées. Ces périodes ne doivent pas se chevaucher.

OvertimePeriod

Période fixe et récurrente régulièrement (généralement 168 heures ou sept périodes consécutives de 24 heures) utilisée pour déterminer le montant de la rémunération des heures supplémentaires. Chaque période a un multiplicateur de heures supplémentaires (par exemple, 1,5) par rapport au baseHourlyRate et une limite du nombre d'heures considérées comme du travail régulier (hors heures supplémentaires). Tout quart de travail qui chevauche la fenêtre de temps startDateTime (incluse) et endDateTime (exclue) est comptabilisé dans le nombre total d'heures travaillées dans la période. Si le chevauchement est partiel, seules les heures qui se chevauchent sont comptabilisées.

Représentation JSON 
{
  "overtimeMultiplier": number,
  "startDateTime": {
    object (DateTime)
  },
  "endDateTime": {
    object (DateTime)
  },
  "maximumRegularHours": number
}
Champs
overtimeMultiplier

number

Multiplicateur pour calculer le taux horaire des heures supplémentaires (il doit être supérieur ou égal à 1,0). Le tarif horaire des heures supplémentaires est généralement calculé comme suit : baseHourlyRate * overtimeMultiplier. Si hourlyRateShiftDifferentials propose plusieurs tarifs, le résolveur calcule le taux horaire des heures supplémentaires en se basant sur une moyenne simple des taux applicables pendant la période supplémentaire. Remarque: Les réglementations en fonction du pays peuvent nécessiter un calcul différent pour la rémunération des heures supplémentaires. Le résolveur évalue la rémunération des heures supplémentaires de façon à minimiser un indicateur du coût total ou à respecter un budget, mais il n'est pas destiné à être utilisé pour calculer la masse salariale.
startDateTime

object (DateTime)

Heure de début de la période de prolongation. Si un quart de travail chevauche ce créneau horaire, les heures correspondantes sont comptabilisés à partir du startDateTime.
endDateTime

object (DateTime)

Heure de fin de la période de prolongation. Si un quart de travail chevauche cette période, les heures correspondantes sont comptabilisées jusqu'à endDateTime.
maximumRegularHours

number

Nombre maximal d'heures de travail payées à un taux normal (hors heures supplémentaires). Cette quantité doit être positive.

Maj

Un quart de travail spécifie une fenêtre de temps fixe pendant laquelle les employés peuvent travailler.

Représentation JSON 
{
  "id": string,
  "locationId": string,
  "startDateTime": {
    object (DateTime)
  },
  "endDateTime": {
    object (DateTime)
  },
  "breakRules": [
    {
      object (BreakRule)
    }
  ]
}
Champs
id

string

ID unique attribué à ce changement.
locationId

string

ID de la zone géographique où ce travail de changement est effectué. Cette valeur n'est pas obligatoire.
startDateTime

object (DateTime)

Heure de début du quart de travail (incluse).
endDateTime

object (DateTime)

Heure de fin du quart de travail (exclue). Actuellement, le résolveur n'accepte que les équipes de moins de 24 heures.
breakRules[]

object (BreakRule)

Liste des règles de non-respect des règles appliquées pendant le quart de travail. Les employés qui effectuent ce quart de travail bénéficient d'une pause par break_rule pendant laquelle ils ne couvrent pas la demande pour le poste qu'ils remplissent. Chaque créneau horaire BreakRule doit être entièrement inclus dans celui de cette équipe.

BreakRule

Règle qui détermine à quel moment une pause peut commencer au sein d'un quart de travail et sa durée. La liste de toutes les coupures possibles prises en compte est déterminée par incréments de ruleIncrementMinutes. Par exemple, si une règle de rupture modélise une pause de 30 minutes qui peut commencer entre 10:00 et 11:00, et que l'incrément de la règle est de 20 minutes, la liste des sauts pris en compte est : [10:00, 10:30], [10:20, 10:50], [10:1, 0], 1:1, 1.

Représentation JSON 
{
  "earliestStartTime": {
    object (DateTime)
  },
  "latestStartTime": {
    object (DateTime)
  },
  "durationMinutes": integer,
  "ruleIncrementMinutes": integer
}
Champs
earliestStartTime

object (DateTime)

Heure de début au plus tôt de la coupure (incluse). Vous ne pouvez définir que hours et minutes.
latestStartTime

object (DateTime)

Dernière heure de début de la pause (incluse). Vous ne pouvez définir que hours et minutes.
durationMinutes

integer

Durée de la pause en minutes.
ruleIncrementMinutes

integer

[Facultatif] Incrément de temps en minutes pour tous les sauts pris en compte dans cette règle de rupture. Si ce champ n'est pas défini, la valeur par défaut est durationMinutes.

CoverageRequirement

Une exigence de couverture spécifie le nombre d'employés requis pour un ensemble de rôles et/ou de compétences pendant une période donnée et dans un lieu donné. Les intervalles DateTime d'un emplacement particulier ne peuvent pas se chevaucher. Vous pouvez également fournir une liste des ID d'équipes au lieu d'une période et d'un lieu. Seuls les employés pouvant être affectés à un rôle spécifique (ou possédant la compétence spécifique) peuvent répondre à cette exigence.

Pour un poste et/ou une compétence donnés, l'exigence de couverture est remplie lorsqu'au moins targetEmployeeCount employés travaillent à tout moment de la période (ou pour chaque quart de travail du shiftIds). En revanche, l'exigence de couverture n'est pas respectée si, à un moment donné de la période (ou pour l'une des périodes de travail du shiftIds), moins de targetEmployeeCount employés travaillent au cours de cette période. Le nombre d'employés actifs est supérieur au nombre de targetEmployeeCount, mais le résolveur limite le nombre d'employés.

Représentation JSON 
{
  "startDateTime": {
    object (DateTime)
  },
  "endDateTime": {
    object (DateTime)
  },
  "locationId": string,
  "shiftIds": [
    string
  ],
  "roleRequirements": [
    {
      object (RoleRequirement)
    }
  ],
  "skillRequirements": [
    {
      object (SkillRequirement)
    }
  ]
}
Champs
startDateTime

object (DateTime)

Heure de début de la couverture requise (incluse). S'il est défini, shiftIds doit être vide.
endDateTime

object (DateTime)

Heure de fin de la condition de couverture (exclue). S'il est défini, shiftIds doit être vide.
locationId

string

Lieu où les employés sont nécessaires. shiftIds n'est pas vide. Ce champ doit être vide.
shiftIds[]

string

S'ils sont définis, les exigences de poste et de compétences sont appliquées individuellement à chaque ID d'équipe de cette liste. Si les valeurs "shiftId" ne sont pas vides, les champs startDateTime, endDateTime et locationId doivent être vides.
roleRequirements[]

object (RoleRequirement)

Nombre requis d'employés à attribuer aux rôles spécifiés pendant la période. Vous ne devez indiquer qu'un seul élément role_requirement par ID de rôle. Le niveau de priorité par défaut pour chacune des exigences est PRIORITY_MANDATORY. Ces contraintes ne sont pas respectées si les rôles spécifiés sont attribués à moins de targetEmployeeCount employés au cours de la période.
skillRequirements[]

object (SkillRequirement)

Nombre requis d'employés possédant les compétences spécifiées et affectés à des équipes pendant la période. Vous ne devez indiquer qu'un seul élément skill_requirement par ID de compétence. Le niveau de priorité par défaut pour chacune des exigences est PRIORITY_LOW. Ces contraintes ne sont pas respectées si moins de targetEmployeeCount employés possèdent les compétences données à un moment donné au cours de la période.

RoleRequirement

Nombre requis d'employés à attribuer au rôle spécifié pendant la période.

Représentation JSON 
{
  "roleId": string,
  "targetEmployeeCount": integer,
  "priority": enum (Priority)
}
Champs
roleId

string

ID de rôle pour l'exigence.
targetEmployeeCount

integer

Nombre souhaité d'employés affectés au rôle pendant la période.
priority

enum (Priority)

Niveau de priorité pour cette contrainte d'exigence. La priorité par défaut pour toutes les contraintes de ressources est PRIORITY_MANDATORY.

SkillRequirement

Nombre requis d'employés qui travaillent pendant la période donnée et possèdent les compétences spécifiées.

Représentation JSON 
{
  "skillId": string,
  "targetEmployeeCount": integer,
  "priority": enum (Priority)
}
Champs
skillId

string

ID de compétence pour la condition.
targetEmployeeCount

integer

Nombre souhaité d'employés ayant la compétence donnée et travaillant pendant la fenêtre de temps.
priority

enum (Priority)

Niveau de priorité pour cette contrainte d'exigence. La priorité par défaut pour toutes les contraintes de ressources est PRIORITY_LOW.

BudgetRequirement

Exigences budgétaires pour un intervalle donné.

Représentation JSON 
{
  "totalBudget": number,
  "startDateTime": {
    object (DateTime)
  },
  "endDateTime": {
    object (DateTime)
  },
  "priority": enum (Priority)
}
Champs
totalBudget

number

Budget total pour l'intervalle donné. Vous devez indiquer un budget total si la priorité est PRIORITY_MANDATORY.

Si totalBudget n'est pas défini, le coût total de la planification est réduit en fonction de la valeur priority spécifiée. Par exemple, si le priority du budget est de PRIORITY_MEDIUM, le résolveur réduira le coût avant de réduire les cas de non-respect de la contrainte avec la priorité PRIORITY_LOW.
startDateTime

object (DateTime)

Heure de début à laquelle ce budget s'applique. Si aucune heure de début n'est spécifiée, elle est définie comme étant l'heure de début la plus proche pour toutes les périodes de travail données.
endDateTime

object (DateTime)

Heure de fin à laquelle ce budget s'applique. Si aucune heure de fin n'est spécifiée, elle est définie comme étant la dernière heure de fin de toutes les périodes de travail données.
priority

enum (Priority)

Niveau de priorité pour respecter le budget requis au cours de la période spécifiée. La priorité par défaut est PRIORITY_LOW. Si la priorité est définie sur PRIORITY_MANDATORY, totalBudget doit être défini.

Notez que si cette priorité est plus élevée que d'autres priorités de contraintes et que totalBudget est serré, le calendrier qui en résulte peut considérablement enfreindre les contraintes liées aux employés ou les exigences de couverture.

ShiftAssignment

Attribuer un rôle à un employé

Représentation JSON 
{
  "employeeId": string,
  "shiftId": string,
  "roleId": string,
  "breaks": [
    {
      object (Break)
    }
  ]
}
Champs
employeeId

string

ID de l'employé en cours d'attribution.
shiftId

string

ID d'équipe attribué à l'employé.
roleId

string

ID de rôle attribué à l'employé pour le quart de travail.
breaks[]

object (Break)

Liste des pauses pour cette attribution de quarts.

Pause

Période pendant laquelle un employé interrompt son travail pendant un quart de travail.

Représentation JSON 
{
  "startDateTime": {
    object (DateTime)
  },
  "durationMinutes": integer
}
Champs
startDateTime

object (DateTime)

Heure de début d'une pause.
durationMinutes

integer

Durée de la pause en minutes.

SolutionStatus

État de la solution (planification) fourni dans la réponse d'un résolveur.

Enums
SOLUTION_STATUS_UNSPECIFIED État de la réponse non spécifié.
FEASIBLE Le calendrier renvoyé est faisable, mais peut ne pas être optimal.
OPTIMAL Le calendrier renvoyé est optimal.
INFEASIBLE Il n'existe aucun calendrier réalisable pour les contraintes données. Le résolveur peut renvoyer cette valeur si un sous-ensemble des contraintes avec le niveau de priorité PRIORITY_MANDATORY ne peut pas être satisfait.
NOT_SOLVED Aucune programmation n'a été trouvée.
NOT_SOLVED_DEADLINE_EXCEEDED Aucune planification n'a été trouvée dans le délai indiqué.