if (scope.data.status) {			// only fields not NULL are in the data object, so check for existence
	if (scope.data.status == 'active') { ... }
}

if( scope.situation == 'SEARCH' ) return;      // other situation values are EDIT and CREATE
// ... additional script code

// Abbreviate with 'm' in the FormModel of the scope.
// You could just use 'scope.model' everywhere instead of 'm'.
var m=scope.model;
// We want to know if the active state changes
// To do so, we register an onchange handler function
m.aktiv.onchange=updateActiveState;
// The logic should also run when there are changes in the area, since we want to
// control the error state of the script here.
m.bereich.onchange=updateActiveState;
// When the weekly hours change, we want to know this for our calculation
m.weekhours.onchange=updateWeekdays;
// Here is the logic implementation for what happens when the active state changes
function updateActiveState() {
  // Track the current active state - as an abbreviation.
  var active = m.active.value;
   
  // Employee initials + status + employee number are required fields,
  // when the employee is active.
  m.emplshort.required      = active;
  m.status.required         = active;
  m.personnelno.required     = active;
   
  // The regulations cannot be changed as long as the employee is active.
  m.unbefristet.readonly        = active;
  m.zielvereinbarung.readonly   = active;
  m.altersvorsorge.readonly     = active;
   
  // Example for a deliberately-set validation error with relevant error message
  // take into account that the error message will be offered for non read-only fields!
  if( active && (!m.area.value || m.area.value=='') ) {
    m.area.error = {msg:'Ein aktiver Mitarbeiter muss einem Bereich zugeordnet sein.'};
  } else {
    // If the validation error does not occur, we may have to reset a previously-set error:
	if (scope.user) {
	    scope.model.area.error = null;
	}
    m.area.error = null;
  }
}
// Here we calculate the weekdays
function updateWeekdays() {
    m.weekdays.value=m.weekdays.value / 8;
}
// Since the active/not active logic should already apply during form initialization,
// we call the function here.
updateActiveState();

// 1st example: fill a selection list simply
var costcenter = scope.model.costcenter;
costcenter.setList({
	config: {			// configuration with respect to the behavior of the catalog fields 
		allelementsselectable: true,     // use false to only allow to select subentries
		valueField: 'costvalue',         //optional, if not given, the name 'value' is used
		subEntriesField: 'subentries',   //optional, if not given, the name 'entries' is used
        descriptionField: 'descr'        //optional, if not given, the name 'description' is used
	},
	entries: [    // prepare a tree
		{
            costvalue: '4711',
            subentries: [
                {
                    costvalue: '1',
					descr: "Value 1"
                },
                {
                    costvalue: '2',
					descr: "Value 2"
                }
            ]
        },
        {
            costvalue: '4712',
            subentries: [
                {
                    costvalue: '3',
					descr: "Value 3"
                },
				{
					costvalue: '4',
					descr: "Value 4"
				}
            ]
		}
	]
});

// 2nd example: first prepare a flat list variable and a reference to it
var cclist = [];              // this prepares the list 'cclist' with values to be passed to the field 'costcenter' as list 'entries'
for (j = 1; j < 10; j++) {
	for (i = 0; i < 1000; i++) {
		cclist.push({
			value: j*1001000 + i + 1 + ''   // the empty string at the end results in a string format of the value
		});	
	};
};

var costcenter = scope.model.costcenter;
costcenter.setList({
	config: {
		allelementsselectable: true     // optional, default is 'true'; if a hierarchical list is set to 'false', only leaves are selectable
	},
	entries: cclist
});

// 3rd example: lists can be filled by HTTP Request (see also later chapter)
// find in object type 'accounts' where in its field 'costcenter' the value of the variable 'costcenter' is given 
// and generate a list with the value of the fields 'accountno' and 'description
scope.api.dms.getResult({costcenter:costcenter.value},'accounts').then(         // remark: this must be 'then' because 'await' is currently not supported
	function(result) {
		var acnolist = [];
			result.forEach(function(row) {
				if( row.data.accountno ) {
					acnolist.push({
						value: row.data.accountno+' '+row.data.acdescription
					})
				}
			});
			accountno.setList({
				config: {
					allelementsselectable: true
				},
				entries: acnolist
			};
	}),
	function(error) {
		scope.api.util.notifier.error('Failed',error);
	}
);

// 2.b example for tables:

scope.model.etlapositions.onrowedit=function(table,row) {
	row.model.etlacostcenter.setList({
		config: {
			allelementsselectable: true
		},
		entries: [
			{
            	value: '4711'
	        },
    	    {
        	    value: '4712'
			}
		]
	}
}

// 4th example: filling the description depending on the user settings for 'definition language' and different entries for the form situation similar to the standard catalog behavior
var qadynlist = scope.model.myfieldname; 
var myRequest={};							// for search situation take all entries
if ( scope.situation == 'CREATE' ) { 
	 myRequest={create:true};				// for create situation take only those entries where the field 'create' is checked
}
if ( scope.situation == 'EDIT' ) {
	 myRequest={edit:true};					// for edit situation take only those entries where the field 'edit' is checked
}
scope.api.dms.getResult(myRequest,'qadynlist').then(       // remark: this must be 'then' because 'await' is currently not supported
	function(result) {
		var dynlist = [];
		result.forEach(function(row) {
			if( row.data.qavalue ) {
				dynlist.push({
					value: row.data.qavalue,
					description: row.data[scope.api.session.getUser().schemaLocale]    // this feature is available beginning with release 2017-09-13 (3.21.x)
				});
			};
		});
		qadynlist.setList({
			entries: dynlist
		});
	},
	function(error) {
		scope.api.util.notifier.error('Could not values',error);
	}
);

// 5th example: fill dynamic list with favorites data

scope.api.http.get('/service/user/favorites','/rest-ws').then(            // remark: this must be 'then' because 'await' is currently not supported
	function(result) {
	    var favslist=[];
		_.forEach(result.data, function(row) {          // row gets all relevant objects
			favslist.push({
				value: row.title
			});
		});
		scope.model.favoritslist.setList({
			config: {
				allelementsselectable: true
			},
			entries: favslist
		});
	},
	function(error) {
		scope.api.util.notifier.error('Failed to load favorites',error+'');
	}
)

var m=scope.model;
// The name of the date field is Deadline
var deadline=m.Deadline;


// Register the onchange handler
deadline.onchange=updateDeadlineState;


// Next is the logic for what we want to happen if the state changes
function updateDeadlineState() {
   
  if( isBeforeToday( deadline.value ) ) {
  	deadline.error = {msg:'Please select a date in the future.'};
  } else {
    // If the validation error does not occur, we may have to delete a previously-set error
    deadline.error = null;
  }
}
function isBeforeToday( pDate ) {
   
  // 
	var date = new Date();
	var today = moment(date).startOf('day');
	return moment(pDate).isBefore(today);
  
}

// allowed:
scope.model.datumfeld.value = new Date()
scope.model.datumfeld.value = moment().toDate()

// not allowed, sets the date one day into the past after save:
scope.model.datumfeld.value = moment();

scope.model.klasse.applyFilter(function(entry){
  return entry.data === 'Employee';
}) 

scope.model.klasse.applyFilter(null)

scope.model.mytablefield.onrowedit = function(table, row){
	row.model.mycodesystemfield.applyFilter(function(entry){
		return entry.data === 'foo';
	}) 
};

scope.model.class.applyDisablingFilter(function(entry){
  return entry.defaultrepresentation !== 'Employee';   // entry is disabled when condition is true
}); 

// set filter
scope.model.myOrgaField.setFilter({
	type: 'USER',                            // show only user elements
	groups: ['Employees', 'Accounting'],     // show only members of the listed groups
	roles: ['Trainer', 'Reviewer'],           // show only members of the listed roles
	activeonly: false						// controls whether or not only active users are listed
});

// remove filter
scope.model.myOrgaField.setFilter(null);

if(scope.context){
	scope.model.myidreferencefield.contextId = scope.context.id;
}

scope.model.responsibles.setQueryFilters({
	"personalakte.name": {
		o: 'eq',
		v1: 'Engel'
	}
})

scope.model.referenceddocs.setQueryFilters({
	"basisdocument.status": {
		o: 'eq',
		v1: 'active'
	}
}, ["contract", "statementofearnings"])

/**
 * Example script: Manipulating table data based on index data change.
 */
// Add change listener to field number
scope.model.number.onchange=function() {
     
    // The current user input on field with the internal name number
    var num = scope.model.number.value;
     
    // Shortcut to access the table
    var table = scope.model.changes;
     
    if(num>0 ) {
        // If number is set (greater than 0) we automatically fill the table
        if( !table.readonly ) {
            // The user may not modify the table
            table.readonly=true;
            // Copy the current values to a property using lodash
            table.old_value=_.map(table.value, _.clone);
        }
    } else {
        // If number is not set (less than 0) we let the user fill the table
        if( table.readonly ) {
            // Copy the old values back to values using lodash
            table.value=_.map(table.old_value, _.clone);
            // The user may modify the table
            table.readonly=false;
            // Cleanup
            delete table.old_value;
        }
    }
    // automatically fills the table if number is greater than 0
    // and add num rows to the table
    if(num>0) {
        // Clean up the table by setting a empty array
		table.value.length=0;   // changes of a single cell must be done in an array variable first, 
								// and then this array has to be pushed back to the table.
        for( i=0; i<num; i++ ) {
            // For each number add a row
            // Each row is an object defined by the internal names of the column elements.
            table.value.push(
                {
                    accepted: i%2,                              // Boolean
                    created: moment().add(i,'day').toDate(),        // Date
                    activedate: moment().add(i,'day').toDate(),     // Another date
                    author: 'Marie Curie '+i,                       // String: Author name with i postfix
                    prio: i+.42,                                    // Decimal
                    company : 'OSVH'                                // Codesystem - the 'data' values must be used.
                }
            )
        } // end for num
    } // end if num>0
}

// Example for row edit
// The 'scope.model.notices' element is a table type with a few columns.
// This example script tries to achieve that only new rows can be edited. New rows are rows that the user has not saved yet.
scope.model.notices.onrowedit=function(table,row) {
    // 'table' is the element, the callback event was triggered.
    // In this case the same as scope.model.notices. 'row' is the row object.
 
    // Show some information as a toast notification - just for demonstration
    scope.api.util.notifier.info("Editing table row","A row at index "+row.index+" is being edited.");
 
    // First we check whether the row is a new, not yet persisted, row, or an existing row
    if(!row.persisted) {
        // This is a row created by the user.
        // He is allowed to change it. So all table columns are set to be editable
        // by setting all row fields' readonly property (the column elements) to false.
        Object.keys(row.model).forEach( function(e) { e.readonly=false });
         
        // Delete/save is enabled by default, but the user is not allowed to copy the existing row as a new one.
        // So we switch off the copy function.
        row.copyEnabled = false;
    } else {
        // This is an already-saved row, so cell values are no longer editable, we have set them all to read only.
        Object.keys(row.model).forEach( function(e) { e.readonly=true });
         
        // Copy/delete/save are all disabled. The user can only 'cancel' the row editing. Nothing else.
        row.copyEnabled = false;
        row.deleteEnabled = false;
        row.saveEnabled = false;
    }
}

scope.model.mytable.onrowedit = function(table, row){
	// On this element we register a value change handler
	row.model.number.onchange = function(el, rowmodel) {	
		// The rowmodel provides access to the other elements
		// 'number2' is another element of type 'NUMBER' that is contained in the table element
		// For the sake of example this field is set to readonly, if the user inputs a special number in 'elementNumber'

		rowmodel.number2.readonly = ( el.value == 42 );
	}
}

scope.model.mytable.onrowedit = function(table, row){
	// On this element we register a value change handler.
	row.model.mybool.onchange = function(el, rowmodel) {
		// The rowmodel provides access to the other elements
		// 'myorg' is another element of type 'ORGANIZATION' that is contained in the table element.
		// We apply different filters, depending on the current value of 'myBool'
		if( rowmodel.mybool.value ) {
			rowmodel.myorg.setFilter({
				type: 'USER',              // show only user elements
				groups: ['Employees'],     // show only members of this group
			)};
		} else {
			rowmodel.myorg.setFilter({
				type: 'USER',              // show only user elements
				groups: ['Accounting'],    // show only members of this group
			)};	
		}
	}
}

var countries = scope.model.addresslist.onrowedit=function(table,row){
	row.model.country.onchange=function() {
		if(row.model.country.value === 'Germany'){
			row.model.zip.required=true;		// depending on value of country set a zip code as mandatory
		} else {
			row.model.zip.required=false;
		}
	}
}

// see Manipulating table data
...
let tableCopy = JSON.parse(JSON.stringify(table.value)); //create a copy
for ( i = 0; i < num; i++ ) {
	if (i === 0) {
			tableCopy[i].accepted = !i%2,                               // Boolean
            tableCopy[i].created = moment().add(i+5,'day').toDate(),    // Date
            tableCopy[i].activedate = moment().add(i+5,'day').toDate(), // Another date
			tableCopy[i].author = 'Pierre Curie '+i,                    // String: Author name with i postfix
            tableCopy[i].prio = i+.00,                                  // Decimal
            tableCopy[i].company = 'OSVH'                               // Codesystem - the 'data' values must be used.
	} else {
    	// For each number add a row
	    // Each row is an object defined by the internal names of the column elements.
    	tableCopy.push({
            	accepted: i%2,                              // Boolean
	            created: moment().add(i,'day').toDate(),    // Date
            	activedate: moment().add(i,'day').toDate(), // Another date
        	    author: 'Marie Curie '+i,                   // String: Author name with i postfix
    	        prio: i+.42,                                // Decimal
	            company: 'OSVH'                             // Codesystem - the 'data' values must be used.
    	    });
	}
	// do even more fancy data manipulations
} // end for num
table.value = tableCopy;
...
// see Manipulating table data

scope.model.addresslist.onchange=function(){

	if(scope.model.addresslist.value.length > 0){
		scope.model.addresslist.error = null;
    } else if (scope.model.addresslist.value.length == 0) {
		scope.model.addresslist.error = {msg:'At least one address must be given.'};
	}
}

var init = function(){
	if(scope.model.addresslist.value === null || scope.model.addresslist.value.length < 1){
		scope.model.addresslist.error = {msg:'Mindestens eine Adresse muss angegeben werden.'};
	}
}

init()

scope.model.checkbox.onchange = function(){
	scope.actions['1'].feasibility(!scope.actions['1'].feasibility());
};

If ( scope.objects[0].data.status == ‘active’) {
   Scope.model.responsibility.error = {msg: ‘Customer already set to active‘};
}

...
if( active && (!model.area.value || model.area.value=='') ) {
    model.area.error = {msg:'An active employee has to be assigned to an area.'};
} else {
  // if no validation error has occurred an error set before has to be reset
  model.area.error = null;
}
...

var objectcount = 0
if ( scope.objects ) {					// relevant if a process is started for one or more objects
	objectcount = scope.objects.length
}
scope.model.objectcount.value = objectcount;

if ( objectcount == 1) {
	scope.model.dmsdataboolean.value = false;
	scope.model.dmstype.value = scope.objects[0].type;
	scope.model.dmsid.value = scope.objects[0].id;    // this and the following are object attributes of type string
	scope.model.dmstitle.value = scope.objects[0].title;
	scope.model.dmsdescription.value = scope.objects[0].label;
	scope.model.dmscreator.value = scope.objects[0].created.by.title;
	scope.model.dmsmodifier.value = scope.objects[0].modified.by.title;
	scope.model.dmcreated.value = scope.objects[0].created.on;        // type ISO-String
	scope.model.dmsmodified.value = scope.objects[0].modified.on;     // type ISO-String
	if (scope.model.dmstype.value = 'myobjecttype') {
		scope.model.dmsdataname.value = scope.objects[0].data.myname;           // this and the following are object index fields
		scope.model.dmsdatadate.value = scope.objects[0].data.mydate;
		scope.model.dmsdatadatetime.value = scope.objects[0].data.mydatetime;
		scope.model.dmsdatainteger.value = scope.objects[0].data.myinteger;
		scope.model.dmsdatadecimal.value = scope.objects[0].data.mydecimal;
		scope.model.dmsdatacatalog1.value = scope.objects[0].data.mycatalog;
		scope.model.dmsdatausergroup.value = scope.objects[0].data.myusergroup;
		scope.model.dmsdataboolean.value = scope.objects[0].datamy.boolean
	} 
}

// usually, all form fields (scope.model) mapped to object field data are set to read-only by form design. The following fields are controlled by a Boolean field of the first object:  

if ( scope.model.dmsdataboolean.value == true ) {
	scope.model.value1.required = true;
	scope.model.value3.readonly = true
} else {
	scope.model.value1.readonly = true;
	scope.model.value3.required = true
}

scope.model.dmsaddtime.value = scope.objects[0].addtime,		// time at which the object was added to the process file; example: 1521534418927
scope.model.dmscreator.value = scope.objects[0].creator;		// string, login name of the user who added the object; example: 'johnson'
scope.model.dmstype.value = scope.objects[0].type;			// string, type of added object as configured in yuuvis® RAD designer; example: 'invoice'
scope.model.dmstitle.value = scope.objects[0].title;			// string, title format of the added object as configured in yuuvis® RAD designer; example: 'Invoice-no: 4711'
scope.model.dmsdescription.value = scope.objects[0].description;	// string, description format of the added object as configured in yuuvis® RAD designer; example: 'Delivered by: MyCompany'
scope.model.dmsid.value = scope.objects[0].id;					// string with the added object ID; example: '4AAB835352294DE0B359A05160B6C1BC'
scope.model.dmsiconid.value = scope.objects[0].iconid;		// string with the icon ID of added object; example: '8ED1E037E4D7468AB69EB8A04C2EA080'

return {
	exports : {
		markRequired: function(element) { element.required=true; }
	}
}

return {
	uses : ['FormUtils'],
	init: function(util) {
		util.markRequired(scope.model.vorname);
    }
}

//
// Example: Global Form Utilities
//
return {
    // Here we define the public exports. The exports are available to users of this global script.
    // You could implement the functions here, but instead we only declare them.
    // This is for readability and also adheres to the John Papa Style Guide for angular factories. See also https://github.com/johnpapa/angular-styleguide#style-y052
    exports : {
        toUpper : toUpper,
        toLower : toLower,
        forEachElement : forEachElement,
        hasAlias : hasAlias,
        onChangeOf : onChangeOf
    }
}
// Element value toUpperCase
function toUpper(el) {
    if( el.type==='STRING' && el.value) {
        el.value=el.value.toUpperCase();
    }
}
// Element value toLowerCase
function toLower(el) {
    if( el.type==='STRING' && el.value) {
        el.value=el.value.toLowerCase();
    }
}
// Goes through each element and calls the callback - optional filter
function forEachElement(callback, filter) {
    _.forEach(scope.model, function(el) {
        if( filter ) {
            if( filter(el) ) {
                callback(el);
            }
        } else {
            callback(el);
        }
    });
}
// Checks whether an alias exists
function hasAlias(el, searchalias) {
    var aliasFound = false;
    if( el.aliases ) {
        _.forEach(el.aliases, function(el) {
            if (el.indexOf(searchalias)==0) {
                aliasFound=true;
            }
        });
    }
    return aliasFound;
}
// Sets an onchange handler for an array of elements
function onChangeOf(elements, changecallback) {
    _.forEach(elements, function(element) {
        element.onchange = changecallback;
    });
}

//
// Example: Simple calculations
//
return {
    exports : {
        sum : buildSum,
        mul : buildMul
    }
}
function buildSum(elements) {
    var sum = 0;
    _.forEach(elements, function(el) {
        sum += el.value;
    });
    return sum;
}
function buildMul(elements) {
    if( !elements || elements.length==0 ) {
        return 0;
    }
     
    var sum = 1;
    _.forEach(elements, function(el) {
        sum *= el.value;
    });
    return sum;
}

return {
    uses : ['Utilities','Calculator'],
    init: function(util,calc) {
         
        // We track the model
        var m = scope.model;
         
        // Set some test values
        m.name.value='Feuerstein';
        m.vorname.value='Herbert';
         
        // Example: All values UPPPERCASE
        util.forEachElement(util.toUpper);
         
        // Example: Set certain fields with certain aliases to read-only.
        util.forEachElement(
            function(el) { el.readonly=true},                                   // This is the executed action.
            function(el) { return util.hasAlias( el, 'extract.OS:Title') }      // Filter: true when the alias exists.
        );
         
        // Example: If last or first name changes, change title.
        util.onChangeOf([m.name,m.vorname], updateTitle);
         
        // Example: Calculation with help function from the global script
        var sizeElements=[m.width,m.height];
        util.onChangeOf(sizeElements, updatePixel)  // If width or height changes -> updatePixel
        // Funktion: Pixel ausrechnen
        function updatePixel() {
            m.pixel.value=calc.mul(sizeElements);   // Pixel is the multiplication of the size fields.
        }
         
        // Function: Update title
        function updateTitle() {
            m.titel.value='Passfoto von "'+m.vorname.value+' '+m.name.value+'"';
        }
         
        // Execute function so that values are current.
        updateTitle();
        updatePixel();
         
    }
}

var task = {				// use the two-character DIN values for languages as attribute 
	de: 'Bitte, ...',
	en: 'Please, ...',
	ru: 'Пожалуйста, ...'
}
scope.model.Task.value = task[scope.api.session.getUser().schemaLocale];      // give the value depending on the user language setting for 'Definition' = schemalocale

var m=scope.model;
m.unlimited.onchange=function() {
	if( m.unlimited.value ) {	
		scope.api.util.notifier.success( 
			 m.firstname.value +' ' +m.familiyname.value+' is now employed without time limit.',		// Message
			'Personal information changed'   // optional: use a short title
		);
	}
}