Question

We had an issue where our workflows have not been creating activities.

I now need to report which accounts have not had their workflows invoked.

I’ve tried advanced find and then moved to sql.

My question is can someone provide a simple starter query to pull which ‘entity’ has NOT had a specific activity associated with it?

Please let me know if the question is not clear enough or more info, is needed.

Answer 1

Below is a solution using SQL where I step through my thought process, and below that is a solution that gets started with the C# API (edit: just realized this is for a report, so that part can be disregarded). I’ve commented in most places, so I hope my methods are fairly straightforward.

SQL

1.

--get all the entities that aren't activities and aren't intersect entities (N:N tables)
--Put in your own where conditions to further filter this list,
--which is still probably far too expansive
SELECT
    A.name EntityName
FROM MetadataSchema.Entity A
WHERE 
    A.IsActivity = 0
        AND A.IsIntersect = 0

2.

--CROSS JOIN the non-activity entities with the activity entities
--to get a list of all possible entity/activity pairings
SELECT DISTINCT
    A.name EntityName
    , B.Name ActivityName
FROM MetadataSchema.Entity A
    CROSS JOIN MetadataSchema.Entity B
WHERE 
    A.IsActivity = 0
        AND A.IsIntersect = 0
        AND B.IsActivity = 1

3.

--LEFT JOIN the partial cartesian join above against the Activity table,
--making a note of which entities actually have activity records.
--This will provide a complete list of which entity/activity pairings
--exist and don't exist
SELECT
    A.name EntityName
    , B.Name ActivityName
    --if there is a matching activity, the unique key,
    --ActivityTypeCode (int), will be positive.
    --So, if there is a positive sum for an entity/activity
    --pairing, you know there is a valid pair; otherwise
    --no pair
    , CAST(CASE WHEN sum(coalesce(C.ActivityTypeCode, 0)) > 0
        THEN 1
    ELSE 0
    END AS BIT) EntityOwnsActivity  
FROM MetadataSchema.Entity A
    CROSS JOIN MetadataSchema.Entity B
    LEFT JOIN dbo.ActivityPointer C ON
        --ObjectTypeCode is a unique identifier for Entities;
        --RegardingObjectTypeCode is the code for the entity type
        --associated with a particular activity
        A.ObjectTypeCode = C.RegardingObjectTypeCode
        --ActivityTypeCode is the code for the particular activity
            AND B.ObjectTypeCode = C.ActivityTypeCode
WHERE 
    A.IsActivity = 0
        AND A.IsIntersect = 0
        AND B.IsActivity = 1
GROUP BY 
    A.name
    , B.Name

4.

--Putting it all together, using the above master table,
--filter out the entities/activities you're interested in
--(in this case, all entities that aren't associated with
--any emails)
SELECT 
    EntityName
FROM
(
    SELECT
        A.name EntityName
        , B.Name ActivityName
        , CAST(CASE WHEN sum(coalesce(C.ActivityTypeCode, 0)) > 0
            THEN 1
        ELSE 0
        END AS BIT) EntityOwnsActivity  
    FROM MetadataSchema.Entity A
        CROSS JOIN MetadataSchema.Entity B
        LEFT JOIN dbo.ActivityPointer C ON
            A.ObjectTypeCode = C.RegardingObjectTypeCode
                AND B.ObjectTypeCode = C.ActivityTypeCode
    WHERE 
        A.IsActivity = 0
            AND A.IsIntersect = 0
            AND B.IsActivity = 1
    GROUP BY 
        A.name
        , B.Name
) EntityActivities
WHERE ActivityName = 'Email'
    AND EntityOwnsActivity = 0
ORDER BY
    EntityName

C#.NET API

using (OrganizationServiceProxy _serviceProxy = 
        new OrganizationServiceProxy(
        new Uri(".../XRMServices/2011/Organization.svc"), null, null, null))
{
    _serviceProxy.EnableProxyTypes();

    RetrieveAllEntitiesRequest request = new RetrieveAllEntitiesRequest()
    {
        EntityFilters = EntityFilters.Entity,
        RetrieveAsIfPublished = true
    };

    // Retrieve the MetaData.
    EntityMetadata[] entities = 
            ((RetrieveAllEntitiesResponse)_serviceProxy.Execute(request)).EntityMetadata;

    var ents = from e1 in entities.Where(x => x.IsActivity != true)
                                  .Where(x => x.IsIntersect != true)
               from e2 in entities.Where(x => x.IsActivity == true)
               select new
               {
                   entityName = e1.SchemaName
                   ,
                   activityName = e2.SchemaName
               };
    //at this point, because of the limited nature of the Linq provider for left joins
    //and sums, probably the best approach is to do a fetch query on each entity/activity
    //combo, do some sort of sum and find out which combos have matches
    // in the activity pointer table

    //API = very inefficient; maybe improved in next CRM release? Let's hope so!

}