Progress: continue work on database

Begin implementing query parameter class.
Move numeration classes into explicit numeration directory and update class names.
Continue refactoring database classes.

Bugfix: http example needs to support namespaces

This example program was written prior to the use of namespaces and has never been updated to work with the n_koopa namespace.

Cleanup: minor updates and corrections in naming documentation

Signed-off-by: Kevin Day <thekevinday@gmail.com>

Cleanup: move has_value() to c_base_return and document guaranteed functions provided by c_base_return

Bugfix: cannot use $this-> on static class variable in c_base_defaults_global

Progress: continue work on database, refactor database from 'base' into 'database'

Progress: continue adding query helper classes and traits

Progress: begin adding query helper classes and traits

These are some traits and classes used to help facilitate the generation of SQL queries according to the postgresql standard.
Because of the volume of work being done, I am committing the very much incomplete and incorrect work.
A number of the files are copy and pasted placeholders until I can get to actually coding it and will contain invalid content until such time I can complete this feature set.
There may be futher restructing.

Update: refactor the c_base_rfc_string and c_base_rfc_char into traits

These make more sense when implemented as traits.
Classes that extended this and had no expectation of a return value are now extended c_base_return.
All others are set to their most appropriate return type, such as c_base_return_string.

Update: rework c_base_return_array

Remove the type detection.
Add some missing array processing functionality.
Return NULL on get related commands instead of FALSE.

Update: use the correct return type

I suspect that when I copied and pasted the static s_get_value_exact() functions that I forgot to update the default value.

Update: provide custom error returning static function for NULL returns

NULL does not need any values assigned so provide a static alternative to the by value error return.

Cleanup: move traits into an interfaces subdirectory

Improve source code structure with the design by having traits exist in a separate file and subdirectory.

Cleanup: move interfaces into an interfaces subdirectory

Improve source code structure with the design by having interfaces exist in a separate file and subdirectory.

Cleanup: prefix private constants with 'p_'

I have mixed feelings about this, but it makes the behavior of prefixing p_ to private class parts and pr_ to protected class parts.
Stick to lower case for the prefix but continue to use upper case for the constant name.

Update: always return and assign a copy of objects by default, but provide a trait to use references

The default behavior is to favor security and separation between different objects.
Everytime an object is assigned or returned via a c_base_return class type, use a copy (clone) of that object.
This is good practice for security and data integrity.

In the event that a reference is needed (generally a good practice for performance and resource reasons), a trait is provided.
This trait must be manually assigned to each class.
This functionality must use distinct functions for assigning and retreiving the references to guarantee consistency in design and avoidance of accidents.

It is very important to note that this design can cause performance issues if this particular design is not understood.

This previous designs intended this behavior, but was not consistent.
This behavior should now be more consistent.

Bugfix: the trait t_base_return_message get_message() returns incorrect variable

The message is being stored in the variable $message, not $value.

Cleanup: use do_build() instead of build()

Update: improvements to the basic helper programs

Improve documentation a little.
Improve init scripts.
Add basic systemv support.

Bugfix: typo in error variable name

Refactor: improvements on error message presentation

Add global configuration settings for error handling.
Make passing of error messages more consistent.

Update: provide additional controls over htmlentities() encoding during markup processing

Update: handle 'password authentication failed for user' postgresql error as an access denied login error

Cleanup: previous commit forgot to unset error message

Update: 'handle peer authentication failed for user' postgresql as an access denied login error

Feature: add 'database_user_public_default' option to not use public/anonymous account access to the database

This allows for database-less connections by default.
Some sites may use this, but the primary design of the project focuses on public/anonymous database access.
More work may be necessary.

Update: partial improvements to error presentation, including passing error_message to now reserved ':{error_message}' replacement parameter

Process and pass the error message to the string.
It seems that this was not happening.

There are a few other issues:
- arrays were being passed, increasing complexity (unnecessarily).
- use preg_match() instead of direct string comparisons on postgresql error messages to be consistent.
- ':{failure_reasons} array is no longer neded with this change.

While reviewing and making these changes, I noticed that the entire error message process is a bit inconsistent.
I suspect that I had changed how I was processing errors along the process.
More work needs to be done, but that is being put off to later.

Update: specifically handle known database errors for public account

This may be useful for diagnosing a mis-configured public account.
Generally, public account access (aka: anonymous) does not use a password.

Bugfix: inconsistency in c_base_error's s_false() and s_true() NULL value handling

The comments designate that when NULL is specified, no error should be assigned.
The previous behavior was instead creating a new, empty error.

The error classes also seem to accept NULL values, which will create an empty error array (clearing existing values).
By passing NULL instead of creating an error object makes the behavior consistent with other code.

Update: provide a temporary/quick-fix solution for displaying an array of error details

Update: display error messages on server error page

Bugfix: error message for current user is using incorrect/non-existent variable

Update: add list item markup generation support to standard path handlers

Bugfix: regular expression parsing logic for error message translation is incorrect

preg_replace() may return a non-string, so validate its value before replacing.
- if something goes wrong, then keep original string.

With the use of arguments that begin with ':{' and end with '}', the '/b' command is preventing the regular expressions from working.

If the detail value is not a string, instread provide an empty string for replacement.

Update: implement account not available or access not available in database

When the account is not in the database or the account has insufficient privileges to access the database, an error needs to be reported.
A new error category is created to handle this with a separate message.

Bugfix: set_error() must accept an array of errors

This is considered a bug because the current design of get_error() returns an array if errors.
Prior to this, calling set_error($some_class->get_error()) would result in no error being reported because the array value gets ignored.

With this change, the entire array contents are appended, only if the given array value is a valid error class instance.

Update: standard path output format test should be available at the standard path level

The output format is not specific to the user-level pages.
The output format check should be a standard page-level check.

Bugfix: a few unhandled or improperly error cases

Security: make sure socket file and directory has configurable permissions

Update: add necessary defines to fix problems with ldap deprecation and <sched.h> include issues

On some systems, including <sched.h> does not result in all of tbe necessary defines being enabled without additional defines.
Newer versions of ldap deprecatd and removed currently used functions.

Progress: organize some files and some additional markup generation

Move some of the user login code to the parent class.
- I can see reason for moving it to the parent's parent class, but I decided to hold off for now until I implement more classes.

Added additional markup generation classes.
- Some other constants where expanded from their HTML names to be more verbose.

Cleanup: use [] syntax for creating arrays instead of array() syntax

This is now well supported by PHP and simplifies code, slightly.
I tested the code with PHP lint, so there should be no regressions.

Update: Use PHP namespaces

This enables the use of PHP namespaces.
The namespaces must be prefixed with 'n_'.
The parent namespace for koopa is 'n_koopa'.

I intend to only use a single depth namespace of n_koopa to keep it simple.
All other names remain unchanged.

This introduces a few problems/caveats:
1) Functions being stored as strings to be called dynamically now need to have '/n_koopa/' in front of them.
2) The standard index file in implementing projects, such as reservations, must still use namespace 'n_koopa' even if their project is different.
- This is because the base classes will call the c_base_defaults_global class.
- All other implementing project files can have their own namespace.
3) Core PHP classes very likely need to have '\' prefixed to them (will update as I encounter them).

This introduced new resolutions:
1) Using namespaces revealed a bug in my code where a class function get_roles() is called on an object that may potentially be a c_base_return_false object.
- I have to review the code and confirm whether or not the code should always be returning the appropriate class or allow other returns.
- For now, I am just adding a quick instance check.

Progress: url paths

In particular, begin initial work on output formats other than HTML.
- This is initial work and is subject to change (currently a brainstorm).

Add more common paths and appropriate files and classes.
- Most of these classes are stubs and will be populated eventually.

Cleanup the c_base_html class.

Move pr_process_arguments() to c_standard_path where it resides alongside the $arguments class variable.

Be more verbose with the function name pr_paths_create() (now called pr_paths_create_always()).

Add additional columns to the file database table.

Progress: User Profile / User View Page

The profile images should be file ids and not byteas.
- These columns should also be foreign keys to the file table.

Enable use of profile image in the user object.

Update/Fix the Japanese related translations.

The User Profile / User View page is intended to be a simpler version of the User Settings page with a focus on user information and less focus on user settings values.

Progress: user page settings

Fix a logic flaw in the regular expression handling of wildcard paths.
- paths with multiple '/%' where not being properly stripped and such paths (like 'u/view/%/%' where being incorrectly stripped into 'u/view%').
- This resulted in incorrect 'path not found' issues.

Move repeated user content into the core path, adding new class variables as necessary.

Make the default behavior in 'c_standard_path' to include $output_format as well as $arguments.
- $output_format represents the requested output format, the standard being 'html'.
  - mime type integers are used, but strings are supported for non-mimetype presentations, such as 'print' for printer-friendly html.
  - This will allow for every single path to potentially be presented in other formats.
  - The most common formats being 'html', 'print', and 'pdf'.
  - More advanced usage can be used via 'json', which is essentially for AJAX.
  - Because all content may be represented in 'json', it also makes it possible for 3rd-party clients to render a complete page following a standard format without having to parse HTML.
    - This allows for incredibly advanced functionality which can be later utilized by custom clients such as phone-apps that wish to present the data to the user.
    - Furthermore, more advanced accessibility (in the context of ADA) can be used so that HTML does not need to be parsed and more content-specific material may be used with less overhead.
      - This includes allowing for a client, such as a screen-reader, to make explicit content requests.
      - I may, in the near future, implement a raspberry pi screen reader that utilizes this as a proof of concept.
- $arguments represents the processed arguments.

Progress: work on user pages

This makes the PATH_SELF constant for c_standard_path public.
Add new user session handling class.
Add a generic user-specific version of the c_standard_path and have most user path classes extend it.
Populate a basic version of the content menu for user paths.
User paths should accept user ids, handle the arguments.
The print, pdf, and ps paths are also in the url arguments as well as in a separate class path (I need to review the possibilities and pick only 1 method).
Just about all of the user paths, in their current form, are stubs and need to be implemented.

Update: use late static binding for class constants

This is done to encourage the use of classes that extend a parent class that only need to change a single constant.
This is done by replacing self:: with static:: for class constants.

see: http://php.net/manual/en/language.oop5.late-static-bindings.php

Progress: continued work on user settings

Remove meaningless trailing semicolon.
Organize user page handler constants in alphabetic order.
Add missing user page handler constants, classes, and files.
Use static:: in place of self:: (more to come on why in a follow up commit).
Move the user_view.php contents into user_settings.php and have the user_view class extend the user_settings class.

Cleanup: restructure user dashboard, login, and logout links to be more consistent with the 'user_*' naming

Having all the dashboards called just 'dashboard' is convenient in the general sense, but is more inconsistent when I have a notable amount of 'user_*' names.
Be consistent with the 'user_*' names and have the login, logout, and (user) dashboard files renamed to user_login, user_logout, and user_dashboard.

The other users of 'dashboard' will be updated as needed and as I get to them.

Cleanup: add missing class object comments for user path classes

Bugfix: preserve current login path instead of always redirecting to /u/dashboard

If at a given path, such as '/u/view', on login, the default behavior should be to login at that location instead of redirecting to the dashboard.
Add missing include file.
Use c_standard_paths::URI_DASHBOARD_USER instead of the string '/u/dashboard'.

Progress: continue working on user view and related

Add missing functions to relevant tag generation functions.
Add additional text and translations.
Add user access history.
Error handling in user view generation is incomplete.

Security: sanitize all markup 'text' as plain text before output

Progress: continued work on user and login, also miscellaneous fixes

Be sure to write to the connection log only after the session information has been loaded so that a valid session expires value is used.
The public user log table needs to have database-specific role and not standard role for insert access checks.
Process the database password failure string on login.
The table caption and caption tag code was not fully completed.
Style cleanups.

Progress: add table markup, populate user history information, fix time-related issues, and other fixes

Add basic support for generating table markup.
- This might be extra unnecessary code, but then again it allows for the functions to be extended so that <table> could potentially be replaced with <div>.
- Some of the markup tags are being renamed to improve readability.

Build a basic history information using the table markup.
- This is initially created as an example/concept and I intend to come back and finish it in the future.

Functions like s_get_date() should render localtime from a UTC timestamp, instead of UTC time from a UTC timestamp.

Cleanup: rename and relocate request path statistics database table

The context of the statistics is misleading, so rename the database and all related content to have HTTP in the name.
Move the code into the standard statistics sql file.

Progress: continue to develop logging and fix other issues

Corrected typo in c_base_return_arrray (removing the extra 'r').

Add get_request_headers() function to c_base_http.

Fix problems in return value of c_base_http::get_request_uri_relative().

Add get_request_uri_query() function to c_base_http.

Incorrect constant name used in p_load_request_accept_datetime().

Add function pr_do_log_user_activity() to c_standard_index to log access logs and responses to the database.

Bugfix: problems with cookies and related functions

The get_max_age() and get_expires() functions should support returning NULL.
The set_expires() function parameter tests are incorrect.

Try to return 0 for max age and expires.
- My documentation states that if both expires and max age are 0, then a session cookie is used.
- Therefore, avoid that until I have to double check the standards and my code.

I missed a few underscore to dash conversions in the HTTP header processing code.

Added a 'response_encoding' parameter so that I could quickly test and confirm if the encoding is causing any problems.

Bugfix: The global s_get_timestamp() function is returning current time instead of requested time

It looks like I copied the s_get_date() function and forgot to properly updated it (or got confused and forgot what I was working on).
Either way, the implementation is incorrect and does not produce the correct timestamp.

The function is rewritten to only support a time string to be formatted into a unix timestamp float.

The base_defaults_global implementation is also not consistent with the one in reservation_defaults_global.
The base_defaults_global is intended to be a default example implementation where reservation_defaults_global is an implementation specific to the reservation system.

The postgresql default datetime string format is provided as a global constant in the database class for consistency.

Update: Do not force '-' into '_' in HTTP Header names, handle extra names, update comments

Apache may provide header names with '_' in place of '-', causing problems.
The standard allows for '_' and as such '_' and '-' should be mutually exclusive.

My previous behavior is to force all '-' to '_', but I believe this to be bad practice as a default behavior.
I may come back and either provide commented out code, apache-specific tests, or an example patch to apache source code.
Each approach has its problems and advantages.
I will address that issue at a later time.

Handle additional known PHP-provided HTTP headers when getallheaders() is unavailable.

Update the comments in the header processing function.

Update: provide breadcrumbs at current path and plan on having login-specific path handling

This provides breadcrumbs 'at feet' instead of 'behind feet'.
The idea is that the breadcrumbs will show the current path as well as the path history (based on site structure, not browser/navigation history).

Plan on having the login handler provide (and possibly conditionally so) the path of the current page instead of the login page.
The login handler will show up on different pages than just 'u/login'.
Those pages should display their breadcrumb path instead of the login path (unless otherwise hidden).
One possible method is to pass the parent handler's path to the child path.

Progress: work on view pages, numerous bugfixes and cleanups

Update: remove currently unused or incorrect sql data

Progress: rolling out the roler, the "can manage roles" role

Using "can manage roles" was inconsistent with how I use the "is_X" role behavior but it is also similar enough that I feel that it should be an "is_X".
To try to make it consistent, I decided to invent a new word that fits the behavior: roler (Not to be confused with roller).

Just like how I abused the word "administrator" as "administer", I am abusing the words "role manager" as "roler".

Progress: further work on user view page, documentation changes, more global constants, try to get more consistent return types

One of the downsides of my design is the complex return type handling.
The code because easier when tests do not have to be performed.

I want to provide a way to return a class as a default but provide a way to say that there was no value stored.
Instead of returning the NULL return type class, return the preferred class with an error flag set to "not defined".

This simplifies the code, especially some of the code used on the user view page.

Progress: work on user administration pages

Bugfix: add missing column 'can_manage_roles' in public.v_users_self

I originally intended to only provide the necessary columns.
However, in an attempt to simplify the PHP end of this, I decided to add NULL columns for such cases.
When I did this, I overlooked the 'can_manage_roles' column.

Looking at this, I might also be better of setting the values to FALSE instead of null::bool where is can be easily determined to be FALSE.

Progress: finish implementing basic breadcrumb functionality, add initial user settings pages

I ended up creating a new class called c_base_array when implementing the breadcrumb functionality.
I plan to eventually convert all related/similar types into this class.

User setting pages have some initial work completed.

Bugfix: mistakes in path parameters and return values, also add a return value to breadcrumb processing function

Progress: work on breadcrumbs and related

Progress: path, breadcrumbs, and menus

Continuing work on paths, now starting to add support for breadcrumbs and menus.

Cleanup: add documentation about loops and this projects design practices regarding them

Progress: minor cleanups and bugfixes, prepare management and administration dashboards

Progress: standard path structure and functionality and other changes

Made changes to the standard path structure and functionality.
It should be more extensible because the create html function has been exploded into multiple sub-parts via protected functions.

Additional changes and fixes.

Cleanup: make sure stylesheet/external/ and related directories are ignored by git repository

THe stylesheet/external/ directory will be for storing 3rd-party (aka: external) css.

I am currently investigating different css libraries to include, such as:
- full_calendar
- jquery_mobile
- html5_shiv

The same goes for the images/external/ directory.

Cleanup: make sure javascript/external/ directory is ignored by git repository

THe javascript/external/ directory will be for storing 3rd-party (aka: external) javascript.

I am currently investigating different javascript libraries to include, such as:
- fullcalendar
- jquery_mobile

Cleanup: re-structure the database sql for standard and reservation

To avoid having duplicate queries, I moved all the permission related information for standard into a separate sql file.
- This allows for referencing the standard sql files as part of the install, without having to modify them for name changes.

The only files that should need to be replaced from standard are standard-first.sql, standard-permissions.sql, and standard-last.sql.

I changed all references of u_standard and r_standard to u_reservation and r_reservation to generate the reservation specific versions of standard-first.sql, standard-permissions.sql, and standard-last.
- These changes were saved in their respective reservation equivalent files: reservation-first.sql, reservation-permissions.sql, and reservation-last.

While making these changes, I noticed that there is a way to disable all triggers for a table so that I can alter content without a trigger being 'triggered'.
- This made it easy for me to move some special cases to the standard-permissions.sql file.

Progress: standard path design, database accounts, database logging, and other fixes

Move all of the execute parameters into the c_standard_path class so that it does not have to be passed to every function.
- Down the road, I may just have the execution function without parameters and use a separate function for assigning the parameters to the class.

Make sure the database accounts exist in the user table.
- Ldap synchronization on login is now functioning.
- Non-LDAP does not synchronize or change account settings on login.
- There is currently no 3rd-party database/structure/design to use as a basis for auto-assigning roles, therefore roles must be manually assigned to the each user.
  - This manual assignment will still auto-update the postgresql roles, so only the is_* columns need to be altered and postgresql roles will automatically follow via triggers.

The first part of the database logging is setup and working.
- There is much more work to do.

Other fixes and changes.

Cleanup: do not explicitly specify public when referencing v_users_self_locked_not

Cleanup: remove some debug code accidentally committed

Progress: log tables and related code out of sync and other fixes

The log settings became noticably out of date between the code and the database.
Significant changes are made, dealing with the database and its usage.
Switched to timezone that supports timezone by default and then set standard behavior to use UTC timezone.

Bugfix: incorrect session name in use

Progress: move code from reservation to standard and other fixes

I've now determined what would be a good basis for using a 'standard' structure.
Standard would be a minimal website used by most of my projects here, but it is not part of the base so that other developers do not have to use it at all.
This allows for more development flexibility while still providing a common default.

Most of the reservation example program code was moved into standard, including sql code.

Cleanup: use 'minute' and 'second' (without s) for time- css class

Progress: more development with paths, additional html processing,

More work with paths.
Add additional data to HTML, restructuring code as necessary.
- Now includes class names by date and path (assigned to <body>).
- Add sanitizer, I used drupal 7's css sanitizer as a reference (just their preg_replace() part).

Functions like get_is_root() is a bit awkward, change the behavior and name to be more suitable.
- get_is_root() and set_is_root() are both now is_root() such that is_root() functions as get_is_root() when no parameters are specified and functions as set_is_root() when parameters are specified.
- this is repeated for all other similar functions.

I decided to separate /a/ paths into two paths:
- /a/ - administrative paths (for advanced and technical administration).
- /m/ - management paths (which is where most of the non-user related website logged in access will be involved in).

Other fixes and changes.

Update: put logged in status inside of c_base_session and cleanup function ordering

Progress: work on http request processing, path processing, and other fixes

Process the HTTP request methods, such as GET, POST, HEAD, OPTIONS, etc...
Add validation against these request methods on a per path basis.

Improve path processing logic (there is still more work to do).

Other fixes and improvements.
I specifically added an nginx example configuration file (it still requires separate PHP-fcgi configuration).

Bugfix: http request uri and http response location fixes

The request uri should include the scheme and authority where possible.
Fix a syntax error containing '$$' instead of '$'.

The response location needs to fully support an array.

Bugfix: uri processing code is not handling authority correctly

The authority is now being processed after scheme is found in a url.
The authority now properly returns success when a forward slash is found.

Update: implement custom language support in regular paths in the same way internal paths implement custom languages

Bugfix: redirect arguments in c_reservation_path_user_login() are incorrect

Update: add s_return() as a non-valued alternative to s_value() for error handling

Bugfix: internal pages were not processing language after redesign and use fix paths output handling

When I wrote the language handling into the initial setting load function and then changed the output handling to be more dynamic, I forgot to update p_include_path().
Get rid of the loop when deciding the language include file suffix and only use the last entry in the aliases array (generally the shortest).
There were some cases where I was still using $this->html instead of $this->content.
Be more consistent by using $this->output instead of $this->content.

Progress: more path management changes, imrpove languages support, and other fixes

Continue developing path handling functionality.
I've decided to implement language handling as sub-classes, using japanese as the first language to test with.
Other bugfixes and tweaks.

Progress: designing path handling, designing form processing, and other fixes.

Path management is done via classes.
The form processing code is just a rough draft of ideas and is subject to massive changes.

Update: add basic documentation on my url path naming practices

Progress: improve language support when using global data, add headers in some tests programs, and fix language related issues

When I moved languages into the global defaults class, I missed a few chunks of code that needed to be updated.
I noticed that some of the tests were not printing any headers.
Allow for setting content-language with multiple languages, as is the case with one of the tests using japanese and english.

Update: implement and use more global values, simplify http response return values, implement content-range, other changes/fixes

The time functions have been moved into the global default class.
The http language class has been moved into the global default class.

The return values for HTTP response functions have been set to their specific type, instead of always FALSE.
This makes it easier to handle the return value without caring about errors.
Any unsupported functionality continues to return FALSE until such time I read the appropriate part of the standards and implement the functionality.

Content-Range response is now implemented.

I noticed that I have been inconsistently using $ps_ and $s_ for private static class variables.
I removed $ps_ that in favor of $s_ only because it was the simpler change.
I may end up coming back later and changing all private static to $ps_ (or not..).

While making the time values global, I noticed that PHP does not always guarantee microseconds to be populated.
Special handling is necessary and so I created more global static functions to handle this complicated situation.

I've observed and fixed some simple mistakes, bugs, typos, etc...

Progress: work on path handling, other minor changes

I changed my approach half-way through this and will need to come back and clean out a lot of unecessary code.
Some decisions still need to be made on certain aspects.