Add GetDataPortal<T>() function publicly to ApplicationContext

[mtavares628]

Is it possible to add a GetDataPortal() function directly to the injected ApplicationContext? This would make things a little easier when converting my static methods. So using my earlier example from #2681

        public static async Task<bool> CanGetObjectAsync(int clientID, IDataPortal<HasPermissionForClientCommand> cmdPortal)
        {
            var result = default(bool);
            if (BusinessRules.HasPermission(AuthorizationActions.GetObject, typeof(Client)))
            {
                HasPermissionForClientCommand cmd = await cmdPortal.CreateAsync(clientID, AccessPermissions.ReadAccess);
                cmd = await cmdPortal.ExecuteAsync(cmd);
                result = cmd.HasPermission;
            }

            return result;
        }

        public async static Task<Client> GetClientAsync(int clientID, IDataPortal<Client> clientPortal, IDataPortal<HasPermissionForClientCommand> cmdPortal)
        {
            var canGet = await CanGetObjectAsync(clientID, cmdPortal);
            if (!canGet)
            {
                throw new System.Security.SecurityException("User not authorized to load this Client");
            }

            return await clientPortal.FetchAsync<Client>(clientID);
        } 

You can see that I have to pass in multiple DataPortals into my method, one for the command object to check for authorization, and the other for retrieving the object. I would rather just pass in the ApplicationContext, and then have that issue the dataportals within the method. That way the Consumer wouldn't even need to know what dataportals are needed. So something like this:

    public static async Task<bool> CanGetObjectAsync(int clientID, ApplicationContext appContext)
    {
        var result = default(bool);
        if (BusinessRules.HasPermission(AuthorizationActions.GetObject, typeof(Client)))
        {
            var cmdPortal = appContext.GetDataPortal<HasPermissionForClientCommand>();
            HasPermissionForClientCommand cmd = await cmdPortal.CreateAsync(clientID, AccessPermissions.ReadAccess);
            cmd = await cmdPortal.ExecuteAsync(cmd);
            result = cmd.HasPermission;
        }

        return result;
    }

    public async static Task<Client> GetClientAsync(int clientID, ApplicationContext appContext)
    {
        var canGet = await CanGetObjectAsync(clientID, appContext);
        if (!canGet)
        {
            throw new System.Security.SecurityException("User not authorized to load this Client");
        }
        var clientPortal = appContext.GetDataPortal<Client>();
        return await clientPortal.FetchAsync<Client>(clientID);
    }

This would just make life a lot easier not needing to know what DataPortal types need to be injected from the UI, as well as still being able to make use of static methods, just passing in the ApplicationContext.

If this is a bad idea, just let me know, but I think it would give better flexibility with migrating from v5.x.

[rockfordlhotka]

I think I'd rather add something like a DataPortalFactory concept.

ApplicationContext already violates the single responsibility pattern, and I hesitate to keep adding functionality that makes it worse in that regard.

However, the need to inject numerous data portal instances is not unique to your scenario. It is also (I'm finding) quite common in data portal operation methods where a root class is responsible for loading a lot of child types, or in a command object that interacts with numerous business types.

Being able to inject an IDataPortalFactory that is then used to get the various data portal instances might be a good solution.

Issue #2676 is tracking this idea - I added some more thoughts to it today.

[mtavares628]

My apologies, I didn't realize that Issue #2676 was asking for essentially the same thing that I was looking for. I've taken a look at your code example in that issue, and I think that will work, but I just want make sure that I understand it correctly. Your example shows using that factory within a Fetch method itself. So that would mean that the initial DataPortal call would still use the same methodology that you've already laid out of injecting the DataPortal into the page and then calling its FetchAsync method.

For my use case with static methods calling one another before the initial dataportal call, I could just pass the injected DataPortalFactory into my static methods on the BO and be able to achieve the same thing, correct? So something like:

public static async Task<bool> CanGetObjectAsync(int clientID, IDataPortalFactory dataPortalFactory)
 {
     var result = default(bool);
     if (BusinessRules.HasPermission(AuthorizationActions.GetObject, typeof(Client)))
     {
         var cmdPortal = dataPortalFactory.GetDataPortal<HasPermissionForClientCommand>();
         HasPermissionForClientCommand cmd = await cmdPortal.CreateAsync(clientID, AccessPermissions.ReadAccess);
         cmd = await cmdPortal.ExecuteAsync(cmd);
         result = cmd.HasPermission;
     }

     return result;
 }

 public async static Task<Client> GetClientAsync(int clientID, IDataPortalFactory dataPortalFactory)
 {
     var canGet = await CanGetObjectAsync(clientID, dataPortalFactory);
     if (!canGet)
     {
         throw new System.Security.SecurityException("User not authorized to load this Client");
     }
     var clientPortal = dataPortalFactory.GetDataPortal<Client>();
     return await clientPortal.FetchAsync<Client>(clientID);
 }

If I am correct in following this, then I think this would make life a lot easier in transitioning to Csla 6.

[rockfordlhotka]

Yes, that is the idea.