Casos de uso de script do lado do servidor

  • Versão de lançamento: Zurich
  • Atualizado 31 de jul. de 2025
  • 16 min. de leitura

    • Os casos de uso para scripts do lado do servidor incluem saída em log, obtenção de objetos do usuário e modificação de valores de data/hora.

    Acessar o bloco de anotações do fluxo de trabalho a partir de regras de negócios

    Um item do catálogo foi solicitado e o fluxo de trabalho anexado contém uma atividade de script de execução que preenche um valor no bloco de anotações. Em uma regra de negócios em execução no item solicitado, você deseja recuperar ou definir valores do bloco de anotações.

    Pré-requisitos

    Função necessária: administrador

    Access Workflow Scratchpad em Regras de negócio.

    Tipo: Regra de negócio.

    Tabela: sc_req_item (Item solicitado).

    Descrição: Um item do catálogo foi solicitado, o fluxo de trabalho anexado contém uma atividade de script de execução que preenche um valor no bloco de anotações. Em uma regra de negócios em execução no item solicitado, você deseja recuperar ou definir valores do bloco de anotações.

    Parâmetros: n/a.

    Script: 
    //the run script activity sets a value in the scratchpad
workflow.scratchpad.important_msg = "scratch me";
 
//get the workflow script include helper 
var workflow = new Workflow();
 
//get the requested items workflow context 
//this will get all contexts so you will need to get the proper one if you have multiple workflows for a record 
var context = workflow.getContexts(current); 
//make sure we have a valid context 
if (context.next()) { 
  //get a value from the scratchpad 
  var msg = context.scratchpad.important_msg; 
  //msg now equals "scratch me", that was set in the run script activity
 
  //add or modify a scratchpad value
  context.scratchpad.status = "completed"; 
  //we need to save the context record to save the scratchpad
  context.update(); 
}

    Atribua um item do catálogo a um grupo com base em uma tarefa de plano de entrega

    Atribua um item do catálogo de serviços ao grupo de banco de dados se ele usar um plano de entrega que tenha uma tarefa de catálogo atribuída ao grupo de desktop.

    Pré-requisitos

    Função necessária: administrador

    Aviso:
    A personalização descrita aqui foi desenvolvida para uso em instâncias específicas e não é compatível com Now Support. Este método é fornecido no estado em que se encontra e deve ser testado cuidadosamente antes da implementação. Publique todas as perguntas e comentários sobre esta personalização no fórum da nossa comunidade.

    Nome: Atribuir item do catálogo ao grupo com base na tarefa do plano de entrega.

    Tipo: Regra de atribuição.

    Descrição: Esta regra de atribuição atribui um item do catálogo de serviços ao grupo de banco de dados se ele usar um plano de entrega que tenha uma tarefa de catálogo atribuída ao grupo de desktop.

    Script:

    //Return catalog items that have no group but do have a delivery plan assigned var ri  = new GlideRecord ( "sc_cat_item" ) ;
ri.addQuery("group", "=", null);
ri.addQuery("delivery_plan", "!=", null);
ri.query(); 
while(ri.next()) {
    gs.log("Found an item"); 
    //Return tasks that point to the same delivery plan as the above item 
    var dptask = new GlideRecord("sc_cat_item_delivery_task");
    dptask.addQuery("delivery_plan", "=", ri. delivery_plan);
    dptask.query(); 
    while(dptask.next()) {
        gs.log("Found a task");
        var gp = dptask.group.getDisplayValue();
        gs.log(gp); 
        //If the task is assigned to desktop, assign the item's group to desktop
        if (dptask.group.getDisplayValue() == "Desktop") {
            ri.group.setDisplayValue("Desktop");
            gs.log("updating " + ri.getDisplayValue());
            ri.update(); 
            break; } } }

    Calculando durações

    Muitas vezes, você pode precisar fornecer aos usuários uma maneira de especificar quando uma tarefa ou processo deve vencer. Usando a inclusão de script DurationCalculator, você pode calcular a data de vencimento usando uma duração simples ou uma duração relativa.

    Definir uma data de vencimento requer que você calcule o tempo de trabalho em vez do tempo total. Somente a parte do dia em que o trabalho é realizado é considerada ao determinar a data de vencimento. Por exemplo, uma tarefa vence em 10 horas, mas é restrita a uma programação de dia útil. Se o trabalho começar às 10h na segunda-feira, ele vencerá na terça-feira às 12h, conforme calculado abaixo.
    10am-5pm on Monday (6 hours) + 8am-12pm on Tuesday (4 hours)

    Para obter informações sobre cronogramas, que você pode usar como entradas para métodos DurationCalculator, consulte Criação e uso de cronogramas .

    Este script demonstra como usar DurationCalculator para calcular uma data de vencimento.

    /**
 * Demonstrate the use of DurationCalculator to compute a due date.
 * 
 * You must have a start date and a duration. Then you can compute a
 * due date using the constraints of a schedule.
 */
 
gs.include('DurationCalculator');
executeSample();
 
/**
 * Function to house the sample script.
 */function executeSample(){
 
    // First we need a DurationCalculator object.var dc =new DurationCalculator();
 
    // --------------- No schedule examples ------------------
 
    // Simple computation of a due date without using a schedule. Seconds// are added to the start date continuously to get to a due date.
    dc.setStartDateTime("5/1/2012");if(!dc.calcDuration(2*24*3600)){// 2 days
    	gs.log("*** Error calculating duration");return;}
    gs.log("calcDuration no schedule: "+ dc.getEndDateTime());// "2012-05-03 00:00:00" two days later
 
    // Start in the middle of the night (2:00 am) and compute a due date 1 hour in the future// Without a schedule this yields 3:00 am.
    dc.setStartDateTime("5/3/2012 02:00:00");if(!dc.calcDuration(3600)){
        gs.log("*** Error calculating duration");return;}
    gs.log("Middle of night + 1 hour (no schedule): "+ dc.getEndDateTime());// No scheduled start date, just add 1 hour
 
 
    // -------------- Add a schedule to the date calculator ---------------------
    addSchedule(dc);
 
    // Start in the middle of the night and compute a due date 1 hour in the future.// Since we start at 2:00 am the computation adds the 1 hour from the start// of the day, 8:00am to get to 9:00am
    dc.setStartDateTime("5/3/2012 02:00:00");if(!dc.calcDuration(3600)){// 
        gs.log("*** Error calculating duration");return;}
    gs.log("Middle of night + 1 hour (with 8-5 schedule): "+ dc.getEndDateTime());// 9:00 am
 
    // Start in the afternoon and add hours beyond quiting time. Our schedule says the work day// ends at 5:00pm, if the duration extends beyond that, we roll over to the next work day.// In this example we are adding 4 hours to 3:00pm which gives us 10:00 am the next day.
    dc.setStartDateTime("5/3/2012 15:00:00");if(!dc.calcDuration(4*3600)){// 
        gs.log("*** Error calculating duration");return;}
    gs.log("Afternoon + 4 hour (with 8-5 schedule): "+ dc.getEndDateTime());// 10:00 am.
 
    // This is a demo of adding 2 hours repeatedly and examine the result. This// is a good way to visualize the result of a due date calculation.
    dc.setStartDateTime("5/3/2012 15:00:00");// for(var i=2; i<24; i+=1){if(!dc.calcDuration(i*3600)){// 
            gs.log("*** Error calculating duration");return;}
        gs.log("add "+ i +" hours gives due date: "+ dc.getEndDateTime());}
 
    // Setting the timezone causes the schedule to be interpreted in the specified timezone.// Run the same code as above with different timezone. Note that the 8 to 5 workday is// offset by the two hours as specified in our timezone.
    dc.setTimeZone("GMT-2");
    dc.setStartDateTime("5/3/2012 15:00:00");for(var i=2; i<24; i+=1){if(!dc.calcDuration(i*3600)){// 
            gs.log("*** Error calculating duration");return;}
        gs.log("add "+ i +" hours gives due date (GMT-2): "+ dc.getEndDateTime());}}
 
/** 
 * Add a specific schedule to the DurationCalculator object.
 *  
 * @param durationCalculator An instance of DurationCalculator
 */function addSchedule(durationCalculator){//  Load the "8-5 weekdays excluding holidays" schedule into our duration calculator.var scheduleName ="8-5 weekdays excluding holidays";var grSched =new GlideRecord('cmn_schedule');
    grSched.addQuery('name', scheduleName);
    grSched.query();if(!grSched.next()){
        gs.log('*** Could not find schedule "'+ scheduleName +'"');return;}
    durationCalculator.setSchedule(grSched.getUniqueValue(),"GMT");}

    Duração simples versus duração relativa

    Quanto trabalho é necessário para concluir uma tarefa pode ser expresso como uma "duração relativa".

    A duração relativa determina a data e a hora de vencimento esperadas em relação à hora de início. Exemplos de durações relativas incluem "Próximo dia útil até 16h" ou "2 dias úteis até 10:30".

    Para calcular uma duração relativa, o calendário e o fuso horário devem ser considerados para determinar o que "próximo dia útil" significa, já que é o calendário que define quais dias são dias úteis válidos e o fuso horário afetará o resultado também. Como exemplo, considere "Próximo dia útil às 16h":
    • Se for segunda-feira às 12h: Próximo dia útil às 16h: Terça-feira às 16h
    • Se for sexta-feira às 14h: Próximo dia útil às 16h: Na segunda-feira seguinte às 16h
    Nota:
    O próximo dia útil geralmente é definido por um dia e hora de início. Por exemplo, "Próximo dia útil às 16h se antes das 14h" indica que, se a hora atual for após as 14h em um dia útil, "Próximo dia útil" realmente significa 2 dias úteis, já que hoje não conta.

    Para obter mais informações sobre durações relativas, consulte Define a relative duration.

    Calculando uma duração simples

    Este exemplo de regra de negócio e script demonstra como calcular uma duração simples.

    var dur =new DurationCalculator();
dur.setSchedule(current.schedule);
dur.setStartDateTime("");
 
if(current.duration_type==""){
         dur.calcDuration(current.duration.getGlideObject().getNumericValue()/1000);}else{
         dur.calcRelativeDuration(current.duration_type);}
 
    current.end_date_time= dur.getEndDateTime();
    current.work_seconds= dur.getSeconds();

    Este script demonstra como usar DurationCalculator para calcular uma duração simples.

    /**
 * Sample script demonstrating use of DurationCalculator to compute simple durations
 * 
 */
 
gs.include('DurationCalculator');
executeSample();
 
/**
 * Function to house the sample script.
 */
function executeSample(){
 
    // First we need a DurationCalculator object.
    var dc =new DurationCalculator();
 
    // Compute a simple duration without any schedule. The arguments
    // can also be of type GlideDateTime, such as fields from a GlideRecord.
    var dur = dc.calcScheduleDuration("5/1/2012","5/2/2012");
    gs.log("calcScheduleDuration no schedule: "+ dur);
    // 86400 seconds (24 hours)
 
    // The above sample is useful in limited cases. We almost always want to 
    // use some schedule in a duration computation, let's load a schedule.
    addSchedule(dc);
 
    // Compute a duration using the schedule. The schedule
    // specifies a nine hour work day. The output of this is 32400 seconds, or
    // a nine hour span.
    dur = dc.calcScheduleDuration("5/23/2012 12:00","5/24/2012 12:00");
    gs.log("calcScheduleDuration with schedule: "+ dur);
    // 32400 seconds (9 hours)
 
    // Compute a duration that spans a weekend and holiday. Even though this
    // spans three days, it only spans 9 work hours based on the schedule.
    dur = dc.calcScheduleDuration("5/25/2012 12:00","5/29/2012 12:00");
    gs.log("calcScheduleDuration with schedule spaning holiday: "+ dur);
    // 32400 seconds (9 hours)
 
    // Use the current date time in a calculation. The output of this is
    // dependent on when you run it.
    var now =new Date();
    dur = dc.calcScheduleDuration("5/15/2012",new GlideDateTime());
    gs.log("calcScheduleDuration with schedule to now: "+ dur);
    // Different on every run.}
 
/** 
 * Add a specific schedule to the DurationCalculator object.
 *  
 * @param durationCalculator An instance of DurationCalculator
 */
function addSchedule(durationCalculator){
   //  Load the "8-5 weekdays excluding holidays" schedule into our duration calculator.
   var scheduleName ="8-5 weekdays excluding holidays";
   var grSched =new GlideRecord('cmn_schedule');
   grSched.addQuery('name', scheduleName);
   grSched.query();if(!grSched.next()){
        gs.log('*** Could not find schedule "'+ scheduleName +'"');
        return;}
    durationCalculator.setSchedule(grSched.getUniqueValue());}

    Calculando uma duração relativa

    Um exemplo de script de cálculo de duração relativa.

    Este script calcula a duração relativa de "Próximo dia às 16h se depois das 10h":
    // Next day at 4pm if before 10am
var days =1;
if(calculator.isAfter(calculator.startDateTime,"10:00:00")) 
      days++;
 
calculator.calcRelativeDueDate(calculator.startDateTime, days,"16:00:00");

    Este script demonstra como usar DurationCalculator para calcular uma duração relativa.

    /**
 * Sample use of relative duration calculation.
 * 
 */
 
gs.include('DurationCalculator');
executeSample();
 
/**
 * Function to house the sample script.
 */
function executeSample(){
 
    // First we need a DurationCalculator object. We will also use
    // the out-of-box relative duration "2 bus days by 4pm"
    var dc =new DurationCalculator();
    var relDur ="3bf802c20a0a0b52008e2859cd8abcf2";
    // 2 bus days by 4pm if before 10am
    addSchedule(dc);
 
    // Since our start date is before 10:00am our result is two days from
    // now at 4:00pm.
    dc.setStartDateTime("5/1/2012 09:00:00");
    if(!dc.calcRelativeDuration(relDur)){
        gs.log("*** calcRelativeDuration failed");
        return;}
    gs.log("Two days later 4:00pm: "+ dc.getEndDateTime());
 
    // Since our start date is after 10:00am our result is three days from
    // now at 4:00pm.
    dc.setStartDateTime("5/1/2012 11:00:00");
    if(!dc.calcRelativeDuration(relDur)){
        gs.log("*** calcRelativeDuration failed");
        return;}
    gs.log("Three days later 4:00pm: "+ dc.getEndDateTime());}
 
/** 
 * Add a specific schedule to the DurationCalculator object.
 *  
 * @param durationCalculator An instance of DurationCalculator
 */
function addSchedule(durationCalculator){
  //  Load the "8-5 weekdays excluding holidays" schedule into our duration calculator.
  var scheduleName ="8-5 weekdays excluding holidays";
  var grSched =new GlideRecord('cmn_schedule');
  grSched.addQuery('name', scheduleName);
  grSched.query();
  if(!grSched.next()){
        gs.log('*** Could not find schedule "'+ scheduleName +'"');
        return;}
  durationCalculator.setSchedule(grSched.getUniqueValue(),"GMT");}

    Como implementar uma duração relativa

    Você pode implementar uma duração relativa criando a tabela cmn_relative_duration e DurationCalculator inclusão de script.

    Antes de Iniciar

    Função necessária: administrador

    Procedimento

    1. Crie a tabela cmn_relative_duration.
    2. Crie a inclusão de script DurationCalculator.
    3. Crie uma entrada de duração relativa de amostra (por exemplo, "Próximo dia útil às 16h").
    4. Adicione os campos necessários às tabelas de ANS para oferecer suporte a durações relativas.
    5. Modifique o cálculo de duração para ANS.
    6. Modifique o cálculo do temporizador de porcentagem de ANS para ANS (deve usar work_seconds).
    7. Adicione campos de programação ao Fluxo de trabalho: Programação e Fuso horário (selecionados com base no campo da tabela de fluxo de trabalho).
    8. Adicione campos de suporte de duração à atividade Tarefa de fluxo de trabalho.
    9. Implementar script de cálculo de duração para a atividade da tarefa.

    A tabela Duração relativa e os métodos DurationCalculator

    A tabela cmn_relative_duration oferece suporte à definição de um prazo como uma duração de tempo ou uma duração relativa.

    Esta tabela consiste em dois campos: "Nome" e "script". O campo "script" contém o script de cálculo de duração relativa. Este script inclui a variável "calculadora", que é usada para calcular a data de vencimento.

    A inclusão de script DurationCalculator pode ser usada para executar os cálculos de duração. Os métodos a seguir estão disponíveis nesta inclusão de script.

    Tabela 1. Tabela de inclusão de script DurationCalculator
    Método Descrição
    SetSchedSchedID(cadeia de caracteres schedID, [cadeia de caracteres de fuso horário]) Define a programação e o fuso horário a serem usados para calcular a data de vencimento.
    SetStartDateTime (início GlideDateTime) Define a hora de início dos cálculos de duração. Se "start" estiver em branco, usará a data/hora atual.
    CalcDuration (int segundos) Calcula a data e a hora de término. Após a conclusão, as propriedades this.endDateTime e this.seconds serão definidas para indicar os resultados do cálculo.
    CalcRelativeDuration(cadeia de caracteres relativeDurationID) Calcula a duração usando o script de duração relativa especificado. Após a conclusão, as propriedades this.endDateTime e this.seconds serão definidas para indicar os resultados do cálculo.
    GetEndDateTime() Obtém a propriedade this.endDateTime que foi definida por calcDuration/calcRelativeDuration indicando a data e a hora de término da duração.
    getSeconds() Obtém a propriedade this.seconds que foi definida por calcDuration/calcRelativeDuration, indicando o número total de segundos de trabalho a serem executados para a duração.
    Nota:
    Este é o tempo total de trabalho, não o tempo total entre as horas de início e término e pode ser usado para determinar porcentagens do tempo de trabalho
    GetTotalSeconds() Obtém a propriedade this.totalSeconds que foi definida por calcDuration/calcRelativeDuration, indicando o número total de segundos entre as horas de início e término da duração.

    As seguintes funções são usadas em scripts de duração relativa:

    Tabela 2. Funções de script de duração relativa
    Função Descrição
    IsAfter booliano(GlideDateTime dt, hora da cadeia de caracteres) "Hora" do dia após a hora do dia especificada por "dt"? dt, se estiver em branco, usa a data/hora atual. a hora está em "hh:mm:ss" no formato de 24 horas.
    CalcRelativeDueDate(início GlideDateTime, int dias, cadeia de caracteres endTime) Calcula a data de vencimento começando em "início" e adicionando "dias" usando a programação e o fuso horário. Quando encontrarmos o dia em que o trabalho vence, defina a hora como "endTime" desse dia. Após a conclusão, as propriedades this.endDateTime e this.seconds serão definidas para indicar os resultados do cálculo. Se a hora de término estiver em branco, use o fim do dia útil de término.

    Obtenha um objeto de usuário

    Em uma regra de negócio ou outro script de servidor, o. gs.getUser() o método retorna um objeto de usuário. O objeto de usuário é uma representação interna do usuário conectado no momento e fornece informações sobre o usuário e várias funções de utilitário.

    Por Que e Quando Desempenhar Esta Tarefa

    Para obter uma lista e uma descrição dos métodos com escopo disponíveis para o objeto do usuário, consulte GlideUser .

    Procedimento

    1. Recupere o usuário atual. 
      var myUserObject = gs.getUser()
    2. Use GetUserByID método para buscar um usuário diferente usando user_name campo ou sys_id no registro de destino.
      Por exemplo: 
      var ourUser = gs.getUser(); 
gs.print(ourUser.getFirstName()); //print the first name of the user you are currently logged in as 
newUser = ourUser.getUserByID(<user_sys_id>); //fetch a different user, using the sys_id of the target user record. 
gs.print(newUser.getFirstName()); //first name of the user you fetched above 
gs.print(newUser.isMemberOf('Capacity Mgmt'));

    Saída de log

    GSLog é uma inclusão de script que simplifica o registro em log e a depuração de script implementando níveis de saída de log, selecionáveis por valores sys_properties identificados por chamador.

    Nível de log

    Os logs podem estar no nível de depuração, informação, aviso, aviso, erro, ou crit (após o bsd syslog.h e seguidores). O nível de registro em log padrão é AVISO, portanto, os níveis devem ser escolhidos de acordo.

    Onde usar

    Use para qualquer script do lado do servidor em que você deseja implementar o registro em log de eventos.

    Para obter a referência de API, consulte GSLog() .

    Para obter mais informações, consulte Scripts de depuração

    Modifique um valor do campo GlideDateTime

    Este exemplo demonstra como modificar um GlideDateTime valor do campo usando um script do lado do servidor.

    Fornecido um GlideDateTime campo ou objeto de script, mostre várias maneiras de modificar o valor com facilidade. O mesmo conceito também se aplica ao GlideDate objeto.
    Nota:
    O script a seguir se destina apenas a aplicações globais.
    //You first need a GlideDateTime object
//this can be from instantiating a new object "var gdt = new GlideDateTime()"
//or getting the object from a GlideDateTime field
//getting the field value (for example: var gdt = current.start_date) only returns the string value, not the object
//to get the object use var gdt = current.start_date.getGlideObject();
//now gdt is a GlideDateTime object
var gdt = current.start_date.getGlideObject();
 
//All methods can use negative values to subtract intervals
 
//add 1 hour (60 mins * 60 secs)
gdt.addSeconds(3600);
 
//add 1 day
gdt.addDaysLocalTime(1);
 
//subtract 1 day
gdt.addDaysLocalTime(-1);
 
//add 3 weeks
gdt.addWeeksLocalTime(3);
 
//subtract 6 months
gdt.addMonthsLocalTime(-6);
 
//add 1 year, representing the date and time using the UTC timezone instead of the local user's timezone.
gdt.addYearsUTC(1);
 
//set the value of the GlideDateTime object to the current session timezone/format
GlideSession.get().setTimeZoneName('US/Eastern');
gdt.setDisplayValue('2018-2-28 00:00:00');
gs.info('In ' + GlideSession.get().getTimeZoneName() + ": " + gdt.getDisplayValue());
    Consulte também:

    Usando filas personalizadas para processar eventos

    Você pode usar filas personalizadas para aplicações que criam um grande volume de eventos ou eventos que demoram muito tempo para serem processados. Esta tarefa mostra como criar uma fila personalizada, seu processo de monitoramento e usar um script para enviar eventos para a fila.

    Antes de Iniciar

    Função necessária: administrador

    Nota:
    Essas informações são para usuários avançados que entendem o processamento de eventos.

    Procedimento

    1. Navegar até Política do Sistema > Eventos > Registro.
    2. Selecione o evento para o qual você deseja criar uma fila personalizada.
      . Registro de evento o formulário é exibido.
    3. Preencha Fila Campo do evento no Registro de eventos.
      Use somente letras minúsculas, sem espaços e caracteres especiais, exceto sublinhado (_).

      Formulário de registro de evento destacando o campo Fila que contém o nome da fila em minúsculas.

    4. Clique em Enviar.
      Um novo evento é listado na tabela Eventos [SysEvent].

      No exemplo a seguir, quando o evento employeeOccasion é gerado, o evento é adicionado a my_queue. Os eventos estão travados na fila. Para resolver esse problema, crie um processo para observar a fila em busca de eventos.Tabela de eventos que lista o evento com a fila adicionada listada no campo de fila.

    5. Navegar até Scheduler do Sistema > Trabalhos agendados > Trabalhos agendados e abra o trabalho agendado chamado processo de eventos de índice de texto .
      Programação tabela com *texto em Nome campo de pesquisa e o nome do processo de eventos de índice de texto programação realçada.
    6. Clique no ícone do menu de ações adicionais menu do ícone ações adicionais--> e selecione Inserir e permanecer para criar uma cópia de processo de eventos de índice de texto .
      Importante:
      Certifique-se de copiar o trabalho e não substituir o. processo de eventos de índice de texto Trabalho agendado.
    7. No item de programação copiado, altere o valor em Nome campo.
    8. Em Contexto do trabalho substitua o valor do GlideEventManager() parâmetro com o nome da nova fila.
      Item de programação Formulário que mostra o item copiado renomeado e o nome da fila atualizado para GlideEventManager no Contexto do trabalho campo.
      O processo de monitoramento de fila procura e processa eventos no exemplo my_queue fila de eventos.

      Tabela de eventos que destaca o conteúdo dos campos Processado e Fila.

    9. Use gs.eventQueue() quinto parâmetro do método para enviar eventos para a fila personalizada.

      O código a seguir mostra como enviar um evento para a fila personalizada my_queue.

      gs.eventQueue('x_60157_employee_spe.employeeOccasion', todaysOccasions, todaysOccasions.number, todaysOccasions.u_employee.name, 'my_queue');
      Nota:
      Se um evento estiver em Registro de evento e nenhum nome de fila é fornecido gs.eventQueue , a fila do Registro de evento ainda está atribuído ao evento. Por exemplo, gs.eventQueue('x_60157_employee_spe.employeeOccasion') ainda associa o evento a. my_queue . Se o nome da fila for fornecido em gs.eventQueue() chamada, a fila tem prioridade.
      Você pode verificar se o evento chamado foi processado verificando Eventos tabela [sysvent].

      Tabela de eventos que lista os eventos processados filtrados pelo nome do evento.