Saltar al contenido

Píldoras

RSS

Trucos cortos sobre Dynamics 365, Power Pages y Power Platform: un problema, una solución, en dos minutos de lectura. Una nueva cada semana.

Buscar un texto en todos los archivos de una carpeta con PowerShell

¿En qué archivo de la solución se usaba ese campo? ¿Dónde se quedó la URL antigua? Para eso no hace falta abrir Visual Studio, basta con una línea de PowerShell:

cd "C:\ruta\a\mi\proyecto"
Get-ChildItem -Recurse -File | Select-String -Pattern "new_campo" -List | Select-Object Path

Con -List te quedas con la primera coincidencia de cada archivo, que es justo lo que quieres si solo buscas saber en qué archivos aparece. Si prefieres ver cada línea con su número, quita -List y el | Select-Object Path del final. Y si solo te interesan ciertos tipos, filtra con Get-ChildItem -Recurse -Include *.cs,*.js.

Yo casi siempre excluyo bin, obj y node_modules, porque si no la búsqueda tarda una eternidad y devuelve un montón de resultados que no sirven para nada:

Get-ChildItem -Recurse -File | Where-Object FullName -notmatch '\\(bin|obj|node_modules)\\' | Select-String -Pattern "new_campo" -List | Select-Object Path
Compartir:LinkedInX

Crear y actualizar registros desde Power Pages con la Web API

Una vez tienes la Web API activada para la tabla y el wrapper safeAjax en el Header, crear un registro es un POST y actualizarlo un PATCH, los dos contra /_api/<conjunto>:

function createRecord(entitySet, data) {
  return utilities.safeAjax({
    type: "POST",
    url: "/_api/" + entitySet,
    contentType: "application/json",
    data: JSON.stringify(data),
    success: function (res, status, xhr) {
      console.log("Creado con id", xhr.getResponseHeader("entityid"));
    },
  });
}
 
function updateRecord(entitySet, id, data) {
  return utilities.safeAjax({
    type: "PATCH",
    url: "/_api/" + entitySet + "(" + id + ")",
    contentType: "application/json",
    data: JSON.stringify(data),
  });
}
 
createRecord("accounts", { name: "Axazure", address1_city: "Madrid" });

Fíjate en que el nombre va en plural, porque es el entity set (accounts, contacts). Y el id del registro nuevo no lo vas a encontrar en el cuerpo de la respuesta, viene en la cabecera entityid.

Si justo después intentas leer lo que acabas de crear, puede que no aparezca todavía. Es la caché de Power Pages, no un fallo de tu código.

Cómo obtener el campo principal (nombre) de cualquier tabla de Dataverse

En cuanto haces código genérico, como un plugin que sirve para varias tablas o una herramienta, necesitas saber cuál es el campo principal de cada una. En cuentas es name, en contactos fullname, en casos title. En vez de ponerlo a mano, yo se lo pido a los metadatos.

En C# basta con un RetrieveEntityRequest:

public static string GetPrimaryNameAttribute(IOrganizationService service, string logicalName)
{
    var response = (RetrieveEntityResponse)service.Execute(new RetrieveEntityRequest
    {
        LogicalName = logicalName,
        EntityFilters = EntityFilters.Entity, // solo la tabla, sin columnas: mucho más rápido
    });
 
    return response.EntityMetadata.PrimaryNameAttribute; // PrimaryIdAttribute para el id
}

Y con la Web API es una sola petición:

GET /api/data/v9.2/EntityDefinitions(LogicalName='account')?$select=PrimaryNameAttribute,PrimaryIdAttribute

Como los metadatos casi nunca cambian, no tiene sentido pedirlos dentro de un bucle. Si lo vas a usar mucho, guarda el resultado en una variable estática o en una caché.

Compartir:LinkedInX

Cómo depurar el JavaScript de Dynamics 365 sin subirlo cada vez

Subir el web resource, publicar y refrescar cada vez que cambias una línea es lentísimo. Hay una alternativa mucho más cómoda, que es hacer que el navegador cargue tu archivo local en lugar del que está en Dynamics.

Lo más rápido hoy en día son los Local Overrides de Chrome o Edge. En DevTools vas a Sources → Overrides y eliges una carpeta local. Luego, en la pestaña Network, buscas tu JavaScript, botón derecho y Override content. A partir de ahí editas el archivo (en DevTools o en esa carpeta), recargas y el formulario usa tu versión.

Si ya tienes Fiddler instalado, el AutoResponder hace lo mismo y es lo que se ha usado toda la vida:

  1. Tools → Options → HTTPS, activa Decrypt HTTPS traffic y confía en el certificado.
  2. Rules → Performance → Disable Caching.
  3. En AutoResponder, marca Enable rules y Unmatched requests passthrough.
  4. Añade una regla con REGEX:(?insx).+(?'nombredetujs'[^?]*.js) y la ruta a tu archivo local.

Me ha pasado más de una vez que el JS ni aparece en Fiddler. Casi siempre es que el navegador lo tiene en caché, y se arregla marcando Disable cache en DevTools → Network.

Cuando termines, acuérdate de quitarlo. Nadie más ve tus cambios, así que si te lo dejas puesto acabas probando un código que no tiene nadie.

Compartir:LinkedInX

El wrapper safeAjax para llamar a la Web API de Power Pages

Las llamadas a /_api/ que escriben datos necesitan el token anti-falsificación (__RequestVerificationToken). Microsoft propone un pequeño wrapper sobre $.ajax que lo añade por ti, y yo lo pongo en el Header del sitio para tenerlo disponible en todas las páginas:

(function (utilities, $) {
  function safeAjax(ajaxOptions) {
    const deferredAjax = $.Deferred();
    shell.getTokenDeferred().done(function (token) {
      ajaxOptions.headers = ajaxOptions.headers || {};
      ajaxOptions.headers["__RequestVerificationToken"] = token;
      $.ajax(ajaxOptions)
        .done(function (data, textStatus, jqXHR) {
          validateLoginSession(data, textStatus, jqXHR, deferredAjax.resolve);
        })
        .fail(deferredAjax.reject);
    }).fail(function () {
      deferredAjax.rejectWith(this, arguments);
    });
    return deferredAjax.promise();
  }
  utilities.safeAjax = safeAjax;
})((window.utilities = window.utilities || {}), jQuery);

A partir de ahí, desde cualquier página haces utilities.safeAjax({ type: "PATCH", url: "/_api/accounts(" + id + ")", ... }).

No tienes que definir shell.getTokenDeferred() ni validateLoginSession, los dos vienen con el propio Power Pages. El segundo, además, redirige al login si la sesión del usuario ha caducado.

Un aviso por experiencia: algunos bloqueadores de anuncios cortan estas peticiones. Si al probar parece que no pasa nada, desactiva el Adblock antes de ponerte a revisar el código línea a línea.

Xrm.WebApi en una chuleta: crear, leer, actualizar y borrar

Esta es la chuleta que tengo a mano para las cuatro operaciones básicas con Xrm.WebApi desde un formulario, usando async/await:

// Crear: devuelve { entityType, id }
const { id } = await Xrm.WebApi.createRecord("account", {
  name: "Axazure",
  revenue: 5000000,
  "primarycontactid@odata.bind": "/contacts(00000000-0000-0000-0000-000000000000)",
});
 
// Leer un registro
const account = await Xrm.WebApi.retrieveRecord("account", id, "?$select=name,revenue");
 
// Actualizar (ojo: el id va como segundo parámetro)
await Xrm.WebApi.updateRecord("account", id, { revenue: 6000000 });
 
// Borrar
await Xrm.WebApi.deleteRecord("account", id);

Los lookups se rellenan con campo@odata.bind y la ruta /<nombre-del-conjunto>(<guid>), en plural (/contacts(...)). Ese nombre de campo es la propiedad de navegación, que en los campos personalizados suele coincidir con el nombre de esquema, con sus mayúsculas.

Pon siempre $select al leer, porque si no te traes todas las columnas y la llamada va bastante más lenta.

El fallo que más veo es en updateRecord, cuando alguien se olvida del id y pasa los datos como segundo parámetro. Falla, y el mensaje de error no ayuda mucho a darse cuenta.

Compartir:LinkedInX

Error "The entity name doesn't exist" en las vistas de Dynamics 365

Abres una vista de una tabla personalizada y te salta “The entity name doesn’t exist”. Lo más probable es que la vista tenga guardado un código de tipo de objeto (ObjectTypeCode) que no corresponde a este entorno. Suele pasar al mover soluciones de un entorno a otro, porque las tablas personalizadas no tienen por qué recibir el mismo código en cada uno. Con las estándar (account, contact y demás) no te va a pasar, su código es siempre el mismo.

Para arreglarlo, primero saca el ObjectTypeCode real de la tabla en tu entorno:

https://TU-ENTORNO.crm4.dynamics.com/api/data/v9.2/EntityDefinitions?$select=LogicalName,ObjectTypeCode&$filter=LogicalName eq 'nombre_tabla'

Después abre XrmToolBox → View Designer, carga la tabla y, en cada vista, edita el XML para sustituir el número antiguo del atributo object por el que acabas de copiar. Guarda, publica y la vista debería abrir sin problema.

Compartir:LinkedInX

Cómo llevarte tus cambios a otra rama en Git sin hacer commit

Te pones a programar y a mitad te das cuenta de que estás en la rama que no era, normalmente main. No hace falta copiar archivos a mano a ningún sitio.

Si la rama ya existe, guarda los cambios, cambia de rama y recupéralos:

git stash
git checkout otra-rama
git stash pop

Si la rama todavía no existe es aún más fácil, porque al crearla los cambios sin commit se vienen contigo y ni siquiera necesitas stash:

git switch -c mi-nueva-rama

Puede que el git stash pop te dé conflictos si la otra rama tocó los mismos archivos. No pasa nada, los resuelves como cualquier otro conflicto. El stash no se borra hasta que se aplica bien, así que no pierdes nada y lo puedes ver con git stash list.

Compartir:LinkedInX

Plantilla de plugin en Dataverse: contexto, servicio y Target

Todos los plugins arrancan igual. Hay que sacar el contexto, el servicio de trazas, el servicio de organización y el registro que ha disparado el plugin (Target). Esta es la base que copio siempre:

public void Execute(IServiceProvider serviceProvider)
{
    var context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));
    var tracing = (ITracingService)serviceProvider.GetService(typeof(ITracingService));
    var factory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
    var service = factory.CreateOrganizationService(context.UserId);
 
    if (!context.InputParameters.Contains("Target") || !(context.InputParameters["Target"] is Entity target))
        return;
 
    tracing.Trace("Plugin ejecutado sobre {0} {1}", target.LogicalName, target.Id);
    // Tu lógica aquí
}

Con CreateOrganizationService(context.UserId) el servicio usa los permisos del usuario que lanzó la acción. Si le pasas null se ejecuta como SYSTEM y se salta la seguridad, algo que yo solo hago cuando no queda otra.

La comprobación del tipo del Target tampoco está de adorno. En un Delete llega una EntityReference y no una Entity, así que si haces el cast directamente a Entity, el plugin falla.

Por último, en un Update el Target solo trae los campos que han cambiado. Si necesitas leer alguno más, configura una pre-image en el paso.

Compartir:LinkedInX

Cómo rellenar un lookup desde JavaScript en un formulario de Dynamics 365

Un campo de búsqueda (lookup) no se rellena pasándole un GUID sin más. Lo que espera es un array con un objeto que tenga id, name y entityType, y yo suelo tener una función pequeña para no repetirlo cada vez:

function setLookup(executionContext, fieldName, id, name, entityType) {
  const formContext = executionContext.getFormContext();
  formContext.getAttribute(fieldName).setValue([
    { id: id, name: name, entityType: entityType },
  ]);
}
 
// Ejemplo: poner la cuenta principal
setLookup(executionContext, "parentcustomerid", "00000000-0000-0000-0000-000000000000", "Axazure", "account");

En entityType va el nombre lógico de la tabla (account, contact), no el nombre para mostrar. El name es el texto que se ve en el formulario, y si no lo pones el campo parece vacío hasta que guardas.

Con los lookups de cliente, como customerid o parentcustomerid, hay que fijarse más, porque aceptan varias tablas y si el entityType no es el correcto el guardado falla.

Para vaciar el campo, formContext.getAttribute(fieldName).setValue(null).

Compartir:LinkedInX

Cómo activar la Web API de Power Pages para una tabla

La Web API de Power Pages (/_api/...) no funciona con ninguna tabla hasta que la activas tú. Hacen falta dos cosas, la configuración del sitio y los permisos de tabla.

En Site Settings crea estas dos entradas:

NombreValor
Webapi/account/enabledtrue
Webapi/account/fieldsaddress1_city,description

Cambia account por el nombre lógico de tu tabla. En fields van, separados por comas, los campos que se podrán leer y escribir. Se puede poner * para que entren todos, pero yo prefiero limitarlo a los que de verdad uso.

Luego, en Table Permissions, crea un permiso para esa tabla con los privilegios que necesites (lectura, creación, escritura) y el ámbito que toque, ya sea global, de contacto o de cuenta. Asígnaselo al rol web de los usuarios que van a llamar a la API.

Si después de todo esto sigue sin responder, seguramente es la caché, que todavía no ha recogido los cambios. Como administrador puedes forzar el refresco desde /_services/about.