Stalker

========

* Changed these default setting value names to corresponding new names:

* ``DEFAULT_TASK_DURATION`` -> ``TASK_DURATION``
* ``DEFAULT_TASK_PRIORITY`` -> ``TASK_PRIORITY``
* ``DEFAULT_VERSION_TAKE_NAME`` -> ``VERSION_TAKE_NAME``
* ``DEFAULT_TICKET_LABEL`` -> ``TICKET_LABEL``
* ``DEFAULT_ACTIONS`` -> ``ACTIONS``
* ``DEFAULT_BG_COLOR`` -> ``BG_COLOR``
* ``DEFAULT_FG_COLOR`` -> ``FG_COLOR``

* stalker.conf.defaults:

* Added default settings for project working hours (``WORKING_HOURS``,
``DAY_ORDER``, ``DAILY_WORKING_HOURS``)

* Added a new variable for setting the task time resolution called
``TIME_RESOLUTION``.

* stalker.models.project.Project:

* Removed Project.project_tasks attribute, use Project.tasks directly to get
all the Tasks in that project. For root task you can do a quick query::

Task.query.filter(Task.project==proj_id).filter(Task.parent==None).all()

This will also return the Assets, Sequences and Shots in that project,
which are also Tasks.

* Users are now assigned to Projects by appending them to the Project.users
list. This is done in this way to allow a reduced list of resources to be
shown in the Task creation dialogs.

* Added a new helper class for Project working hour management, called
WorkingHours.

* Added a new attribute to Project class called ``working_hours`` which holds
stalker.models.project.WorkingHours instances to manage the Project working
hours. It will directly be passed to TaskJuggler.

* stalker.models.task.Task:

* Removed the Task.task_of attribute, use Task.parent to get the owner of
this Task.

* Task now has two new attributes called Task.parent and Task.children which
allow more complex Task-to-Task relation.

* Secondary table name for holding Task to Task dependency relation is
renamed from ``Task_Tasks`` to ``Task_Dependencies``.

* check_circular_dependency function is now accepting a third argument which
is the name of the attribute to be investigated for circular relationship.
It is done in that way to be able to use the same function in searching for
circular relations both in parent/child and depender/dependee relations.

* ScheduleMixin:

* Added a new attribute to ScheduleMixin for time resolution adjustment.
Default value is 1 hour and can be set with
stalker.conf.defaults.TIME_RESOLUTION. Any finer time than the resolution
is rounded to the closest multiply of the resolution. It is possible to set
it from microseconds to years. Although 1 hour is a very reasonable
resolution which is also the default resolution for TaskJuggler.

* ScheduleMixin now uses datetime.datetime for the start and end attributes.

* Renamed the ``start_date`` attribute to ``start``.

* Renamed the ``end_date`` attribute to ``end``

* Removed the TaskableEntity.

* Asset, Sequence and Shot classes are now derived from Task class allowing
more complex Task relation combined with the new parent/child relation of
Tasks. Use Asset.children or Asset.tasks to reach the child tasks of that
asset (same with Sequence and Shot classes).

* stalker.models.shot.Shot:

* Removed the sequence and introduced sequences attribute in Shot class. Now
one shot can be in more than one Sequence. Allowing more complex
Shot/Sequence relations..

* Shots can now be created without a Sequence instance. The sequence
attribute is just used to group the Shots.

* Shots now have a new attribute called ``scenes``, holding Scene instances.
It is created to group same shots occurring in the same scenes.

* In tests all the Warnings are now properly handled as Warnings.

* stalker.models.ticket.Ticket:

* Ticket instances are now tied to Projects and it is now possible to create
Tickets without supplying a Version. They are free now.

* It is now possible to link any SimpleEntity to a Ticket.

* The Ticket Workflow is now fully customizable. Use
stalker.conf.defaults.TICKET_WORKFLOW dictionary to define the workflow and
stalker.conf.defaults.TICKET_STATUS_ORDER for the order of the ticket
statuses.

* Added a new class called ``Scene`` to manage Shots with another property.

* Removed the ``output_path`` attribute in FilenameTemplate class.

* Grouped the templates for each entity under a directory with the entity name.

========

* Users now can have more than one Department.

* User instances now have two new properties for getting the user tickets
(User.tickets) and the open tickets (User.open_tickets).

* New shortcut Task.project returns the Task.task_of.project value.

* Shot and Asset creation dialogs now automatically updated with the given
Project instance info.

* User overview page is now reflection the new design.

========

* The ``code`` attribute of the SimpleEntity is now introduced as a separate
mixin. To let it be used by the classes it is really needed.

* The ``query`` method is now converted to a property so it is now possible to
use it like a property as in the SQLAlchemy.orm.Session as shown below::

from stalker import Project
Project.query.all() instead of Project.query().all()

* ScheduleMixin.due_date is renamed to ScheduleMixin.end_date.

* Added a new class attribute to SimpleEntity called ``__auto_name__`` which
controls the naming of the instances and instances derived from SimpleEntity.
If ``__auto_name__`` is set to True the ``name`` attribute of the instance
will be automatically generated and it will have the following format::

{{ClassName}}_{{UUID4}}

Here are a couple of naming examples::

Ticket_74bb46b0-29de-4f3e-b4e6-8bcf6aed352d
Version_2fa5749e-8cdb-4887-aef2-6d8cec6a4faa

* Fixed an autoflush issue with SQLAlchemy in StatusList class. Now the status
column is again not nullable in StatusMixin.

========

* Added a new class called EntityType to hold all the available class names and
capabilities.

* Version class now has a new attribute called ``inputs`` to hold the inputs of
the current Version instance. It is a list of Link instances.

* FilenameTemplate classes ``path`` and ``filename`` attributes are no more
converted to string, so given a non string value will raise TypeError.

* Structure.custom_template now only accepts strings and None, setting it to
anything else will raise a TypeError.

* Two Type's for FilenameTemplate's are created by default when initializing
the database, first is called "Version" and it is used to define
FilenameTemplates which are used for placing Version source files. The second
one is called "Reference" and it is used when injecting references to a given
class. Along with the FilenameTemplate.target_entity_type this will allow one
to create two different FilenameTemplates for one class::

first get the Types
vers_type = Type.query()\
.filter_by(target_entity_type="FilenameTemplate")\
.filter_by(type="Version")\
.first()

ref_type = Type.query()\
.filter_by(target_entity_type="FilenameTemplate")\
.filter_by(type="Reference")\
.first()

lets create a FilenameTemplate for placing Asset Version files.
f_ver = FilenameTemplate(
target_entity_type="Asset",
type=vers_type,
path="Assets/{{asset.type.code}}/{{asset.code}}/{{task.type.code}}",
filename="{{asset.code}}_{{version.take_name}}_{{task.type.code}}_v{{'%03d'|version.version_number}}{{link.extension}}"
output_path="{{version.path}}/Outputs/{{version.take_name}}"
)

and now define a FilenameTemplate for placing Asset Reference files.
no need to have an output_path here...
f_ref = FilenameTemplate(
target_entity_type="Asset",
type=ref_type,
path="Assets/{{asset.type.code}}/{{asset.code}}/References",
filename="{{link.type.code}}/{{link.id}}{{link.extension}}"
)

* stalker.db.register() now accepts only real classes instead of class names.
This way it can store more information about classes.

* Status.bg_color and Status.fg_color attributes are now simple integers. And
the Color class is removed.

* StatusMixin.status is now a ForeignKey to a the Statuses table, thus it is a
real Status instance instead of an integer showing the index of the Status in
the related StatusList. This way the Status of the object will not change if
the content of the StatusList is changed.

* Added new attribute Project.project_tasks which holds all the direct or
indirect Tasks created for that project.

* User.login_name is renamed to User.login.

* Removed the ``first_name``, ``last_name`` and ``initials`` attributes from
User class. Now the ``name`` and ``code`` attributes are going to be used,
thus the ``name`` attribute is no more the equivalent of ``login`` and the
``code`` attribute is doing what was ``initials`` doing previously.

========

* Status class now has two new attributes ``bg_color`` and ``fg_color`` to hold
the UI colors of the Status instance. The colors are Color instances.

========

* SimpleEntity now has an attribute called ``generic_data`` which can hold any
kind of ``SOM`` object inside and it is a list.

* Changed the formatting rules for the ``name`` in SimpleEntity class, now it
can start with a number, and it is not allowed to have multiple whitespace
characters following each other.

* The ``source`` attribute in Version is renamed to ``source_file``.

* The ``version`` attribute in Version is renamed to ``version_number``.

* The ``take`` attribute in Version is renamed to ``take_name``.

* The ``version_number`` in Version is now generated automatically if it is
skipped or given as None or it is too low where there is already a version
number for the same Version series (means attached to the same Task and has
the same ``take_name``.

* Moved the User class to ``stalker.models.auth module``.

* Removed the ``stalker.ext.auth`` module because it is not necessary anymore.
Thus the User now handles all the password conversions by itself.

* ``PermissionGroup`` is renamed back to Group
again to match with the general naming of the authorization concept.

* Created two new classes for the Authorization system, first one is called
Permission and the second one is a Mixin which is called ACLMixin which adds
ACLs to the mixed in class. For now, only the User and Group classes are
mixed with this mixin by default.

* The declarative Base class of SQLAlchemy is now created by binding it to a
ORMClass (a random name) which lets all the derived class to have a method
called ``query`` which will bypass the need of calling
``DBSession.query(class_)`` but instead just call ``class_.query()``::

from stalker.models.auth import User
user_1 = User.query().filter_by(name='a user name').first()