Hello Community,

 

I'm trying to use the "Apply Filter" function to filter a lookup value based on three parameters. The business rule works correctly when adding a new record and copy record; however, when editing an existing record, only one filter is being triggered (marked).

 

 

Has anyone encountered this issue, and is there a solution to ensure all filters are applied when editing a record?

Like 0

Like

0 comments
Show all comments

Hello creatio community,

 

I am trying to apply a filter into cases mini page which is developed using freedom ui screens. Code as below:

{
	request: "crt.LoadDataRequest",
	handler: async (request, next) => {
 
		if(request.dataSourceName == "CaseDS_OPCaseType_4943d10_List_DS") {
			const caseType = await request.$context.CaseDS_OPCaseType_4943d10;
 
			var moduleTypesIds = await OPPermissionFunctionsSsp.getModuleTypes();
 
			const filter = new sdk.FilterGroup();
			if(moduleTypesIds.length > 0){
				filter.logicalOperation = sdk.LogicalOperatorType.Or;		
				for (let i = 0; i < moduleTypesIds.length; i++) {
					await filter.addSchemaColumnFilterWithParameter(sdk.ComparisonType.Equal, "Id", moduleTypesIds[i].value);
				}
			}
			else{
				await filter.addSchemaColumnFilterWithParameter(sdk.ComparisonType.Equal, "OPCode", '');
			}
 
			const newFilter = Object.assign({}, filter);
			newFilter.items = filter.items;
 
			request.parameters.push({
				type: "filter",
				value: newFilter
			});
		}
		return await next?.handle(request);
	}
}

 

The filter newFilter shows the right filter condition. I also used sql profiler and it returned the correct values. The issue here is that the CaseDS_OPCaseType_4943d10_List_DS lookup its not showing any value and does not apply the developed filter.

 

This issue happens only in the mini page. I have used this approach in freedom ui form pages and it works fine. Is there something I'm missing?

 

Kind regards

Like 0

Like

2 comments

I assume this is a dropdown lookup and not a lookup that opens the Select dialog? 

I just double-checked and I do have similar code to filter a dropdown on a Freedom UI mini page/dialog and it is working. I don't see anything that looks incorrect in the code you posted - just wanted to confirm that it does work on mini pages (at least in my case it is)

Show all comments

Dear colleagues,

 

I'm facing an issue with filtering records in a ListPage. I need to implement a cascading lookup relationship between two Quick Filters:

  1. Quick Filter 1 (QF1): Category
  2. Quick Filter 2 (QF2): Subcategory
  3.  

My goal is to dynamically update the options in QF2 based on the selected value in QF1. For instance, if the user chooses "Category A" in QF1, QF2 should only display the subcategories associated with "Category A.", 

 

If user in QF1 selects Category A & C, in QF2, just see SubCategories associated with "Category A & C"

 

Is this functionality possible?

 

Thank you for your help.

 

Julio Falcón

Like 2

Like

1 comments

Hi,

 

We have consulted with the product owners of this feature, and we are sure that this task can only be achieved using development.

Also, we have created a request for our developers to bring this functionality in future releases.

Thank you for this suggestion; it helps make our product better!

Show all comments

Hi community
I want to filter lookup field in detail of a page on the basis of record of another section and the page is in freedom UI and object of that detail is in classic UI
 

Like 0

Like

1 comments

Hello!

 

Thank you for submitting the post on the Community!

 

Could you please provide more details regarding your task so we can better understand what solution we can suggest?  

Show all comments

I am writing to request assistance with applying a filter on a lookup field within a detail while performing inline editing of a record on a Freedom UI page in Creatio. The object of this detail resides in the Classic UI.

Could you please provide guidance on how to achieve this functionality? Any examples, documentation, or step-by-step instructions would be greatly appreciated.

Thank you

Like 0

Like

1 comments

Hello,

 

Please note that this can be setup with the help of business rules, you can find the detailed instructions in this Academy article:
https://academy.creatio.com/docs/8.x/no-code-customization/customization-tools/ui-and-business-logic-customization/freedom-ui-business-rules


You can set it up either for the detail element or for the object itself, you can try the latter to achieve your business goal.

Show all comments

Hi Everyone,

I'm looking to filter a lookup value based on "StartDate" and "EndDate" column field which is present in the lookup object . I attempted to achieve this through the following handler code, where I compare the current date with the End Date. However, it didn't work. Does anyone know of a better approach to filter the lookup value?

Below is my handler code:

{

    request: "crt.LoadDataRequest",

    handler: async (request, next) => {

        // filter the contact lookup for the account

                     

        if (request.dataSourceName !== "LookupAttribute_jw8dbjp_List_DS") {

            return await next?.handle(request);

        }

        // Add filter for UsrEndDate not less than the current date

        const currentDate = new Date();

        const filter = new sdk.FilterGroup(sdk.ComparisonType.And);

        filter.addItem(sdk.Filter.createColumnFilterWithParameter(

            "UsrEndDate",

            sdk.ComparisonType.GreaterThanOrEqual,

            currentDate

        ));

        request.parameters.push({

            type: "filter",

            value: filter

        });

        return await next?.handle(request);

    }

}

Like 0

Like

1 comments

Hello,

Take a look at this discussion, in there you can find an example of how to configure and add a needed filter.

In order to get the exact filter you need, use the test list method described there.

Show all comments

How can we apply custom filters on Lookups in Freedom UI? I can see that there is some existence of a filtersConfig potential property for the object passed as the first parameter to executeRequest, but cannot find any examples or information on how this should be configured in Academy or on other Community questions. We are trying to use this to associate records to a parent record using the + button on a Freedom UI "detail" list, but we don't want any records already associated with any parent by foreign key to be eligible for association using the lookup, and also have some other conditions to apply based on the child entity. Our environment is currently on 8.1 Quantum.

 

Here is the relevant excerpt from the handler on our form page, without any filters applied and with the non-relevant logic applied in the afterClosed area removed for brevity:

request.$context.executeRequest({
	type: "crt.OpenLookupPageRequest",
	$context: request.$context,
	entitySchemaName: "Order",
	caption: "Select Quotes to associate with the Lead",
	features: {
		select: {
			multiple: true,
			selectAll: false,
			resultType: 'lookupValues'
		},
		create: {
			enabled: false
		}
	},
	afterClosed: async function(selectedItems) {
		// logic here
		return next?.handle(request)
	}
});

 

Like 0

Like

5 comments
Best reply

Hello,

Here is an example of OpenLookupPageRequest with a filtersConfig.

handlers: /**SCHEMA_HANDLERS*/[
			{
				request: "usr.OpenLookupRequest",
				handler: async (request, next) =&gt; {
					devkit.HandlerChainService.instance.process({
						type: "crt.OpenLookupPageRequest",
						scopes: [...request.scopes],
						$context: request.$context,
						entitySchemaName: "Contact",
						// caption: 'Responsible',
						schemaName: 'CustomLookupPage',
						itemAttributeName: 'LookupAttribute_2mnilrq',
						// itemsAttributeName: 'Contact_List',
						afterClosed: (result) =&gt; {
							alert(result?.displayValue ?? '');
						},
						filtersConfig: {
							filterAttributes: [
								{
									name: 'MyFilter',
									loadOnChange: false
								}
							],
							attributesConfig: {
								MyFilter: {
									value: {
										"items": {
											"29e16d42-36f1-4e04-9029-4321cbb2494d": {
												"filterType": 1,
												"comparisonType": 11,
												"isEnabled": true,
												"trimDateTimeParameterToDate": false,
												"leftExpression": {
													"expressionType": 0,
													"columnPath": "Name"
												},
												"isAggregative": false,
												"dataValueType": 1,
												"rightExpression": {
													"expressionType": 2,
													"parameter": {
														"dataValueType": 1,
														"value": "Super"
													}
												}
											}
										},
										"logicalOperation": 0,
										"isEnabled": true,
										"filterType": 6,
										"rootSchemaName": "Contact"
									}
								}
							}
						}
					});
					return next?.handle(request);
				}
			}
		]/**SCHEMA_HANDLERS*/,

If you don't know how to build a proper filter here is a small tip. On a Freedom UI page add a list with the object you want to filter. In this list add a static filter with a condition you want to apply to a OpenLookupPageRequest and save it. As a result, in the code of this page, you can find the full filter code, all you need to do is to replace "MyFilter" with it.

Hello,

Here is an example of OpenLookupPageRequest with a filtersConfig.

handlers: /**SCHEMA_HANDLERS*/[
			{
				request: "usr.OpenLookupRequest",
				handler: async (request, next) =&gt; {
					devkit.HandlerChainService.instance.process({
						type: "crt.OpenLookupPageRequest",
						scopes: [...request.scopes],
						$context: request.$context,
						entitySchemaName: "Contact",
						// caption: 'Responsible',
						schemaName: 'CustomLookupPage',
						itemAttributeName: 'LookupAttribute_2mnilrq',
						// itemsAttributeName: 'Contact_List',
						afterClosed: (result) =&gt; {
							alert(result?.displayValue ?? '');
						},
						filtersConfig: {
							filterAttributes: [
								{
									name: 'MyFilter',
									loadOnChange: false
								}
							],
							attributesConfig: {
								MyFilter: {
									value: {
										"items": {
											"29e16d42-36f1-4e04-9029-4321cbb2494d": {
												"filterType": 1,
												"comparisonType": 11,
												"isEnabled": true,
												"trimDateTimeParameterToDate": false,
												"leftExpression": {
													"expressionType": 0,
													"columnPath": "Name"
												},
												"isAggregative": false,
												"dataValueType": 1,
												"rightExpression": {
													"expressionType": 2,
													"parameter": {
														"dataValueType": 1,
														"value": "Super"
													}
												}
											}
										},
										"logicalOperation": 0,
										"isEnabled": true,
										"filterType": 6,
										"rootSchemaName": "Contact"
									}
								}
							}
						}
					});
					return next?.handle(request);
				}
			}
		]/**SCHEMA_HANDLERS*/,

If you don't know how to build a proper filter here is a small tip. On a Freedom UI page add a list with the object you want to filter. In this list add a static filter with a condition you want to apply to a OpenLookupPageRequest and save it. As a result, in the code of this page, you can find the full filter code, all you need to do is to replace "MyFilter" with it.

Question on OpenLookupPageRequest. In an edit scenario, could you pass the already selected options so that they appear already selected in the lookup list?

You can use the option selectionState to predefine selected rows, which will be pre-selected

type: "crt.OpenLookupPageRequest",
	...
	selectionState: {
		type: 'specific',
		selected: [
			'9d06bf9f-eb7a-4849-b83d-cbba994f185d',
			'49ba9a9e-2e28-48cb-b1bc-81b7871acb9d',
		],
	},

 

Dmytro Vovchenko,

 

Those are really useful, are there any other parameters that can be passed to the newly opened lookup page? I'm currently looking for a way to automatically set the initial search value of the lookup window, but I'm sure there are many other undocumented useful parameters like the selectionState that can be passed to a lookup page when opening it. A generic way to pass data into the page would be great!

 

I looked into passing a defaultSearchValue parameter into the request, but it didn't seem to affect the modal lookup.

Harvey Adcock,

 

Hello,

 

Here is all the available documentation we have:

 

Lookup window example:

In order to open the lookup window, you have to use crt.OpenSelectionWindowRequest

/**
&nbsp;* @publicApi
&nbsp;*/
@CrtRequest({
&nbsp; &nbsp; type: 'crt.OpenSelectionWindowRequest',
})
export class OpenSelectionWindowRequest extends BaseRequest {
&nbsp; &nbsp; public itemAttributeName?: string;
&nbsp; &nbsp; public itemsAttributeName?: string;
&nbsp; &nbsp; /**
&nbsp; &nbsp; &nbsp;* @publicApi
&nbsp; &nbsp; &nbsp;*/
&nbsp; &nbsp; public entitySchemaName?: string;
&nbsp; &nbsp; /**
&nbsp; &nbsp; &nbsp;* @publicApi
&nbsp; &nbsp; &nbsp;*/
&nbsp; &nbsp; public schemaName?: string;
&nbsp; &nbsp; /**
&nbsp; &nbsp; &nbsp;* @publicApi
&nbsp; &nbsp; &nbsp;*/
&nbsp; &nbsp; public filtersConfig?: FiltersConfig;
&nbsp; &nbsp; /**
&nbsp; &nbsp; &nbsp;* @publicApi
&nbsp; &nbsp; &nbsp;*/
&nbsp; &nbsp; public features?: PageLookupFeatures;
&nbsp; &nbsp; /**
&nbsp; &nbsp; &nbsp;* @publicApi
&nbsp; &nbsp; &nbsp;*/
&nbsp; &nbsp; public selectionState?: SelectionState;
&nbsp; &nbsp; /**
&nbsp; &nbsp; &nbsp;* @publicApi
&nbsp; &nbsp; &nbsp;*/
&nbsp; &nbsp; public afterClosed?: (result: SelectionWindowResult) =&gt; void;
&nbsp; &nbsp; /**
&nbsp; &nbsp; &nbsp;* @publicApi
&nbsp; &nbsp; &nbsp;*/
&nbsp; &nbsp; public caption?: LocalizableString;
}

Add the following code to your custom handler:

handlers: /**SCHEMA_HANDLERS*/[
			{
				request: "usr.OpenLookupRequest",
				handler: async (request, next) =&gt; {
					devkit.HandlerChainService.instance.process({
						type: "crt.OpenSelectionWindowRequest",
						scopes: [...request.scopes],
						$context: request.$context,
						entitySchemaName: "Contact",
						// caption: 'Responsible',
						schemaName: 'CustomLookupPage',
						itemAttributeName: 'LookupAttribute_2mnilrq',
						// itemsAttributeName: 'Contact_List',
						afterClosed: async (result) =&gt; {
							if (!result.canceled) {
								const lookupValues = await result.getLookupValues();
								const value = lookupValues[0];
								if (value) {
									alert(value?.displayValue ?? '');
								}
							}
						},
						filtersConfig: {
							filterAttributes: [
								{
									name: 'MyFilter',
									loadOnChange: false
								}
							],
							attributesConfig: {
								MyFilter: {
									value: {
										"items": {
											"29e16d42-36f1-4e04-9029-4321cbb2494d": {
												"filterType": 1,
												"comparisonType": 11,
												"isEnabled": true,
												"trimDateTimeParameterToDate": false,
												"leftExpression": {
													"expressionType": 0,
													"columnPath": "Name"
												},
												"isAggregative": false,
												"dataValueType": 1,
												"rightExpression": {
													"expressionType": 2,
													"parameter": {
														"dataValueType": 1,
														"value": "Super"
													}
												}
											}
										},
										"logicalOperation": 0,
										"isEnabled": true,
										"filterType": 6,
										"rootSchemaName": "Contact"
									}
								}
							}
						}
					});
					return next?.handle(request);
				}
			}
		]/**SCHEMA_HANDLERS*/,

where

 

entitySchemaName - the name of the entity schema whose data is displayed in the lookup window. Optional parameter. If not specified, the data source is taken from the attribute specified in itemAttributeName

 

caption - optional parameter, displayed in the window title. If caption is not specified, the caption is taken from the attribute specified in the itemAttributeName parameter. If itemAttributeName is not specified, then from the entity schema.

 

schemaName - the name of the schema that is displayed in the lookup window. Optional parameter. Default is BaseLookupPageTemplate

 

itemAttributeName - the name of the attribute from which the title is taken, the name of the entity schema and in which the result of the selection in the window will be written. Optional parameter. As a rule, this is the attribute with which the Combobox control is associated.

 

itemsAttributeName - the name of the attribute from which the data source name is taken. Optional parameter.

 

afterClosed - callback function returning the result of the selection in the window. Optional parameter.

 

filtersConfig-  describes the filter to be applied to the data. Optional parameter

 

PageLookupFeatures

 

Additionally, the user can specify additional features for the selection window.

export interface PageLookupFeatures {
&nbsp; &nbsp; create?: {
&nbsp; &nbsp; &nbsp; &nbsp; enabled: boolean;                         // false by default
&nbsp; &nbsp; };
    select: {
    &nbsp; &nbsp; multiple: boolean;                        // false by default
    &nbsp; &nbsp; selectAll: boolean;                       // false by default
    };
    showDeactivatedRecords?: boolean;
}

 

The user should provide the Create option as enabled to display the New button in the selection window (only for the FreedomUI host).

devkit.HandlerChainService.instance.process({
	type: "crt.OpenSelectionWindowRequest",
	scopes: [...request.scopes],
	$context: request.$context,
	....
	"features": {
		"create": {
            "enabled": true;
        }
	}
});

 

The New button in this window works best only in the Freedom UI shell. In the Classic UI, new record will be created, but the selection window will close after saving it without passing the created record selected value. If you want to use this window in the Classic UI, please consider it, or don’t show this button there.

 

SelectionWindowResult  type

export class SelectionWindowResult {
&nbsp; &nbsp; canceled: boolean; // indicates whether selection window was canceled by user
&nbsp; &nbsp; filter: FilterMetadata; // Filter 
&nbsp; &nbsp; async getLookupValues(options?: { pagingConfig: DataSourcePagingConfig }): Promise&lt;LookupValue[]&gt;; // method to get lookup values
}

where DataSourcePagingConfig is 

interface DataSourcePagingConfig {
&nbsp; &nbsp; rowsOffset: number;
&nbsp; &nbsp; rowCount: number;
}

example

devkit.HandlerChainService.instance.process({
	type: "crt.OpenSelectionWindowRequest",
	scopes: [...request.scopes],
	$context: request.$context,
	....
	"features": {
		"select": {
            "multiple": true;
        }
	},
	afterClosed: async (selectionWindowResult) =&gt; {
		const filter = selectionWindowResult.filter // getting filter
		// or 
		const lookupValues = await selectionWindowResult.getLookupValues(); // getting lookupValues
	}
});

 

Multiselection mode

 

To enable multiselection mode user should add next feature to OpenPageLookupRequest

devkit.HandlerChainService.instance.process({
	type: "crt.OpenSelectionWindowRequest",
	scopes: [...request.scopes],
	$context: request.$context,
	....
	features: {
		select: {
            "multiple": true
        }
	}
});

So afterClosed will look like this 

devkit.HandlerChainService.instance.process({
	type: "crt.OpenSelectionWindowRequest",
	scopes: [...request.scopes],
	$context: request.$context,
	....
	features: {
		select: {
			multiple: true
		}
	},
	afterClosed: async (selectionWindowResult) =&gt; {
		const lookupValues = await selectionWindowResult.getLookupValues();
		// do something with lookup values
	}
});

 

Select all


To enable the ability to select all records, you should add the next features to OpenPageLookupRequest.

devkit.HandlerChainService.instance.process({
	type: "crt.OpenSelectionWindowRequest",
	scopes: [...request.scopes],
	$context: request.$context,
	....
	features: {
		select: {
            multiple: true,
            selectAll: true
        }
	}
});

 

Canceled
 

Handling cases when the user presses the cancels Selection window

devkit.HandlerChainService.instance.process({
	type: "crt.OpenSelectionWindowRequest",
	scopes: [...request.scopes],
	$context: request.$context,
	....
	features: {
		select: {
			multiple: true
		}
	},
	afterClosed: (selectionWindowResult) =&gt; {
		const canceled = selectionWindowResult.canceled;
		if (canceled) {
			// do some logic when user canceled selection window
		}
	}
});

 

Selecting a special set of values


getLookupValues could be called with paging config where user can specify rowsOffset and rowCount to get a specific list of values

devkit.HandlerChainService.instance.process({
	type: "crt.OpenSelectionWindowRequest",
	scopes: [...request.scopes],
	$context: request.$context,
	....
	features: {
		select: {
			multiple: true
		}
	},
	afterClosed: async (selectionWindowResult) =&gt; {
		const pagingConfig = {
			rowsOffset: 2,
			rowCount: 2
		}
		const lookupValues = await selectionWindowResult.getLookupValues({ pagingConfig });
		// do something with received lookup values
	}
});

Example of iterating through lookupValues. Getting pair of 2 lookupValues with step of 2

devkit.HandlerChainService.instance.process({
	type: "crt.OpenSelectionWindowRequest",
	scopes: [...request.scopes],
	$context: request.$context,
	....
	features: {
		select: {
			multiple: true
		}
	},
	afterClosed: async (selectionWindowResult) =&gt; {
		let rowsOffset = 0;
        const rowCount = 2;
        const pagingConfig = { rowsOffset, rowCount };
        let lookupValues = await selectionWindowResult.getLookupValues({ pagingConfig });
        while (lookupValues.length) {
            /*
              fn(lookupValues); // do something with received lookupValues pair
            */
            rowsOffset += 2;
            lookupValues = await selectionWindowResult.getLookupValues({ pagingConfig: { rowsOffset, rowCount }});
        }
        if (!lookupValues.length) {
            /*
              Do some logic here on end of list - when there are no more lookupValues
            */
        }
	}
});

 

Selection state


and SelectionState is:

{
&nbsp; &nbsp; type: 'specific';
&nbsp; &nbsp; selected: unknown[]; // array of id's
}

 

So user can predefine selected rows, which will be pre-selected

devkit.HandlerChainService.instance.process({
	type: "crt.OpenSelectionWindowRequest",
	...
	selectionState: {
		type: 'specific',
		selected: [
			'9d06bf9f-eb7a-4849-b83d-cbba994f185d',
			'49ba9a9e-2e28-48cb-b1bc-81b7871acb9d',
		],
	},
});

 

showDeactivatedRecords


When set to true, deactivated entries of the object are shown.

 

This is all the information that we have on the lookup page handling cases, I hope it helps.

Show all comments

I have a problem filtering a lookup filed using Freedom UI.

The issue here:

The first lookup filed linked to the Contact entity

The second lookup filed's entity Account, contains a field "SMPrimaryAccountOwner" and it should be equal to the first filed value. 



Here is the filter:

 

{
				request: "crt.LoadDataRequest",
				handler: async (request, next) => {
					// filter the contact lookup for the account
					debugger;
					if(request.dataSourceName !== "LookupAttribute_emk4fel_List_DS") {
						return await next?.handle(request);
					}
 
 
					const account = await request.$context.LookupAttribute_r6avpkd;
					if (account) {
						const filter = new sdk.FilterGroup();
						await filter.addSchemaColumnFilterWithParameter(sdk.ComparisonType.Equal, "SMPrimaryAccountOwner.Id", account.value);
 
						// note, these lines are only needed due to an issue with filters in Creatio-DevKit SDK
						// expected to be fixed in Creatio 8.1
						//const newFilter = Object.assign({}, filter);
						//newFilter.items = filter.items;
 
						request.parameters.push({
							type: sdk.ModelParameterType.Filter,
							value: filter
						});
					}
 
					return await next?.handle(request);
 
				}
			}



And here is the error on the console:



 

Maybe anyone here had the same issue.

Like 0

Like

2 comments
Best reply

Try changing to just the field "SMPrimaryAccountOwner" and not the ".Id" part at the end.

await filter.addSchemaColumnFilterWithParameter(sdk.ComparisonType.Equal, "SMPrimaryAccountOwner", account.value);

Also, even if you're on 8.1 the commented lines are necessary - the issue that works around was *not* fixed in 8.1.

Ryan

Try changing to just the field "SMPrimaryAccountOwner" and not the ".Id" part at the end.

await filter.addSchemaColumnFilterWithParameter(sdk.ComparisonType.Equal, "SMPrimaryAccountOwner", account.value);

Also, even if you're on 8.1 the commented lines are necessary - the issue that works around was *not* fixed in 8.1.

Ryan

Try adding the filter for "SMPrimaryAccountOwner" and not "SMPrimaryAccountOwner.Id", as in: 

await filter.addSchemaColumnFilterWithParameter(sdk.ComparisonType.Equal, "SMPrimaryAccountOwner", account.value);

Also, the workaround that is commented out is still needed in 8.1. It was not fixed in 8.1.

Ryan

Show all comments

Hello community!

 

I am trying to filter some values of a lookup, and this is the error i get in the console

Does anyone know how can I fix it, or where it's coming from?

Thank you.

Like 0

Like

3 comments

Hi Nicolaiciuc,

 

Can you share the code that you have implemented to filter?

 

Regards,

Sourav

 

Sourav Kumar Samal,

Hello, here is my code:

 

"LbkNewSearchCollateralsInOpp": {

                "dataValueType": Terrasoft.DataValueType.LOOKUP,

                "lookupListConfig": {

                    "filters": [

                        function() {                        

                            // adding the filter to the detail

                            var parentProduct = this.get("OpportunityProductInterest");

                            var filterGroup = Ext.create("Terrasoft.FilterGroup");

                            if (parentProduct) {

                                var parentProductId = parentProduct.value;

                                var subFilters = this.Terrasoft.createFilterGroup();

                                

                                var esq = Ext.create("Terrasoft.EntitySchemaQuery", {

                                    rootSchemaName: "OpportunityProductInterest"

                                });

                                esq.addColumn("Opportunity");

                                esq.getEntity(parentProductId, function(result) {

                                if (result.success) {

                                   

                                    var opportunityId = result.entity.get("Opportunity").Id; 

                                    var newesq = Ext.create("Terrasoft.EntitySchemaQuery", {

                                        rootSchemaName: "LbkProductCollateralTypes"

                                    });

                                    newesq.addColumn("LbkProductCollateralTypesRemainingAllocation");

                                    

                                    var esqFilter = newesq.createColumnFilterWithParameter(Terrasoft.ComparisonType.EQUAL, "Opportunity.Id", opportunityId);

                                    newesq.filters.add(esqFilter);

                                    newesq.getEntityCollection(function (newresult) {

                                        if (newresult.success) {

                                          

                                                newresult.collection.each(function (item) {

                                                

                                                   

                                                    var defaultRemainingInBaseCollateral = item.values.LbkProductCollateralTypesRemainingAllocation;

                                                    console.log(defaultRemainingInBaseCollateral);

                                                    subFilters.addItem(this.Terrasoft.createColumnFilterWithParameter(

                                    Terrasoft.ComparisonType.GREATER, defaultRemainingInBaseCollateral, 0));

                                

                                filterGroup.add("Remaining value greater than 0",

                                                Terrasoft.createExistsFilter("[LbkCollateralsNew:LbkNewSearchCollateralsInOpp].Id",

                                                                                subFilters));                                                    

                                                

                                            });

                                        }

                                    }, this);

                                }

                            }, this);

                               

                                

                            }

                            return filterGroup;

                        }

                    ]

                }

            }

Nicolaiciuc Maria,

This won't work. The ESQ query you are attempting is asyncronous, meaning the filter function will return/complete before the ESQ has completed. You'll need to split this into two parts. One part will retrieve the values from LbkProductCollateralTypes and store them in an attribute on the page. This would be called in the onEntityInitialized. The idea is that you're pre-fetching the values from that object beforehand. Then, in the filter function, you'd be reading that attribute to construct and return the FilterGroup as needed, all synchronous since you've already pre-fetched the LbkProductCollateralTypes values in the onEntityInitialized. The filter function won't get called until the lookup is used, so the code in the onEntityInitialized will have completed before then and the LbkProductCollateralTypes values in the attribute will be available by then. Does that make sense? 

Ryan

Show all comments

Hello, community!

This is a selection window for my lookup. Lets take this example, I should not be able to select collaterals that have remaining allocation 0. My problem is that this field is being populated by a process, and the regular lookup filtration does not work. Is there any way to make that select button throw an error/ not let the user save their pick? As in, if remaining allocation equals 0 => select button will do nothing.

Like 0

Like

1 comments

Hello Maria,

Modifying this module window is quite a hard task to do. I believe is your case attribute filter will work just fine:

attributes: {
			"{Your lookup column Name}": {
                "dataValueType": Terrasoft.DataValueType.LOOKUP,
                "lookupListConfig": {
                    "filters": [
                        function() {
                            var filterGroup = Ext.create("Terrasoft.FilterGroup");
                            filterGroup.add("IsNotNull",
                                Terrasoft.createColumnFilterWithParameter(
                                    Terrasoft.ComparisonType.GREATER,
                                    "[{Your lookup column Name}:Id].RemainingAllocation", 0));
                            return filterGroup;
                        }
                    ]
                }
            }
		},

With these records where the remaining allocation is 0 will not be displayed.

Show all comments