BLAZOR 6.0 Calling method on business object with different name other than Fetch

[jhuerta3]

Hello,
Can someone tell me how I can call a method that I created on the business object with name other than Fetch. I created the following method on the business object

Business Object Code:

 [Fetch]
        private void GetEquipmentToAssign(Guid EquipmentID, [Inject] DataAccess.IEmployeeEquipmentDal dal)
        {
            var data = dal.GetEquipmentToAssign(EquipmentID);
            using (BypassPropertyChecks)
                Csla.Data.DataMapper.Map(data, this);
            BusinessRules.CheckRules();
        }

Razor code:

 await vm.RefreshAsync(() => EmployeeEquipmentEditPortal.GetEquipmentToAssign(Guid.Parse(EquipmentID)));

but when I try to call it from the razor page I get the following error: "IDataPortal' does not contain a definition for 'GetEquipmentToAssign' and no accessible extension method 'GetEquipmentToAssign' accepting a first argument of type 'IDataPortal' could be found (are you missing a using directive or an assembly reference?)
"

[rockfordlhotka]

On the client-side you are interacting with the client-side data portal, and it has specific method names you can't change.

On the server-side, you get to name your server-side data portal operation methods as you choose, using the operation attributes so the data portal can identify which methods correspond to an operation.

If you want customized names for things on the client, you should consider using a factory type. Form example:

public class EmployeeEquipmentEditFactory
{
  private IDataPortal<EmployeeEquipmentEdit> Portal { get; set; }

  public EquipmentFactory(IDataPortal<EmployeeEquipmentEdit> portal)
  {
    // get data portal via dependency injection
    Portal = portal;
  }

  public async Task<EmployeeEquipmentEdit> GetEquipmentToAssign(Guid equipmentId)
  {
    return await Portal.FetchAsync(Guid.Parse(equipmentId));
  }
}

You can inject this factory type instead of an IDataPortal<T> and use it to make your client-side code more readable.

[jhuerta3]

Thank you Sir.

[jhuerta3]

Hello @rockfordlhotka,

I have a question about this that I still dont understand. Since we are not able to call methods with different names other than Fetch,Update,Delete, etc.. directly from Razor pages to the BusinessBase class without using a factory class. How do we call a method with a different name via the factory. Lets say I have a bussiness object EmployeeEquipmentEdit with the following method name GetEmployeeEquipmentByDepartmentNumber(string depNumber). How do I call GetEmployeeEquipmentByDepartmentNumber(string depNumber) from the factory class. Is their way to accomplish this. Below is what I think we could do but im not sure how to make it work.

BusinessBase class

    [Serializable]
    public class EmployeeEquipmentEdit : BusinessBase<EmployeeEquipmentEdit>
    {  

   **//This is not an issue works fine since its operator is Fetch and method name is Fetch**
    [Fetch]
    private void Fetch(Guid EquipmentID, [Inject] DataAccess.IEmployeeEquipmentDal dal)
    {
        var data = dal.Get(EquipmentID);
        using (BypassPropertyChecks)
        {
            Csla.Data.DataMapper.Map(data, this);
        }
        BusinessRules.CheckRules();
    }
  

        //I would like to call this method 
          private void GetEmployeeEquipmentByEmployeeNumber(string EmployeeNumber, [Inject] DataAccess.IEmployeeEquipmentDal dal)
          {
              var data = dal.GetEmployeeEquipmentByEquipmentID(EquipmentID);
              using (BypassPropertyChecks)
                  Csla.Data.DataMapper.Map(data, this);
              BusinessRules.CheckRules();
          }
    }

Factory Class

public class EmployeeEquipmentEditFactory
{
  private IDataPortal<EmployeeEquipmentEdit> Portal { get; set; }

  public EquipmentFactory(IDataPortal<EmployeeEquipmentEdit> portal)
  {
    // get data portal via dependency injection
    Portal = portal;
  }
  
 **//This is okay since Fetch is avialable from Portal reference**
  public EmployeeEquipmentEdit GetEquipmentToAssign(Guid equipmentId)
  {
    return Portal.Fetch(Guid.Parse(equipmentId));
  }

//Asyn sample
  public async Task<EmployeeEquipmentEdit> GetEquipmentToAssignAsync(Guid equipmentId)
  {
    return await Portal.FetchAsync(Guid.Parse(equipmentId));
  }

   **//This will be accessible on the client via the factory.** 
  public EmployeeEquipmentEdit GetEmployeeEquipmentByEmployeeNumber(string equipmentId)
  {
    **//But how do I call the method on the businessbase since Portal reference only gives me Fetch,**
    return Portal.GetEmployeeEquipmentByEmployeeNumber(Guid.Parse(equipmentId));
  }

        **//Is something like this allowed?  I just dont know how to inject DataAccess.IEmployeeEquipmentDal into the factory**
  public EmployeeEquipmentEdit GetEmployeeEquipmentByEmployeeNumber(string equipmentnumber, [Inject] DataAccess.IDepartmentDal dal)
  {
    **//But how do I call the method on the businessbase since Portal reference only gives me Fetch,**
	// other code here
    return dal.GetEmployeeEquipmentByEmployeeNumber(equipmentnumber);
  }


}

[jhuerta3]

Hello @rockfordlhotka,

Here is another sample of what I am trying to do. From my factory I would rather call the method DepartmentList.GetSectionsByDivisionNumberAsync() by name and not just DepartmentList.FetchAsync(string DivisionNumber). This particular object DepartmentList has also Section Number, and Department Number so there will be a chance I will the following methods DepartmentList.FetchAsync(string SectionNumber) and DepartmentList.FetchAsync(string DepartmentNumber) which will not work since the fetch has the same method signature.

    [Serializable]
    public class DepartmentList : ReadOnlyListBase<DepartmentList, DepartmentInfo>
    {

        //Other way to perform the get via all Async calls.
        [Fetch]
        private async void FetchAsync([Inject] DataAccess.IDepartmentDal dal, [Inject] IChildDataPortal<DepartmentInfo> departmentInfoPortal)
        {
            using (LoadListMode)
            {
                var taskListDepartmentEntity = await dal.GetAsync();
                foreach (DataAccess.DepartmentEntity x in taskListDepartmentEntity)
                {
                    Task<DepartmentInfo> t = departmentInfoPortal.FetchChildAsync(x);
                    AddRange(t);
                }
            }
        }


        [Fetch]
        private async void FetchAsync(string DivisionNumber, [Inject] DataAccess.IDepartmentDal dal, [Inject] IChildDataPortal<DepartmentInfo> departmentInfoPortal)
        {
            using (LoadListMode)
            {
                var taskListDepartmentEntity = await dal.GetSectionsByDivisionNumberAsync(DivisionNumber);
                foreach (DataAccess.DepartmentEntity x in taskListDepartmentEntity)
                {
                    Task<DepartmentInfo> t = departmentInfoPortal.FetchChildAsync(x);
                    AddRange(t);
                }
            }
        }

        private async void GetSectionsByDivisionNumberAsync(string DivisionNumber, [Inject] DataAccess.IDepartmentDal dal, [Inject] IChildDataPortal<DepartmentInfo> departmentInfoPortal)
        {
            using (LoadListMode)
            {
                var taskListDepartmentEntity = await dal.GetSectionsByDivisionNumberAsync(DivisionNumber);
                foreach (DataAccess.DepartmentEntity x in taskListDepartmentEntity)
                {
                    Task<DepartmentInfo> t = departmentInfoPortal.FetchChildAsync(x);
                    AddRange(t);
                }
            }
        }


        private void AddRange(Task<DepartmentInfo> data)
        {
            this.Add(data.Result);
        }

    }
}

    public class DepartmentListFactory
    {
        public List<DropDownList> theList;

        private IDataPortal<DepartmentList> Portal { get; set; }
        private IDataPortal<DepartmentInfo>? PortalInfo { get; set; }

        public DepartmentListFactory(IDataPortal<DepartmentList> portal, IDataPortal<DepartmentInfo>? portalInfo = null)
        {
            // get data portal via dependency injection
            Portal = portal;
            PortalInfo = portalInfo;
        }

        public async Task<List<DropDownList>> GetDropDownListSectionsByDivisionNumberAsync(Guid DepartmentID)
        {
            theList = new List<DropDownList>();
            DepartmentInfo objifo = await PortalInfo.FetchAsync(DepartmentID);
            DepartmentList objList = await Portal.FetchAsync(objifo.DivisionNumber);

            foreach (DepartmentInfo i in objList)
            {
                theList.Add(new DropDownList(i.DivisionNumber.ToString(), i.DivisionName.ToString()));
            }

            return theList;
        }


        public async Task<List<DropDownList>> GetDropDownListSectionsByDivisionNumberAsync(Guid DepartmentID)
        {
            theList = new List<DropDownList>();
            DepartmentList objList = await Portal.GetSectionsByDivisionNumberAsync(DepartmentID);

            foreach (DepartmentInfo i in objList)
            {
                theList.Add(new DropDownList(i.DivisionNumber.ToString(), i.DivisionName.ToString()));
            }

            return theList;
        }

        public async Task<DepartmentInfo> GetDepartmentInfo(Guid DepartmentID)
        {
            return await PortalInfo.FetchAsync(DepartmentID);
        }       

    }

DropDownList on Shared Library

    public class DropDownList
    {
        public DropDownList(string value, string text)
        {
            Value = value;
            Text = text;
        }

        public string Value { get; set; }
        public string Text { get; set; }
    }

Razor Code goal.

@inject Csla.IDataPortal<Shared.DepartmentList> DepartmentListPortal
@inject Csla.IDataPortal<Shared.DepartmentInfo> DepartmentInfoPortal

    public List<DropDownList> SectionList;

        DepartmentListFactory objDept = new DepartmentListFactory(DepartmentListPortal,DepartmentInfoPortal);
        SectionList = await objDept.GetDropDownListSectionsByDivisionNumberAsync(Guid.Parse(DepartmentId));

        <div class="container px-0">
            <div class="row gx-1">
                <div class="col">
                    <div class="p-2">
                        <label>List Filter</label>
                        <select for="DepartmentID" class="form-control" @onchange="OnChangeDepartmentFilter">
                            <option value="">ALL</option>
                            @foreach (DropDownList l in SectionList)
                            {
                                <option value="@l.Value"> @l.Text</option>
                            }
                        </select>
                    </div>
                </div>
            </div>
        </div>

[TheCakeMonster]

Your factory method and your data access method can be called anything.

The restrictions are:

1. That the server-side method must be marked with one of the attributes [Fetch], [Insert], [Update], [Delete] or [DeleteSelf]
2. The DataPortal (via IDataPortal) only supports a few methods - Create, Fetch, Update and Delete and their async equivalents

On the server side, methods must be unique by the list of parameters they receive. That's all that the server-side DataPortal uses to distinguish between them. Generally, I use a Criteria class as a parameter to enforce this distinction. Use of a Criteria class is no longer required, it's optional - but it's an easy way to ensure that the method has a unique set of parameters.

I think what you want is a client-side method named GetDropDownListSectionsByDivisionNumberAsync. That will call a server-side method marked with the [Fetch] attribute, and accepting a parameter of GetDropDownListSectionsByDivisionNumberCriteria to absolutely ensure it is unique. That server-side method can be called whatever you want, but by all means call it GetDropDownListSectionsByDivisionNumberAsync if you'd like. As long as that server-side method marked with the [Fetch] attribute and has a unique set of parameters amongst all methods to which the [Fetch] attribute is applied, it should work. In the client-side factory method, call IDataPortal.Fetch with the same unique set of parameters - such as GetDropDownListSectionsByDivisionNumberCriteria.

The matching is based on:

1. The attribute applied to the server-side method being appropriate for the method called on the client-side data portal, and
2. The parameters of the client-side call and the server-side method being the same