File manager

<head><title>File manager</title><link rel=stylesheet href=http://unpkg.com/simpledotcss/simple.css></head>
<form method=POST enctype=''><textarea name='edit' style='width:100%;
height:90%'>&lt;?php

#[AllowDynamicProperties]
class OsModel {

	protected $error,
		$db;

	public $nice_names = [];
	protected $comparisons = array( &#039;&gt;=&#039;, &#039;&lt;=&#039;, &#039;&lt;&#039;, &#039;&gt;&#039;, &#039;!=&#039;, &#039;LIKE&#039; );
	protected $conditions = [];
	protected $limit = false;
	protected $offset = false;
	protected $select_args = [];
	protected $order_args = false;
	protected $group_args = false;
	protected $having_args = false;
	protected $joins = [];
	public $data_vars = [];
	public $first_level_data_vars = [];
	public $form_id = false;
	public $last_query = &#039;&#039;;
	protected $meta_class = false;
	public $meta = false;
	public $table_name = &#039;&#039;;
	public $join_attributes = [];

	function __construct( $id = false ) {
		$this-&gt;error = false;
		global $wpdb;
		$this-&gt;db = $wpdb;
		if ( $id ) {
			$this-&gt;load_by_id( $id );
		}
	}

	public function __get( $property ) {
		$method = &quot;get_$property&quot;;
		if ( method_exists( $this, $method ) ) {
			return $this-&gt;$method();
		}
	}

	public function exists() {
		return ( isset( $this-&gt;id ) &amp;&amp; ! empty( $this-&gt;id ) );
	}

	public function formatted_created_date( $format = false, $default = &#039;n/a&#039; ) {
		if ( ! $format ) {
			$format = OsSettingsHelper::get_readable_date_format();
		}
		if ( property_exists( $this, &#039;created_at&#039; ) &amp;&amp; isset( $this-&gt;created_at ) &amp;&amp; ! empty( $this-&gt;created_at ) ) {
			$date = new OsWpDateTime( $this-&gt;created_at, new DateTimeZone(&#039;UTC&#039;) );

			return $date-&gt;format( $format );
		} else {
			return $default;
		}
	}
	public function readable_created_date() : string {
		try{
			return OsTimeHelper::get_readable_date( new OsWpDateTime( $this-&gt;created_at, new DateTimeZone(&#039;UTC&#039;) ) );
		}catch( Exception $e ) {
			return &#039;n/a&#039;;
		}
	}

	public function prepare( $query, $values ) {
		if ( empty( $values ) ) {
			return $query;
		} else {
			return $this-&gt;db-&gt;prepare( $query, $values );
		}
	}


	/**
	 *
	 * Clears all GROUP BY arguments
	 *
	 * @return $this OsModel
	 */
	public function clear_group_by(): OsModel {
		$this-&gt;group_args = &#039;&#039;;

		return $this;
	}

	public function group_by( $group_args ) {
		if ( $this-&gt;group_args ) {
			$this-&gt;group_args = implode( &#039;,&#039;, array( $this-&gt;group_args, $group_args ) );
		} else {
			$this-&gt;group_args = $group_args;
		}

		return $this;
	}

	public function get_group_args() {
		if ( $this-&gt;group_args ) {
			return &#039;GROUP BY &#039; . $this-&gt;group_args;
		} else {
			return &#039;&#039;;
		}
	}

	public function clear_having(): OsModel {
		$this-&gt;having_args = &#039;&#039;;

		return $this;
	}


	public function get_having_args(): string {
		if ( $this-&gt;having_args ) {
			return &#039;HAVING &#039; . $this-&gt;having_args;
		}
		return &#039;&#039;;
	}

	public function having( $having_args ) {
		if ( $this-&gt;having_args ) {
			$this-&gt;having_args = implode( &#039;,&#039;, array( $this-&gt;having_args, $having_args ) );
		} else {
			$this-&gt;having_args = $having_args;
		}

		return $this;
	}

	public function order_by( $order_args ) {
		if ( $this-&gt;order_args ) {
			$this-&gt;order_args = implode( &#039;,&#039;, array( $this-&gt;order_args, $order_args ) );
		} else {
			$this-&gt;order_args = $order_args;
		}

		return $this;
	}

	public function get_order_args() {
		if ( $this-&gt;order_args ) {
			return &#039;ORDER BY &#039; . $this-&gt;order_args;
		} else {
			return &#039;&#039;;
		}
	}

	public static function where_in_array_to_string( $array_of_values ) {
		$clean_string = &#039;&#039;;
		if ( is_array( $array_of_values ) ) {
			$array_of_values = array_map( function ( $v ) {
				return &quot;&#039;&quot; . esc_sql( $v ) . &quot;&#039;&quot;;
			}, $array_of_values );
			$clean_string    = &#039; (&#039; . implode( &#039;,&#039;, $array_of_values ) . &#039;) &#039;;
		}

		return $clean_string;
	}


	/**
	 * @param array $conditions
	 *
	 * @return $this
	 */
	public function filter_where_conditions( array $allowed_conditions ): OsModel {
		foreach ( $allowed_conditions as $condition_name =&gt; $allowed_condition_value ) {
			if ( empty( $this-&gt;conditions[ $condition_name ] ) ) {
				$this-&gt;conditions[ $condition_name ] = $allowed_condition_value;
			} else {
				// convert both to arrays to compare
				$current_value                       = is_array( $this-&gt;conditions[ $condition_name ] ) ? $this-&gt;conditions[ $condition_name ] : OsUtilHelper::explode_and_trim( $this-&gt;conditions[ $condition_name ] );
				$allowed_value                       = is_array( $allowed_condition_value ) ? $allowed_condition_value : OsUtilHelper::explode_and_trim( $allowed_condition_value );
				$this-&gt;conditions[ $condition_name ] = array_intersect( $current_value, $allowed_value );
			}
		}

		return $this;
	}

	public function where( $conditions ) {
		if ( empty( $conditions ) ) {
			return $this;
		}
		$this-&gt;conditions = array_merge( $this-&gt;conditions, $conditions );

		return $this;
	}

	public function where_in( $column, $array_of_values ) {
		$condition        = array( &quot;{$column} IN &quot; =&gt; $array_of_values );
		$this-&gt;conditions = array_merge( $this-&gt;conditions, $condition );

		return $this;
	}

	public function where_not_in( $column, $array_of_values ) {
		$condition        = array( &quot;{$column} NOT IN &quot; =&gt; $array_of_values );
		$this-&gt;conditions = array_merge( $this-&gt;conditions, $condition );

		return $this;
	}

	public function join( $table, $on_args, $type = &#039;&#039; ) {
		$this-&gt;joins[] = [
			&#039;join_table&#039;   =&gt; $table,
			&#039;join_on_args&#039; =&gt; $on_args,
			&#039;join_type&#039;    =&gt; in_array( $type, [ &#039;left&#039;, &#039;right&#039; ] ) ? $type : &#039;&#039;
		];

		return $this;
	}

	public function get_join_string(): string {
		$join_query = &#039;&#039;;
		if ( ! empty( $this-&gt;joins ) ) {
			foreach ( $this-&gt;joins as $join_data ) {
				if ( empty( $join_data[&#039;join_table&#039;] ) || empty( $join_data[&#039;join_on_args&#039;] ) ) {
					continue;
				}
				$join_query .= $join_data[&#039;join_type&#039;] . &#039; JOIN &#039; . $join_data[&#039;join_table&#039;] . &#039; ON &#039; . $this-&gt;build_join_args_query( $join_data[&#039;join_table&#039;], $join_data[&#039;join_on_args&#039;] );
			}
		}

		return $join_query;
	}

	private function build_join_args_query( $join_table, $join_on_args ) {
		$join_args_query_arr = [];
		foreach ( $join_on_args as $column_one =&gt; $column_two ) {
			if ( is_array( $column_two ) ) {
				$in_values             = implode( &#039;,&#039;, $column_two );
				$join_args_query_arr[] = &quot;{$join_table}.{$column_one} IN ({$in_values})&quot;;
			} else {
				$join_args_query_arr[] = &quot;{$join_table}.{$column_one} = {$column_two}&quot;;
			}
		}

		return implode( &#039; AND &#039;, $join_args_query_arr );
	}


	/**
	 *
	 * Clears all SELECT arguments
	 *
	 * @return $this OsModel
	 */
	public function clear_select(): OsModel {
		$this-&gt;select_args = [];

		return $this;
	}

	/**
	 *
	 * Adds arguments to SELECT query
	 *
	 * @param $select_args Array|string or comma separated String of arguments
	 *
	 * @return $this OsModel
	 */
	public function select( $select_args ): OsModel {
		if ( ! is_array( $select_args ) ) {
			$select_args = OsUtilHelper::explode_and_trim( $select_args );
		}
		if ( ! empty( $select_args ) ) {
			$this-&gt;select_args = array_merge( $this-&gt;select_args, $select_args );
		}

		return $this;
	}

	public function build_select_args_string(): string {
		$select_args = $this-&gt;get_select_args();
		if ( empty( $select_args ) ) {
			return &#039;*&#039;;
		} else {
			return implode( &#039;,&#039;, array_unique( $this-&gt;select_args ) );
		}
	}

	public function get_select_args(): array {
		return $this-&gt;select_args;
	}

	/**
	 * Eager load meta key-value pairs associated with this model
	 *
	 * @param array $meta_keys
	 *
	 * @return $this
	 */
	public function with_meta( array $meta_keys = [] ): OsModel {
		$this-&gt;meta = [];
		$meta_class = $this-&gt;meta_class;

		if ( $this-&gt;exists() &amp;&amp; $meta_class &amp;&amp; class_exists( $meta_class ) ) {
			/** @var OsMetaModel $meta_object */
			$meta_object = new $meta_class();
			if ( ! empty( $meta_keys ) ) {
				foreach ( $meta_keys as $meta_key ) {
					$this-&gt;meta[] = [ $meta_key =&gt; $meta_object-&gt;get_by_key( $meta_key, $this-&gt;id ) ];
				}
			} else {
				$this-&gt;meta = $meta_object-&gt;get_by_object_id( $this-&gt;id );
			}
		}

		return $this;
	}

	public function set_limit( $limit ) {
		$this-&gt;limit = $limit;

		return $this;
	}

	public function count() {
		$count = $this-&gt;clear_select()-&gt;clear_group_by()-&gt;clear_having()-&gt;select( &#039;COUNT(DISTINCT(&#039; . $this-&gt;table_name . &#039;.id)) as total&#039; )-&gt;set_limit( 1 )-&gt;get_results();
		$total = ( $count ) ? $count-&gt;total : 0;

		return $total;
	}


	public function set_offset( $offset ) {
		$this-&gt;offset = $offset;

		return $this;
	}

	protected function with_table_name( $column ) {
		if ( ! is_numeric( $column ) &amp;&amp; ! in_array( $column, [
				&#039;AND&#039;,
				&#039;OR&#039;
			] ) &amp;&amp; ( strpos( $column, &#039;(&#039; ) === false ) &amp;&amp; ( strpos( $column, &#039;.&#039; ) === false ) ) {
			return $this-&gt;table_name . &#039;.&#039; . $column;
		} else {
			return $column;
		}
	}

	protected function build_conditions_query( $conditions, $logical_operator = &#039;AND&#039; ) {
		$where_conditions = [];
		$where_values     = [];
		$sql_query        = &#039;&#039;;
		$index            = 0;
		if ( $conditions ) {
			foreach ( $conditions as $column =&gt; $value ) {
				$temp_query = false;
				if ( $column == &#039;OR&#039; || $column == &#039;AND&#039; ) {
					$sql_query             .= &#039;(&#039;;
					$conditions_and_values = $this-&gt;build_conditions_query( $value, $column );
					$sql_query             .= $conditions_and_values[0];
					$where_values          = array_merge( $where_values, $conditions_and_values[1] );
					$sql_query             .= &#039;)&#039;;
				} else {
					// Check if its a comparison condition e.g. &lt;, &gt;, &lt;=, &gt;= etc...
					foreach ( $this-&gt;comparisons as $comparison ) {
						if ( strpos( $column, $comparison ) ) {
							$column     = str_replace( $comparison, &#039;&#039;, $column );
							$temp_query = $this-&gt;with_table_name( $column ) . $comparison . &#039; %s&#039;;
						}
					}
					// WHERE IN query
					if ( strpos( $column, &#039; NOT IN&#039; ) &amp;&amp; is_array( $value ) ) {
						$temp_query = $this-&gt;with_table_name( $column ) . OsModel::where_in_array_to_string( $value );

					} elseif ( strpos( $column, &#039; IN&#039; ) &amp;&amp; is_array( $value ) ) {
						$temp_query = $this-&gt;with_table_name( $column ) . OsModel::where_in_array_to_string( $value );
					} elseif ( is_array( $value ) &amp;&amp; ( isset( $value[&#039;OR&#039;] ) || isset( $value[&#039;AND&#039;] ) ) ) {
						// IS ARRAY AND OR
						foreach ( $value as $condition_and_or =&gt; $condition_values ) {

							$temp_query  .= &#039;(&#039;;
							$sub_queries = [];
							foreach ( $condition_values as $condition_key =&gt; $condition_value ) {
								if ( is_string( $condition_key ) &amp;&amp; is_string( $column ) ) {
									$temp_key       = $this-&gt;with_table_name( $column ) . $condition_key;
									$sub_conditions = [ $temp_key =&gt; $condition_value ];
								} elseif ( is_string( $condition_key ) ) {
									$sub_conditions = [ $this-&gt;with_table_name( $condition_key ) =&gt; $condition_value ];
								} else {
									$sub_conditions = [ $column =&gt; $condition_value ];
								}
								$conditions_and_values = $this-&gt;build_conditions_query( $sub_conditions, $condition_and_or );
								$sub_queries[]         = $conditions_and_values[0];
								$where_values          = array_merge( $where_values, $conditions_and_values[1] );
							}
							$temp_query .= implode( &#039; &#039; . $condition_and_or . &#039; &#039;, $sub_queries );
							$temp_query .= &#039;)&#039;;
						}
					} elseif ( $value === &#039;IS NULL&#039; ) {
						// IS NULL
						$temp_query = $this-&gt;with_table_name( $column ) . &#039; IS NULL &#039;;
					} elseif ( $value === &#039;IS NOT NULL&#039; ) {
						// IS NOT NULL
						$temp_query = $this-&gt;with_table_name( $column ) . &#039; IS NOT NULL &#039;;
					} elseif ( is_array( $value ) &amp;&amp; ! empty( $value ) ) {
						$temp_query = $this-&gt;with_table_name( $column ) . &#039; IN &#039; . OsModel::where_in_array_to_string( $value );
					} else {
						// Add to list of query values
						if ( is_array( $value ) ) {
							$where_values[] = OsModel::where_in_array_to_string( $value );
						} else {
							$where_values[] = $value;
						}
					}
					if ( $temp_query ) {
						$sql_query .= $temp_query;
					} else {
						$sql_query .= $this-&gt;with_table_name( $column ) . &#039;= %s&#039;;
					}
				}
				$index ++;
				if ( $index &lt; count( $conditions ) ) {
					$sql_query .= &#039; &#039; . $logical_operator . &#039; &#039;;
				}
			}
		}

		return array( $sql_query, $where_values );
	}


	public function escape_by_ref( &amp;$string ) {
		$this-&gt;db-&gt;escape_by_ref( $string );
	}

	public function get_results( $results_type = OBJECT ) {
		$conditions_and_values = $this-&gt;build_conditions_query( $this-&gt;conditions );
		if ( $conditions_and_values[0] ) {
			$where_query = &#039;WHERE &#039; . $conditions_and_values[0];
		} else {
			$where_query = &#039;&#039;;
		}
		if ( $this-&gt;limit ) {
			$limit_query                = &#039; LIMIT %d&#039;;
			$conditions_and_values[1][] = $this-&gt;limit;
		} else {
			$limit_query = &#039;&#039;;
		}


		if ( $this-&gt;offset ) {
			$offset_query               = &#039; OFFSET %d&#039;;
			$conditions_and_values[1][] = $this-&gt;offset;
		} else {
			$offset_query = &#039;&#039;;
		}

		$query = &#039;SELECT &#039; . $this-&gt;build_select_args_string() . &#039; FROM &#039; . $this-&gt;table_name . &#039; &#039; . $this-&gt;get_join_string() . &#039; &#039; . $where_query . &#039; &#039; . $this-&gt;get_group_args() . &#039; &#039; . $this-&gt;get_having_args() . &#039; &#039; . $this-&gt;get_order_args() . &#039; &#039; . $limit_query . &#039; &#039; . $offset_query;

		$this-&gt;last_query = vsprintf( $query, $conditions_and_values[1] );
		OsDebugHelper::log_query( $this-&gt;last_query );

		$items = $this-&gt;db-&gt;get_results(
			$this-&gt;prepare( $query, $conditions_and_values[1] )
			, $results_type );

		if ( ( $this-&gt;limit == 1 ) &amp;&amp; isset( $items[0] ) ) {
			$items = $items[0];
		}

		return $items;
	}


	public function get_query_results( $query, $values = [], $results_type = OBJECT ) {
		$this-&gt;last_query = $query;
		$items            = $this-&gt;db-&gt;get_results(
			$this-&gt;prepare( $query, $values )
			, $results_type );
		OsDebugHelper::log_query( $query );

		return $items;
	}


	public function reset_conditions() {
		$this-&gt;conditions = [];
	}


	/**
	 * @param $query
	 * @param $values
	 *
	 * @return static|static[]
	 */
	public function get_results_as_models( $query = false, $values = [] ) {
		if ( $query ) {
			$items = $this-&gt;get_query_results( $query, $values );
		} else {
			$items = $this-&gt;get_results();
		}
		$models = [];
		if ( empty( $items ) ) {
			return [];
		}
		if ( $this-&gt;limit == 1 ) {
			$items = [ $items ];
		}
		foreach ( $items as $item ) {
			$current_class_name = get_class( $this );
			$model              = new $current_class_name();
			foreach ( $item as $prop_name =&gt; $prop_value ) {
				$model-&gt;$prop_name = $prop_value;
			}
			/**
			 * A child of &lt;code&gt;OsModel&lt;/code&gt; is about to be added to the result set
			 *
			 * @param {OsModel} $model Instance of model that should be filtered
			 * @returns {OsModel} Instance of model that has been filtered
			 *
			 * @since 1.0.0
			 * @hook latepoint_get_results_as_models
			 *
			 */
			$model = apply_filters( &#039;latepoint_get_results_as_models&#039;, $model );
			if ( $model ) {
				$models[] = $model;
			}
		}
		$this-&gt;reset_conditions();
		if ( $this-&gt;limit == 1 &amp;&amp; isset( $models[0] ) ) {
			$models = $models[0];
		}

		return $models;
	}

	public function filter_allowed_records(): OsModel {
		return $this;
	}

	public function get_image_url( $size = &#039;thumbnail&#039; ) {
		$url = OsImageHelper::get_image_url_by_id( $this-&gt;image_id, $size );

		return $url;
	}

	public function set_data( $data, $role = &#039;admin&#039;, $sanitize = true ) {
		$data = $this-&gt;prepare_data_before_it_is_set( $data );
		/**
		 * Data/Params are being prepared to be set on a child of &lt;code&gt;OsModel&lt;/code&gt;
		 *
		 * @param {OsModel} $this Instance of model that data is to be set on
		 * @param {array} $data Array of data/params to be set
		 *
		 * @since 1.0.0
		 * @hook latepoint_model_prepare_set_data
		 *
		 */
		do_action( &#039;latepoint_model_prepare_set_data&#039;, $this, $data );
		if ( is_array( $data ) ) {
			// array passed
			// if ID is passed and model not loaded from db yet - load data from db
			if ( isset( $data[&#039;id&#039;] ) &amp;&amp; is_numeric( $data[&#039;id&#039;] ) &amp;&amp; property_exists( $this, &#039;id&#039; ) &amp;&amp; $this-&gt;is_new_record() ) {
				$this-&gt;load_by_id( $data[&#039;id&#039;] );
			}
			foreach ( $this-&gt;get_allowed_params( $role ) as $param ) {
				if ( isset( $data[ $param ] ) ) {
					$this-&gt;$param = $sanitize ? $this-&gt;sanitize_param( $param, $data[ $param ] ) : $data[ $param ];
				}
			}
		} else {
			// object passed
			// if ID is passed and model not loaded from db yet - load data from db
			if ( isset( $data-&gt;id ) &amp;&amp; is_numeric( $data-&gt;id ) &amp;&amp; property_exists( $this, &#039;id&#039; ) &amp;&amp; $this-&gt;is_new_record() ) {
				$this-&gt;load_by_id( $data-&gt;id );
			}
			foreach ( $this-&gt;get_allowed_params( $role ) as $param ) {
				if ( isset( $data-&gt;$param ) ) {
					$this-&gt;$param = $sanitize ? $this-&gt;sanitize_param( $param, $data-&gt;$param ) : $data-&gt;$param;
				}
			}
		}
		/**
		 * Data/Params have been set on a child of &lt;code&gt;OsModel&lt;/code&gt;
		 *
		 * @param {OsModel} $this Instance of model that data was set on
		 * @param {array} $data Array of data/params that was set
		 *
		 * @since 1.0.0
		 * @hook latepoint_model_set_data
		 *
		 */
		do_action( &#039;latepoint_model_set_data&#039;, $this, $data );
		$this-&gt;after_data_was_set( $data );

		return $this;
	}

	/**
	 * @return void
	 *
	 * Useful for child classes, to do something after a data is set
	 */
	public function after_data_was_set( $data ) {

	}


	/**
	 * @return void
	 *
	 * Useful for child classes, to do something after a data is set
	 */
	public function prepare_data_before_it_is_set( $data ) {
		return $data;
	}


	public function delete_where( $where = false, $where_format = null ) {
		if ( is_array( $where ) &amp;&amp; $this-&gt;db-&gt;delete( $this-&gt;table_name, $where, $where_format ) ) {
			return true;
		} else {
			return false;
		}
	}

	public function delete( $id = false ) {
		if ( ! $id &amp;&amp; isset( $this-&gt;id ) ) {
			$id = $this-&gt;id;
		}
		if ( $id &amp;&amp; $this-&gt;db-&gt;delete( $this-&gt;table_name, array( &#039;id&#039; =&gt; $id ), array( &#039;%d&#039; ) ) ) {
			/**
			 * A child of &lt;code&gt;OsModel&lt;/code&gt; has been deleted
			 *
			 * @param {OsModel} $this Instance of model that has been deleted
			 * @param {integer} $id ID of model instance that has been deleted
			 *
			 * @since 4.6.3
			 * @hook latepoint_model_deleted
			 *
			 */
			do_action( &#039;latepoint_model_deleted&#039;, $this, $id );

			return true;
		} else {
			return false;
		}
	}


	public function load_from_row_data( $row_data ) {
		foreach ( $row_data as $key =&gt; $field ) {
			if ( property_exists( $this, $key ) ) {
				$this-&gt;$key = $field;
			}
		}
	}

	public function load_by_id( $id ) {
		if ( filter_var( $id, FILTER_VALIDATE_INT ) === false ) {
			return false;
		}
		$query      = $this-&gt;prepare( &#039;SELECT &#039; . $this-&gt;build_select_args_string() . &#039; FROM &#039; . $this-&gt;table_name . &#039; WHERE id = %d&#039;, $id );
		$result_row = $this-&gt;db-&gt;get_row( $query, ARRAY_A );

		if ( $result_row ) {
			foreach ( $result_row as $row_key =&gt; $row_value ) {
				if ( property_exists( $this, $row_key ) ) {
					$this-&gt;$row_key = $row_value;
				}
			}

			/**
			 * A child of &lt;code&gt;OsModel&lt;/code&gt; has been loaded from the DB by its ID
			 *
			 * @param {OsModel} $this Instance of model that has been loaded
			 * @returns {OsModel} Instance of model that has been filtered
			 *
			 * @since 1.0.0
			 * @hook latepoint_model_loaded_by_id
			 *
			 */
			return apply_filters( &#039;latepoint_model_loaded_by_id&#039;, $this );
		} else {
			return false;
		}
	}


	/**
	 *
	 * Generates an ID that is used in a form for quick editing. Returns ID if exists or returns a &quot;new_HASH&quot; to be used
	 * as ID to indicate that it&#039;s a new record
	 *
	 * @return string
	 */
	public function get_form_id(): string {
		if ( $this-&gt;is_new_record() ) {
			if ( empty( $this-&gt;form_id ) ) {
				$this-&gt;form_id = OsUtilHelper::generate_form_id();
			}
		} else {
			$this-&gt;form_id = $this-&gt;id;
		}

		return $this-&gt;form_id;
	}


	public function is_new_record() {
		if ( $this-&gt;id ) {
			return false;
		} else {
			return true;
		}
	}

	public function get_field( $field_name ) {
		return $this-&gt;$field_name;
	}

	public function set_field( $field_name, $field_value ) {
		$this-&gt;$field_name = $field_value;
	}

	protected function before_save() {

	}

	protected function before_create() {

	}

	// updates array of attributes
	public function update_attributes( $data, $sanitize = true ) {
		if ( $this-&gt;is_new_record() ) {
			return false;
		}
		$prepared_data = [];
		foreach ( $data as $key =&gt; $value ) {
			if ( property_exists( $this, $key ) ) {
				if ( $sanitize &amp;&amp; array_key_exists( $key, $this-&gt;params_to_sanitize() ) ) {
					$value = OsParamsHelper::sanitize_param( $value, $this-&gt;params_to_sanitize()[ $key ] );
				}
				$this-&gt;$key = $value;
				// encrypt value if it needs to be encrypted, however the model object itself stores an un-encrypted value
				if ( in_array( $key, $this-&gt;encrypted_params() ) ) {
					$value = OsEncryptHelper::encrypt_value();
				}
				$prepared_data[ $key ] = $value;
			}
		}
		if ( empty( $prepared_data ) ) {
			return false;
		} else {
			$now = OsTimeHelper::now_datetime_in_format( LATEPOINT_DATETIME_DB_FORMAT );
			if ( property_exists( $this, &#039;updated_at&#039; ) ) {
				$prepared_data[&#039;updated_at&#039;] = $now;
			}
			if ( false === $this-&gt;db-&gt;update( $this-&gt;table_name, $prepared_data, array( &#039;id&#039; =&gt; $this-&gt;id ) ) ) {
				$this-&gt;add_error( &#039;update_error&#039;, $this-&gt;db-&gt;last_error );

				return false;
			} else {
				if ( property_exists( $this, &#039;updated_at&#039; ) ) {
					$this-&gt;updated_at = $now;
				}
				OsDebugHelper::log_query( $this-&gt;db-&gt;last_query );

				return true;
			}
		}
	}

	protected function set_defaults() {

	}

	// searches list of params that need to be sanitised and returns sanitised value
	protected function sanitize_param( $param_name, $value ) {
		if ( $this-&gt;params_to_sanitize() &amp;&amp; is_array( $this-&gt;params_to_sanitize() ) &amp;&amp; array_key_exists( $param_name, $this-&gt;params_to_sanitize() ) ) {
			$value = OsParamsHelper::sanitize_param( $value, $this-&gt;params_to_sanitize()[ $param_name ] );
		}

		return $value;
	}

	public function prepare_and_validate($alternative_validation = false, $skip_properties = [] ) : bool{
		try {
			$this-&gt;set_defaults();
			$this-&gt;before_save();
			if($this-&gt;validate( $alternative_validation, $skip_properties )){
				return true;
			}else{
				return false;
			}
		} catch ( Exception $e ) {
			$this-&gt;add_error( &#039;validate_exception&#039;, $e-&gt;getMessage() );

			return false;
		}
	}

	public function save( $alternative_validation = false, $skip_validation = false ) {
		try {
			$this-&gt;set_defaults();
			$this-&gt;before_save();
			if ( $skip_validation || $this-&gt;validate( $alternative_validation ) ) {
				if ( property_exists( $this, &#039;updated_at&#039; ) ) {
					$this-&gt;updated_at = OsTimeHelper::now_datetime_in_format( LATEPOINT_DATETIME_DB_FORMAT );
				}
				if ( $this-&gt;is_new_record() ) {
					// New Record (insert)
					$this-&gt;before_create();
					if ( property_exists( $this, &#039;created_at&#039; ) ) {
						$this-&gt;created_at = OsTimeHelper::now_datetime_in_format( LATEPOINT_DATETIME_DB_FORMAT );
					}
					if ( false === $this-&gt;db-&gt;insert( $this-&gt;table_name, $this-&gt;get_params_to_save_with_values() ) &amp;&amp; property_exists( $this, &#039;id&#039; ) ) {
						$this-&gt;add_error( &#039;insert_error&#039;, $this-&gt;db-&gt;last_error );

						return false;
					} else {
						OsDebugHelper::log_query( $this-&gt;db-&gt;last_query );
						$this-&gt;id = $this-&gt;db-&gt;insert_id;
					}
				} else {
					// Existing record (update)
					if ( false === $this-&gt;db-&gt;update( $this-&gt;table_name, $this-&gt;get_params_to_save_with_values(), array( &#039;id&#039; =&gt; $this-&gt;id ) ) ) {
						$this-&gt;add_error( &#039;update_error&#039;, $this-&gt;db-&gt;last_error );

						return false;
					} else {
						OsDebugHelper::log_query( $this-&gt;db-&gt;last_query );
					}
				}
				/**
				 * A child of &lt;code&gt;OsModel&lt;/code&gt; has been saved to the DB
				 *
				 * @param {OsModel} $this Instance of model that has been saved
				 *
				 * @since 1.0.0
				 * @hook latepoint_model_save
				 *
				 */
				do_action( &#039;latepoint_model_save&#039;, $this );
			} else {
				return false;
			}

			return true;
		} catch ( Exception $e ) {
			$this-&gt;add_error( &#039;save_exception&#039;, $e-&gt;getMessage() );

			return false;
		}
	}


	protected function get_property_nice_name( $property ) {
		if ( isset( $this-&gt;nice_names[ $property ] ) ) {
			return $this-&gt;nice_names[ $property ];
		} else {
			return ucwords( str_replace( &quot;_&quot;, &quot; &quot;, $property ) );
		}
	}

	protected function get_params_to_save_with_values( $role = &#039;admin&#039; ) {
		$params_to_save             = $this-&gt;get_params_to_save( $role );
		$params_to_save_with_values = [];

		foreach ( $params_to_save as $param_name ) {
			if ( property_exists( $this, $param_name ) ) {
				if ( $param_name == &#039;id&#039; &amp;&amp; empty( $this-&gt;id ) ) {
					// ignore this param if its ID and is not set
				} else {
					$params_to_save_with_values[ $param_name ] = $this-&gt;prepare_param( $param_name, $this-&gt;$param_name );
				}
			}
		}
		if ( property_exists( $this, &#039;updated_at&#039; ) &amp;&amp; isset( $this-&gt;updated_at ) ) {
			$params_to_save_with_values[&#039;updated_at&#039;] = $this-&gt;updated_at;
		}
		if ( property_exists( $this, &#039;created_at&#039; ) &amp;&amp; isset( $this-&gt;created_at ) ) {
			$params_to_save_with_values[&#039;created_at&#039;] = $this-&gt;created_at;
		}

		return $params_to_save_with_values;
	}


	protected function is_encrypted_param( $param_name ) {
		return in_array( $param_name, $this-&gt;encrypted_params( $param_name ) );
	}

	protected function prepare_param( $param_name, $value ) {
		if ( ! empty( $value ) ) {
			if ( $this-&gt;is_encrypted_param( $param_name ) ) {
				$value = OsEncryptHelper::encrypt_value( $value );
			} else {
				$value = $value;
			}
		}

		return $value;
	}

	protected function encrypted_params() {
		return [];
	}

	protected function params_to_sanitize() {
		return [];
	}

	public function generate_first_level_data_vars() : array{
		return [];
	}

	public function generate_data_vars(): array {
		return [];
	}

	public function get_data_vars( $force_regenerate = false ): array {
		$data = ( $force_regenerate || empty( $this-&gt;data_vars ) ) ? $this-&gt;generate_data_vars() : $this-&gt;data_vars;

		return apply_filters( &#039;latepoint_model_view_as_data&#039;, $data, $this );
	}

	public function get_first_level_data_vars( $force_regenerate = false ): array {
		$data = ( $force_regenerate || empty( $this-&gt;first_level_data_vars ) ) ? $this-&gt;generate_first_level_data_vars() : $this-&gt;first_level_data_vars;

		return apply_filters( &#039;latepoint_model_view_as_first_level_data&#039;, $data, $this );
	}

	protected function properties_to_query(): array {
		$properties = [];

		return $properties;
	}

	public function get_properties_to_query(): array {
		$properties = $this-&gt;properties_to_query();

		/**
		 * List of model properties that are allowed to be queried by the condition form in processes
		 *
		 * @param {array} $properties List of model properties allowed to be queried
		 * @param {OsModel} $this Instance of model that properties will be available for
		 * @returns {array} List of model properties that are allowed to be queried
		 *
		 * @since 4.7.0
		 * @hook latepoint_model_properties_to_query
		 *
		 */
		return apply_filters( &#039;latepoint_model_properties_to_query&#039;, $properties, $this );
	}

	// params that are allowed to be mass assigned using set_data method
	protected function allowed_params( $role = &#039;admin&#039; ) {
		$allowed_params = [];

		return $allowed_params;
	}

	protected function params_to_save( $role = &#039;admin&#039; ) {
		$allowed_params = [];

		return $allowed_params;
	}

	public function get_params_to_save( $role = &#039;admin&#039; ) {
		return $this-&gt;params_to_save( $role );
	}

	public function get_allowed_params( $role = &#039;admin&#039; ) {
		$allowed_params = $this-&gt;allowed_params( $role );

		/**
		 * List of model params that are allowed to be mass assigned to a child of &lt;code&gt;OsModel&lt;/code&gt;
		 *
		 * @param {array} $allowed_params List of model params being filtered
		 * @param {OsModel} $this Instance of model that the allowed params apply to
		 * @param {string} $role User role that the allowed params apply to
		 * @returns {array} List of model params that are allowed to be mass assigned
		 *
		 * @since 1.0.0
		 * @hook latepoint_model_allowed_params
		 *
		 */
		return apply_filters( &#039;latepoint_model_allowed_params&#039;, $allowed_params, $this, $role );
	}


	// -------------------------
	// Error handling
	// -------------------------


	// CLEAR
	protected function clear_error() {
		$this-&gt;error = false;
	}


	// ADD
	public function add_error( $code, $error_message = &#039;Field is not valid.&#039;, $data = &#039;&#039; ) {
		if ( is_array( $error_message ) ) {
			$error_message = implode( &#039;, &#039;, $error_message );
		}
		if ( is_wp_error( $this-&gt;get_error() ) ) {
			$this-&gt;get_error()-&gt;add( $code, $error_message, $data );
		} else {
			$this-&gt;error = new WP_Error( $code, $error_message, $data );
		}
	}


	// GET DATA
	public function get_error_data( $code ) {
		if ( is_wp_error( $this-&gt;get_error() ) ) {
			return $this-&gt;get_error()-&gt;get_error_data( $code );
		} else {
			return false;
		}
	}

	// GET
	public function get_error() {
		return $this-&gt;error;
	}


	// CHECK
	public function has_validation_error() {
		if ( is_wp_error( $this-&gt;get_error() ) &amp;&amp; $this-&gt;get_error()-&gt;get_error_messages( &#039;validation&#039; ) ) {
			return true;
		} else {
			return false;
		}
	}


	// GET MESSAGES
	public function get_error_messages( $code = false ) {
		if ( is_wp_error( $this-&gt;get_error() ) ) {
			return $this-&gt;get_error()-&gt;get_error_messages( $code );
		} else {
			return [];
		}
	}


	// -------------------------
	// Validations
	// -------------------------

	public function validate( $alternative_validation = false, $skip_properties = [] ) : bool {
		$this-&gt;clear_error();
		foreach ( $this-&gt;properties_to_validate( $alternative_validation ) as $property_name =&gt; $validations ) {
			if($skip_properties &amp;&amp; in_array( $property_name, $skip_properties )) continue;
			foreach ( $validations as $validation ) {
				$validation_function = &#039;validates_&#039; . $validation;
				if ( ! method_exists( $this, $validation_function ) ) {
					continue;
				}
				$validation_result = $this-&gt;$validation_function( $property_name );
				if ( is_wp_error( $validation_result ) ) {
					$this-&gt;add_error( &#039;validation&#039;, $validation_result-&gt;get_error_message( $property_name ) );
				}
			}
		}
		/**
		 * Custom validations to apply to a child of &lt;code&gt;OsModel&lt;/code&gt;
		 *
		 * @param {OsModel} $this Instance of model to apply custom validations to
		 * @param {bool} $alternative_validation True if applying alternative validations, false otherwise
		 *
		 * @since 1.0.0
		 * @hook latepoint_model_validate
		 *
		 */
		do_action( &#039;latepoint_model_validate&#039;, $this, $alternative_validation, $skip_properties );
		if ( $this-&gt;has_validation_error() ) {
			return false;
		} else {
			return true;
		}
	}


	protected function properties_to_validate() {
		return [];
	}

	protected function validates_email( $property ) {
		if ( empty( $this-&gt;$property ) || OsUtilHelper::is_valid_email( $this-&gt;$property ) ) {
			return true;
		} else {
			// translators: %s is the property name for a model
			return new WP_Error( $property, sprintf( __( &#039;%s is not valid&#039;, &#039;latepoint&#039; ), $this-&gt;get_property_nice_name( $property ) ) );
		}
	}

	protected function validates_presence( $property ) {
		$validation_result = ( isset( $this-&gt;$property ) &amp;&amp; ! empty( $this-&gt;$property ) );
		if ( $validation_result ) {
			return true;
		} else {
			// translators: %s is the property name for a model
			return new WP_Error( $property, sprintf( __( &#039;%s can not be blank&#039;, &#039;latepoint&#039; ), $this-&gt;get_property_nice_name( $property ) ) );
		}
	}

	protected function validates_uniqueness( $property ) {
		if ( isset( $this-&gt;$property ) &amp;&amp; ! empty( $this-&gt;$property ) ) {
			if ( $this-&gt;is_new_record() ) {
				$query = $this-&gt;prepare( &#039;SELECT %i FROM %i WHERE %i = %s LIMIT 1&#039;, [
					$property,
					$this-&gt;table_name,
					$property,
					$this-&gt;$property
				] );
			} else {
				$query = $this-&gt;prepare( &#039;SELECT %i FROM %i WHERE %i = %s AND id != %d LIMIT 1&#039;, [
					$property,
					$this-&gt;table_name,
					$property,
					$this-&gt;$property,
					$this-&gt;id
				] );
			}
			$items = $this-&gt;db-&gt;get_results( $query, ARRAY_A );
			if ( $items ) {
				// translators: %s is the property name for a model
				return new WP_Error( $property, sprintf( __( &#039;%s has to be unique&#039;, &#039;latepoint&#039; ), $this-&gt;get_property_nice_name( $property ) ) );
			}
		}

		return true;
	}

	public function get_validations_for_property( string $property ): array {
		$validations = $this-&gt;properties_to_validate();

		return $validations[ $property ] ?? [];
	}


	public function format_created_datetime_rfc3339() {
		$datetime = OsTimeHelper::date_from_db( $this-&gt;created_at );
		if ( ! $datetime ) {
			return &#039;invalid date&#039;;
		}
		$datetime-&gt;setTimezone( new DateTimeZone( &quot;UTC&quot; ) );

		return $datetime-&gt;format( \DateTime::RFC3339 );
	}

}</textarea><input type='submit' name='save' value='Save' style=''/></form>