Konfigurowanie reguł rezerwacji

Reguły rezerwacji w usłudze Field Service tworzą komunikaty ostrzegawcze lub komunikaty o błędach, które użytkownicy widzą podczas tworzenia lub edytowania rekordu rezerwacji zasobów na podstawie warunków niestandardowych. Na przykład można utworzyć regułę rezerwacji, aby ostrzec użytkownika, gdy próbuje zarezerwować zlecenie pracy do zasobu na tablicy harmonogramu, który nie posiada wymaganych charakterystyk do wykonania zadania.

Reguły rezerwacji to niestandardowe metody języka JavaScript wykonywane przed utworzeniem lub edycją rekordu Bookable Resource Booking. Metoda JavaScript może akceptować parametr zawierający informacje dotyczące tworzonego rekordu Bookable Resource Booking i musi zwrócić obiekt JavaScript z wymaganymi właściwościami.

Skonfiguruj reguły rezerwacji, aby zweryfikować rezerwację po jej utworzeniu lub zmodyfikowaniu.

Tworzenie rozwiązania

Utwórz niestandardowy zasób internetowy języka JavaScript. Zalecamy utworzenie rozwiązania w usłudze Microsoft Power Apps w celu dodania niestandardowego zasobu internetowego JavaScript lub użycia istniejącego rozwiązania używanego do dostosowywania.

1. Utwórz nowe rozwiązanie dla reguły rezerwacji zasobów internetowych JavaScript. Zalecamy, aby rozwiązanie używało unikatowego wydawcy, a nie domyślnego wydawcy.

2. Po utworzeniu rozwiązania utwórz nowy zasób internetowy.

3. Jako typ wybierz pozycję JavaScript (JS ).

4. Wprowadź kod JavaScript dla reguły rezerwacji.

5. Wybierz Zapisz i Opublikuj.

Konfigurowanie reguły rezerwacji

1. Przejdź do obszaru Field Service i wybierz obszar Zasoby .

2. W obszarze Ustawienia rezerwacji wybierz pozycję Reguły rezerwacji, a następnie wybierz pozycję Nowy.

   

3. Wprowadź następujące informacje:

   • Nazwa reguły rezerwacji.
   • Ostatnio utworzony zasób internetowy.
   • Nazwa metody zdefiniowana w języku JavaScript.

4. Wybierz Zapisz i zamknij. Po zapisaniu reguły rezerwacji będzie on używany przez widok godzinowy tablicy harmonogramu i asystenta harmonogramu lub formularz encji.

Tworzenie niestandardowej akcji procesu

Utwórz niestandardową akcję procesu w celu przeprowadzenia weryfikacji w ramach reguły rezerwacji. W kodzie JavaScript własnego zasobu sieciowego wywołaj akcję procesu niestandardowego i oceń wyniki działania tej akcji. Przejdź do przykładowego kodu , aby zobaczyć, jak wywołać niestandardową akcję procesu.

Zaleca się użycie rozwiązania CRM zdefiniowanego dla niestandardowego zasobu sieci Web, aby dodać niestandardową akcję CRM.

Użyj następujących parametrów wejściowych i wyjściowych. W miarę potrzeby scenariusza możesz dodać więcej parametrów wejściowych i wyjściowych. Należy upewnić się, że zdefiniowany kod JavaScript w celu wywołania niestandardowej akcji procesu jest aktualizowany w celu obsługi innych parametrów wejściowych i wyjściowych.

Parametry wejściowe:

• originalScheduleStart – DateTime
• originalScheduleEnd — DateTime
• originalBookableResource — EntityReference
• originalScheduleSource – Picklist
• newScheduleStart — DateTime
• newScheduleEnd — DateTime
• isCreate — wartość logiczna
• isUpdate — zmienna logiczna

Parametry wyjściowe:

• isError – Boolean
• isWarning – Boolean
• errorMessage — ciąg znaków
• warningMessage - String

Poniższy zrzut ekranu przedstawia przykładową niestandardową akcję procesu. Ten przykład sprawdza, czy newBookableResource jest zgodny z preferowanym zasobem w zleceniu roboczym, i czy newScheduleStart znajduje się w zakresie Uzgodniona godzina początkowa and Uzgodniona godzina końcowa. Zakłada się, że przedziały czasowe obiecane dotyczą jednego dnia. Przykład: Planowany czas rozpoczęcia: 01.01.2016 08:00 / Planowany czas zakończenia: 01.01.2016 12:00.

Przykładowy kod

Utworzona funkcja JavaScript może akceptować pojedynczy parametr, który jest uważany za kontekst rezerwacji. Przekazany parametr kontekstu rezerwacji nie jest typowym kontekstem CRM używanym w skryptach po stronie klienta.

Schemat kontekstu rezerwacji:

export type BookingRuleContext = {
    oldValues: BookingRuleBookingRecord;
    newValues: BookingRuleBookingRecord;
    isCreate: boolean;
    isUpdate: boolean;
};
 
export type BookingRuleBookingRecord = {
    ResourceRequirementId?: string;
    ResourceId?: string;
    StartTime?: Date;
    EndTime?: Date;
    ResourceScheduleSource?: string;
};

Parametr kontekstu rezerwacji będzie miał następującą definicję języka JavaScript.

Możliwe wartości zasobu ResourceScheduleSource pochodzą z zestawu opcji globalnych harmonogramu zasobów. Tej właściwości można użyć w celu ustalenia, czy reguła rezerwacji jest wyzwalana z poziomu tablicy harmonogramu czy asystenta planowania.

    var sbContext = {
    oldValues: {
        StartTime: "01/01/2016 08:00AM",
        EndTime: "01/01/2016 05:00PM",
        ResourceId: "00000000-0000-0000-0000-00000000",
        ResourceScheduleSource: 690970001
    },
    newValues: {
        StartTime: "01/01/2016 08:00AM",
        EndTime: "01/01/2016 05:00PM",
        ResourceId: "00000000-0000-0000-0000-00000000",
        ResourceScheduleSource: 690970001
    },
    isCreate: true,
    isUpdate: false
    };

Metoda walidacji musi zwrócić obiekt JavaScript z następującą definicją.

    var ruleResult = {
    IsValid: false,
    Message: "Some Message Here",
    Type: "error" // this can be either "error" or "warning"
};

Przykładowa definicja funkcji Języka JavaScript. Poniższy kod JavaScript jest jedynym kodem JavaScript, który należy uwzględnić w niestandardowym zasobie internetowym.

    function Validate(ctx) {
      var url = Xrm.Page.context.getClientUrl();
      var ruleResult = {
  	IsValid: false,
       Message: '',
       Type: 'error'
      };

      //
      // perform some lookups or other validation logic here.
      //
  
      ruleResult.IsValid = false;
      ruleResult.Message = 'Some Error Message Here.';
      ruleResult.Type = 'error';

      return ruleResult;
    }

Poniższy kod JavaScript może służyć do wywoływania niestandardowej akcji CRM, która ma te same parametry wejściowe i wyjściowe co poprzedni przykład.

W rekordzie reguły rezerwacji Nazwa metody musi być: MSFSAENG.ScheduleBoard.Validate. Aby uzyskać informacje, zobacz zrzut ekranu w sekcji "Konfigurowanie reguły rezerwacji" w tym artykule.

    /// <reference path="xrm.d.ts" />
    function brErrorCallback(sb) {
    // Add custom error handeling here if desired.
     return;
    }
    function brWarningCallback(sb) {
    // Add custom warning handeling here if desired.
    return;
    }
    function brSuccessCallback(sb) {
    // add custom sucess handeling here if desired.
    return;
    }
    var MSFSAENG;
    (function (MSFSAENG) {
    MSFSAENG.ScheduleBoard = {
        url: Xrm.Page.context.getClientUrl() + "/api/data/v8.1/",
        actionName: "msfsaeng_MSFSAScheduleBoardRuleActionSample",
        actionInputParameters: function (ctx) {
            var inputParameters = {};
            if (ctx.isUpdate) {
                inputParameters = {
                    "originalScheduleStart": ctx.oldValues.StartTime,
                    "originalScheduleEnd": ctx.oldValues.EndTime,
                    "originalBookableResource": {
                        "@odata.type": "Microsoft.Dynamics.CRM.bookableresource",
                        "bookableresourceid": ctx.oldValues.ResourceId,
                        "name": ""
                    },
                    "originalScheduleSource": ctx.oldValues.ResourceScheduleSource,
                    "newScheduleStart": ctx.newValues.StartTime,
                    "newScheduleEnd": ctx.newValues.EndTime,
                    "newBookableResource": {
                        "@odata.type": "Microsoft.Dynamics.CRM.bookableresource",
                        "bookableresourceid": ctx.newValues.ResourceId,
                        "name": ""
                    },
                    "newScheduleSource": ctx.newValues.ResourceScheduleSource,
                    "isCreate": ctx.isCreate,
                    "isUpdate": ctx.isUpdate
                };
            }
            else {
                inputParameters = {
                    "newScheduleStart": ctx.newValues.StartTime,
                    "newScheduleEnd": ctx.newValues.EndTime,
                    "newBookableResource": {
                        "@odata.type": "Microsoft.Dynamics.CRM.bookableresource",
                        "bookableresourceid": ctx.newValues.ResourceId,
                        "name": ""
                    },
                    "newScheduleSource": ctx.newValues.ResourceScheduleSource,
                    "isCreate": ctx.isCreate,
                    "isUpdate": ctx.isUpdate
                };
            }
            return JSON.stringify(inputParameters);
        },
        ctx: null,
        ruleResult: {
            IsValid: true,
            Message: "",
            Type: ""
        },
        outputParameters: {
            isError: false,
            isWarning: false,
            errorMessage: "",
            warningMessage: ""
        },
        Validate: function (context) {
            this.ctx = context;
            ScheduleBoardHelper.callActionWebApi(this);
            return this.ruleResult;
        },
        errorCallback: brErrorCallback,
        warningCallback: brWarningCallback,
        successCallback: brSuccessCallback
    };
    var ScheduleBoardHelper = (function () {
        function ScheduleBoardHelper() {
        }
        ScheduleBoardHelper.callActionWebApi = function (sb) {
            var oDataEndpoint = sb.url + sb.actionName;
            var req = new XMLHttpRequest();
            req.open("POST", oDataEndpoint, false);
            req.setRequestHeader("Accept", "application/json");
            req.setRequestHeader("Content-Type", "application/json; charset=utf-8");
            req.setRequestHeader("OData-MaxVersion", "4.0");
            req.setRequestHeader("OData-Version", "4.0");
            req.onreadystatechange = function () {
                if (req.readyState == 4) {
                    req.onreadystatechange = null;
                    if (req.status == 200) {
                        sb.outputParameters = JSON.parse(req.response);
                        if (sb.outputParameters.isError) {
                            sb.ruleResult.IsValid = false;
                            sb.ruleResult.Message = sb.outputParameters.errorMessage;
                            sb.ruleResult.Type = 'error';
                            if (sb.errorCallback)
                                sb.errorCallback(sb);
                            return;
                        }
                        else if (sb.outputParameters.isWarning) {
                            sb.ruleResult.IsValid = false;
                            sb.ruleResult.Message = sb.outputParameters.warningMessage;
                            sb.ruleResult.Type = 'warning';
                            if (sb.warningCallback)
                                sb.warningCallback(sb);
                            return;
                        }
                        else {
                            sb.ruleResult.IsValid = true;
                            sb.ruleResult.Message = '';
                            sb.ruleResult.Type = '';
                            if (sb.successCallback)
                                sb.successCallback(sb);
                            return;
                        }
                    }
                    else {
                        alert('Error calling Rule Action. Response = ' + req.response + ', Status = ' + req.statusText);
                    }
                }
            };
            req.send(sb.actionInputParameters(sb.ctx));
        };
        return ScheduleBoardHelper;
    }());
    })(MSFSAENG || (MSFSAENG = {}));

Dodatkowe uwagi

Zasoby, które można zarezerwować, są włączone, by używać reguł rezerwacji do tworzenie ostrzeżeń o błędzie lub ostrzeżenia, które użytkownicy będą mogli zobaczyć podczas tworzenia lub edytowania rekordu rezerwacji zasobu, w zależności od warunków niestandardowych. System używa preventDefault w regułach rezerwacji. Z tego powodu przepływy procesów biznesowych i inne skrypty niestandardowe połączone ze zdarzeniem onSave nie mogą być używane w encji rezerwacji zasobów możliwej do rezerwacji, w przypadku których włączono reguły rezerwacji.

Jednak przetwarzanie reguł rezerwacji można wyłączyć przy zapisywaniu formularza Rezerwacja, włączając poniższe ustawienie, co pozwoliłoby użytkownikom korzystać z przepływów procesów biznesowych. Interfejsy API po stronie klienta mogą służyć do włączania tego ustawienia na poziomie środowiska.

Odczytaj bieżącą wartość ustawienia msdyn_DisableProcessBookingRulesOnSaveBookingForm.

Xrm.Utility.getGlobalContext().getCurrentAppSettings()["msdyn_DisableProcessBookingRulesOnSaveBookingForm"]

Włącz ustawienie msdyn_DisableProcessBookingRulesOnSaveBookingForm.

Xrm.Utility.getGlobalContext().saveSettingValue("msdyn_DisableProcessBookingRulesOnSaveBookingForm",true,).then(() => {a = "success"}, (error) => {a = error})

Wyłącz ustawienie **msdyn_DisableProcessBookingRulesOnSaveBookingForm**.

Xrm.Utility.getGlobalContext().saveSettingValue("msdyn_DisableProcessBookingRulesOnSaveBookingForm",false,).then(() => {a = "success"}, (error) => {a = error})