public virtual async Task <BaseResult <List <Supplier> > > Get()
        {
            BaseResult <List <Supplier> > supplierList = new BaseResult <List <Supplier> >();
            var list = await iSuppliers.GetListByPredicate(s => s.IsActive && !s.IsDeleted);

            if (list != null && list.Result != null && list.Result.Count > 0)
            {
                supplierList.Result = new List <Supplier>();
                foreach (var supplier in list.Result)
                {
                    var bankDetails = await iBank.GetListByPredicate(b => b.IsActive && !b.IsDeleted && b.SupplierId == supplier.Id);

                    var contactDetails = await iContacts.GetListByPredicate(b => b.IsActive && !b.IsDeleted && b.SupplierId == supplier.Id);

                    var paymentDetails = await iPayment.GetListByPredicate(b => b.IsActive && !b.IsDeleted && b.SupplierId == supplier.Id);

                    var userRelationList = await iUserRelation.GetListByPredicate(b => !b.IsDeleted && b.SupplierId == supplier.Id);

                    supplierList.Result.Add(new Supplier
                    {
                        MGSupplier          = supplier,
                        Banks               = (bankDetails.IsError == false && bankDetails.Result != null && bankDetails.Result.Count > 0) ? bankDetails.Result : null,
                        SupplierContacts    = (contactDetails.IsError == false && contactDetails.Result != null && contactDetails.Result.Count > 0) ? contactDetails.Result : null,
                        SupplierPayment     = (paymentDetails.IsError == false && paymentDetails.Result != null && paymentDetails.Result.Count > 0) ? paymentDetails.Result[0] : null,
                        SupplierCredentials = (userRelationList.IsError == false && userRelationList.Result != null && userRelationList.Result.Count > 0) ? userRelationList.Result : null,
                        FunctionEndpoints   = await GetSupplierFunctionEndpoints(supplier.Id),
                    });
                }
            }
            else
            {
                supplierList.IsError          = list.IsError;
                supplierList.ErrorCode        = list.ErrorCode;
                supplierList.ExceptionMessage = list.ExceptionMessage;
                supplierList.Message          = list.Message;
            }

            return(supplierList);
        }
        private async Task <List <FunctionSupplierRelationModel> > GetSupplierFunctionEndpoints(int supplierId)
        {
            var functionList = await iFunctions.GetListByPredicate(f => !f.IsDeleted);

            var supplierFunctionMapping = await iSuppliersFunctionsMapping.GetListByPredicate(f => !f.IsDeleted && f.SupplierId == supplierId);

            if (supplierFunctionMapping == null ||
                functionList == null ||
                supplierFunctionMapping.Result == null ||
                functionList.Result == null ||
                supplierFunctionMapping.Result.Count == 0 ||
                functionList.Result.Count == 0)
            {
                return(null);
            }

            List <FunctionSupplierRelationModel> result = new List <FunctionSupplierRelationModel>();

            foreach (var item in supplierFunctionMapping.Result)
            {
                result.Add(new FunctionSupplierRelationModel
                {
                    CreatedBy     = item.CreatedBy,
                    CreatedDate   = item.CreatedDate,
                    EndpointURL   = item.EndpointURL,
                    EnvironmentId = item.EnvironmentId,
                    FunctionId    = item.FunctionId,
                    FunctionName  = functionList.Result.Find(f => f.Id == item.FunctionId).Name,
                    IsDeleted     = item.IsDeleted,
                    LanguageID    = item.LanguageID,
                    SupplierId    = item.SupplierId,
                    UpdatedBy     = item.UpdatedBy,
                    UpdatedDate   = item.UpdatedDate
                });
            }

            return(result);
        }