Filter sections

Filter by value

curl https://mburger.cloud/api/blocks/<id>/sections?filter[value]=example_value
-H "Accept: application/json" 
-H "X-MBurger-Token: <token>" 
-H "X-MBurger-Version: 3"

let filterParameter = MBFilterParameter(field: "value",
                                        value: THE_VALUE)
MBClient.getSections(ofBlock: BLOCK_ID,
                     parameters: [filterParameter],
                     success: { sections in
                                
                     },
                     failure: { error in
                                
                     })

val arrayFilters = ArrayList<Any>()
filters.add(MBFilterParameter(key = THE_KEY, value = THE_VALUE))

val sectionsListener = object: MBSectionsResultListener{
            override fun onSectionsApiError(error: String) {
            }

            override fun onSectionsApiResult(sections: ArrayList<MBSection>, 
                                             block_id: Long, 
                                             paginationInfos: MBPaginationInfo) {
            }
        }
        
MBurgerTasks.askForSections(context = applicationContext, 
                         block_id = BLOCK_ID,
                         filters = arrayFilters,
                         getElements = true,
                         listener = sectionsListener)

const mburger = require('mburger');

const instance = mburger.createClient({
    api_key: "123456789asdfghj",
});

instance.getBlock({
    block_id: 799,
    filter: {
        'value': 'flowers'
    }
}).then(result => console.log(result));

MBFilterParameter filterParameter = MBFilterParameter(
  field: 'value',
  value: THE_VALUE,
);

MBPaginatedResponse<MBSection> sections =
    await MBManager.shared.getSections(
  blockId: BLOCK_ID,
  parameters: [filterParameter],
);

Filter by an element value

curl https://mburger.cloud/api/blocks/<id>/sections?filter[element.value]=example_value
-H "Accept: application/json" 
-H "X-MBurger-Token: <token>" 
-H "X-MBurger-Version: 3"

let filterParameter = MBFilterParameter(field: "value",
                                        name: ELEMENT_NAME,
                                        value: THE_VALUE)
MBClient.getSections(ofBlock: BLOCK_ID,
                     parameters: [filterParameter],
                     success: { (sections, paginationInfo) in
                                
                     },
                     failure: { error in
                                
                     })

val arrayFilters = ArrayList<Any>()
filters.add(MBElementFilterParameter(element_name= THE_ELEMENT_NAME, 
                                 value = THE_VALUE))

val sectionsListener = object: MBSectionsResultListener{
            override fun onSectionsApiError(error: String) {
            }

            override fun onSectionsApiResult(sections: ArrayList<MBSection>, 
                                             block_id: Long, 
                                             paginationInfos: MBPaginationInfo) {
            }
        }
        
MBurgerTasks.askForSections(context = applicationContext, 
                         block_id = BLOCK_ID,
                         filters = arrayFilters,
                         getElements = true,
                         listener = sectionsListener)

const mburger = require('mburger');

const instance = mburger.createClient({
    api_key: "123456789asdfghj",
});

instance.getBlock({
    block_id: 799,
    filter: {
        'value': 'element_name|element_value'
    }
}).then(result => console.log(result));

MBFilterParameter filterParameter = MBFilterParameter.named(
  field: 'value',
  name: ELEMENT_NAME,
  value: THE_VALUE,
);

MBPaginatedResponse<MBSection> sections =
    await MBManager.shared.getSections(
  blockId: BLOCK_ID,
  parameters: [filterParameter],
);

Filter by relation

curl https://mburger.cloud/api/blocks/<id>/sections?filter[relation]=<block_id>,<section_id>
-H "Accept: application/json" 
-H "X-MBurger-Token: <token>" 
-H "X-MBurger-Version: 3"

let filterParameter = MBFilterParameter(field: "relation",
                                        value: RELATION_BLOCK_ID + "," + RELATION_SECTION_ID)
MBClient.getSections(ofBlock: BLOCK_ID,
                     parameters: [filterParameter],
                     success: { (sections, paginationInfo) in
                                
                     },
                     failure: { error in
                                
                     })

val arrayFilters = ArrayList<Any>()
filters.add(MBFilterParameter(key = "relation", 
                                 value = RELATION_BLOCK_ID 
                                 + "," + RELATION_SECTION_ID))

val sectionsListener = object: MBSectionsResultListener{
            override fun onSectionsApiError(error: String) {
            }

            override fun onSectionsApiResult(sections: ArrayList<MBSection>, 
                                             block_id: Long, 
                                             paginationInfos: MBPaginationInfo) {
            }
        }
        
MBurgerTasks.askForSections(context = applicationContext, 
                         block_id = BLOCK_ID,
                         filters = arrayFilters,
                         getElements = true,
                         listener = sectionsListener)

const mburger = require('mburger');

const instance = mburger.createClient({
    api_key: "123456789asdfghjk",
});

instance.getBlock({
    block_id: 798,
    filter: {
        'relation': 'RELATION_BLOCK_ID,RELATION_SECTION_ID'
    }
}).then(result => console.log(result));

MBFilterParameter filterParameter = MBFilterParameter(
  field: 'relation',
  value: RELATION_BLOCK_ID + ',' + RELATION_SECTION_ID,
);

MBPaginatedResponse<MBSection> sections =
    await MBManager.shared.getSections(
  blockId: BLOCK_ID,
  parameters: [filterParameter],
);

Filter by geofence

curl https://mburger.cloud/api/blocks/<id>/sections?filter[geofence]=latNE,latSW,lngNE,lngSW
-H "Accept: application/json" 
-H "X-MBurger-Token: <token>" 
-H "X-MBurger-Version: 3"

let geofenceParameter = MBGeofenceParameter(NECoordinate: CLLocationCoordinate2D(NELat, NELng),
                                            SWCoordinate: CLLocationCoordinate2D(SWLat, SWLng))
MBClient.getSections(ofBlock: BLOCK_ID,
                     parameters: [geofenceParameter],
                     success: { (sections, paginationInfo) in
                                
                     },
                     failure: { error in
                                
                     })
}

val arrayFilters = ArrayList<Any>()
filters.add(MBGeofenceParameter(latitudeNE = yourLatitudeNE,
                                longitudeNE = yourLongitudeNE,
                                latitudeSW = yourLatitudeSW,
                                longitudeSW = yourLongitudeSW))

val sectionsListener = object: MBSectionsResultListener{
            override fun onSectionsApiError(error: String) {
            }

            override fun onSectionsApiResult(sections: ArrayList<MBSection>, 
                                             block_id: Long, 
                                             paginationInfos: MBPaginationInfo) {
            }
        }
        
MBurgerTasks.askForSections(context = applicationContext, 
                         block_id = BLOCK_ID,
                         filters = arrayFilters,
                         getElements = true,
                         listener = sectionsListener)

MBGeofenceParameter parameter = MBGeofenceParameter(
  northEastLatitude: NELat,
  northEastLongitude: NELng,
  southWestLatitude: SWLat,
  southWestLongitude: SWLng,
);
    
MBPaginatedResponse<MBSection> sections =
    await MBManager.shared.getSections(
  blockId: BLOCK_ID,
  parameters: [parameter],
);

Filter by id

curl https://mburger.cloud/api/blocks/<id>/sections?filter[id]=example_id
-H "Accept: application/json" 
-H "X-MBurger-Token: <token>" 
-H "X-MBurger-Version: 3"

/*
SECTION_ID can be a single id or a list of ids, comma separated.
*/
let filterParameter = MBFilterParameter(field: "id",
                                        value: SECTION_ID)
MBClient.getSections(ofBlock: BLOCK_ID,
                     parameters: [filterParameter],
                     success: { sections in
                                
                     },
                     failure: { error in
                                
                     })

val arrayFilters = ArrayList<Any>()
filters.add(MBFilterParameter(key = "id", 
                                 value = SECTION_ID))

val sectionsListener = object: MBSectionsResultListener{
            override fun onSectionsApiError(error: String) {
            }

            override fun onSectionsApiResult(sections: ArrayList<MBSection>, 
                                             block_id: Long, 
                                             paginationInfos: MBPaginationInfo) {
            }
        }
        
MBurgerTasks.askForSections(context = applicationContext, 
                         block_id = BLOCK_ID,
                         filters = arrayFilters,
                         getElements = true,
                         listener = sectionsListener)

const mburger = require('mburger');

const instance = mburger.createClient({
    api_key: "123456789asdfghjk",
});

instance.getBlock({
    block_id: 798,
    filter: {
        'id': '1,2,3'
    }
}).then(result => console.log(result));

/*
SECTION_ID can be a single id or a list of ids, comma separated.
*/
MBFilterParameter filterParameter = MBFilterParameter(
  field: 'id',
  value: SECTION_ID,
);
    
MBPaginatedResponse<MBSection> sections =
    await MBManager.shared.getSections(
  blockId: BLOCK_ID,
  parameters: [filterParameter],
);

PreviousAdvanced section retrieval NextObtain distance from a section

Last updated 4 years ago

Was this helpful?