Simplify configuration by using regexes.

Create an household context

See merge request Chill-Projet/chill-bundles!74

.gitlab-ci.yml

@@ -11,9 +11,10 @@ before_script:
   - PGPASSWORD=$POSTGRES_PASSWORD psql -U $POSTGRES_USER -h db -c "CREATE EXTENSION IF NOT EXISTS unaccent; CREATE EXTENSION IF NOT EXISTS pg_trgm;"
   # Install and run Composer
   - curl -sS https://getcomposer.org/installer | php
-  - php composer.phar install
+  - php -d memory_limit=2G composer.phar install
   - php tests/app/bin/console doctrine:migrations:migrate -n
-  - php tests/app/bin/console doctrine:fixtures:load -n
+  - php -d memory_limit=2G tests/app/bin/console doctrine:fixtures:load -n
+  - echo "before_script finished"
 
 # Bring in any services we need http://docs.gitlab.com/ee/ci/docker/using_docker_images.html#what-is-a-service
 # See http://docs.gitlab.com/ee/ci/services/README.html for examples.
@@ -38,4 +39,4 @@ variables:
 # Run our tests
 test:
   script:
-    - bin/phpunit --colors=never
+    - php -d memory_limit=3G bin/phpunit --colors=never

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

composer.json

@@ -1,9 +1,69 @@
 {
     "name": "chill-project/chill-bundles",
-    "license": "AGPL-3.0-only",
     "type": "library",
     "description": "Most used bundles for chill-project",
-    "keywords": ["chill", "social worker"],
+    "keywords": [
+        "chill",
+        "social worker"
+    ],
+    "license": "AGPL-3.0-only",
+    "require": {
+        "champs-libres/async-uploader-bundle": "dev-sf4",
+        "composer/package-versions-deprecated": "^1.10",
+        "doctrine/doctrine-bundle": "^2.1",
+        "doctrine/doctrine-migrations-bundle": "^3.0",
+        "doctrine/orm": "^2.7",
+        "drupol/php-conventions": "^5.0",
+        "erusev/parsedown": "^1.7",
+        "graylog2/gelf-php": "^1.5",
+        "knplabs/knp-menu": "^3.1",
+        "knplabs/knp-menu-bundle": "^3.0",
+        "knplabs/knp-time-bundle": "^1.12",
+        "league/csv": "^9.6",
+        "phpoffice/phpspreadsheet": "^1.16",
+        "sensio/framework-extra-bundle": "^5.5",
+        "symfony/asset": "4.*",
+        "symfony/browser-kit": "^5.2",
+        "symfony/css-selector": "^5.2",
+        "symfony/expression-language": "4.*",
+        "symfony/form": "4.*",
+        "symfony/intl": "4.*",
+        "symfony/monolog-bundle": "^3.5",
+        "symfony/security-bundle": "4.*",
+        "symfony/serializer": "^5.2",
+        "symfony/swiftmailer-bundle": "^3.5",
+        "symfony/templating": "4.*",
+        "symfony/translation": "4.*",
+        "symfony/twig-bundle": "^4.4",
+        "symfony/validator": "4.*",
+        "symfony/webpack-encore-bundle": "^1.11",
+        "symfony/workflow": "4.*",
+        "symfony/yaml": "4.*",
+        "twig/extra-bundle": "^2.12 || ^3.0",
+        "twig/intl-extra": "^3.0",
+        "twig/markdown-extra": "^3.3",
+        "twig/twig": "^2.12 || ^3.0"
+    },
+    "conflict": {
+        "symfony/symfony": "*"
+    },
+    "require-dev": {
+        "doctrine/doctrine-fixtures-bundle": "^3.3",
+        "fakerphp/faker": "^1.13",
+        "nelmio/alice": "^3.8",
+        "phpunit/phpunit": "^7.0",
+        "symfony/debug-bundle": "^5.1",
+        "symfony/dotenv": "^5.1",
+        "symfony/maker-bundle": "^1.20",
+        "symfony/phpunit-bridge": "^5.2",
+        "symfony/stopwatch": "^5.1",
+        "symfony/var-dumper": "4.*",
+        "symfony/web-profiler-bundle": "^5.0"
+    },
+    "config": {
+        "bin-dir": "bin",
+        "vendor-dir": "tests/app/vendor"
+    },
     "autoload": {
         "psr-4": {
             "Chill\\ActivityBundle\\": "src/Bundle/ChillActivityBundle",
@@ -21,69 +81,13 @@
     },
     "autoload-dev": {
         "psr-4": {
-          "App\\": "tests/app/src/"
+            "App\\": "tests/app/src/"
         }
     },
-    "require": {
-        "champs-libres/async-uploader-bundle": "dev-sf4",
-        "graylog2/gelf-php": "^1.5",
-        "symfony/form": "4.*",
-        "symfony/twig-bundle": "^4.4",
-        "twig/extra-bundle": "^2.12|^3.0",
-        "twig/twig": "^2.12|^3.0",
-        "composer/package-versions-deprecated": "^1.10",
-        "doctrine/doctrine-bundle": "^2.1",
-        "doctrine/doctrine-migrations-bundle": "^3.0",
-        "doctrine/orm": "^2.7",
-        "symfony/asset": "4.*",
-        "symfony/monolog-bundle": "^3.5",
-        "symfony/security-bundle": "4.*",
-        "symfony/translation": "4.*",
-        "symfony/validator": "4.*",
-        "sensio/framework-extra-bundle": "^5.5",
-        "symfony/yaml": "4.*",
-        "symfony/webpack-encore-bundle": "^1.11",
-        "knplabs/knp-menu": "^3.1",
-        "knplabs/knp-menu-bundle": "^3.0",
-        "symfony/templating": "4.*",
-        "twig/intl-extra": "^3.0",
-        "symfony/workflow": "4.*",
-        "symfony/expression-language": "4.*",
-        "knplabs/knp-time-bundle": "^1.12",
-        "symfony/intl": "4.*",
-        "symfony/swiftmailer-bundle": "^3.5",
-        "league/csv": "^9.6",
-        "phpoffice/phpspreadsheet": "^1.16",
-        "symfony/browser-kit": "^5.2",
-        "symfony/css-selector": "^5.2",
-        "twig/markdown-extra": "^3.3",
-        "erusev/parsedown": "^1.7",
-        "symfony/serializer": "^5.2"
-    },
-    "conflict": {
-        "symfony/symfony": "*"
-    },
-    "require-dev": {
-        "fakerphp/faker": "^1.13",
-        "phpunit/phpunit": "^7.0",
-        "symfony/dotenv": "^5.1",
-        "symfony/maker-bundle": "^1.20",
-        "doctrine/doctrine-fixtures-bundle": "^3.3",
-        "symfony/stopwatch": "^5.1",
-        "symfony/web-profiler-bundle": "^5.0",
-        "symfony/var-dumper": "4.*",
-        "symfony/debug-bundle": "^5.1",
-        "symfony/phpunit-bridge": "^5.2",    
-        "nelmio/alice": "^3.8"
-    },
     "scripts": {
         "auto-scripts": {
             "cache:clear": "symfony-cmd",
             "assets:install %PUBLIC_DIR%": "symfony-cmd"
         }
-    },
-    "config": {
-      "vendor-dir": "tests/app/vendor",
-      "bin-dir": "bin"
     }
 }

docs/source/_static/code/exports/CountPerson.php

@@ -14,7 +14,7 @@ use Chill\MainBundle\Export\FormatterInterface;
 use Doctrine\ORM\EntityManagerInterface;
 
 /**
- * 
+ *
  *
  * @author Julien Fastré <julien.fastre@champs-libres.coop>
  */
@@ -25,94 +25,95 @@ class CountPerson implements ExportInterface
      * @var EntityManagerInterface
      */
     protected $entityManager;
-    
+
     public function __construct(
             EntityManagerInterface $em
             )
     {
         $this->entityManager = $em;
     }
-    
+
     public function getType()
     {
         return Declarations::PERSON_TYPE;
     }
-    
+
     public function getDescription()
     {
         return "Count peoples by various parameters.";
     }
-    
+
     public function getTitle()
     {
         return "Count peoples";
     }
-    
+
     public function requiredRole()
     {
         return new Role(PersonVoter::STATS);
     }
-    
+
     public function initiateQuery(array $requiredModifiers,  array $acl, array $data = array())
     {
         // we gather all center the user choose.
         $centers = array_map(function($el) { return $el['center']; }, $acl);
-        
+
         $qb = $this->entityManager->createQueryBuilder();
-        
+
         $qb->select('COUNT(person.id) AS export_result')
                 ->from('ChillPersonBundle:Person', 'person')
                 ->join('person.center', 'center')
                 ->andWhere('center IN (:authorized_centers)')
                 ->setParameter('authorized_centers', $centers);
                 ;
-        
-        
+
+
         return $qb;
     }
-    
+
     public function getResult($qb, $data)
     {
         return $qb->getQuery()->getResult(Query::HYDRATE_SCALAR);
     }
-    
+
     public function getQueryKeys($data)
     {
         // this array match the result keys in the query. We have only
         // one column.
         return array('export_result');
     }
-    
+
     public function getLabels($key, array $values, $data)
     {
-        
-        // the Closure which will be executed by the formatter. 
+
+        // the Closure which will be executed by the formatter.
         return function($value) {
             switch($value) {
                 case '_header':
-                  // we have to process specifically the '_header' string, 
+                  // we have to process specifically the '_header' string,
                   // which will be used by the formatter to show a column title
                   return $this->getTitle();
                 default:
                   // for all value, we do not process them and return them
                   // immediatly
                   return $value;
+            };
         };
     }
-    
+
     public function getAllowedFormattersTypes()
     {
         return array(FormatterInterface::TYPE_TABULAR);
     }
-    
+
     public function buildForm(FormBuilderInterface $builder) {
         // this export does not add any form
     }
-    
+
     public function supportsModifiers()
     {
         // explain the export manager which formatters and filters are allowed
         return array(Declarations::PERSON_TYPE, Declarations::PERSON_IMPLIED_IN);
     }
-    
+
 }

docs/source/development/pagination/example.php

@@ -8,21 +8,21 @@ use Symfony\Component\HttpFoundation\Request;
 
 class ItemController extends Controller {
 
-    public function yourAction() 
+    public function yourAction()
     {
         $em = $this->getDoctrine()->getManager();
         // first, get the number of total item are available
         $total = $em
              ->createQuery("SELECT COUNT (item.id) FROM ChillMyBundle:Item item")
              ->getSingleScalarResult();
-       
+
         // get the PaginatorFactory
         $paginatorFactory = $this->get('chill_main.paginator_factory');
-        
-        // create a pagination instance. This instance is only valid for 
+
+        // create a pagination instance. This instance is only valid for
         // the current route and parameters
         $paginator = $paginatorFactory->create($total);
-        
+
         // launch your query on item. Limit the query to the results
         // for the current page using the paginator
         $items = $em->createQuery("SELECT item FROM ChillMyBundle:Item item WHERE <your clause>")
@@ -30,12 +30,12 @@ class ItemController extends Controller {
             ->setFirstResult($paginator->getCurrentPage()->getFirstItemNumber())
             // use the paginator to get the number of items to display
             ->setMaxResults($paginator->getItemsPerPage());
-            
+
         return $this->render('ChillMyBundle:Item:list.html.twig', array(
                 'items' => $items,
                 'paginator' => $paginator
-                );
-            
+                )
+        );
     }
 
 }

docs/source/development/timelines.rst

@@ -97,7 +97,7 @@ The has the following signature :
          * 
          * @param string $context
          * @param mixed[] $args the argument to the context.
-         * @return string[]
+         * @return TimelineSingleQuery
          * @throw  \LogicException if the context is not supported
          */
         public function fetchQuery($context, array $args);
@@ -163,18 +163,16 @@ The has the following signature :
 The `fetchQuery` function
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-The fetchQuery function help to build the UNION query to gather events. This function should return an associative array MUST have the following key :
+The fetchQuery function help to build the UNION query to gather events. This function should return an instance of :code:`TimelineSingleQuery`. For you convenience, this object may be build using an associative array with the following keys:
 
 * `id` : the name of the id column
 * `type`: a string to indicate the type
 * `date`: the name of the datetime column, used to order entities by date
-* `FROM` (in capital) : the FROM clause. May contains JOIN instructions
+* `FROM`: the FROM clause. May contains JOIN instructions
+* `WHERE`: the WHERE clause;
+* `parameters`: the parameters to pass to the query
 
-Those key are optional:
-
-* `WHERE` (in capital) : the WHERE clause. 
-
- Where relevant, the data must be quoted to avoid SQL injection.
+The parameters should be replaced into the query by :code:`?`. They will be replaced into the query using prepared statements.
 
 `$context` and `$args` are defined by the bundle which will call the timeline rendering. You may use them to build a different query depending on this context.
 
@@ -186,6 +184,15 @@ For instance, if the context is `'person'`, the args will be this array :
         'person' => $person //a \Chill\PersonBundle\Entity\Person entity
     );
 
+For the context :code:`center`, the args will be:
+
+.. code-block:: php
+
+    array(
+        'centers' => [ ]  // an array of \Chill\MainBundle\Entity\Center entities
+    );
+
+
 You should find in the bundle documentation which contexts are arguments the bundle defines.
 
 .. note::
@@ -199,13 +206,12 @@ Example of an implementation :
     namespace Chill\ReportBundle\Timeline;
 
     use Chill\MainBundle\Timeline\TimelineProviderInterface;
+    use Chill\MainBundle\Timeline\TimelineSingleQuery;
     use Doctrine\ORM\EntityManager;
 
     /**
      * Provide report for inclusion in timeline
      *
-     * @author Julien Fastré <julien.fastre@champs-libres.coop>
-     * @author Champs Libres <info@champs-libres.coop>
      */
     class TimelineReportProvider implements TimelineProviderInterface
     {
@@ -227,16 +233,17 @@ Example of an implementation :
                 
                 $metadata = $this->em->getClassMetadata('ChillReportBundle:Report');
                 
-                return array(
+                return TimelineSingleQuery::fromArray([
                    'id' => $metadata->getColumnName('id'),
                    'type' => 'report',
                    'date' => $metadata->getColumnName('date'),
                    'FROM' => $metadata->getTableName(),
-                   'WHERE' => sprintf('%s = %d',
+                   'WHERE' => sprintf('%s = ?',
                          $metadata
-                            ->getAssociationMapping('person')['joinColumns'][0]['name'],
-                         $args['person']->getId())
-                );
+                            ->getAssociationMapping('person')['joinColumns'][0]['name'])
+                         )
+                   'parameters' => [ $args['person']->getId() ]
+                ]);
             }
 
         //....

grumphp.yml

@@ -0,0 +1,22 @@
+imports:
+  - { resource: tests/app/vendor/drupol/php-conventions/config/php73/grumphp.yml }
+
+parameters:
+  tasks.license.name: AGPL-3.0
+  tasks.license.holder: Champs-Libres
+  tasks.phpstan.configuration: phpstan.neon
+  tasks.phpstan.ignore_patterns:
+    - /src\/Bundle\/(.*)\/migrations/
+    - /src\/Bundle\/(.*)\/Resources/
+    - /src\/Bundle\/(.*)\/Tests/
+    - /src\/Bundle\/(.*)\/Test/
+    - /src\/Bundle\/(.*)\/config/
+    - /src\/Bundle\/(.*)\/translations/
+    - /src\/Bundle\/(.*)\/DataFixtures/
+    - /^docs/
+    - /^tests/
+  skip_tasks:
+    - composer_require_checker
+    - phpcsfixer
+    - phpcs
+    - twigcs

phpstan.neon

@@ -0,0 +1,3 @@
+includes:
+	- phpstan-baseline.neon
+

phpunit.xml.dist

@@ -20,9 +20,18 @@
        </testsuite>
        <testsuite name="PersonBundle">
          <directory suffix="Test.php">src/Bundle/ChillPersonBundle/Tests/</directory>
+         <!-- test for export will be runned later -->
          <exclude>src/Bundle/ChillPersonBundle/Tests/Export/*</exclude>
+         <!-- we are rewriting accompanying periods... Work in progress -->
+         <exclude>src/Bundle/ChillPersonBundle/Tests/Controller/AccompanyingPeriodControllerTest.php</exclude>
+         <!-- we are rewriting address, Work in progress -->
+         <exclude>src/Bundle/ChillPersonBundle/Tests/Controller/PersonAddressControllerTest.php</exclude>
+         <!-- find a solution to create multiple configs -->
+         <exclude>src/Bundle/ChillPersonBundle/Tests/Controller/PersonControllerUpdateWithHiddenFieldsTest.php</exclude>
+         <!-- temporarily removed, the time to find a fix -->
+         <exclude>src/Bundle/ChillPersonBundle/Tests/Controller/PersonDuplicateControllerViewTest.php</exclude>
         </testsuite>
-      </testsuites>
+    </testsuites>
 
     <listeners>
         <listener class="Symfony\Bridge\PhpUnit\SymfonyTestsListener" />

psalm.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<psalm
+    errorLevel="7"
+    resolveFromConfigFile="true"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns="https://getpsalm.org/schema/config"
+    xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+    errorBaseline="psalm-baseline.xml"
+>
+    <projectFiles>
+        <directory name="src" />
+        <ignoreFiles>
+            <directory name="tests/" />
+        </ignoreFiles>
+    </projectFiles>
+</psalm>

src/Bundle/ChillActivityBundle/DependencyInjection/ChillActivityExtension.php

@@ -52,7 +52,6 @@ class ChillActivityExtension extends Extension implements PrependExtensionInterf
         $loader->load('services/export.yaml');
         $loader->load('services/repositories.yaml');
         $loader->load('services/fixtures.yaml');
-        $loader->load('services/menu.yaml');
         $loader->load('services/controller.yaml');
         $loader->load('services/form.yaml');
         $loader->load('services/templating.yaml');

src/Bundle/ChillActivityBundle/Entity/Activity.php

@@ -38,7 +38,7 @@ use Chill\MainBundle\Validator\Constraints\Entity\UserCircleConsistency;
  * Class Activity
  *
  * @package Chill\ActivityBundle\Entity
- * @ORM\Entity()
+ * @ORM\Entity(repositoryClass="Chill\ActivityBundle\Repository\ActivityRepository")
  * @ORM\Table(name="activity")
  * @ORM\HasLifecycleCallbacks()
  * @UserCircleConsistency(

src/Bundle/ChillActivityBundle/Repository/ActivityACLAwareRepository.php

@@ -0,0 +1,169 @@
+<?php
+
+/*
+ * Chill is a software for social workers
+ *
+ * Copyright (C) 2021, Champs Libres Cooperative SCRLFS,
+ * <http://www.champs-libres.coop>, <info@champs-libres.coop>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+namespace Chill\ActivityBundle\Repository;
+
+use Chill\ActivityBundle\Entity\Activity;
+use Chill\PersonBundle\Entity\Person;
+use Chill\ActivityBundle\Repository\ActivityRepository;
+use Chill\ActivityBundle\Security\Authorization\ActivityVoter;
+use Chill\MainBundle\Entity\Scope;
+use Doctrine\ORM\QueryBuilder;
+use Doctrine\ORM\Query\Expr\Orx;
+use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
+use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
+use Symfony\Component\Security\Core\Role\Role;
+use Doctrine\ORM\EntityManagerInterface;
+
+
+final class ActivityACLAwareRepository 
+{
+    private AuthorizationHelper $authorizationHelper;
+
+    private TokenStorageInterface $tokenStorage;
+
+    private ActivityRepository $repository;
+
+    private EntityManagerInterface $em;
+
+    public function __construct(
+        AuthorizationHelper $authorizationHelper,
+        TokenStorageInterface $tokenStorage,
+        ActivityRepository $repository,
+        EntityManagerInterface $em
+    ) {
+        $this->authorizationHelper = $authorizationHelper;
+        $this->tokenStorage = $tokenStorage;
+        $this->repository = $repository;
+        $this->em = $em;
+    }
+
+    public function queryTimelineIndexer(string $context, array $args = []): array
+    {
+        $metadataActivity = $this->em->getClassMetadata(Activity::class);
+
+        $from = $this->getFromClauseCenter($args);
+        [$where, $parameters] = $this->getWhereClause($context, $args);
+
+        return [
+           'id' => $metadataActivity->getTableName()
+                .'.'.$metadataActivity->getColumnName('id'),
+           'type' => 'activity',
+           'date' => $metadataActivity->getTableName()
+                .'.'.$metadataActivity->getColumnName('date'),
+           'FROM' => $from,
+           'WHERE' => $where,
+           'parameters' => $parameters
+       ];
+    }
+
+    private function getFromClauseCenter(array $args): string
+    {
+        $metadataActivity = $this->em->getClassMetadata(Activity::class);
+        $metadataPerson = $this->em->getClassMetadata(Person::class);
+        $associationMapping = $metadataActivity->getAssociationMapping('person');
+        
+        return $metadataActivity->getTableName().' JOIN '
+            .$metadataPerson->getTableName().' ON '
+            .$metadataPerson->getTableName().'.'.
+                $associationMapping['joinColumns'][0]['referencedColumnName']
+            .' = '
+            .$associationMapping['joinColumns'][0]['name']
+            ;
+    }
+
+    private function getWhereClause(string $context, array $args): array
+    {
+        $where = '';
+        $parameters = [];
+        
+        $metadataActivity = $this->em->getClassMetadata(Activity::class);
+        $metadataPerson = $this->em->getClassMetadata(Person::class);
+        $activityToPerson = $metadataActivity->getAssociationMapping('person')['joinColumns'][0]['name'];
+        $activityToScope  = $metadataActivity->getAssociationMapping('scope')['joinColumns'][0]['name'];
+        $personToCenter = $metadataPerson->getAssociationMapping('center')['joinColumns'][0]['name'];
+
+
+        // acls:
+        $role = new Role(ActivityVoter::SEE);
+        $reachableCenters = $this->authorizationHelper->getReachableCenters($this->tokenStorage->getToken()->getUser(), 
+                $role);
+        
+        if (count($reachableCenters) === 0) {
+            // insert a dummy condition
+            return 'FALSE = TRUE';
+        }
+
+        if ($context === 'person') { 
+            // we start with activities having the person_id linked to person 
+            $where .= sprintf('%s = ? AND ', $activityToPerson);
+            $parameters[] = $person->getId();
+        }
+        
+        // we add acl (reachable center and scopes)
+        $where .= '('; // first loop for the for centers
+        $centersI = 0; // like centers#i
+        foreach ($reachableCenters as $center) {
+            // we pass if not in centers
+            if (!\in_array($center, $args['centers'])) {
+                continue;
+            }
+            // we get all the reachable scopes for this center
+            $reachableScopes = $this->authorizationHelper->getReachableScopes($this->tokenStorage->getToken()->getUser(), $role, $center);
+            // we get the ids for those scopes
+            $reachablesScopesId = array_map(
+                function(Scope $scope) { return $scope->getId(); }, 
+                $reachableScopes
+            );
+
+            // if not the first center
+            if ($centersI > 0) {
+                $where .= ') OR (';
+            }
+
+            // condition for the center
+            $where .= sprintf(' %s.%s = ? ', $metadataPerson->getTableName(), $personToCenter);
+            $parameters[] = $center->getId();
+
+            // begin loop for scopes
+            $where .= ' AND (';
+            $scopesI = 0; //like scope#i
+
+            foreach ($reachablesScopesId as $scopeId) {
+                if ($scopesI > 0) {
+                    $where .= ' OR ';
+                }
+                $where .= sprintf(' %s.%s = ? ', $metadataActivity->getTableName(), $activityToScope);
+                $parameters[] = $scopeId;
+                $scopesI ++;
+            }
+            // close loop for scopes
+            $where .= ') ';
+            $centersI++;
+        }
+        // close loop for centers
+        $where .= ')';
+        
+        return [$where, $parameters];
+    }
+
+}

src/Bundle/ChillActivityBundle/Repository/ActivityRepository.php

@@ -0,0 +1,42 @@
+<?php
+
+/*
+ * Chill is a software for social workers
+ *
+ * Copyright (C) 2021, Champs Libres Cooperative SCRLFS,
+ * <http://www.champs-libres.coop>, <info@champs-libres.coop>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+namespace Chill\ActivityBundle\Repository;
+
+use Chill\ActivityBundle\Entity\Activity;
+use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
+use Doctrine\Persistence\ManagerRegistry;
+
+/**
+ * @method AccompanyingPeriodParticipation|null find($id, $lockMode = null, $lockVersion = null)
+ * @method AccompanyingPeriodParticipation|null findOneBy(array $criteria, array $orderBy = null)
+ * @method AccompanyingPeriodParticipation[]    findAll()
+ * @method AccompanyingPeriodParticipation[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
+ */
+class ActivityRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, Activity::class);
+    }
+    
+}

src/Bundle/ChillActivityBundle/Resources/views/Timeline/activity_person_context.html.twig

@@ -1,11 +1,11 @@
 {% import 'ChillActivityBundle:ActivityReason:macro.html.twig' as m %}
 
 <div>
-    <h3>{{ activity.date|format_date('long') }}<span class="activity"> / {{ 'Activity'|trans }}</span></h3>
+  <h3>{{ activity.date|format_date('long') }}<span class="activity"> / {{ 'Activity'|trans }}</span>{% if 'person' != context %} / {{ activity.person|chill_entity_render_box({'addLink': true}) }}{% endif %}</h3>
     <div class="statement">
         <span class="statement">{{ '%user% has done an %activity_type%'|trans(
            {
-             '%user%' : user,
+             '%user%' : activity.user,
              '%activity_type%': activity.type.name|localize_translatable_string,
              '%date%' : activity.date|format_date('long') }
         ) }}</span>
@@ -29,13 +29,13 @@
 
     <ul class="record_actions">
         <li>
-            <a href="{{ path('chill_activity_activity_show', { 'person_id': person.id, 'id': activity.id} ) }}" class="sc-button bt-view">
+            <a href="{{ path('chill_activity_activity_show', { 'person_id': activity.person.id, 'id': activity.id} ) }}" class="sc-button bt-view">
                 {{ 'Show the activity'|trans }}
             </a>
         </li>
         {% if is_granted('CHILL_ACTIVITY_UPDATE', activity) %}
         <li>
-            <a href="{{ path('chill_activity_activity_edit', { 'person_id': person.id, 'id': activity.id} ) }}" class="sc-button bt-edit">
+            <a href="{{ path('chill_activity_activity_edit', { 'person_id': activity.person.id, 'id': activity.id} ) }}" class="sc-button bt-edit">
                 {{ 'Edit the activity'|trans }}
             </a>
         </li>

src/Bundle/ChillActivityBundle/Timeline/TimelineActivityProvider.php

@@ -21,6 +21,7 @@
 namespace Chill\ActivityBundle\Timeline;
 
 use Chill\MainBundle\Timeline\TimelineProviderInterface;
+use Chill\ActivityBundle\Repository\ActivityACLAwareRepository;
 use Doctrine\ORM\EntityManager;
 use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
 use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
@@ -28,13 +29,13 @@ use Symfony\Component\Security\Core\Role\Role;
 use Doctrine\ORM\Mapping\ClassMetadata;
 use Chill\PersonBundle\Entity\Person;
 use Chill\MainBundle\Entity\Scope;
+use Chill\ActivityBundle\Entity\Activity;
+use Chill\MainBundle\Timeline\TimelineSingleQuery;
 
 /**
  * Provide activity for inclusion in timeline
  *
- * @author Julien Fastré <julien.fastre@champs-libres.coop>
- * @author Champs Libres <info@champs-libres.coop>
- */
+*/
 class TimelineActivityProvider implements TimelineProviderInterface
 {
     
@@ -55,6 +56,10 @@ class TimelineActivityProvider implements TimelineProviderInterface
      * @var \Chill\MainBundle\Entity\User 
      */
     protected $user;
+
+    protected ActivityACLAwareRepository $aclAwareRepository;
+
+    private const SUPPORTED_CONTEXTS = [ 'center', 'person'];
     
     /**
      * TimelineActivityProvider constructor.
@@ -66,11 +71,13 @@ class TimelineActivityProvider implements TimelineProviderInterface
     public function __construct(
         EntityManager $em,
         AuthorizationHelper $helper,
-        TokenStorageInterface $storage
+        TokenStorageInterface $storage,
+        ActivityACLAwareRepository $aclAwareRepository
     )
     {
         $this->em = $em;
         $this->helper = $helper;
+        $this->aclAwareRepository = $aclAwareRepository;
         
         if (!$storage->getToken()->getUser() instanceof \Chill\MainBundle\Entity\User)
         {
@@ -86,67 +93,69 @@ class TimelineActivityProvider implements TimelineProviderInterface
      */
     public function fetchQuery($context, array $args)
     {
-        $this->checkContext($context);
+        if ('center' === $context) {
+            return TimelineSingleQuery::fromArray($this->aclAwareRepository
+                ->queryTimelineIndexer($context, $args));
+        }
         
-        $metadataActivity = $this->em->getClassMetadata('ChillActivityBundle:Activity');
-        $metadataPerson = $this->em->getClassMetadata('ChillPersonBundle:Person');
+        $metadataActivity = $this->em->getClassMetadata(Activity::class);
+
+        [$where, $parameters] =  $this->getWhereClauseForPerson($args['person']);
         
-        return array(
+        return TimelineSingleQuery::fromArray([
            'id' => $metadataActivity->getTableName()
                 .'.'.$metadataActivity->getColumnName('id'),
            'type' => 'activity',
            'date' => $metadataActivity->getTableName()
                 .'.'.$metadataActivity->getColumnName('date'),
-           'FROM' => $this->getFromClause($metadataActivity, $metadataPerson),
-           'WHERE' => $this->getWhereClause($metadataActivity, $metadataPerson,
-                   $args['person'])
-        );
+           'FROM' => $this->getFromClausePerson($args['person']),
+           'WHERE' => $where,
+           'parameters' => $parameters
+       ]);
     }
     
-    private function getWhereClause(ClassMetadata $metadataActivity, 
-            ClassMetadata $metadataPerson, Person $person)
+    private function getWhereClauseForPerson(Person $person)
     {
-        $role = new Role('CHILL_ACTIVITY_SEE');
-        $reachableCenters = $this->helper->getReachableCenters($this->user, 
-                $role);
+        $parameters = [];
+        $metadataActivity = $this->em->getClassMetadata(Activity::class);
         $associationMapping = $metadataActivity->getAssociationMapping('person');
-        
-        if (count($reachableCenters) === 0) {
-            return 'FALSE = TRUE';
+        $role = new Role('CHILL_ACTIVITY_SEE');
+        $reachableScopes =  $this->helper->getReachableScopes($this->user,
+            $role, $person->getCenter());
+        $whereClause = sprintf(' {activity.person_id} = ? AND {activity.scope_id} IN ({scopes_ids}) ');
+        $scopes_ids = [];
+
+        // first parameter: activity.person_id 
+        $parameters[] = $person->getId();
+
+        // loop on reachable scopes 
+        foreach ($reachableScopes as $scope) {
+            if (\in_array($scope->getId(), $scopes_ids)) {
+                continue;
+            }
+            $scopes_ids[] = '?'; 
+            $parameters[] = $scope->getId();
         }
-        
-        // we start with activities having the person_id linked to person 
-        // (currently only context "person" is supported)
-        $whereClause = sprintf('%s = %d',
-                 $associationMapping['joinColumns'][0]['name'],
-                 $person->getId());
-        
-        // we add acl (reachable center and scopes)
-        $centerAndScopeLines = array();
-        foreach ($reachableCenters as $center) {
-            $reachablesScopesId = array_map(
-                    function(Scope $scope) { return $scope->getId(); },
-                    $this->helper->getReachableScopes($this->user, $role, 
-                        $person->getCenter())
-                );
-                    
-            $centerAndScopeLines[] = sprintf('(%s = %d AND %s IN (%s))',
-                    $metadataPerson->getTableName().'.'.
-                        $metadataPerson->getAssociationMapping('center')['joinColumns'][0]['name'],
-                    $center->getId(),
-                    $metadataActivity->getTableName().'.'.
+
+        return [
+            \strtr(
+                $whereClause,
+                [
+                    '{activity.person_id}' => $associationMapping['joinColumns'][0]['name'],
+                    '{activity.scope_id}' => $metadataActivity->getTableName().'.'.
                         $metadataActivity->getAssociationMapping('scope')['joinColumns'][0]['name'],
-                    implode(',', $reachablesScopesId));
-            
-        }
-        $whereClause .= ' AND ('.implode(' OR ', $centerAndScopeLines).')';
-        
-        return $whereClause;
+                    '{scopes_ids}' => \implode(", ", $scopes_ids)
+,
+                ]
+            ),
+            $parameters
+        ];
     }
     
-    private function getFromClause(ClassMetadata $metadataActivity,
-            ClassMetadata $metadataPerson)
+    private function getFromClausePerson()
     {
+        $metadataActivity = $this->em->getClassMetadata(Activity::class);
+        $metadataPerson = $this->em->getClassMetadata(Person::class);
         $associationMapping = $metadataActivity->getAssociationMapping('person');
         
         return $metadataActivity->getTableName().' JOIN '
@@ -157,14 +166,14 @@ class TimelineActivityProvider implements TimelineProviderInterface
             .$associationMapping['joinColumns'][0]['name']
             ;
     }
-
+    
     /**
      * 
      * {@inheritDoc}
      */
     public function getEntities(array $ids)
     {
-        $activities = $this->em->getRepository('ChillActivityBundle:Activity')
+        $activities = $this->em->getRepository(Activity::class)
               ->findBy(array('id' => $ids));
         
         $result = array();
@@ -183,14 +192,13 @@ class TimelineActivityProvider implements TimelineProviderInterface
     {
         $this->checkContext($context);
         
-        return array(
+        return [
            'template' => 'ChillActivityBundle:Timeline:activity_person_context.html.twig',
-           'template_data' => array(
+           'template_data' => [
               'activity' => $entity,
-              'person' => $args['person'],
-              'user' => $entity->getUser()
-           )
-        );
+              'context' => $context
+            ]
+        ];
     }
 
     /**
@@ -210,7 +218,7 @@ class TimelineActivityProvider implements TimelineProviderInterface
      */
     private function checkContext($context)
     {
-        if ($context !== 'person') {
+        if (FALSE === \in_array($context, self::SUPPORTED_CONTEXTS)) {
             throw new \LogicException("The context '$context' is not "
                   . "supported. Currently only 'person' is supported");
         }

src/Bundle/ChillActivityBundle/config/services.yaml

@@ -22,6 +22,14 @@ services:
             - '@doctrine.orm.entity_manager'
             - '@chill.main.security.authorization.helper'
             - '@security.token_storage'
+            - '@Chill\ActivityBundle\Repository\ActivityACLAwareRepository'
         public: true
         tags:
             - { name: chill.timeline, context: 'person' }
+            - { name: chill.timeline, context: 'center' }
+
+    Chill\ActivityBundle\Menu\:
+        autowire: true
+        autoconfigure: true
+        resource: '../Menu/'
+        tags: ['chill.menu_builder']

src/Bundle/ChillActivityBundle/config/services/menu.yaml

@@ -1,8 +0,0 @@
-services:
-    Chill\ActivityBundle\Menu\MenuBuilder:
-        arguments:
-            $authorizationHelper: '@Chill\MainBundle\Security\Authorization\AuthorizationHelper'
-            $tokenStorage: '@Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface'
-            $translator: '@Symfony\Component\Translation\TranslatorInterface'
-        tags:
-            - { name: 'chill.menu_builder' }

src/Bundle/ChillActivityBundle/config/services/repositories.yaml

@@ -1,18 +1,32 @@
+---
 services:
     chill_activity.repository.activity_type:
         class: Doctrine\ORM\EntityRepository
         factory: ['@doctrine.orm.entity_manager', getRepository]
         arguments:
             - 'Chill\ActivityBundle\Entity\ActivityType'
-            
+
     chill_activity.repository.reason:
         class: Doctrine\ORM\EntityRepository
         factory: ['@doctrine.orm.entity_manager', getRepository]
         arguments:
             - 'Chill\ActivityBundle\Entity\ActivityReason'
-            
+
     chill_activity.repository.reason_category:
         class: Doctrine\ORM\EntityRepository
         factory: ['@doctrine.orm.entity_manager', getRepository]
         arguments:
             - 'Chill\ActivityBundle\Entity\ActivityReasonCategory'
+
+    Chill\ActivityBundle\Repository\ActivityRepository:
+        tags: [doctrine.repository_service]
+        arguments:
+            - '@Doctrine\Persistence\ManagerRegistry'
+
+    Chill\ActivityBundle\Repository\ActivityACLAwareRepository:
+        arguments:
+            $tokenStorage: '@Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface'
+            $authorizationHelper: '@Chill\MainBundle\Security\Authorization\AuthorizationHelper'
+            $repository: '@Chill\ActivityBundle\Repository\ActivityRepository'
+            $em: '@Doctrine\ORM\EntityManagerInterface'
+

src/Bundle/ChillEventBundle/Timeline/TimelineEventProvider.php

@@ -23,6 +23,7 @@ namespace Chill\EventBundle\Timeline;
 use Chill\EventBundle\Entity\Event;
 use Chill\MainBundle\Entity\Scope;
 use Chill\MainBundle\Timeline\TimelineProviderInterface;
+use Chill\MainBundle\Timeline\TimelineSingleQuery;
 use Doctrine\ORM\EntityManager;
 use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
 use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
@@ -88,13 +89,14 @@ class TimelineEventProvider implements TimelineProviderInterface
         $metadataParticipation = $this->em->getClassMetadata('ChillEventBundle:Participation');
         $metadataPerson = $this->em->getClassMetadata('ChillPersonBundle:Person');
         
-        $query = array(
+        $query = TimelineSingleQuery::fromArray([
             'id' => $metadataEvent->getTableName().'.'.$metadataEvent->getColumnName('id'),
             'type' => 'event',
             'date' => $metadataEvent->getTableName().'.'.$metadataEvent->getColumnName('date'),
             'FROM' => $this->getFromClause($metadataEvent, $metadataParticipation, $metadataPerson),
-            'WHERE' => $this->getWhereClause($metadataEvent, $metadataParticipation, $metadataPerson, $args['person'])
-        );
+            'WHERE' => $this->getWhereClause($metadataEvent, $metadataParticipation, $metadataPerson, $args['person']),
+            'parameters' => []
+        ]);
         
         return $query;
     }
@@ -238,4 +240,4 @@ class TimelineEventProvider implements TimelineProviderInterface
         );
     }
     
-}
+}

src/Bundle/ChillMainBundle/CRUD/Controller/AbstractCRUDController.php

@@ -40,6 +40,20 @@ class AbstractCRUDController extends AbstractController
         return $e;
     }
 
+    /**
+     * Create an entity.
+     * 
+     * @param string $action
+     * @param Request $request
+     * @return object
+     */
+    protected function createEntity(string $action, Request $request): object
+    {
+        $type = $this->getEntityClass();
+        
+        return new $type;
+    }
+
     /**
      * Count the number of entities
      *

src/Bundle/ChillMainBundle/CRUD/Controller/ApiController.php

@@ -85,11 +85,75 @@ class ApiController extends AbstractCRUDController
             case Request::METHOD_PUT:
             case Request::METHOD_PATCH:
                 return $this->entityPut('_entity', $request, $id, $_format);
+            case Request::METHOD_POST:
+                return $this->entityPostAction('_entity', $request, $id, $_format);
+            default:
+                throw new \Symfony\Component\HttpFoundation\Exception\BadRequestException("This method is not implemented");
+        }
+    }
+    public function entityPost(Request $request, $_format): Response
+    {
+        switch($request->getMethod()) {
+            case Request::METHOD_POST:
+                return $this->entityPostAction('_entity', $request, $_format);
             default:
                 throw new \Symfony\Component\HttpFoundation\Exception\BadRequestException("This method is not implemented");
         }
     }
 
+    protected function entityPostAction($action, Request $request, string $_format): Response
+    {
+        $entity = $this->createEntity($action, $request);
+
+        try {
+            $entity = $this->deserialize($action, $request, $_format, $entity);
+        } catch (NotEncodableValueException $e) {
+            throw new BadRequestException("invalid json", 400, $e);
+        }
+        
+        $errors = $this->validate($action, $request, $_format, $entity);
+        
+        $response = $this->onAfterValidation($action, $request, $_format, $entity, $errors);
+        if ($response instanceof Response) {
+            return $response;
+        }
+
+        if ($errors->count() > 0) {
+            $response = $this->json($errors);
+            $response->setStatusCode(Response::HTTP_UNPROCESSABLE_ENTITY);
+
+            return $response;
+        }
+        
+        $response = $this->checkACL($action, $request, $_format, $entity);
+        if ($response instanceof Response) {
+            return $response;
+        }
+        
+        $response = $this->onPostCheckACL($action, $request, $_format, $entity);
+        if ($response instanceof Response) {
+            return $response;
+        }
+
+        $this->getDoctrine()->getManager()->persist($entity);
+        $this->getDoctrine()->getManager()->flush();
+
+        $response = $this->onAfterFlush($action, $request, $_format, $entity, $errors);
+        if ($response instanceof Response) {
+            return $response;
+        }
+        $response = $this->onBeforeSerialize($action, $request, $_format, $entity);
+        if ($response instanceof Response) {
+            return $response;
+        }
+        
+        return $this->json(
+            $entity,
+            Response::HTTP_OK,
+            [], 
+            $this->getContextForSerializationPostAlter($action, $request, $_format, $entity)
+        );
+    }
     public function entityPut($action, Request $request, $id, string $_format): Response
     {
         $entity = $this->getEntity($action, $id, $request, $_format);
@@ -407,6 +471,7 @@ class ApiController extends AbstractCRUDController
                 return [ 'groups' => [ 'read' ]];
             case Request::METHOD_PUT:
             case Request::METHOD_PATCH:
+            case Request::METHOD_POST:
                 return [ 'groups' => [ 'write' ]];
             default:
                 throw new \LogicException("get context for serialization is not implemented for this method");

src/Bundle/ChillMainBundle/CRUD/Routing/CRUDRoutesLoader.php

@@ -189,6 +189,20 @@ class CRUDRoutesLoader extends Loader
                     "or allow, at least, one method"); 
             }
 
+            if ('_entity' === $name && \in_array(Request::METHOD_POST, $methods)) {
+                unset($methods[\array_search(Request::METHOD_POST, $methods)]);
+                $entityPostRoute = $this->createEntityPostRoute($name, $crudConfig, $action, 
+                    $controller);
+                $collection->add("chill_api_single_{$crudConfig['name']}_{$name}_create", 
+                    $entityPostRoute);
+            }
+
+            if (count($methods) === 0) {
+                // the only method was POST,
+                // continue to next
+                continue;
+            }
+
             $route = new Route($path, $defaults, $requirements);
             $route->setMethods($methods);
             
@@ -197,4 +211,18 @@ class CRUDRoutesLoader extends Loader
 
         return $collection;
     }
+
+    private function createEntityPostRoute(string $name, $crudConfig, array $action, $controller): Route
+    {
+        $localPath = $action['path'].'.{_format}';
+        $defaults = [
+            '_controller' => $controller.':'.($action['controller_action'] ?? 'entityPost')
+        ];
+        $path = $crudConfig['base_path'].$localPath;
+        $requirements = $action['requirements'] ?? [];
+        $route = new Route($path, $defaults, $requirements);
+        $route->setMethods([ Request::METHOD_POST ]);
+
+        return $route;
+    }
 }

src/Bundle/ChillMainBundle/Controller/AddressController.php

@@ -1,63 +0,0 @@
-<?php
-
-namespace Chill\MainBundle\Controller;
-
-use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
-use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
-use Symfony\Component\HttpFoundation\Response;
-use Symfony\Component\HttpFoundation\Exception\BadRequestException;
-use Symfony\Component\Routing\Annotation\Route;
-use Chill\MainBundle\Entity\Address;
-use Chill\MainBundle\Entity\AddressReference;
-
-/**
- * Class AddressController
- *
- * @package Chill\MainBundle\Controller
- */
-class AddressController extends AbstractController
-{
-
-
-    /**
-     * Get API Data for showing endpoint
-     *
-     * @Route(
-     *     "/{_locale}/main/api/1.0/address/{address_id}/show.{_format}",
-     *     name="chill_main_address_api_show"
-     * )
-     * @ParamConverter("address", options={"id": "address_id"})
-     */
-    public function showAddress(Address $address, $_format): Response
-    {
-        // TODO check ACL ?
-        switch ($_format) {
-            case 'json':
-                return $this->json($address);
-            default:
-                throw new BadRequestException('Unsupported format');
-        }
-    }
-
-
-    /**
-     * Get API Data for showing endpoint
-     *
-     * @Route(
-     *     "/{_locale}/main/api/1.0/address-reference/{address_reference_id}/show.{_format}",
-     *     name="chill_main_address_reference_api_show"
-     * )
-     * @ParamConverter("addressReference", options={"id": "address_reference_id"})
-     */
-    public function showAddressReference(AddressReference $addressReference, $_format): Response
-    {
-        // TODO check ACL ?
-        switch ($_format) {
-            case 'json':
-                return $this->json($addressReference);
-            default:
-                throw new BadRequestException('Unsupported format');
-        }
-
-    }
-}

src/Bundle/ChillMainBundle/Controller/AddressReferenceAPIController.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Chill\MainBundle\Controller;
+
+use Chill\MainBundle\CRUD\Controller\ApiController;
+use Symfony\Component\HttpFoundation\Request;
+
+/**
+ * Class AddressReferenceAPIController
+ *
+ * @package Chill\MainBundle\Controller
+ * @author Champs Libres
+ */
+class AddressReferenceAPIController extends ApiController
+{
+
+    protected function customizeQuery(string $action, Request $request, $qb): void
+    {
+        if ($request->query->has('postal_code')) {
+
+            $qb->where('e.postcode = :postal_code')
+               ->setParameter('postal_code', $request->query->get('postal_code'));
+
+        }
+    }
+
+}

src/Bundle/ChillMainBundle/Controller/PostalCodeAPIController.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Chill\MainBundle\Controller;
+
+use Chill\MainBundle\CRUD\Controller\ApiController;
+use Symfony\Component\HttpFoundation\Request;
+
+/**
+ * Class PostalCodeAPIController
+ *
+ * @package Chill\MainBundle\Controller
+ * @author Champs Libres
+ */
+class PostalCodeAPIController extends ApiController
+{
+
+    protected function customizeQuery(string $action, Request $request, $qb): void
+    {
+        if ($request->query->has('country')) {
+
+            $qb->where('e.country = :country')
+               ->setParameter('country', $request->query->get('country'));
+
+        }
+    }
+
+}

src/Bundle/ChillMainBundle/Controller/TimelineCenterController.php

@@ -0,0 +1,91 @@
+<?php
+
+/*
+ * Copyright (C) 2015 Champs-Libres Coopérative <info@champs-libres.coop>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+namespace Chill\MainBundle\Controller;
+
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\Request;
+use Chill\MainBundle\Timeline\TimelineBuilder;
+use Chill\MainBundle\Pagination\PaginatorFactory;
+use Chill\PersonBundle\Security\Authorization\PersonVoter;
+use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
+use Symfony\Component\Security\Core\Role\Role;
+use Symfony\Component\Routing\Annotation\Route;
+use Symfony\Component\Security\Core\Security;
+
+class TimelineCenterController extends AbstractController
+{
+    
+    protected TimelineBuilder $timelineBuilder;
+    
+    protected PaginatorFactory $paginatorFactory;
+
+    private Security $security;
+    
+    public function __construct(
+        TimelineBuilder $timelineBuilder,
+        PaginatorFactory $paginatorFactory,
+        Security $security
+    ) {
+        $this->timelineBuilder = $timelineBuilder;
+        $this->paginatorFactory = $paginatorFactory;
+        $this->security = $security;
+    }
+
+    /**
+     * @Route("/{_locale}/center/timeline",
+     *    name="chill_center_timeline",
+     *    methods={"GET"}
+     *  )
+     */ 
+    public function centerAction(Request $request)
+    {
+        // collect reachable center for each group
+        $user = $this->security->getUser();
+        $centers = [];
+        foreach ($user->getGroupCenters() as $group) {
+            $centers[] = $group->getCenter();
+        }
+
+        if (0 === count($centers)) {
+            throw $this->createNotFoundException();
+        }
+        
+        $nbItems = $this->timelineBuilder->countItems('center', 
+            [ 'centers' => $centers ]
+            );
+        
+        $paginator = $this->paginatorFactory->create($nbItems);
+        
+        return $this->render('@ChillMain/Timeline/index.html.twig', array
+            (
+                'timeline' => $this->timelineBuilder->getTimelineHTML(
+                    'center', 
+                    [ 'centers' => $centers ],
+                    $paginator->getCurrentPage()->getFirstItemNumber(),
+                    $paginator->getItemsPerPage()
+                    ),
+                'nb_items' => $nbItems,
+                'paginator' => $paginator
+            )
+        );
+    }
+}

src/Bundle/ChillMainBundle/DependencyInjection/ChillMainExtension.php

@@ -35,6 +35,8 @@ use Chill\MainBundle\Doctrine\DQL\OverlapsI;
 use Symfony\Component\DependencyInjection\Definition;
 use Symfony\Component\DependencyInjection\Reference;
 use Chill\MainBundle\Doctrine\DQL\Replace;
+use Chill\MainBundle\Doctrine\Type\NativeDateIntervalType;
+use Chill\MainBundle\Doctrine\Type\PointType;
 use Symfony\Component\HttpFoundation\Request;
 
 /**
@@ -167,37 +169,49 @@ class ChillMainExtension extends Extension implements PrependExtensionInterface,
         $container->prependExtensionConfig('twig', $twigConfig);
 
         //add DQL function to ORM (default entity_manager)
-        $container->prependExtensionConfig('doctrine', array(
-           'orm' => array(
-              'dql' => array(
-                 'string_functions' => array(
-                    'unaccent' => Unaccent::class,
-                    'GET_JSON_FIELD_BY_KEY' => GetJsonFieldByKey::class,
-                    'AGGREGATE' => JsonAggregate::class,
-                    'REPLACE' => Replace::class,
-                 ),
-                 'numeric_functions' => [
-                    'JSONB_EXISTS_IN_ARRAY' => JsonbExistsInArray::class,
-                    'SIMILARITY' => Similarity::class,
-                    'OVERLAPSI' => OverlapsI::class
-                ]
-              )
-           )
-        ));
+        $container
+            ->prependExtensionConfig(
+                'doctrine',
+                [
+                    'orm' => [
+                        'dql' => [
+                            'string_functions' => [
+                                'unaccent' => Unaccent::class,
+                                'GET_JSON_FIELD_BY_KEY' => GetJsonFieldByKey::class,
+                                'AGGREGATE' => JsonAggregate::class,
+                                'REPLACE' => Replace::class,
+                            ],
+                            'numeric_functions' => [
+                                'JSONB_EXISTS_IN_ARRAY' => JsonbExistsInArray::class,
+                                'SIMILARITY' => Similarity::class,
+                                'OVERLAPSI' => OverlapsI::class,
+                            ],
+                        ],
+                    ],
+                ],
+        );
 
         //add dbal types (default entity_manager)
-        $container->prependExtensionConfig('doctrine', array(
-           'dbal' => [
-               'types' => [
-                   'dateinterval' => [
-                       'class' => \Chill\MainBundle\Doctrine\Type\NativeDateIntervalType::class
-                   ],
-                   'point' => [
-                       'class' => \Chill\MainBundle\Doctrine\Type\PointType::class
-                   ]
-               ]
-           ]
-        ));
+        $container
+            ->prependExtensionConfig(
+                'doctrine',
+                [
+                   'dbal' => [
+                        // This is mandatory since we are using postgis as database.
+                        'mapping_types' => [
+                            'geometry' => 'string',
+                        ],
+                        'types' => [
+                            'dateinterval' => [
+                                'class' => NativeDateIntervalType::class
+                            ],
+                            'point' => [
+                                'class' => PointType::class
+                            ]
+                        ]
+                    ]
+                ]
+        );
 
         //add current route to chill main
         $container->prependExtensionConfig('chill_main', array(
@@ -270,6 +284,7 @@ class ChillMainExtension extends Extension implements PrependExtensionInterface,
                     ]
                 ],
                 [
+                    'controller' => \Chill\MainBundle\Controller\AddressReferenceAPIController::class,
                     'class' => \Chill\MainBundle\Entity\AddressReference::class,
                     'name' => 'address_reference',
                     'base_path' => '/api/1.0/main/address-reference',
@@ -290,6 +305,7 @@ class ChillMainExtension extends Extension implements PrependExtensionInterface,
                     ]
                 ],
                 [
+                    'controller' => \Chill\MainBundle\Controller\PostalCodeAPIController::class,
                     'class' => \Chill\MainBundle\Entity\PostalCode::class,
                     'name' => 'postal_code',
                     'base_path' => '/api/1.0/main/postal-code',

src/Bundle/ChillMainBundle/Doctrine/Model/Point.php

@@ -9,11 +9,11 @@ use \JsonSerializable;
  *
  */
 class Point implements JsonSerializable {
-    private float $lat;
-    private float $lon;
+    private ?float $lat = null;
+    private ?float $lon = null;
     public static string $SRID = '4326';
 
-    private function __construct(float $lon, float $lat)
+    private function __construct(?float $lon, ?float $lat)
     {
         $this->lat = $lat;
         $this->lon = $lon;

src/Bundle/ChillMainBundle/Entity/Address.php

@@ -4,6 +4,7 @@ namespace Chill\MainBundle\Entity;
 
 use Doctrine\ORM\Mapping as ORM;
 use Symfony\Component\Validator\Context\ExecutionContextInterface;
+use Symfony\Component\Serializer\Annotation\Groups;
 use Chill\MainBundle\Doctrine\Model\Point;
 use Chill\ThirdPartyBundle\Entity\ThirdParty;
 
@@ -22,6 +23,7 @@ class Address
      * @ORM\Id
      * @ORM\Column(name="id", type="integer")
      * @ORM\GeneratedValue(strategy="AUTO")
+     * @groups({"write"})
      */
     private $id;
 
@@ -29,6 +31,7 @@ class Address
      * @var string
      *
      * @ORM\Column(type="string", length=255)
+     * @groups({"write"})
      */
     private $street = '';
 
@@ -36,6 +39,7 @@ class Address
      * @var string
      *
      * @ORM\Column(type="string", length=255)
+     * @groups({"write"})
      */
     private $streetNumber = '';
 
@@ -43,6 +47,7 @@ class Address
      * @var PostalCode
      *
      * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\PostalCode")
+     * @groups({"write"})
      */
     private $postcode;
 
@@ -50,6 +55,7 @@ class Address
      * @var string|null
      *
      * @ORM\Column(type="string", length=16, nullable=true)
+     * @groups({"write"})
      */
     private $floor;
 
@@ -57,6 +63,7 @@ class Address
      * @var string|null
      *
      * @ORM\Column(type="string", length=16, nullable=true)
+     * @groups({"write"})
      */
     private $corridor;
 
@@ -64,6 +71,7 @@ class Address
      * @var string|null
      *
      * @ORM\Column(type="string", length=16, nullable=true)
+     * @groups({"write"})
      */
     private $steps;
 
@@ -71,6 +79,7 @@ class Address
      * @var string|null
      *
      * @ORM\Column(type="string", length=255, nullable=true)
+     * @groups({"write"})
      */
     private $buildingName;
 
@@ -78,6 +87,7 @@ class Address
      * @var string|null
      *
      * @ORM\Column(type="string", length=16, nullable=true)
+     * @groups({"write"})
      */
     private $flat;
 
@@ -85,6 +95,7 @@ class Address
      * @var string|null
      *
      * @ORM\Column(type="string", length=255, nullable=true)
+     * @groups({"write"})
      */
     private $distribution;
 
@@ -92,6 +103,7 @@ class Address
      * @var string|null
      *
      * @ORM\Column(type="string", length=255, nullable=true)
+     * @groups({"write"})
      */
     private $extra;
 
@@ -102,6 +114,7 @@ class Address
      * @var \DateTime
      *
      * @ORM\Column(type="date")
+     * @groups({"write"})
      */
     private $validFrom;
 
@@ -112,11 +125,13 @@ class Address
      * @var \DateTime|null
      *
      * @ORM\Column(type="date", nullable=true)
+     * @groups({"write"})
      */
     private $validTo;
 
     /**
      * True if the address is a "no address", aka homeless person, ...
+     * @groups({"write"})
      *
      * @var bool
      */
@@ -128,6 +143,7 @@ class Address
      * @var Point|null
      *
      * @ORM\Column(type="point", nullable=true)
+     * @groups({"write"})
      */
     private $point;
 
@@ -137,7 +153,8 @@ class Address
      * @var ThirdParty|null
      *
      * @ORM\ManyToOne(targetEntity="Chill\ThirdPartyBundle\Entity\ThirdParty")
-     * @ORM\JoinColumn(nullable=true)
+     * @groups({"write"})
+     * @ORM\JoinColumn(nullable=true, onDelete="SET NULL")
      */
     private $linkedToThirdParty;
 

src/Bundle/ChillMainBundle/Entity/AddressReference.php

@@ -4,6 +4,7 @@ namespace Chill\MainBundle\Entity;
 
 use Doctrine\ORM\Mapping as ORM;
 use Chill\MainBundle\Doctrine\Model\Point;
+use Symfony\Component\Serializer\Annotation\Groups;
 
 /**
  * @ORM\Entity()
@@ -16,21 +17,25 @@ class AddressReference
      * @ORM\Id
      * @ORM\GeneratedValue
      * @ORM\Column(type="integer")
+     * @groups({"read"})
      */
     private $id;
 
     /**
      * @ORM\Column(type="string", length=255)
+     * @groups({"read"})
      */
     private $refId;
 
     /**
      * @ORM\Column(type="string", length=255, nullable=true)
+     * @groups({"read"})
      */
     private $street;
 
     /**
      * @ORM\Column(type="string", length=255, nullable=true)
+     * @groups({"read"})
      */
     private $streetNumber;
 
@@ -38,16 +43,19 @@ class AddressReference
      * @var PostalCode
      *
      * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\PostalCode")
+     * @groups({"read"})
      */
     private $postcode;
 
     /**
      * @ORM\Column(type="string", length=255, nullable=true)
+     * @groups({"read"})
      */
     private $municipalityCode;
 
     /**
      * @ORM\Column(type="string", length=255, nullable=true)
+     * @groups({"read"})
      */
     private $source;
 
@@ -57,6 +65,7 @@ class AddressReference
      * @var Point
      *
      * @ORM\Column(type="point")
+     * @groups({"read"})
      */
     private $point;
 

src/Bundle/ChillMainBundle/Entity/Country.php

@@ -3,6 +3,7 @@
 namespace Chill\MainBundle\Entity;
 
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Annotation\Groups;
 
 /**
  * Country
@@ -20,6 +21,7 @@ class Country
      * @ORM\Id
      * @ORM\Column(name="id", type="integer")
      * @ORM\GeneratedValue(strategy="AUTO")
+     * @groups({"read"})
      */
     private $id;
 
@@ -27,13 +29,16 @@ class Country
      * @var string
      *
      * @ORM\Column(type="json_array")
+     * @groups({"read"})
+     *
      */
     private $name;
-    
+
     /**
      * @var string
      *
      * @ORM\Column(type="string", length=3)
+     * @groups({"read"})
      */
     private $countryCode;
 
@@ -41,7 +46,7 @@ class Country
     /**
      * Get id
      *
-     * @return integer 
+     * @return integer
      */
     public function getId()
     {
@@ -57,20 +62,20 @@ class Country
     public function setName($name)
     {
         $this->name = $name;
-    
+
         return $this;
     }
 
     /**
      * Get name
      *
-     * @return string 
+     * @return string
      */
     public function getName()
     {
         return $this->name;
     }
-    
+
     /**
      * @return string
      */
@@ -90,12 +95,12 @@ class Country
 
     /**
      *
-     * @param string $countryCode            
+     * @param string $countryCode
      */
     public function setCountryCode($countryCode)
     {
         $this->countryCode = $countryCode;
         return $this;
     }
- 
+
 }

src/Bundle/ChillMainBundle/Entity/PostalCode.php

@@ -3,6 +3,7 @@
 namespace Chill\MainBundle\Entity;
 
 use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Annotation\Groups;
 
 /**
  * PostalCode
@@ -25,6 +26,7 @@ class PostalCode
      * @ORM\Id
      * @ORM\Column(name="id", type="integer")
      * @ORM\GeneratedValue(strategy="AUTO")
+     * @groups({"read"})
      */
     private $id;
 
@@ -32,6 +34,7 @@ class PostalCode
      * @var string
      *
      * @ORM\Column(type="string", length=255, name="label")
+     * @groups({"read"})
      */
     private $name;
 
@@ -39,6 +42,7 @@ class PostalCode
      * @var string
      *
      * @ORM\Column(type="string", length=100)
+     * @groups({"read"})
      */
     private $code;
 
@@ -46,6 +50,7 @@ class PostalCode
      * @var Country
      *
      * @ORM\ManyToOne(targetEntity="Chill\MainBundle\Entity\Country")
+     * @groups({"read"})
      */
     private $country;
 

src/Bundle/ChillMainBundle/Resources/public/modules/bootstrap/bootstrap.scss

@@ -23,7 +23,7 @@
 // @import "bootstrap/scss/button-group";
 // @import "bootstrap/scss/input-group";
 // @import "bootstrap/scss/custom-forms";
-// @import "bootstrap/scss/nav";
+@import "bootstrap/scss/nav";
 // @import "bootstrap/scss/navbar";
 // @import "bootstrap/scss/card";
 // @import "bootstrap/scss/breadcrumb";

src/Bundle/ChillMainBundle/Resources/public/modules/scratch/custom/_address.scss

@@ -9,6 +9,12 @@ div.chill_address {
             margin: 0 0 0 1.5em;
             text-indent: -1.5em;
         }
+
+        &.chill_address_address--multiline {
+            p {
+                display: block;
+            }
+        }
         
     }
 }

src/Bundle/ChillMainBundle/Resources/public/modules/scratch/custom/_record_actions.scss

@@ -9,6 +9,11 @@ ul.record_actions li {
 ul.record_actions, ul.record_actions_column {
     display: flex;
     justify-content: flex-end;
+
+    &.record_actions--left {
+      justify-content: flex-start;
+    }
+
     padding: 0.5em 0;
     flex-wrap: wrap-reverse;
 

src/Bundle/ChillMainBundle/Resources/public/scss/chillmain.scss

@@ -1,45 +1,23 @@
 /*
  * NOTE 2021.04
- * scss/chill.scss is the main sass file for the new chill.2
+ * scss/chillmain.scss is the main sass file for the new chill.2
  * scratch will be replaced by bootstrap, please avoid to edit in modules/scratch/_custom.scss
  *
- * when possible, try to use bootstrap class naming
+ * when possible, try to use bootstrap html class
 */
 
-/*
- *  Header custom for Accompanying Course
- */
 
-div#header-accompanying_course-name {
-  background: none repeat scroll 0 0 #718596;
-  color: #FFF;
-  padding-top: 1em;
-  padding-bottom: 1em;
-
-  span {
-    a {
-      color: white;
-    }
-    a:hover {
-      text-decoration: underline;
-    }
-  }
-}
-
-div#header-accompanying_course-details {
-  background: none repeat scroll 0 0 #718596ab;
-  color: #FFF;
-  padding-top: 1em;
-  padding-bottom: 1em;
-}
-
-/*  /!\  Contourne le positionnement problématique du div#content_conainter suivant,
+/*  [hack]  /!\ Contourne le positionnement problématique du div#content_conainter suivant,
  *  car sa position: relative le place au-dessus du bandeau et les liens sont incliquables  */
 div.subheader {
   height: 130px;
 }
 
-//// SCRATCH BUTTONS
+/*
+ * Specific rules
+ */
+
+// [scratch] un bouton 'disabled' non clickable
 .sc-button {
    &.disabled {
       cursor: default;
@@ -49,8 +27,237 @@ div.subheader {
    }
 }
 
-//// à ranger
+// [debug] un affichage discret pour le debug
 .discret {
    color: grey;
    margin-right: 1em;
 }
+
+// reserre la hauteur des rangées de tableau (ul.record_actions prennait trop de place)
+table {
+   ul.record_actions {
+      margin: 0;
+      padding: 0.5em;
+   }
+}
+
+/*
+ *  ACCOMPANYING_COURSE
+ *  Header custom for Accompanying Course
+ */
+
+div#header-accompanying_course-name {
+  background: none repeat scroll 0 0 #718596;
+  color: #FFF;
+  h1 {
+    margin: 0.4em 0;
+  }
+  span {
+    a {
+      color: white;
+    }
+    a:hover {
+      text-decoration: underline;
+    }
+  }
+}
+div#header-accompanying_course-details {
+  background: none repeat scroll 0 0 #718596ab;
+  color: #FFF;
+  padding-top: 1em;
+  padding-bottom: 1em;
+}
+
+/*
+*  FLEX RESPONSIVE TABLE/BLOCK PRESENTATION
+*/
+div.flex-bloc,
+div.flex-table {
+   h2, h3, h4, dl, p {
+      margin: 0;
+   }
+   h2, h3, h4 {
+      color: var(--chill-blue);
+   }
+}
+
+/*
+* Bloc appearance
+*/
+div.flex-bloc {
+   box-sizing: border-box;
+   display: flex;
+   flex-direction: row;
+   flex-wrap: wrap;
+   align-items: stretch;
+   align-content: stretch;
+
+   div.item-bloc {
+      flex-grow: 0; flex-shrink: 1; flex-basis: 50%;
+
+      margin: 0;
+      border: 1px solid #000;
+      padding: 1em;
+
+      border-top: 0;
+      &:nth-child(1), &:nth-child(2) {
+         border-top: 1px solid #000;
+      }
+      border-left: 0;
+      &:nth-child(odd) {
+         border-left: 1px solid #000;
+      }
+
+      //background-color: #e6e6e6;
+      display: flex;
+      flex-direction: column;
+
+      div.item-row {
+         flex-grow: 1; flex-shrink: 1; flex-basis: auto;
+         display: flex;
+         flex-direction: column;
+
+         div.item-col {
+            &:first-child {
+               flex-grow: 0; flex-shrink: 0; flex-basis: auto;
+            }
+            &:last-child {
+               flex-grow: 1; flex-shrink: 1; flex-basis: auto;
+               display: flex;
+
+               .list-content { // ul, dl, or div
+               }
+               ul.record_actions {
+                  margin: 0;
+                  align-self: flex-end;
+                  flex-grow: 1; flex-shrink: 0; flex-basis: auto;
+                  li {
+                     margin-right: 5px;
+                  }
+               }
+            }
+         }
+      }
+   }
+   @media only screen and (max-width: 945px) { margin: auto -0.2em; }
+   @media only screen and (max-width: 935px) { margin: auto -0.5em; }
+   @media only screen and (max-width: 920px) { margin: auto -0.9em; }
+   @media only screen and (max-width: 900px) {
+      flex-direction: column;
+      margin: auto 0;
+      div.item-bloc {
+         border-left: 1px solid #000;
+         &:nth-child(2) {
+            border-top: 0;
+         }
+      }
+   }
+}
+
+/*
+* Table appearance
+*/
+div.flex-table {
+   display: flex;
+   flex-direction: column;
+   align-items: stretch;
+   align-content: stretch;
+
+   div.item-bloc {
+      display: flex;
+      flex-direction: column;
+      padding: 1em;
+      border: 1px solid #000;
+      border-top: 0;
+      &:first-child {
+         border-top: 1px solid #000;
+      }
+      &:nth-child(even) {
+         background-color: #e6e6e6;
+      }
+
+      div.item-row {
+         display: flex;
+         flex-direction: row;
+         &:not(:first-child) {
+            margin-top: 0.5em;
+            border-top: 1px dotted #0000004f;
+            padding-top: 0.5em;
+            flex-direction: column;
+         }
+
+         div.item-col {
+            &:first-child {
+               flex-grow: 0; flex-shrink: 0; flex-basis: 33%;
+            }
+            &:last-child {
+               flex-grow: 1; flex-shrink: 1; flex-basis: auto;
+               display: flex;
+               justify-content: flex-end;
+
+               .list-content { // ul, dl, or div
+               }
+               ul.record_actions {
+                  margin: 0;
+                  align-self: flex-start;
+                  flex-grow: 1; flex-shrink: 0; flex-basis: auto;
+                  li {
+                     margin-right: 5px;
+                  }
+               }
+            }
+         }
+         @media only screen and (max-width: 900px) {
+            flex-direction: column;
+            div.item-col {
+               &:last-child {
+                  ul.record_actions {
+                     align-self: flex-end;
+                  }
+               }
+            }
+         }
+
+         // neutralize
+         div.chill_address div.chill_address_address p { text-indent: 0; }
+      }
+   }
+}
+
+
+
+/*
+* Address form
+*/
+div.address_form {
+   display: flex;
+   flex-direction: column;
+   div.address_form__header {
+
+   }
+   div.address_form__select {
+      display: flex;
+      flex-direction: row;
+      justify-content: space-between;
+
+      div.address_form__select__body {
+         display: flex;
+         flex-direction: column;
+         flex-grow: 1;
+      }
+
+      div.address_form__select__map {
+         margin: 0px 20px;
+         div#address_map {
+            height:400px;
+            width:400px;
+         }
+      }
+   }
+   div.address_form__more {
+
+   }
+}
+
+
+

src/Bundle/ChillMainBundle/Resources/public/vuejs/Address/App.vue

@@ -1,5 +1,5 @@
 <template>
-   
+
    <div v-if="address.address">
       {{ address.address.street }}, {{ address.address.streetNumber }}
    </div>
@@ -9,7 +9,7 @@
    <div v-if="address.country">
       {{ address.country.name }}
    </div>
-   
+
    <add-address
       @addNewAddress="addNewAddress">
    </add-address>
@@ -33,7 +33,26 @@ export default {
    methods: {
       addNewAddress({ address, modal }) {
          console.log('@@@ CLICK button addNewAdress', address);
-         this.$store.dispatch('addAddress', address.selected);
+
+         let newAddress = {
+            'isNoAddress': address.isNoAddress,
+            'street': address.selected.address.street,
+            'streetNumber': address.selected.address.streetNumber,
+            'postcode': {'id': address.selected.city.id },
+            'floor': address.floor,
+            'corridor': address.corridor,
+            'steps': address.steps,
+            'flat': address.flat,
+            'buildingName': address.buildingName,
+            'distribution': address.distribution,
+            'extra': address.extra
+         };
+
+         if (address.selected.address.point !== undefined){
+            newAddress = Object.assign(newAddress, {'point': address.selected.address.point.coordinates});
+         }
+
+         this.$store.dispatch('addAddress', newAddress);
          modal.showModal = false;
       }
    }

src/Bundle/ChillMainBundle/Resources/public/vuejs/Address/js/i18n.js

@@ -1,12 +1,13 @@
 const addressMessages = {
    fr: {
-      add_an_address: 'Ajouter une adresse',
-      select_an_address: 'Sélectionner une adresse',
+      add_an_address_title: 'Ajouter une adresse',
+      select_an_address_title: 'Sélectionner une adresse',
       fill_an_address: 'Compléter l\'adresse',
       select_country: 'Choisir le pays',
       select_city: 'Choisir une localité',
       select_address: 'Choisir une adresse',
-      isNoAddress: 'L\'adresse n\'est pas celle d\'un domicile fixe ?',
+      create_address: 'Appuyer sur "Entrée" pour créer une nouvelle adresse',
+      isNoAddress: 'Pas d\'adresse complète',
       floor: 'Étage',
       corridor: 'Couloir',
       steps: 'Escalier',

src/Bundle/ChillMainBundle/Resources/public/vuejs/Address/store/index.js

@@ -1,8 +1,7 @@
 import 'es6-promise/auto';
 import { createStore } from 'vuex';
 
-// le fetch POST serait rangé dans la logique du composant qui appelle AddAddress
-//import { postAddress } from '... api' 
+import { postAddress } from '../../_api/AddAddress'
 
 const debug = process.env.NODE_ENV !== 'production';
 
@@ -10,11 +9,14 @@ const store = createStore({
    strict: debug,
    state: {
       address: {},
-      errorMsg: {}
+      errorMsg: []
    },
    getters: {
    },
    mutations: {
+      catchError(state, error) {
+         state.errorMsg.push(error);
+      },
       addAddress(state, address) {
          console.log('@M addAddress address', address);
          state.address = address;
@@ -23,19 +25,19 @@ const store = createStore({
    actions: {
       addAddress({ commit }, payload) {
          console.log('@A addAddress payload', payload);
-         commit('addAddress', payload); // à remplacer par 
-         
-         // fetch POST qui envoie l'adresse, et récupère la confirmation que c'est ok. 
-         // La confirmation est l'adresse elle-même.
-         //
-         //   postAddress(payload) 
-         //   .fetch(address => new Promise((resolve, reject) => {
-         //      commit('addAddress', address);
-         //      resolve();
-         //   }))
-         //   .catch((error) => { 
-         //      state.errorMsg.push(error.message); 
-         //   }); 
+         //commit('addAddress', payload); // à remplacer par la suite
+
+         //fetch POST qui envoie l'adresse, et récupère la confirmation que c'est ok.
+         //La confirmation est l'adresse elle-même.
+
+         postAddress(payload)
+            .then(address => new Promise((resolve, reject) => {
+               commit('addAddress', address);
+               resolve();
+            }))
+            .catch((error) => {
+               commit('catchError', error);
+            });
       }
    }
 });

src/Bundle/ChillMainBundle/Resources/public/vuejs/_api/AddAddress.js

@@ -1,37 +1,43 @@
 /*
-* Endpoint countries GET
-* TODO
+* Endpoint chill_api_single_country__index
+* method GET, get Country Object
+* @returns {Promise} a promise containing all Country object
 */
 const fetchCountries = () => {
    console.log('<<< fetching countries');
-   return [
-      {id: 1, name: 'France', countryCode: 'FR'},
-      {id: 2, name: 'Belgium', countryCode: 'BE'}
-   ];
+
+   const url = `/api/1.0/main/country.json?item_per_page=1000`;
+   return fetch(url)
+      .then(response => {
+         if (response.ok) { return response.json(); }
+         throw Error('Error with request resource response');
+      });
 };
 
 /*
-* Endpoint cities GET 
-* TODO
+* Endpoint chill_api_single_postal_code__index
+* method GET, get Country Object
+* @returns {Promise} a promise containing all Postal Code objects filtered with country
 */
-const fetchCities = (country) => {   
+const fetchCities = (country) => {
    console.log('<<< fetching cities for', country);
-   return [
-      {id: 1, name: 'Bruxelles', code: '1000', country: 'BE'},
-      {id: 2, name: 'Aisne', code: '85045', country: 'FR'},
-      {id: 3, name: 'Saint-Gervais', code: '85230', country: 'FR'}
-   ];
+   const url = `/api/1.0/main/postal-code.json?item_per_page=1000&country=${country.id}`;
+   return fetch(url)
+      .then(response => {
+         if (response.ok) { return response.json(); }
+         throw Error('Error with request resource response');
+      });
 };
 
 /*
-* Endpoint chill_main_address_reference_api_show
+* Endpoint chill_api_single_address_reference__index
 * method GET, get AddressReference Object
-* @returns {Promise} a promise containing all AddressReference object
+* @returns {Promise} a promise containing all AddressReference objects filtered with postal code
 */
-const fetchReferenceAddresses = (city) => {
-    console.log('<<< fetching references addresses for', city); // city n'est pas utilisé pour le moment
-    
-    const url = `/api/1.0/main/address-reference.json`;
+const fetchReferenceAddresses = (postalCode) => {
+    console.log('<<< fetching references addresses for', postalCode);
+   //TODO deal with huge number of addresses... we should do suggestion...
+    const url = `/api/1.0/main/address-reference.json?item_per_page=1000&postal_code=${postalCode.id}`;
     return fetch(url)
        .then(response => {
           if (response.ok) { return response.json(); }
@@ -39,8 +45,31 @@ const fetchReferenceAddresses = (city) => {
        });
 };
 
+/*
+* Endpoint chill_api_single_address__entity__create
+* method POST, post Address Object
+* @returns {Promise}
+*/
+const postAddress = (address) => {
+   console.log(address);
+   const url = `/api/1.0/main/address.json?`;
+   const body = address;
+
+   return fetch(url, {
+      method: 'POST',
+      headers: {
+         'Content-Type': 'application/json;charset=utf-8'
+         },
+      body: JSON.stringify(body)
+   }).then(response => {
+      if (response.ok) { return response.json(); }
+      throw Error('Error with request resource response');
+   });
+};
+
 export {
    fetchCountries,
    fetchCities,
-   fetchReferenceAddresses
+   fetchReferenceAddresses,
+   postAddress
 };

src/Bundle/ChillMainBundle/Resources/public/vuejs/_components/AddAddress.vue

@@ -1,6 +1,6 @@
 <template>
    <button class="sc-button bt-create centered mt-4" @click="openModal">
-      {{ $t('add_an_address') }}
+      {{ $t('add_an_address_title') }}
    </button>
 
    <teleport to="body">
@@ -9,76 +9,64 @@
          @close="modal.showModal = false">
 
          <template v-slot:header>
-            <h3 class="modal-title">{{ $t('add_an_address') }}</h3>
+            <h3 class="modal-title">{{ $t('add_an_address_title') }}</h3>
          </template>
 
          <template v-slot:body>
-            
-            <h4>{{ $t('select_an_address') }}</h4>
-            
-            <label for="isNoAddress">
-               <input type="checkbox" 
-                  name="isNoAddress" 
-                  v-bind:placeholder="$t('isNoAddress')" 
-                  v-model="isNoAddress" 
-                  v-bind:value="value"/>
-               {{ $t('isNoAddress') }}
-            </label>
+            <div class="address_form">
 
-            <country-selection
-               v-bind:address="address"
-               v-bind:getCities="getCities">
-            </country-selection>
-            
-            <city-selection
-               v-bind:address="address"
-               v-bind:getReferenceAddresses="getReferenceAddresses">
-            </city-selection>
-            
-            <address-selection
-               v-bind:address="address"
-               v-bind:updateMapCenter="updateMapCenter">
-            </address-selection>
+               <div class="address_form__header">
+                  <h4>{{ $t('select_an_address_title') }}</h4>
+               </div>
 
-            <address-map
-               v-bind:address="address"
-               ref="addressMap">
-            </address-map>
-            
-            <address-more 
-               v-if="!isNoAddress"
-               v-bind:address="address">
-            </address-more>
-                        
-            <!--
-            <div class="address_form__fields__isNoAddress"></div>
-            <div class="address_form__select">
-               <div class="address_form__select__header"></div>
-               <div class="address_form__select__left"></div>
-               <div class="address_form__map"></div>
+               <div class="address_form__select">
+
+                  <div class="address_form__select__body">
+                     <label for="isNoAddress">
+                        <input type="checkbox"
+                           name="isNoAddress"
+                           v-bind:placeholder="$t('isNoAddress')"
+                           v-model="isNoAddress"
+                           v-bind:value="value"/>
+                        {{ $t('isNoAddress') }}
+                     </label>
+
+                     <country-selection
+                        v-bind:address="address"
+                        v-bind:getCities="getCities">
+                     </country-selection>
+
+                     <city-selection
+                        v-bind:address="address"
+                        v-bind:getReferenceAddresses="getReferenceAddresses">
+                     </city-selection>
+
+                     <address-selection
+                        v-bind:address="address"
+                        v-bind:updateMapCenter="updateMapCenter">
+                     </address-selection>
+                  </div>
+
+                  <div class="address_form__select__map">
+                     <address-map
+                        v-bind:address="address"
+                        ref="addressMap">
+                     </address-map>
+                  </div>
+               </div>
+
+               <div class="address_form__more">
+                  <address-more
+                     v-if="!isNoAddress"
+                     v-bind:address="address">
+                  </address-more>
+               </div>
             </div>
-            <div class="address_form__fields">
-               <div class="address_form__fields__header"></div>
-               <div class="address_form__fields__left"></div>
-               <div class="address_form__fields__right"></div>
-            </div>
-         
-            à discuter, 
-            mais je pense qu'il est préférable de profiter de l'imbriquation des classes css 
-            
-            div.address_form {
-               div.select {
-                  div.header {}
-                  div.left {}
-                  div.map {}
-               }
-            }
-         
-            -->
+
          </template>
 
          <template v-slot:footer>
-            <button class="sc-button green" 
+            <button class="sc-button green"
                @click.prevent="$emit('addNewAddress', { address, modal })">
                <i class="fa fa-plus fa-fw"></i>{{ $t('action.add')}}
             </button>
@@ -155,49 +143,47 @@ export default {
          }
       }
    },
+   mounted() {
+       this.getCountries();
+   },
    methods: {
       openModal() {
          this.modal.showModal = true;
          this.resetAll();
-         this.getCountries();
-         
          //this.$nextTick(function() {
          //   this.$refs.search.focus(); // positionner le curseur à l'ouverture de la modale
          //})
       },
       getCountries() {
          console.log('getCountries');
-         this.address.loaded.countries = fetchCountries(); // à remplacer par
-         //  fetchCountries().then(countries => new Promise((resolve, reject) => {
-         //     this.address.loaded.countries = countries;
-         //     resolve()
-         //  }))
-         //  .catch((error) => { 
-         //     this.errorMsg.push(error.message); 
-         //  }); 
+         fetchCountries().then(countries => new Promise((resolve, reject) => {
+             this.address.loaded.countries = countries.results;
+             resolve()
+          }))
+          .catch((error) => {
+             this.errorMsg.push(error.message);
+          });
       },
       getCities(country) {
          console.log('getCities for', country.name);
-         this.address.loaded.cities = fetchCities(); // à remplacer par
-         //  fetchCities(country).then(cities => new Promise((resolve, reject) => {
-         //     this.address.loaded.cities = cities;
-         //     resolve()
-         //  }))
-         //  .catch((error) => { 
-         //     this.errorMsg.push(error.message); 
-         //  }); 
+         fetchCities(country).then(cities => new Promise((resolve, reject) => {
+            this.address.loaded.cities = cities.results;
+            resolve()
+         }))
+         .catch((error) => {
+            this.errorMsg.push(error.message);
+         });
       },
       getReferenceAddresses(city) {
          console.log('getReferenceAddresses for', city.name);
-         fetchReferenceAddresses(city)  // il me semble que le paramètre city va limiter le poids des adresses de références reçues
-            .then(addresses => new Promise((resolve, reject) => {
+         fetchReferenceAddresses(city).then(addresses => new Promise((resolve, reject) => {
                console.log('addresses', addresses);
                this.address.loaded.addresses = addresses.results;
                resolve();
             }))
-            .catch((error) => { 
-               this.errorMsg.push(error.message); 
-            }); 
+            .catch((error) => {
+               this.errorMsg.push(error.message);
+            });
       },
       updateMapCenter(point) {
          console.log('point', point);
@@ -208,7 +194,7 @@ export default {
       resetAll() {
          console.log('reset all selected');
          this.address.loaded.addresses = [];
-         this.address.selected.address = {}; 
+         this.address.selected.address = {};
          this.address.loaded.cities = [];
          this.address.selected.city = {};
          this.address.selected.country = {};

src/Bundle/ChillMainBundle/Resources/public/vuejs/_components/AddAddress/AddressMap.vue

@@ -1,6 +1,6 @@
 <template>
    <div class="container">
-      <div id='address_map' style='height:400px; width:400px;'></div>
+      <div id='address_map'></div>
    </div>
 </template>
 
@@ -11,6 +11,7 @@ import markerIconPng from 'leaflet/dist/images/marker-icon.png'
 import 'leaflet/dist/leaflet.css';
 
 let map;
+let marker;
 
 export default {
    name: 'AddressMap',
@@ -30,13 +31,15 @@ export default {
 
          const markerIcon = L.icon({
             iconUrl: markerIconPng,
+            iconAnchor: [12, 41],
          });
 
-         L.marker([48.8589, 2.3469], {icon: markerIcon}).addTo(map);
+         marker = L.marker([48.8589, 2.3469], {icon: markerIcon}).addTo(map);
 
       },
       update() {
          console.log('update map with : ', this.address.addressMap.center)
+         marker.setLatLng(this.address.addressMap.center);
          map.setView(this.address.addressMap.center, 12);
       }
    },

src/Bundle/ChillMainBundle/Resources/public/vuejs/_components/AddAddress/AddressSelection.vue

@@ -1,38 +1,56 @@
 <template>
    <div class="container">
-      <select 
-         v-model="selected">
-         <option :value="{}" disabled selected>{{ $t('select_address') }}</option>
-         <option 
-            v-for="item in this.addresses" 
-            v-bind:item="item" 
-            v-bind:key="item.id" 
-            v-bind:value="item">
-            {{ item.street }}, {{ item.streetNumber }}
-         </option>
-      </select>
+      <VueMultiselect
+         v-model="value"
+         @select="selectAddress"
+         name="field"
+         track-by="id"
+         label="value"
+         :custom-label="transName"
+         :taggable="true"
+         :multiple="false"
+         @tag="addAddress"
+         :placeholder="$t('select_address')"
+         :tagPlaceholder="$t('create_address')"
+         :options="addresses">
+      </VueMultiselect>
    </div>
 </template>
 
 <script>
+import VueMultiselect from 'vue-multiselect';
 
 export default {
    name: 'AddressSelection',
+   components: { VueMultiselect },
    props: ['address', 'updateMapCenter'],
+   data() {
+      return {
+         value: null
+      }
+   },
    computed: {
-      addresses() { 
-         return this.address.loaded.addresses; 
+      addresses() {
+         return this.address.loaded.addresses;
+      }
+   },
+   methods: {
+      transName(value) {
+         return value.streetNumber === undefined ? value.street : `${value.street}, ${value.streetNumber}`
       },
-      selected: {
-         set(value) {
-            console.log('selected value', value);
-            this.address.selected.address = value;
-            this.updateMapCenter(value.point);
-         },
-         get() {
-            return this.address.selected.address;
-         }
+      selectAddress(value) {
+         this.address.selected.address = value;
+         this.updateMapCenter(value.point);
       },
+      addAddress (newAddress) {
+         const address = {
+            street: newAddress
+         };
+         this.value = address;
+         this.address.selected.address = address;
+      }
    }
 };
 </script>
+
+<style src="vue-multiselect/dist/vue-multiselect.css"></style>

src/Bundle/ChillMainBundle/Resources/public/vuejs/_components/AddAddress/CitySelection.vue

@@ -1,38 +1,45 @@
 <template>
    <div class="container">
-      <select 
-         v-model="selected">
-         <option :value="{}" disabled selected>{{ $t('select_city') }}</option>
-         <option 
-            v-for="item in this.cities" 
-            v-bind:item="item" 
-            v-bind:key="item.id" 
-            v-bind:value="item">
-            {{ item.code }}-{{ item.name }}
-         </option>
-      </select>
+      <VueMultiselect
+         v-model="value"
+         @select="selectCity"
+         name="field"
+         track-by="id"
+         label="value"
+         :custom-label="transName"
+         :placeholder="$t('select_city')"
+         :options="cities">
+      </VueMultiselect>
    </div>
 </template>
 
 <script>
+import VueMultiselect from 'vue-multiselect';
 
 export default {
    name: 'CitySelection',
+   components: { VueMultiselect },
    props: ['address', 'getReferenceAddresses'],
+   data() {
+      return {
+         value: null
+      }
+   },
+   methods: {
+      transName(value) {
+         return `${value.code}-${value.name}`
+      },
+      selectCity(value) {
+         this.address.selected.city = value;
+         this.getReferenceAddresses(value);
+      },
+   },
    computed: {
-      cities() { 
-         return this.address.loaded.cities; 
-      },
-      selected: {
-         set(value) {
-            console.log('selected value', value.name);
-            this.address.selected.city = value;
-            this.getReferenceAddresses(value);
-         },
-         get() {
-            return this.address.selected.city;
-         }
-      },
+      cities() {
+         return this.address.loaded.cities;
+      }
    }
 };
 </script>
+
+<style src="vue-multiselect/dist/vue-multiselect.css"></style>

src/Bundle/ChillMainBundle/Resources/public/vuejs/_components/AddAddress/CountrySelection.vue

@@ -1,38 +1,59 @@
 <template>
    <div class="container">
-      <select 
-         v-model="selected">
-         <option :value="{}" disabled selected>{{ $t('select_country') }}</option>
-         <option 
-            v-for="item in this.countries" 
-            v-bind:item="item" 
-            v-bind:key="item.id" 
-            v-bind:value="item">
-            {{ item.name }}
-         </option>
-      </select>
+      <VueMultiselect
+         v-model="value"
+         name="field"
+         track-by="id"
+         label="name"
+         :custom-label="transName"
+         :placeholder="$t('select_country')"
+         :options="countries"
+         @select="selectCountry">
+      </VueMultiselect>
    </div>
 </template>
 
 <script>
+import VueMultiselect from 'vue-multiselect';
 
 export default {
    name: 'CountrySelection',
+   components: { VueMultiselect },
    props: ['address', 'getCities'],
-   computed: {
-      countries() { 
-         return this.address.loaded.countries; 
-      },
-      selected: {
-         set(value) {
-            console.log('selected value', value.name);
-            this.address.selected.country = value;
-            this.getCities(value);
-         },
-         get() {
-            return this.address.selected.country;
+   data() {
+      return {
+         value: this.address.loaded.countries.filter(c => c.countryCode === 'FR')[0]
+      }
+   },
+   methods: {
+      init() {
+         if (this.value !== undefined) {
+            this.getCities(this.value);
          }
+      },
+      transName ({ name }) {
+         return name.fr //TODO multilang
+      },
+      selectCountry(value) {
+         console.log(value);
+         this.address.selected.country = value;
+         this.getCities(value);
+      },
+   },
+   mounted(){
+      this.init()
+   },
+   computed: {
+      countries() {
+         const countries = this.address.loaded.countries;
+         let orderedCountries = [];
+         orderedCountries.push(...countries.filter(c => c.countryCode === 'FR'))
+         orderedCountries.push(...countries.filter(c => c.countryCode === 'BE'))
+         orderedCountries.push(...countries.filter(c => c.countryCode !== 'FR').filter(c => c.countryCode !== 'BE'))
+         return orderedCountries;
       }
    }
 };
 </script>
+
+<style src="vue-multiselect/dist/vue-multiselect.css"></style>

src/Bundle/ChillMainBundle/Resources/public/vuejs/_components/OnTheFly.vue

@@ -0,0 +1,153 @@
+<template>
+  
+   <a class="sc-button" target="_blank"
+      :class="classAction"
+      :title="$t(titleAction)"
+      @click="openModal">
+      {{ buttonText }}
+   </a>
+  
+   <teleport to="body">
+      <modal v-if="modal.showModal"
+         :modalDialogClass="modal.modalDialogClass"
+         @close="modal.showModal = false">
+         
+         <template v-slot:header>
+            <h3 class="modal-title">{{ $t(titleModal) }}</h3>
+         </template>
+         
+         <template v-slot:body v-if="type === 'person'">
+            <on-the-fly-person
+               v-bind:id="id"
+               v-bind:type="type"
+               v-bind:action="action"
+               ref="castPerson">
+            </on-the-fly-person>
+         </template>
+         
+         <template v-slot:body v-else-if="type === 'thirdparty'">
+            <on-the-fly-thirdparty
+               v-bind:id="id"
+               v-bind:type="type"
+               v-bind:action="action"
+               ref="castThirdparty">
+            </on-the-fly-thirdparty>
+         </template>
+         
+         <template v-slot:body v-else>
+            <on-the-fly-create
+               v-bind:action="action"
+               ref="castNew">
+            </on-the-fly-create>
+         </template>
+            
+         <template v-slot:footer>
+            <button v-if="action === 'show'"
+               @click="changeActionTo('edit')"
+               class="sc-button bt-update"> <!-- @click.prevent="$emit('..', ..)" -->
+            </button>
+            <button v-else
+               class="sc-button bt-save"
+               @click="saveAction"
+               > <!--  
+               -->
+               {{ $t('action.save')}}
+            </button>
+         </template>
+         
+      </modal>
+   </teleport>
+   
+</template>
+
+<script>
+import Modal from 'ChillMainAssets/vuejs/_components/Modal.vue';
+import OnTheFlyPerson from 'ChillPersonAssets/vuejs/_components/OnTheFly/Person.vue';
+import OnTheFlyThirdparty from './OnTheFly/ThirdParty.vue';
+import OnTheFlyCreate from './OnTheFly/Create.vue';
+
+export default {
+   name: 'OnTheFly',
+   components: {
+      Modal,
+      OnTheFlyPerson,
+      OnTheFlyThirdparty,
+      OnTheFlyCreate
+   },
+   props: ['type', 'id', 'action', 'buttonText'],
+   data() {
+      return {
+         modal: {
+            showModal: false,
+            modalDialogClass: "modal-dialog-scrollable modal-xl"
+         },
+         action: this.action
+      }
+   },
+   computed: {
+      action() {
+         return this.$data.action;
+      },
+      classAction() {
+         switch (this.action) {
+            case 'show':
+               return 'bt-show';
+            case 'edit':
+               return 'bt-update';
+            case 'create':
+               return 'bt-create';
+         }
+      },
+      titleAction() {
+         switch (this.action) {
+            case 'show':
+               return 'action.show';
+            case 'edit':
+               return 'action.edit';
+            case 'create':
+               return 'action.create';
+         }
+      },
+      titleModal() {
+         switch (this.action) {
+            case 'show':
+               return 'onthefly.show.' + this.type;
+            case 'edit':
+               return 'onthefly.edit.' + this.type;
+            case 'create':
+               return 'onthefly.create.title';
+         }
+      }
+   },
+   methods: {
+      openModal() {
+         this.modal.showModal = true;
+         this.$nextTick(function() {
+            //this.$refs.search.focus();
+         })
+      },
+      changeActionTo(action) {
+         // [BUG] clic first on show item button; in modal clic edit button; close modal; clic again on show item button
+         this.$data.action = action; 
+      },
+      saveAction() {
+         console.log('saveAction');
+         if (this.type === 'person') {
+            this.$refs.castPerson.postData();
+         } else if (this.type === 'thirdparty') {
+            this.$refs.castThirdparty.postData();
+         } else {
+            // saveAction() ==cast=to==> child.castByType() ==cast=to==> grand-child.postData()
+            this.$refs.castNew.castByType();
+         }
+         this.modal.showModal = false;
+      }
+   }
+}
+</script>
+
+<style lang="css" scoped>
+a {
+   cursor: pointer;
+}
+</style>

src/Bundle/ChillMainBundle/Resources/public/vuejs/_components/OnTheFly/Create.vue

@@ -0,0 +1,84 @@
+<template>   
+   <ul class="nav nav-tabs">
+      <li class="nav-item">
+         <a class="nav-link" :class="{ active: isActive('person') }">
+            <label for="person">
+               <input type="radio" name="person" v-model="radioType" value="person">
+               {{ $t('onthefly.create.person') }}
+            </label>
+         </a>
+      </li>
+      <li class="nav-item">
+         <a class="nav-link" :class="{ active: isActive('thirdparty') }">
+            <label for="thirdparty">
+               <input type="radio" name="thirdparty" v-model="radioType" value="thirdparty">
+               {{ $t('onthefly.create.thirdparty') }}
+            </label>
+         </a>
+      </li>
+   </ul>
+   
+   <div class="my-4">
+      <on-the-fly-person
+         v-if="type === 'person'"
+         v-bind:action="action"
+         ref="castPerson">
+      </on-the-fly-person>
+      
+      <on-the-fly-thirdparty
+         v-if="type === 'thirdparty'"
+         v-bind:action="action"
+         ref="castThirdparty">
+      </on-the-fly-thirdparty>
+   </div>      
+</template>
+
+<script>
+import OnTheFlyPerson from 'ChillPersonAssets/vuejs/_components/OnTheFly/Person.vue';
+import OnTheFlyThirdparty from './ThirdParty.vue'; // TODO move in ChillThirdpartyAssets
+
+export default {
+   name: "OnTheFlyCreate",
+   props: ['action'], 
+   components: {
+      OnTheFlyPerson,
+      OnTheFlyThirdparty
+   },
+   data() {
+      return {
+         type: 'person' //by default
+      }
+   },
+   computed: {
+      radioType: {
+         set(type) {
+            this.type = type;
+         },
+         get() {
+            return this.type;
+         }
+      }
+   },
+   methods: {
+      isActive(tab) {
+         return (this.type === tab) ? true : false; 
+      },
+      castByType() {
+         console.log('saveActionByType');
+         if (this.type === 'person') {
+            this.$refs.castPerson.postData();
+         } else if (this.type === 'thirdparty') {
+            this.$refs.castThirdparty.postData();
+         } else {
+            throw Error('Invalid type of entity');
+         }
+      }
+   }
+}
+</script>
+
+<style lang="css" scoped>
+label {
+   cursor: pointer;
+}
+</style>

src/Bundle/ChillMainBundle/Resources/public/vuejs/_components/OnTheFly/ThirdParty.vue

@@ -0,0 +1,23 @@
+<template>
+   <div v-if="action === 'show'">
+      show
+      thirdparty
+      {{ id }}
+   </div>
+   <div v-else-if="action === 'edit' || action === 'create'">
+      {{ action }}
+      thirdparty 
+      {{ id }}
+   </div>
+</template>
+
+<script>
+export default {
+   name: "OnTheFlyThirdParty",
+   props: ['id', 'type', 'action']
+}
+// TODO move in ChillThirdpartyAssets
+</script>
+
+<style lang="css" scoped>
+</style>

src/Bundle/ChillMainBundle/Resources/public/vuejs/_js/i18n.js

@@ -37,12 +37,32 @@ const messages = {
          ok: "OK",
          cancel: "Annuler",
          close: "Fermer",
-         next: "Suivant",
-         previous: "Précédent",
          back: "Retour",
          check_all: "cocher tout",
          reset: "réinitialiser"
       },
+      nav: {
+         next: "Suivant",
+         previous: "Précédent",
+         top: "Haut",
+         bottom: "Bas",
+      },
+      onthefly: {
+         show: {
+            person: "Détails de l'usager",
+            thirdparty: "Détails du tiers"
+         },
+         edit: {
+            person: "Modifier un usager",
+            thirdparty: "Modifier un tiers"
+         },
+         create: {
+            button: "Créer \"{q}\"",
+            title: "Créer à la volée…",
+            person: "un nouvel usager",
+            thirdparty: "un nouveau tiers"
+         },         
+      }
    }
 };
 

src/Bundle/ChillMainBundle/Resources/views/Address/entity_render.html.twig

@@ -0,0 +1,16 @@
+<div class="chill_address">
+    {% if options['has_no_address'] == true and address.isNoAddress == true %}
+        <div class="chill_address_is_noaddress">{{ 'address.consider homeless'|trans }}</div>
+    {% endif %}
+    <div class="chill_address_address {% if options['multiline'] %}chill_address_address--multiline{% endif %}">
+    {% if address.street is not empty %}<p class="street street1">{{ address.street }}</p>{% endif %}
+    {% if address.streetNumber is not empty %}<p class="street street2">{{ address.streetNumber }}</p>{% endif %}
+    {% if address.postCode is not empty %}
+    <p class="postalCode"><span class="code">{{ address.postCode.code }}</span> <span class="name">{{ address.postCode.name }}</span></p>
+    <p class="country">{{ address.postCode.country.name|localize_translatable_string }}</p>
+    {% endif %}
+    </div>
+{%- if options['with_valid_from'] == true -%}
+<span class="address_since">{{ 'Since %date%'|trans( { '%date%' : address.validFrom|format_date('long') } ) }}</span>
+{%- endif -%}
+</div>

src/Bundle/ChillMainBundle/Resources/views/Address/macro.html.twig

@@ -1,11 +1,12 @@
 {%- macro _render(address, options) -%}
     {%- set options = { 'with_valid_from' : true  }|merge(options|default({})) -%}
     {%- set options = { 'has_no_address'  : false }|merge(options|default({})) -%}
+    {%- set options = { 'with_icon' : false }|merge(options|default({})) -%}
     <div class="chill_address">
         {% if options['has_no_address'] == true and address.isNoAddress == true %}
             <div class="chill_address_is_noaddress">{{ 'address.consider homeless'|trans }}</div>
         {% endif %}
-        <div class="chill_address_address">
+        <div class="chill_address_address">{% if options['with_icon'] == true %}<i class="fa fa-fw fa-map-marker"></i>{% endif %}
         {% if address.street is not empty %}<p class="street street1">{{ address.street }}</p>{% endif %}
         {% if address.streetNumber is not empty %}<p class="street street2">{{ address.streetNumber }}</p>{% endif %}
         {% if address.postCode is not empty %}

src/Bundle/ChillMainBundle/Resources/views/Timeline/chain_timelines.html.twig

@@ -0,0 +1,7 @@
+<div class="timeline">
+    {% for result in results %}
+        <div class="timeline-item {% if loop.index0 is even %}even{% else %}odd{% endif %}">
+            {% include result.template with result.template_data %}
+        </div>
+    {% endfor %}
+</div>

src/Bundle/ChillMainBundle/Resources/views/Timeline/index.html.twig

@@ -1,7 +1,15 @@
-<div class="timeline">
-    {% for result in results %}
-        <div class="timeline-item {% if loop.index0 is even %}even{% else %}odd{% endif %}">
-            {% include result.template with result.template_data %}
-        </div>
-    {% endfor %}
-</div>
+{% extends "@ChillMain/layout.html.twig"  %}
+
+{% block content %}
+  <div id="container content">
+    <div class="grid-8 centered">
+      <h1>{{ 'Global timeline'|trans }}</h1>
+
+      {{ timeline|raw }}
+      
+      {% if nb_items > paginator.getItemsPerPage %}
+      {{ chill_pagination(paginator) }}
+      {% endif %}
+    </div>
+  </div>
+  {% endblock content %}

src/Bundle/ChillMainBundle/Routing/MenuBuilder/SectionMenuBuilder.php

@@ -68,6 +68,14 @@ class SectionMenuBuilder implements LocalMenuBuilderInterface
                 'icons' => ['home'],
                 'order' => 0
             ]);
+
+        $menu->addChild($this->translator->trans('Global timeline'), [
+            'route' => 'chill_center_timeline',
+        ])
+            ->setExtras([
+                'order' => 10
+            ]
+        );
         
         if ($this->authorizationChecker->isGranted(ChillExportVoter::EXPORT)) {
             $menu->addChild($this->translator->trans('Export Menu'), [

src/Bundle/ChillMainBundle/Security/Authorization/AuthorizationHelper.php

@@ -110,8 +110,6 @@ class AuthorizationHelper
             return false;
         }
         
-        $role = ($attribute instanceof Role) ? $attribute : new Role($attribute);
-        
         foreach ($user->getGroupCenters() as $groupCenter){
             //filter on center
             if ($groupCenter->getCenter()->getId() === $entity->getCenter()->getId()) {
@@ -119,8 +117,7 @@ class AuthorizationHelper
                 //iterate on roleScopes
                 foreach($permissionGroup->getRoleScopes() as $roleScope) {
                     //check that the role allow to reach the required role
-                    if ($this->isRoleReached($role, 
-                          new Role($roleScope->getRole()))){
+                    if ($this->isRoleReached($attribute, $roleScope->getRole())) {
                         //if yes, we have a right on something...
                         // perform check on scope if necessary
                         if ($entity instanceof HasScopeInterface) {
@@ -149,12 +146,15 @@ class AuthorizationHelper
      * and optionnaly Scope
      * 
      * @param User $user
-     * @param Role $role
+     * @param string|Role $role
      * @param null|Scope $scope
      * @return Center[]
      */
-    public function getReachableCenters(User $user, Role $role, Scope $scope = null)
+    public function getReachableCenters(User $user, $role, Scope $scope = null)
     {
+        if ($role instanceof Role) {
+            $role = $role->getRole();
+        }
         $centers = array();
         
         foreach ($user->getGroupCenters() as $groupCenter){
@@ -162,8 +162,7 @@ class AuthorizationHelper
             //iterate on roleScopes
             foreach($permissionGroup->getRoleScopes() as $roleScope) {
                 //check that the role is in the reachable roles
-                if ($this->isRoleReached($role, 
-                      new Role($roleScope->getRole()))) {
+                if ($this->isRoleReached($role, $roleScope->getRole())) {
                     if ($scope === null) {
                         $centers[] = $groupCenter->getCenter();
                         break 1;
@@ -180,6 +179,30 @@ class AuthorizationHelper
         
         return $centers;
     }
+
+    /**
+     * Filter an array of centers, return only center which are reachable
+     *
+     * @param User $user The user
+     * @param array $centers a list of centers which are going to be filtered
+     * @param string|Center $role
+     */
+    public function filterReachableCenters(User $user, array $centers, $role): array
+    {
+        $results = [];
+
+        if ($role instanceof Role) {
+            $role = $role->getRole();
+        }
+
+        foreach ($centers as $center) {
+            if ($this->userCanReachCenter($user, $center, $role)) {
+                $results[] = $center;
+            }
+        }
+
+        return $results;
+    }
     
     /**
      * Return all reachable scope for a given user, center and role
@@ -191,8 +214,12 @@ class AuthorizationHelper
      * @param Center $center
      * @return Scope[]
      */
-    public function getReachableScopes(User $user, Role $role, Center $center)
+    public function getReachableScopes(User $user, $role, Center $center)
     {
+        if ($role instanceof Role) {
+            $role = $role->getRole();
+        }
+
         return $this->getReachableCircles($user, $role, $center);
     }
     
@@ -200,12 +227,15 @@ class AuthorizationHelper
      * Return all reachable circle for a given user, center and role
      * 
      * @param User $user
-     * @param Role $role
+     * @param string|Role $role
      * @param Center $center
      * @return Scope[]
      */
-    public function getReachableCircles(User $user, Role $role, Center $center)
+    public function getReachableCircles(User $user, $role, Center $center)
     {
+        if ($role instanceof Role) {
+            $role = $role->getRole();
+        }
         $scopes = array();
         
         foreach ($user->getGroupCenters() as $groupCenter){
@@ -215,9 +245,7 @@ class AuthorizationHelper
                 //iterate on roleScopes
                 foreach($permissionGroup->getRoleScopes() as $roleScope) {
                     //check that the role is in the reachable roles
-                    if ($this->isRoleReached($role, 
-                          new Role($roleScope->getRole()))) {
-
+                    if ($this->isRoleReached($role, $roleScope->getRole())) {
                         $scopes[] = $roleScope->getScope();
                     }
                 }
@@ -269,10 +297,10 @@ class AuthorizationHelper
      * @param Role $parentRole The role which should give access to $childRole
      * @return boolean true if the child role is granted by parent role
      */
-    protected function isRoleReached(Role $childRole, Role $parentRole)
+    protected function isRoleReached($childRole, $parentRole)
     {
         $reachableRoles = $this->roleHierarchy
-                ->getReachableRoles([$parentRole]);
+                ->getReachableRoleNames([$parentRole]);
         
         return in_array($childRole, $reachableRoles);
     }

src/Bundle/ChillMainBundle/Serializer/Normalizer/CenterNormalizer.php

@@ -20,19 +20,32 @@
 namespace Chill\MainBundle\Serializer\Normalizer;
 
 use Chill\MainBundle\Entity\Center;
+use Chill\MainBundle\Repository\CenterRepository;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
+use Symfony\Component\Serializer\Exception\InvalidArgumentException;
+use Symfony\Component\Serializer\Exception\UnexpectedValueException;
 
 /**
  * 
  *
  */
-class CenterNormalizer implements NormalizerInterface
+class CenterNormalizer implements NormalizerInterface, DenormalizerInterface
 {
+    private CenterRepository $repository;
+
+
+    public function __construct(CenterRepository $repository)
+    {
+        $this->repository = $repository;
+    }
+
     public function normalize($center, string $format = null, array $context = array())
     {
         /** @var Center $center */
         return [
             'id' => $center->getId(),
+            'type' => 'center',
             'name' => $center->getName()
         ];
     }
@@ -41,4 +54,30 @@ class CenterNormalizer implements NormalizerInterface
     {
         return $data instanceof Center;
     }
+
+    public function denormalize($data, string $type, string $format = null, array $context = [])
+    {
+        if (FALSE === \array_key_exists('type', $data)) {
+            throw new InvalidArgumentException('missing "type" key in data');
+        }
+        if ('center' !== $data['type']) {
+            throw new InvalidArgumentException('type should be equal to "center"');
+        }
+        if (FALSE === \array_key_exists('id', $data)) {
+            throw new InvalidArgumentException('missing "id" key in data');
+        }
+
+        $center = $this->repository->find($data['id']);
+
+        if (null === $center) {
+            throw new UnexpectedValueException("The type with id {$data['id']} does not exists");
+        }
+
+        return $center;
+    }
+
+    public function supportsDenormalization($data, string $type, string $format = null)
+    {
+        return $type === Center::class;
+    }
 }

src/Bundle/ChillMainBundle/Serializer/Normalizer/PointNormalizer.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Chill\MainBundle\Serializer\Normalizer;
+
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+use Symfony\Component\Serializer\Exception\InvalidArgumentException;
+
+use Chill\MainBundle\Doctrine\Model\Point;
+
+
+class PointNormalizer implements DenormalizerInterface
+{
+
+    public function supportsDenormalization($data, string $type, string $format = null) : bool
+    {
+        return $type === Point::class;
+    }
+
+    public function denormalize($data, string $type, string $format = null, array $context = [])
+    {
+
+        if (!is_array($data)) {
+            throw new InvalidArgumentException('point data is not an array. It should be an array of 2 coordinates.');
+        } else {
+            if (count($data) !== 2) {
+                throw new InvalidArgumentException('point data is not an array of 2 elements. It should be an array of 2 coordinates.');
+            } else {
+                return Point::fromLonLat($data[0], $data[1]);
+            }
+        }
+
+    }
+
+}

src/Bundle/ChillMainBundle/Templating/Entity/AddressRender.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Chill\MainBundle\Templating\Entity;
+
+use Symfony\Component\Templating\EngineInterface;
+use Chill\MainBundle\Entity\Address;
+
+class AddressRender implements ChillEntityRenderInterface
+{
+    private EngineInterface $templating;
+
+    public const DEFAULT_OPTIONS = [
+        'with_valid_from' => true,
+        'has_no_address' => false,
+        'multiline' => true,
+    ];
+
+    public function __construct(EngineInterface $templating)
+    {
+        $this->templating = $templating;
+    }
+    
+    /**
+     * {@inheritDoc}
+     */
+    public function supports($entity, array $options): bool
+    {
+        return $entity instanceof Address;
+    }
+
+    /**
+     * @param Address addr
+     */
+    public function renderString($addr, array $options): string
+    {
+        $lines = [];
+        if (!empty($addr->getStreet())) {
+            $lines[0] = $addr->getStreet();
+        }
+        if (!empty($addr->getStreetNumber())) {
+            $lines[0] .= ", ".$addr->getStreetNumber();
+        }
+        if (!empty($addr->getPostcode())) {
+            $lines[1] = \strtr("{postcode} {label}", [
+                '{postcode}' => $addr->getPostcode()->getCode(),
+                '{label}' => $addr->getPostcode()->getName()
+            ]);
+        }
+
+        return implode(" - ", $lines);
+    }
+
+    /**
+     * {@inheritDoc}
+     * @param Address addr
+     */
+    public function renderBox($addr, array $options): string
+    {
+        $options = \array_merge(self::DEFAULT_OPTIONS, $options); 
+
+        return $this->templating
+            ->render('@ChillMain/Address/entity_render.html.twig', [
+                'address' => $addr,
+                'options' => $options
+            ]);
+    }
+}

src/Bundle/ChillMainBundle/Tests/Templating/Entity/AddressRenderTest.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Chill\MainBundle\Tests\Templating\Entity;
+
+use Chill\MainBundle\Entity\Country;
+use Chill\MainBundle\Entity\PostalCode;
+use Chill\MainBundle\Templating\Entity\AddressRender;
+use Chill\MainBundle\Entity\Address;
+use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
+use Symfony\Component\Templating\EngineInterface;
+
+class AddressRenderTest extends KernelTestCase
+{
+
+    protected function setUp()
+    {
+        self::bootKernel();
+    }
+
+    /**
+     * @dataProvider addressDataProvider
+     */
+    public function testRenderString(Address $addr, string $expectedString): void
+    {
+        $engine = self::$container->get(EngineInterface::class);
+        $renderer = new AddressRender($engine);
+
+        $this->assertEquals($expectedString, $renderer->renderString($addr, []));
+        return;
+        $this->assertIsString($renderer->renderBox($addr, []));
+    } 
+
+
+    public function addressDataProvider(): \Iterator
+    {
+        $addr = new Address();
+        $country = (new Country())
+            ->setName([ "fr" => "Pays" ])
+            ->setCountryCode("BE")
+            ;
+        $postCode = new PostalCode();
+        $postCode->setName("Locality")
+            ->setCode("012345")
+            ->setCountry($country)
+            ;
+
+        $addr->setStreet("Rue ABC")
+            ->setStreetNumber("5")
+            ->setPostcode($postCode)
+            ;
+
+        yield[ $addr, "Rue ABC, 5 - 012345 Locality"];
+    }
+    
+}

src/Bundle/ChillMainBundle/Timeline/TimelineBuilder.php

@@ -23,11 +23,11 @@ use Doctrine\ORM\Query\ResultSetMapping;
 use Doctrine\DBAL\Types\Type;
 use Doctrine\ORM\EntityManagerInterface;
 use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Doctrine\ORM\Query;
+use Doctrine\ORM\NativeQuery;
 
 /**
  * Build timeline
- *
- * @author Julien Fastré <julien.fastre@champs-libres.coop>
  */
 class TimelineBuilder implements ContainerAwareInterface
 {
@@ -78,14 +78,14 @@ class TimelineBuilder implements ContainerAwareInterface
      */
     public function getTimelineHTML($context, array $args, $firstItem = 0, $number = 20)
     {
-        $union = $this->buildUnionQuery($context, $args);
+        list($union, $parameters) = $this->buildUnionQuery($context, $args);
         
         //add ORDER BY clause and LIMIT
         $query = $union . sprintf(' ORDER BY date DESC LIMIT %d OFFSET %d',
             $number, $firstItem);
         
         // run query and handle results
-        $fetched = $this->runUnionQuery($query);
+        $fetched = $this->runUnionQuery($query, $parameters);
         $entitiesByKey = $this->getEntities($fetched, $context);
         
         return $this->render($fetched, $entitiesByKey, $context, $args);
@@ -100,16 +100,18 @@ class TimelineBuilder implements ContainerAwareInterface
      */
     public function countItems($context, array $args)
     {
-        $union = $this->buildUnionQuery($context, $args);
-        
-        // embed the union query inside a count query
-        $count = sprintf('SELECT COUNT(sq.id) AS total FROM (%s) as sq', $union);
-        
         $rsm = (new ResultSetMapping())
             ->addScalarResult('total', 'total', Type::INTEGER);
+
+        list($select, $parameters) = $this->buildUnionQuery($context, $args);
+
+        // embed the union query inside a count query
+        $countQuery = sprintf('SELECT COUNT(sq.id) AS total FROM (%s) as sq', $select);
+
+        $nq = $this->em->createNativeQuery($countQuery, $rsm);
+        $nq->setParameters($parameters);
         
-        return $this->em->createNativeQuery($count, $rsm)
-            ->getSingleScalarResult();
+        return $nq->getSingleScalarResult();
     }
     
     /**
@@ -154,40 +156,59 @@ class TimelineBuilder implements ContainerAwareInterface
      *
      * @uses self::buildSelectQuery to build individual SELECT queries
      *
-     * @param string $context
-     * @param mixed $args
-     * @param int $page
-     * @param int $number
-     * @return string
      * @throws \LogicException if no builder have been defined for this context
+     * @return array, where first element is the query, the second one an array with the parameters
      */
-    private function buildUnionQuery($context, array $args)
+    private function buildUnionQuery(string $context, array $args): array
     {
         //append SELECT queries with UNION keyword between them
         $union = '';
+        $parameters = [];
+
         foreach($this->getProvidersByContext($context) as $provider) {
-            $select = $this->buildSelectQuery($provider, $context, $args);
-            $append = ($union === '') ?  $select : ' UNION '.$select;
+            $data = $provider->fetchQuery($context, $args);
+            list($select, $selectParameters) = $this->buildSelectQuery($data);
+            $append = empty($union) ?  $select : ' UNION '.$select;
             $union .= $append;
+            $parameters = array_merge($parameters, $selectParameters);
         }
         
-        return $union;
+        return [$union, $parameters];
     }
+
+    /**
+     * Hack to replace the arbitrary "AS" statement in DQL
+     * into proper SQL query
+     * TODO remove
+    private function replaceASInDQL(string $dql): string
+    {
+        $pattern = '/^(SELECT\s+[a-zA-Z0-9\_\.\']{1,}\s+)(AS [a-z0-9\_]{1,})(\s{0,},\s{0,}[a-zA-Z0-9\_\.\']{1,}\s+)(AS [a-z0-9\_]{1,})(\s{0,},\s{0,}[a-zA-Z0-9\_\.\']{1,}\s+)(AS [a-z0-9\_]{1,})(\s+FROM.*)/';
+        $replacements = '${1} AS id ${3} AS type ${5} AS date ${7}';
+
+        $s = \preg_replace($pattern, $replacements, $dql, 1);
+
+        if (NULL === $s) {
+            throw new \RuntimeException('Could not replace the "AS" statement produced by '.
+                'DQL with normal SQL AS: '.$dql);
+        }
+
+        return $s;
+    }
+     */
     
     /**
      * return the SQL SELECT query as a string,
      *
-     * @uses TimelineProfiderInterface::fetchQuery use the fetchQuery function
-     * @param \Chill\MainBundle\Timeline\TimelineProviderInterface $provider
-     * @param string $context
-     * @param mixed[] $args
-     * @return string
+     * @return array: first parameter is the sql string, second an array with parameters
      */
-    private function buildSelectQuery(TimelineProviderInterface $provider, $context, array $args)
+    private function buildSelectQuery($data): array
     {
-        $data = $provider->fetchQuery($context, $args);
-        
-        return sprintf(
+        return [$data->buildSql(), $data->getParameters()];
+
+        // dead code
+        $parameters = [];
+
+        $sql = sprintf(
                 'SELECT %s AS id, '
                 . '%s AS "date", '
                 . "'%s' AS type "
@@ -197,16 +218,19 @@ class TimelineBuilder implements ContainerAwareInterface
                 $data['date'],
                 $data['type'],
                 $data['FROM'],
-                $data['WHERE']);
+                is_string($data['WHERE']) ? $data['WHERE'] : $data['WHERE'][0]
+            );
+
+        return [$sql, $data['WHERE'][1]];
+ 
     }
     
     /**
      * run the UNION query and return result as an array
      *
-     * @param string $query
-     * @return array
+     * @return array an array with the results
      */
-    private function runUnionQuery($query)
+    private function runUnionQuery(string $query, array $parameters): array
     {
         $resultSetMapping = (new ResultSetMapping())
                 ->addScalarResult('id', 'id')
@@ -214,7 +238,8 @@ class TimelineBuilder implements ContainerAwareInterface
                 ->addScalarResult('date', 'date');
         
         return $this->em->createNativeQuery($query, $resultSetMapping)
-                ->getArrayResult();
+            ->setParameters($parameters)
+            ->getArrayResult();
     }
     
     /**
@@ -274,7 +299,7 @@ class TimelineBuilder implements ContainerAwareInterface
         }
         
         return $this->container->get('templating')
-                ->render('@ChillMain/Timeline/index.html.twig', array(
+                ->render('@ChillMain/Timeline/chain_timelines.html.twig', array(
                     'results' => $timelineEntries
                 ));
         

src/Bundle/ChillMainBundle/Timeline/TimelineSingleQuery.php

@@ -0,0 +1,155 @@
+<?php
+
+namespace Chill\MainBundle\Timeline;
+
+
+class TimelineSingleQuery
+{
+    private ?string $id;
+
+    private ?string $date;
+
+    private ?string $key;
+
+    private ?string $from;
+
+    private ?string $where;
+
+    private array $parameters = [];
+
+    private bool $distinct = false;
+
+    public function __construct(
+        string $id = null,
+        string $date = null,
+        string $key = null,
+        string $from = null,
+        string $where = null,
+        array $parameters = []
+    ) {
+        $this->id = $id;
+        $this->date = $date;
+        $this->key = $key;
+        $this->from = $from;
+        $this->where = $where;
+        $this->parameters = $parameters;
+    }
+
+    public static function fromArray(array $a)
+    {
+        return new TimelineSingleQuery(
+            $a['id'] ?? null,
+            $a['date'] ?? null,
+            $a['type'] ?? $a['key'] ?? null,
+            $a['FROM'] ?? $a['from'] ?? null,
+            $a['WHERE'] ?? $a['where'] ?? null,
+            $a['parameters'] ?? null);
+    }
+
+    public function getId(): string
+    {
+        return $this->id;
+    }
+    
+    public function setId(string $id): self
+    {
+        $this->id = $id;
+    
+        return $this;
+    }
+
+    public function getDate(): string
+    {
+        return $this->date;
+    }
+    
+    public function setDate(string $date): self
+    {
+        $this->date = $date;
+    
+        return $this;
+    }
+
+    public function getKey(): string
+    {
+        return $this->key;
+    }
+    
+    public function setKey(string $key): self
+    {
+        $this->key = $key;
+    
+        return $this;
+    }
+
+    public function getFrom(): string
+    {
+        return $this->from;
+    }
+    
+    public function setFrom(string $from): self
+    {
+        $this->from = $from;
+    
+        return $this;
+    }
+
+    public function getWhere(): string
+    {
+        return $this->where;
+    }
+    
+    public function setWhere(string $where): self
+    {
+        $this->where = $where;
+    
+        return $this;
+    }
+
+    public function getParameters(): array
+    {
+        return $this->parameters;
+    }
+    
+    public function setParameters(array $parameters): self
+    {
+        $this->parameters = $parameters;
+    
+        return $this;
+    }
+
+    public function setDistinct(bool $distinct): self
+    {
+        $this->distinct = $distinct;
+
+        return $this;
+    }
+
+    public function isDistinct(): bool
+    {
+        return $this->distinct;
+    }
+
+    public function buildSql(): string
+    {
+        $parameters = [];
+
+        $sql = \strtr(
+                'SELECT {distinct} {id} AS id, '
+                . '{date} AS "date", '
+                . "'{key}' AS type "
+                . 'FROM {from} '
+                . 'WHERE {where}',
+                [
+                    '{distinct}' => $this->distinct ? 'DISTINCT' : '',
+                    '{id}' => $this->getId(),
+                    '{date}' => $this->getDate(),
+                    '{key}' => $this->getKey(),
+                    '{from}' => $this->getFrom(),
+                    '{where}' => $this->getWhere(),
+                ]
+            );
+
+        return $sql;
+    }
+}

src/Bundle/ChillMainBundle/chill.api.specs.yaml

@@ -9,15 +9,14 @@ servers:
     description: "Your current dev server"
 
 components:
-  parameters:
-    _format:
-      name: _format
-      in: path
-      required: true
-      schema:
-        type: string
-        enum:
-          - json
+  schemas:
+    Center:
+      type: object
+      properties:
+        id:
+          type: integer
+        name:
+          type: string
 
 paths:
   /1.0/search.json:

src/Bundle/ChillMainBundle/config/routes.yaml

@@ -1,3 +1,7 @@
+chill_main_controllers:
+    resource: '../Controller/'
+    type: annotation
+
 chill_main_admin_permissionsgroup:
     resource: "@ChillMainBundle/config/routes/permissionsgroup.yaml"
     prefix:   "{_locale}/admin/permissionsgroup"

src/Bundle/ChillMainBundle/config/services.yaml

@@ -31,14 +31,14 @@ services:
             - [ setContainer, ["@service_container"]]
         tags:
             - { name: twig.extension }
-            
+
     chill.main.twig.widget:
         class: Chill\MainBundle\Templating\Widget\WidgetRenderingTwig
         arguments:
             - "@event_dispatcher"
         tags:
             - { name: twig.extension }
-            
+
     chill.main.twig.csv_cell:
         class: Chill\MainBundle\Templating\CSVCellTwig
         tags:
@@ -65,3 +65,4 @@ services:
             - "@security.authorization_checker"
             - "@chill.main.security.authorization.helper"
             - "@security.token_storage"
+

src/Bundle/ChillMainBundle/config/services/command.yaml

@@ -7,7 +7,7 @@ services:
             $validator: '@Symfony\Component\Validator\Validator\ValidatorInterface'
         tags:
             - { name: console.command }
-            
+
     Chill\MainBundle\Command\ChillUserSendRenewPasswordCodeCommand:
         arguments:
             $logger: '@Psr\Log\LoggerInterface'

src/Bundle/ChillMainBundle/config/services/serializer.yaml

@@ -1,7 +1,7 @@
 ---
 services:
-    
-    # note: the autowiring for serializers and normalizers is declared 
+
+    # note: the autowiring for serializers and normalizers is declared
     # into ../services.yaml
 
     Chill\MainBundle\Serializer\Normalizer\DoctrineExistingEntityNormalizer:

src/Bundle/ChillMainBundle/config/services/templating.yaml

@@ -41,3 +41,10 @@ services:
     Chill\MainBundle\Templating\ChillMarkdownRenderExtension:
         tags:
             - { name: twig.extension }
+
+    Chill\MainBundle\Templating\Entity\AddressRender:
+        arguments:
+            - '@Symfony\Component\Templating\EngineInterface'
+        tags:
+            - { name: 'chill.render_entity' }
+            

src/Bundle/ChillMainBundle/config/services/timeline.yaml

@@ -4,4 +4,7 @@ services:
         arguments:
             - "@doctrine.orm.entity_manager"
         calls:
-            - [ setContainer, ["@service_container"]]
+            - [ setContainer, ["@service_container"]]
+    # alias:
+    Chill\MainBundle\Timeline\TimelineBuilder: '@chill_main.timeline_builder'
+

src/Bundle/ChillMainBundle/migrations/Version20210525144016.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Chill\Migrations\Main;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Specify ON DELETE behaviour to handle deletion of parents in associated tables
+ */
+final class Version20210525144016 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'Specify ON DELETE behaviour to handle deletion of parents in associated tables';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql('ALTER TABLE chill_main_address DROP CONSTRAINT FK_165051F6114B8DD9');
+        $this->addSql('ALTER TABLE chill_main_address ADD CONSTRAINT FK_165051F6114B8DD9 FOREIGN KEY (linkedToThirdParty_id) REFERENCES chill_3party.third_party (id) ON DELETE SET NULL NOT DEFERRABLE INITIALLY IMMEDIATE');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('ALTER TABLE chill_main_address DROP CONSTRAINT fk_165051f6114b8dd9');
+        $this->addSql('ALTER TABLE chill_main_address ADD CONSTRAINT fk_165051f6114b8dd9 FOREIGN KEY (linkedtothirdparty_id) REFERENCES chill_3party.third_party (id) NOT DEFERRABLE INITIALLY IMMEDIATE');
+    }
+}

src/Bundle/ChillMainBundle/migrations/Version20210528090000.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Chill\Migrations\Main;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Add extension btree_gist
+ */
+final class Version20210528090000 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return 'add extension btree_gist';
+    }
+
+    public function up(Schema $schema): void
+    {
+        $this->addSql('CREATE EXTENSION IF NOT EXISTS btree_gist');
+    }
+
+    public function down(Schema $schema): void
+    {
+        $this->addSql('DROP EXTENSION btree_gist');
+    }
+}

src/Bundle/ChillMainBundle/translations/messages.fr.yml

@@ -46,6 +46,11 @@ Back to the list: Retour à la liste
 #interval
 Years: Années
 
+# misc date
+Since %date%: Depuis le %date%
+since %date%: depuis le %date%
+Until %date%: Jusqu'au %date%
+until %date%: jusqu'au %date%
 #elements used in software
 centers: centres
 Centers: Centres
@@ -78,6 +83,9 @@ Results %start%-%end% of %total%: Résultats %start%-%end% sur %total%
 See all results: Voir tous les résultats
 Advanced search: Recherche avancée
 
+# timeline
+Global timeline: Historique global
+
 #admin
 Create: Créer
 show: voir

src/Bundle/ChillPersonBundle/Controller/AccompanyingCourseApiController.php

@@ -75,10 +75,10 @@ $workflow = $this->registry->get($accompanyingPeriod);
 
         switch ($request->getMethod()) {
             case Request::METHOD_POST:
-                $participation = $accompanyingPeriod->addPerson($person);
+                $participation = $accompanyingPeriod->createParticipationFor($person);
                 break;
             case Request::METHOD_DELETE:
-                $participation = $accompanyingPeriod->removePerson($person);
+                $participation = $accompanyingPeriod->closeParticipationFor($person);
                 break;
             default:
                 throw new BadRequestException("This method is not supported");

src/Bundle/ChillPersonBundle/Controller/AccompanyingCourseController.php

@@ -72,7 +72,7 @@ class AccompanyingCourseController extends Controller
         $em->persist($period);
         $em->flush();
 
-        return $this->redirectToRoute('chill_person_accompanying_course_show', [
+        return $this->redirectToRoute('chill_person_accompanying_course_edit', [
             'accompanying_period_id' => $period->getId()
         ]);
          
@@ -92,17 +92,16 @@ class AccompanyingCourseController extends Controller
     }
 
     /**
-     * Show page of Accompanying Course section
+     * Edit page of Accompanying Course section
      *
-     * the page show all blocks except one active edit block, managed by vuejs component
-     * that's why title of page is 'edit accompanying course'
+     * the page edit all blocks managed by vuejs component
      *
-     * @Route("/{_locale}/parcours/{accompanying_period_id}/show", name="chill_person_accompanying_course_show")
+     * @Route("/{_locale}/parcours/{accompanying_period_id}/edit", name="chill_person_accompanying_course_edit")
      * @ParamConverter("accompanyingCourse", options={"id": "accompanying_period_id"})
      */
-    public function showAction(AccompanyingPeriod $accompanyingCourse): Response
+    public function editAction(AccompanyingPeriod $accompanyingCourse): Response
     {
-        return $this->render('@ChillPerson/AccompanyingCourse/show.html.twig', [
+        return $this->render('@ChillPerson/AccompanyingCourse/edit.html.twig', [
             'accompanyingCourse' => $accompanyingCourse
         ]);
     }

src/Bundle/ChillPersonBundle/Controller/AccompanyingPeriodController.php

@@ -390,13 +390,13 @@ class AccompanyingPeriodController extends AbstractController
         /** @var Person $person */
         $person = $this->_getPerson($person_id);
 
-        $criteria = Criteria::create();
-        $criteria->where($criteria->expr()->eq('id', $period_id));
-
         /* @var $period AccompanyingPeriod */
-        $period = $person->getAccompanyingPeriods()
-                ->matching($criteria)
-                ->first();
+        $period = \array_filter(
+            $person->getAccompanyingPeriods(), 
+            function (AccompanyingPeriod $p) use ($period_id) {
+                return $p->getId() === ($period_id);
+            }
+        )[0] ?? NULL;
 
         if ($period === NULL) {
             throw $this->createNotFoundException('period not found');

src/Bundle/ChillPersonBundle/Controller/ApiPersonController.php

@@ -1,30 +0,0 @@
-<?php
-/*
- * Copyright (C) 2015-2021 Champs-Libres Coopérative <info@champs-libres.coop>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-namespace Chill\PersonBundle\Controller;
-
-use Symfony\Bundle\FrameworkBundle\Controller\Controller;
-use Symfony\Component\HttpFoundation\JsonResponse;
-
-
-class ApiPersonController extends Controller
-{
-    public function viewAction($id, $_format) 
-    {
-        
-    }
-}

src/Bundle/ChillPersonBundle/Controller/HouseholdController.php

@@ -0,0 +1,88 @@
+<?php
+
+namespace Chill\PersonBundle\Controller;
+
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Annotation\Route;
+use Sensio\Bundle\FrameworkExtraBundle\Configuration\ParamConverter;
+use Chill\PersonBundle\Entity\Household\Household;
+
+/**
+ * @Route("/{_locale}/person/household")
+ */
+class HouseholdController extends AbstractController
+{
+    /**
+     * @Route(
+     *      "/{household_id}/summary",
+     *      name="chill_person_household_summary",
+     *      methods={"GET", "HEAD"}
+     *  )
+     *  @ParamConverter("household", options={"id" = "household_id"})
+     */
+    public function summary(Request $request, Household $household)
+    {
+        // TODO ACL
+        return $this->render('@ChillPerson/Household/summary.html.twig',
+            [
+                'household' => $household
+            ]
+        );
+    }
+
+    /**
+     * @Route(
+     *      "/{household_id}/members",
+     *      name="chill_person_household_members",
+     *      methods={"GET", "HEAD"}
+     *  )
+     *  @ParamConverter("household", options={"id" = "household_id"})
+     */
+    public function members(Request $request, Household $household)
+    {
+        // TODO ACL
+        return $this->render('@ChillPerson/Household/members.html.twig',
+            [
+                'household' => $household
+            ]
+        );
+    }
+
+    /**
+     * @Route(
+     *      "/{household_id}/addresses",
+     *      name="chill_person_household_addresses",
+     *      methods={"GET", "HEAD"}
+     *  )
+     *  @ParamConverter("household", options={"id" = "household_id"})
+     */
+    public function addresses(Request $request, Household $household)
+    {
+        // TODO ACL
+        return $this->render('@ChillPerson/Household/addresses.html.twig',
+            [
+                'household' => $household
+            ]
+        );
+    }
+
+    /**
+     * @Route(
+     *      "/{household_id}/address/move",
+     *      name="chill_person_household_address_move",
+     *      methods={"GET", "HEAD", "POST"}
+     *  )
+     *  @ParamConverter("household", options={"id" = "household_id"})
+     */
+    public function addressMove(Request $request, Household $household)
+    {
+        // TODO ACL
+        return $this->render('@ChillPerson/Household/address_move.html.twig',
+            [
+                'household' => $household
+            ]
+        );
+    }
+}

src/Bundle/ChillPersonBundle/Controller/HouseholdMemberController.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Chill\PersonBundle\Controller;
+
+use Symfony\Component\HttpFoundation\Exception\BadRequestException;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Serializer\Exception;
+use Symfony\Component\Routing\Annotation\Route;
+use Chill\MainBundle\CRUD\Controller\ApiController;
+use Chill\PersonBundle\Household\MembersEditor;
+use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
+
+class HouseholdMemberController extends ApiController
+{
+    /**
+     * @Route(
+     *      "/api/1.0/person/household/members/move.{_format}",
+     *      name="chill_person_household_members_move"
+     *  )
+     */
+    public function move(Request $request, $_format): Response
+    {
+        try {
+            $editor = $this->getSerializer()
+                ->deserialize($request->getContent(), MembersEditor::class,
+                    $_format, ['groups' => [ "read" ]]);
+        } catch (Exception\InvalidArgumentException | Exception\UnexpectedValueException $e) {
+            throw new BadRequestException("Deserialization error: {$e->getMessage()}", 45896, $e);
+        }
+
+        // TODO ACL
+        //
+        // TODO validation
+        //
+        $em = $this->getDoctrine()->getManager();
+
+        foreach ($editor->getPersistable() as $el) {
+           $em->persist($el); 
+        }
+        $em->flush();
+        
+        return $this->json($editor->getHousehold(), Response::HTTP_OK, [], [
+            "groups" => ["read"],
+        ]);
+    }
+}

src/Bundle/ChillPersonBundle/Controller/PersonApiController.php

@@ -0,0 +1,50 @@
+<?php
+/*
+ * Copyright (C) 2015-2021 Champs-Libres Coopérative <info@champs-libres.coop>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+namespace Chill\PersonBundle\Controller;
+
+use Chill\PersonBundle\Security\Authorization\PersonVoter;
+use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
+use Symfony\Component\Security\Core\Role\Role;
+use Chill\MainBundle\CRUD\Controller\ApiController;
+use Symfony\Component\HttpFoundation\Request;
+
+
+class PersonApiController extends ApiController
+{
+    private AuthorizationHelper $authorizationHelper;
+
+    /**
+     * @param AuthorizationHelper $authorizationHelper
+     */
+    public function __construct(AuthorizationHelper $authorizationHelper)
+    {
+        $this->authorizationHelper = $authorizationHelper;
+    }
+    
+    protected function createEntity(string $action, Request $request): object
+    {
+        $person = parent::createEntity($action, $request);
+
+        // TODO temporary hack to allow creation of person with fake center
+        $centers = $this->authorizationHelper->getReachableCenters($this->getUser(),
+            new Role(PersonVoter::CREATE));
+        $person->setCenter($centers[0]);
+
+        return $person;
+    }
+}

src/Bundle/ChillPersonBundle/Controller/TimelinePersonController.php

@@ -27,32 +27,17 @@ use Symfony\Component\HttpFoundation\Request;
 use Chill\MainBundle\Timeline\TimelineBuilder;
 use Chill\MainBundle\Pagination\PaginatorFactory;
 use Chill\PersonBundle\Security\Authorization\PersonVoter;
+use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
+use Symfony\Component\Security\Core\Role\Role;
 
-/**
- * Class TimelinePersonController
- *
- * @package Chill\PersonBundle\Controller
- * @author Julien Fastré <julien.fastre@champs-libres.coop>
- */
 class TimelinePersonController extends AbstractController
 {
     
-    /**
-     * @var EventDispatcherInterface
-     */
-    protected $eventDispatcher;
+    protected EventDispatcherInterface $eventDispatcher;
     
-    /**
-     *
-     * @var TimelineBuilder
-     */
-    protected $timelineBuilder;
+    protected TimelineBuilder $timelineBuilder;
     
-    /**
-     *
-     * @var PaginatorFactory
-     */
-    protected $paginatorFactory;
+    protected PaginatorFactory $paginatorFactory;
     
     /**
      * TimelinePersonController constructor.
@@ -62,11 +47,13 @@ class TimelinePersonController extends AbstractController
     public function __construct(
         EventDispatcherInterface $eventDispatcher,
         TimelineBuilder $timelineBuilder,
-        PaginatorFactory $paginatorFactory
+        PaginatorFactory $paginatorFactory,
+        AuthorizationHelper $authorizationHelper
     ) {
         $this->eventDispatcher = $eventDispatcher;
         $this->timelineBuilder = $timelineBuilder;
         $this->paginatorFactory = $paginatorFactory;
+        $this->authorizationHelper = $authorizationHelper;
     }
     
     

src/Bundle/ChillPersonBundle/DataFixtures/ORM/LoadHousehold.php

@@ -0,0 +1,126 @@
+<?php
+
+namespace Chill\PersonBundle\DataFixtures\ORM;
+
+use Chill\PersonBundle\Entity\Person;
+use Chill\PersonBundle\Entity\Household\Household;
+use Chill\PersonBundle\Household\MembersEditorFactory;
+use Doctrine\Bundle\FixturesBundle\Fixture;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\Persistence\ObjectManager;
+use Doctrine\Common\DataFixtures\DependentFixtureInterface;
+
+class LoadHousehold extends Fixture implements DependentFixtureInterface
+{
+    private MembersEditorFactory $editorFactory;
+
+    private EntityManagerInterface $em;
+
+    private CONST NUMBER_OF_HOUSEHOLD = 10;
+
+    public function __construct(MembersEditorFactory $editorFactory, EntityManagerInterface $em)
+    {
+        $this->editorFactory = $editorFactory;
+        $this->em = $em;
+    }
+
+    public function load(ObjectManager $manager)
+    {
+        // generate two times the participation. This will lead to 
+        // some movement in participation (same people in two differents
+        // households)
+
+        $this->preparePersonIds();
+
+        $this->generateHousehold(
+            $manager,
+            \DateTimeImmutable::createFromFormat('Y-m-d', '2010-01-01')
+        );
+
+        $this->preparePersonIds();
+
+        $this->generateHousehold(
+            $manager,
+            \DateTimeImmutable::createFromFormat('Y-m-d', '2015-01-01')
+        );
+
+        $manager->flush();
+    }
+
+    private function generateHousehold(ObjectManager $manager, \DateTimeImmutable $startDate)
+    {
+        for ($i=0; $i < self::NUMBER_OF_HOUSEHOLD; $i++) {
+            $household = new Household();
+            $manager->persist($household);
+
+            $movement = $this->editorFactory->createEditor($household);
+
+            // load adults
+            $k = 0;
+            foreach ($this->getRandomPersons(1, 3) as $person) {
+                $date = $startDate->add(new \DateInterval('P'.\random_int(1, 200).'W'));
+                $position = $this->getReference(LoadHouseholdPosition::ADULT);
+
+                $movement->addMovement($date, $person, $position, $k === 0, "self generated");
+                $k++;
+            }
+
+            // load children
+            foreach ($this->getRandomPersons(0, 3) as $person) {
+                $date = $startDate->add(new \DateInterval('P'.\random_int(1, 200).'W'));
+                $position = $this->getReference(LoadHouseholdPosition::CHILD);
+
+                $movement->addMovement($date, $person, $position, $k === 0, "self generated");
+                $k++;
+            }
+
+            // load children out
+            foreach ($this->getRandomPersons(0, 2) as $person) {
+                $date = $startDate->add(new \DateInterval('P'.\random_int(1, 200).'W'));
+                $position = $this->getReference(LoadHouseholdPosition::CHILD_OUT);
+
+                $movement->addMovement($date, $person, $position, $k === 0, "self generated");
+                $k++;
+            }
+
+            foreach ($movement->getPersistable() as $obj) {
+                $manager->persist($obj);
+            }
+        }
+    }
+
+    private function preparePersonIds()
+    {
+        $this->personIds = $this->em
+            ->createQuery('SELECT p.id FROM '.Person::class.' p '.
+                'JOIN p.center c '.
+                'WHERE c.name = :center '
+            )
+            ->setParameter('center', 'Center A')
+            ->getScalarResult()
+            ;
+        \shuffle($this->personIds);
+    }
+
+    private function getRandomPersons(int $min, int $max)
+    {
+        $nb = \random_int($min, $max);
+
+        for ($i=0; $i < $nb; $i++) {
+            $personId = \array_pop($this->personIds)['id'];
+            $persons[] = $this->em->getRepository(Person::class)
+                ->find($personId)
+                ;
+        }
+
+        return $persons ?? [];
+    }
+
+    public function getDependencies()
+    {
+        return [
+            LoadPeople::class,
+            LoadHouseholdPosition::class
+        ];
+    }
+}

src/Bundle/ChillPersonBundle/DataFixtures/ORM/LoadHouseholdPosition.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Chill\PersonBundle\DataFixtures\ORM;
+
+use Chill\PersonBundle\Entity\Household\Position;
+use Doctrine\Bundle\FixturesBundle\Fixture;
+use Doctrine\Persistence\ObjectManager;
+
+class LoadHouseholdPosition extends Fixture
+{
+    const POSITIONS_DATA = [
+        ["Adulte", true, true, 1.0, self::ADULT ],
+        ["Enfants", true, false, 2.0, self::CHILD ],
+        ["Enfants hors ménage", false, false, 3.0, self::CHILD_OUT ]
+    ];
+
+    const ADULT = "position_adulte";
+    const CHILD = "position_enfant";
+    const CHILD_OUT = "position_enfant_hors";
+
+    public function load(ObjectManager $manager)
+    {
+        foreach (self::POSITIONS_DATA as list($name, $share, $allowHolder, 
+            $ordering, $ref)) {
+            $position = (new Position())
+                ->setLabel([ "fr" => $name ])
+                ->setAllowHolder($allowHolder)
+                ->setShareHousehold($share)
+                ->setOrdering($ordering)
+                ;
+
+            $manager->persist($position);
+            $this->addReference($ref, $position);
+        }
+
+        $manager->flush();
+    }
+}

src/Bundle/ChillPersonBundle/DataFixtures/ORM/LoadSocialActions.php

@@ -37,32 +37,32 @@ class LoadSocialActions extends AbstractFixture implements OrderedFixtureInterfa
         return 10020;
     }
 
-    public static $socialActions = array(
-        'social_action_info_conseil' => array(
-            'title' => array(
+    public static $socialActions = [
+        'social_action_info_conseil' => [
+            'title' => [
                 'fr' => 'Informer, conseiller'
-            ),
+            ],
             'issue' => 'social_issue_prev_prot'
-        ),
-        'social_action_instruire' => array(
-            'title' => array(
+        ],
+        'social_action_instruire' => [
+            'title' => [
                 'fr' => 'Instruire l\'imprime unique pour des impayés'
-            ),
+            ],
             'issue' => 'social_issue_prev_prot'
-        ),
-        'social_action_MASP' => array(
-            'title' => array(
+        ],
+        'social_action_MASP' => [
+            'title' => [
                 'fr' => 'MASP'
-            ),
+            ],
             'issue' => 'social_issue_diff_fin'
-        ),
-        'social_action_protection_enfant' => array(
-            'title' => array(
+        ],
+        'social_action_protection_enfant' => [
+            'title' => [
                 'fr' => 'Protection Enfant confié dans le cadre judiciaire'
-            ),
+            ],
             'issue' => 'social_issue_enfant_protection'
-        ),
-    );
+        ],
+    ];
 
     public function load(ObjectManager $manager)
     {

src/Bundle/ChillPersonBundle/DataFixtures/ORM/LoadSocialGoals.php

@@ -38,20 +38,20 @@ class LoadSocialGoals extends AbstractFixture implements OrderedFixtureInterface
         return 10030;
     }
 
-    public static $socialGoals = array(
-        'social_goal_instuire_dossier' => array(
-            'title' => array(
+    public static $socialGoals = [
+        'social_goal_instuire_dossier' => [
+            'title' => [
                 'fr' => 'Instruire le dossier de surendettement'
-            ),
+            ],
             'action' => 'social_action_MASP'
-        ),
-        'social_goal_proteger' => array(
-            'title' => array(
+        ],
+        'social_goal_proteger' => [
+            'title' => [
                 'fr' => 'Protéger via une assistance educative placement'
-            ),
+            ],
             'action' => 'social_action_protection_enfant'
-        ),
-    );
+        ],
+    ];
 
     public function load(ObjectManager $manager)
     {

src/Bundle/ChillPersonBundle/DataFixtures/ORM/LoadSocialIssues.php

@@ -37,36 +37,36 @@ class LoadSocialIssues extends AbstractFixture implements OrderedFixtureInterfac
         return 10010;
     }
 
-    public static $socialIssues = array(
-        'social_issue_diff_fin_or_admin' => array(
-            'title' => array(
+    public static $socialIssues = [
+        'social_issue_diff_fin_or_admin' => [
+            'title' => [
                 'fr' => 'ADULTE - DIFFICULTES FINANCIERES ET/OU ADMINISTRATIVES'
-            )
-        ),
-        'social_issue_prev_prot' => array(
-            'title' => array(
+            ]
+        ],
+        'social_issue_prev_prot' => [
+            'title' => [
                 'fr' => 'ADULTE PREVENTION/PROTECTION'
-            ),
+            ],
             'parent' => 'social_issue_diff_fin_or_admin'
-        ),
-        'social_issue_diff_fin' => array(
-            'title' => array(
+        ],
+        'social_issue_diff_fin' => [
+            'title' => [
                 'fr' => 'Difficulté financière'
-            ),
+            ],
             'parent' => 'social_issue_diff_fin_or_admin'
-        ),
-        'social_issue_enfant_famille' => array(
-            'title' => array(
+        ],
+        'social_issue_enfant_famille' => [
+            'title' => [
                 'fr' => 'Enfant / famille'
-            )
-        ),
-        'social_issue_enfant_protection' => array(
-            'title' => array(
+            ]
+        ],
+        'social_issue_enfant_protection' => [
+            'title' => [
                 'fr' => 'enfant - protection'
-            ),
+            ],
             'parent' => 'social_issue_enfant_famille'
-        ),
-    );
+        ],
+    ];
 
     public function load(ObjectManager $manager)
     {

src/Bundle/ChillPersonBundle/DataFixtures/ORM/LoadSocialResults.php

@@ -38,34 +38,34 @@ class LoadSocialResults extends AbstractFixture implements OrderedFixtureInterfa
         return 10040;
     }
 
-    public static $socialResults = array(
-        'social_result_FSL_acces' => array(
-            'title' => array(
+    public static $socialResults = [
+        'social_result_FSL_acces' => [
+            'title' => [
                 'fr' => 'FSL - accès cautionnement'
-            ),
+            ],
             'action' => 'social_action_instruire'
-        ),
-        'social_result_FSL_maintien' => array(
-            'title' => array(
+        ],
+        'social_result_FSL_maintien' => [
+            'title' => [
                 'fr' => 'FSL maintien - impayés de loyer'
-            ),
+            ],
             'action' => 'social_action_MASP'
-        ),
-        'social_result_soutien_parental' => array(
-            'title' => array(
+        ],
+        'social_result_soutien_parental' => [
+            'title' => [
                 'fr' => 'Soutien parental'
-            ),
+            ],
             // 'action' => 'social_action_protection_enfant', (via le goal)
             'goal' => 'social_goal_proteger'
-        ),
-        'social_result_accompagnement_mineur' => array(
-            'title' => array(
+        ],
+        'social_result_accompagnement_mineur' => [
+            'title' => [
                 'fr' => 'Accompagnement du mineur'
-            ),
+            ],
             // 'action' => 'social_action_protection_enfant', (via le goal)
             'goal' => 'social_goal_proteger',
-        ),
-    );
+        ],
+    ];
 
     public function load(ObjectManager $manager)
     {

src/Bundle/ChillPersonBundle/DependencyInjection/ChillPersonExtension.php

@@ -72,8 +72,8 @@ class ChillPersonExtension extends Extension implements PrependExtensionInterfac
         $loader->load('services/command.yaml');
         $loader->load('services/actions.yaml');
         $loader->load('services/form.yaml');
-        $loader->load('services/templating.yaml');
         $loader->load('services/alt_names.yaml');
+        $loader->load('services/household.yaml');
         // We can get rid of this file when the service 'chill.person.repository.person' is no more used.
         // We should use the PersonRepository service instead of a custom service name.
         $loader->load('services/repository.yaml');
@@ -497,15 +497,18 @@ class ChillPersonExtension extends Extension implements PrependExtensionInterfac
                     'name' => 'person',
                     'base_path' => '/api/1.0/person/person',
                     'base_role' => \Chill\PersonBundle\Security\Authorization\PersonVoter::SEE,
+                    'controller' => \Chill\PersonBundle\Controller\PersonApiController::class,
                     'actions' => [
                         '_entity' => [
                             'methods' => [
                                 Request::METHOD_GET => true,
-                                Request::METHOD_HEAD => true
+                                Request::METHOD_HEAD => true,
+                                Request::METHOD_POST=> true,
                             ],
                             'roles' => [
                                 Request::METHOD_GET => \Chill\PersonBundle\Security\Authorization\PersonVoter::SEE,
                                 Request::METHOD_HEAD => \Chill\PersonBundle\Security\Authorization\PersonVoter::SEE,
+                                Request::METHOD_POST => \Chill\PersonBundle\Security\Authorization\PersonVoter::CREATE,
 
                             ]
                         ],

src/Bundle/ChillPersonBundle/Entity/AccompanyingPeriod.php

@@ -369,13 +369,9 @@ class AccompanyingPeriod implements TrackCreationInterface, TrackUpdateInterface
         return false;
     }
 
-    public function setRemark(string $remark): self
+    public function setRemark(string $remark = null): self
     {
-        if ($remark === null) {
-            $remark = '';
-        }
-
-        $this->remark = $remark;
+        $this->remark = (string) $remark;
 
         return $this;
     }
@@ -447,12 +443,13 @@ class AccompanyingPeriod implements TrackCreationInterface, TrackUpdateInterface
      */
     public function getParticipationsContainsPerson(Person $person): Collection
     {
-        return $this->getParticipations($person)->filter(
-            function(AccompanyingPeriodParticipation $participation) use ($person) {
-                if ($person === $participation->getPerson()) {
-                    return $participation;
+        return $this
+            ->getParticipations()
+            ->filter(
+                static function(AccompanyingPeriodParticipation $participation) use ($person): bool {
+                    return $person === $participation->getPerson();
                 }
-            });
+            );
     }
 
     /**
@@ -462,12 +459,13 @@ class AccompanyingPeriod implements TrackCreationInterface, TrackUpdateInterface
      */
     public function getOpenParticipationContainsPerson(Person $person): ?AccompanyingPeriodParticipation
     {
-        $collection = $this->getParticipationsContainsPerson($person)->filter(
-            function(AccompanyingPeriodParticipation $participation) use ($person) {
-                if (NULL === $participation->getEndDate()) {
-                    return $participation;
+        $collection = $this
+            ->getParticipationsContainsPerson($person)
+            ->filter(
+                static function(AccompanyingPeriodParticipation $participation): bool {
+                    return null === $participation->getEndDate();
                 }
-            });
+            );
 
         return $collection->count() > 0 ? $collection->first() : NULL;
     }
@@ -483,9 +481,9 @@ class AccompanyingPeriod implements TrackCreationInterface, TrackUpdateInterface
     }
 
     /**
-     * Add Person
+     * Open a new participation for a person
      */
-    public function addPerson(Person $person = null): AccompanyingPeriodParticipation
+    public function createParticipationFor(Person $person): AccompanyingPeriodParticipation
     {
         $participation = new AccompanyingPeriodParticipation($this, $person);
         $this->participations[] = $participation;
@@ -493,10 +491,24 @@ class AccompanyingPeriod implements TrackCreationInterface, TrackUpdateInterface
         return $participation;
     }
 
+    public function addPerson(Person $person = null): self
+    {
+        if (NULL !== $person) {
+            $this->createParticipationFor($person);
+        }
+
+        return $this;
+    }
+
     /**
-     * Remove Person
+     * Close a participation for a person
+     *
+     * Search for the person's participation and set the end date at
+     * 'now'.
+     *
+     * @return void
      */
-    public function removePerson(Person $person): ?AccompanyingPeriodParticipation
+    public function closeParticipationFor($person): ?AccompanyingPeriodParticipation
     {
         $participation = $this->getOpenParticipationContainsPerson($person);
 
@@ -506,6 +518,17 @@ class AccompanyingPeriod implements TrackCreationInterface, TrackUpdateInterface
 
         return $participation;
     }
+    
+
+    /**
+     * Remove Person
+     */
+    public function removePerson(Person $person): self
+    {
+        $this->closeParticipationFor($person);
+
+        return $this;
+    }
 
 
     public function getClosingMotive(): ?ClosingMotive
@@ -532,15 +555,16 @@ class AccompanyingPeriod implements TrackCreationInterface, TrackUpdateInterface
             return false;
         }
 
-        $participation = $this->getParticipationsContainsPerson($person);
-        if (!null === $participation)
+        $participation = $this->getOpenParticipationContainsPerson($person);
+
+        if (null === $participation)
         {
-            $person = $participation->getPerson();
-            $periods = $person->getAccompanyingPeriodsOrdered();
-            return end($periods) === $this;
+            return false;
         }
 
-        return false;
+        $periods = $participation->getPerson()->getAccompanyingPeriodsOrdered();
+
+        return end($periods) === $this;
     }
 
     /**
@@ -800,14 +824,18 @@ class AccompanyingPeriod implements TrackCreationInterface, TrackUpdateInterface
 
     /**
      * Get a list of all persons which are participating to this course
+     *
+     * @psalm-return Collection<int, Person>
      */
     public function getPersons(): Collection
     {
-        return $this->participations->map(
-            function(AccompanyingPeriodParticipation $participation) {
-                return $participation->getPerson();
-            }
-        );
+        return $this
+            ->participations
+            ->map(
+                static function(AccompanyingPeriodParticipation $participation): Person {
+                    return $participation->getPerson();
+                }
+            );
     }
 
     public function setCreatedAt(\DateTimeInterface $datetime): self

src/Bundle/ChillPersonBundle/Entity/AccompanyingPeriod/Comment.php

@@ -51,7 +51,7 @@ class Comment implements TrackCreationInterface, TrackUpdateInterface
      * @ORM\ManyToOne(
      *     targetEntity="Chill\PersonBundle\Entity\AccompanyingPeriod",
      *     inversedBy="comments")
-     * @ORM\JoinColumn(nullable=false)
+     * @ORM\JoinColumn(nullable=false, onDelete="CASCADE")
      */
     private $accompanyingPeriod;
 

src/Bundle/ChillPersonBundle/Entity/AccompanyingPeriod/Resource.php

@@ -32,7 +32,7 @@ use Symfony\Component\Serializer\Annotation\DiscriminatorMap;
 use Symfony\Component\Serializer\Annotation\Groups;
 
 /**
- * @ORM\Entity(repositoryClass=ResourceRepository::class)
+ * @ORM\Entity
  * @ORM\Table(name="chill_person_accompanying_period_resource")
  * @DiscriminatorMap(typeProperty="type", mapping={
  *   "accompanying_period_resource"=Resource::class

src/Bundle/ChillPersonBundle/Entity/Household/Household.php

@@ -2,12 +2,21 @@
 
 namespace Chill\PersonBundle\Entity\Household;
 
+use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\ORM\Mapping as ORM;
 use Doctrine\Common\Collections\Collection;
+use Symfony\Component\Serializer\Annotation as Serializer;
 use Chill\MainBundle\Entity\Address;
+use Chill\PersonBundle\Entity\Household\HouseholdMember;
 
 /**
  * @ORM\Entity
+ * @ORM\Table(
+ *      name="chill_person_household"
+ *  )
+ * @Serializer\DiscriminatorMap(typeProperty="type", mapping={
+ *    "household"=Household::class
+ * })
  */
 class Household
 {
@@ -15,17 +24,12 @@ class Household
      * @ORM\Id
      * @ORM\GeneratedValue
      * @ORM\Column(type="integer")
+     * @Serializer\Groups({"read"})
      */
-    private $id;
-
-    public function getId(): ?int
-    {
-        return $this->id;
-    }
+    private ?int $id = null;
 
     /**
      * Addresses
-     * @var Collection
      *
      * @ORM\ManyToMany(
      *     targetEntity="Chill\MainBundle\Entity\Address",
@@ -33,8 +37,27 @@ class Household
      * @ORM\JoinTable(name="chill_person_household_to_addresses")
      * @ORM\OrderBy({"validFrom" = "DESC"})
      */
-    private $addresses;
+    private Collection $addresses;
 
+    /**
+     * @ORM\OneToMany(
+     *      targetEntity=HouseholdMember::class,
+     *      mappedBy="household"
+     *  )
+     * @Serializer\Groups({"read"})
+     */
+    private Collection $members;
+
+    public function __construct()
+    {
+        $this->addresses = new ArrayCollection();
+        $this->members = new ArrayCollection();
+    }
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
 
     /**
      * @param Address $address
@@ -66,4 +89,34 @@ class Household
         return $this->addresses;
     }
 
+    /**
+     * @return Collection|HouseholdMember[]
+     */
+    public function getMembers(): Collection
+    {
+        return $this->members;
+    }
+
+    public function addMember(HouseholdMember $member): self
+    {
+        if (!$this->members->contains($member)) {
+            $this->members[] = $member;
+            $member->setHousehold($this);
+        }
+
+        return $this;
+    }
+
+    public function removeMember(HouseholdMember $member): self
+    {
+        if ($this->members->removeElement($member)) {
+            // set the owning side to null (unless already changed)
+            if ($member->getHousehold() === $this) {
+                $member->setHousehold(null);
+            }
+        }
+
+        return $this;
+    }
+
 }

src/Bundle/ChillPersonBundle/Entity/Household/HouseholdMember.php

@@ -0,0 +1,197 @@
+<?php
+
+namespace Chill\PersonBundle\Entity\Household;
+
+use Doctrine\ORM\Mapping as ORM;
+use Chill\PersonBundle\Entity\Person;
+use Chill\PersonBundle\Entity\Household\Household;
+use Chill\PersonBundle\Entity\Household\Position;
+use Symfony\Component\Serializer\Annotation as Serializer;
+
+
+/**
+ * @ORM\Entity
+ * @ORM\Table(
+ *      name="chill_person_household_members"
+ *  )
+ */
+class HouseholdMember
+{
+    /**
+     * @ORM\Id
+     * @ORM\GeneratedValue
+     * @ORM\Column(type="integer")
+     * @Serializer\Groups({"read"})
+     */
+    private $id;
+
+    /**
+     * @ORM\ManyToOne(targetEntity=Position::class)
+     * @Serializer\Groups({"read"})
+     */
+    private ?Position $position = null;
+
+    /**
+     * @ORM\Column(type="date_immutable", nullable=true, options={"default": null})
+     * @Serializer\Groups({"read"})
+     */
+    private ?\DateTimeImmutable $startDate = null;
+
+    /**
+     * @ORM\Column(type="date_immutable", nullable= true, options={"default": null})
+     * @Serializer\Groups({"read"})
+     */
+    private ?\DateTimeImmutable $endDate = null;
+
+    /**
+     * @ORM\Column(type="string", length=255, nullable=true)
+     * @Serializer\Groups({"read"})
+     */
+    private ?string $comment = NULL;
+
+    /**
+     * @ORM\Column(type="boolean")
+     */
+    private bool $sharedHousehold = false;
+
+    /**
+     * @ORM\Column(type="boolean", options={"default": false})
+     * @Serializer\Groups({"read"})
+     */
+    private bool $holder = false;
+
+    /**
+     *
+     * @var Person
+     * @ORM\ManyToOne(
+     *  targetEntity="\Chill\PersonBundle\Entity\Person"
+     * )
+     * @Serializer\Groups({"read"})
+     */
+    private ?Person $person = null;
+
+    /**
+     *
+     * @var Household
+     * @ORM\ManyToOne(
+     *  targetEntity="\Chill\PersonBundle\Entity\Household\Household"
+     * )
+     */
+    private ?Household $household = null;
+
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getPosition(): ?Position
+    {
+        return $this->position;
+    }
+
+    public function setPosition(Position $position): self
+    {
+        if ($this->position instanceof Position) {
+            throw new \LogicException("The position is already set. You cannot change ".
+                "a position of a membership");
+        }
+
+        $this->position = $position;
+        $this->sharedHousehold = $position->getShareHousehold();
+
+        return $this;
+    }
+
+    public function getStartDate(): ?\DateTimeImmutable
+    {
+        return $this->startDate;
+    }
+
+    public function setStartDate(\DateTimeImmutable $startDate): self
+    {
+        $this->startDate = $startDate;
+
+        return $this;
+    }
+
+    public function getEndDate(): ?\DateTimeImmutable
+    {
+        return $this->endDate;
+    }
+
+    public function setEndDate(\DateTimeImmutable $endDate): self
+    {
+        $this->endDate = $endDate;
+
+        return $this;
+    }
+
+    public function getComment(): ?string
+    {
+        return $this->comment;
+    }
+
+    public function setComment(?string $comment): self
+    {
+        $this->comment = $comment;
+
+        return $this;
+    }
+
+    /**
+     * @Serializer\Groups({"read"})
+     */
+    public function getShareHousehold(): ?bool
+    {
+        return $this->sharedHousehold;
+    }
+
+
+    public function getPerson(): ?Person
+    {
+        return $this->person;
+    }
+
+    public function setPerson(?Person $person): self
+    {
+        if ($this->person instanceof Person) {
+            throw new \LogicException("You cannot change person ".
+                "on a membership");
+        }
+
+        $this->person = $person;
+        $this->person->addHouseholdParticipation($this);
+
+        return $this;
+    }
+
+    public function getHousehold(): ?Household
+    {
+        return $this->household;
+    }
+
+    public function setHousehold(?Household $household): self
+    {
+        if ($this->household instanceof Household) {
+            throw new \LogicException("You cannot change household ".
+                "on a membership");
+        }
+
+        $this->household = $household;
+
+        return $this;
+    }
+
+    public function setHolder(bool $holder): self
+    {
+        $this->holder = $holder;
+
+        return $this;
+    }
+
+    public function isHolder(): bool
+    {
+        return $this->holder;
+    }
+}

src/Bundle/ChillPersonBundle/Entity/Household/HouseholdMembers.php

@@ -1,152 +0,0 @@
-<?php
-
-namespace Chill\PersonBundle\Entity\Household;
-
-use Doctrine\ORM\Mapping as ORM;
-use Chill\PersonBundle\Entity\Person;
-use Chill\PersonBundle\Entity\Household\Household;
-
-/**
- * @ORM\Entity
- */
-class HouseholdMembers
-{
-    /**
-     * @ORM\Id
-     * @ORM\GeneratedValue
-     * @ORM\Column(type="integer")
-     */
-    private $id;
-
-    /**
-     * @ORM\Column(type="string", length=255, nullable=true)
-     */
-    private $position;
-
-    /**
-     * @ORM\Column(type="date")
-     */
-    private $startDate;
-
-    /**
-     * @ORM\Column(type="date")
-     */
-    private $endDate;
-
-    /**
-     * @ORM\Column(type="string", length=255, nullable=true)
-     */
-    private $comment;
-
-    /**
-     * @ORM\Column(type="boolean")
-     */
-    private $sharedHousehold;
-
-    /**
-     *
-     * @var Person
-     * @ORM\ManyToOne(
-     *  targetEntity="\Chill\PersonBundle\Entity\Person"
-     * )
-     */
-    private $person;
-
-    /**
-     *
-     * @var Household
-     * @ORM\ManyToOne(
-     *  targetEntity="\Chill\PersonBundle\Entity\Household\Household"
-     * )
-     */
-    private $household;
-
-    public function getId(): ?int
-    {
-        return $this->id;
-    }
-
-    public function getPosition(): ?string
-    {
-        return $this->position;
-    }
-
-    public function setPosition(?string $position): self
-    {
-        $this->position = $position;
-
-        return $this;
-    }
-
-    public function getStartDate(): ?\DateTimeInterface
-    {
-        return $this->startDate;
-    }
-
-    public function setStartDate(\DateTimeInterface $startDate): self
-    {
-        $this->startDate = $startDate;
-
-        return $this;
-    }
-
-    public function getEndDate(): ?\DateTimeInterface
-    {
-        return $this->endDate;
-    }
-
-    public function setEndDate(\DateTimeInterface $endDate): self
-    {
-        $this->endDate = $endDate;
-
-        return $this;
-    }
-
-    public function getComment(): ?string
-    {
-        return $this->comment;
-    }
-
-    public function setComment(?string $comment): self
-    {
-        $this->comment = $comment;
-
-        return $this;
-    }
-
-    public function getSharedHousehold(): ?bool
-    {
-        return $this->sharedHousehold;
-    }
-
-    public function setSharedHousehold(bool $sharedHousehold): self
-    {
-        $this->sharedHousehold = $sharedHousehold;
-
-        return $this;
-    }
-
-    public function getPerson(): ?Person
-    {
-        return $this->person;
-    }
-
-    public function setPerson(?Person $person): self
-    {
-        $this->person = $person;
-
-        return $this;
-    }
-
-    public function getHousehold(): ?Household
-    {
-        return $this->household;
-    }
-
-    public function setHousehold(?Household $household): self
-    {
-        $this->household = $household;
-
-        return $this;
-    }
-}

src/Bundle/ChillPersonBundle/Entity/Household/Position.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace Chill\PersonBundle\Entity\Household;
+
+use Chill\PersonBundle\Repository\Household\PositionRepository;
+use Doctrine\ORM\Mapping as ORM;
+use Symfony\Component\Serializer\Annotation as Serializer;
+
+/**
+ * @ORM\Entity(repositoryClass=PositionRepository::class)
+ * @ORM\Table(name="chill_person_household_position")
+ * @Serializer\DiscriminatorMap(typeProperty="type", mapping={
+ *   "household_position"=Position::class
+ *   })
+ */
+class Position
+{
+    /**
+     * @ORM\Id
+     * @ORM\GeneratedValue
+     * @ORM\Column(type="integer")
+     * @Serializer\Groups({ "read" })
+     */
+    private $id;
+
+    /**
+     * @ORM\Column(type="json")
+     */
+    private $label = [];
+
+    /**
+     * @ORM\Column(type="boolean")
+     */
+    private $shareHouseHold;
+
+    /**
+     * @ORM\Column(type="boolean")
+     */
+    private $allowHolder;
+
+    /**
+     * @ORM\Column(type="float")
+     */
+    private $ordering;
+
+    public function getId(): ?int
+    {
+        return $this->id;
+    }
+
+    public function getLabel(): ?array
+    {
+        return $this->label;
+    }
+
+    public function setLabel(array $label): self
+    {
+        $this->label = $label;
+
+        return $this;
+    }
+
+    public function getShareHousehold(): ?bool
+    {
+        return $this->shareHouseHold;
+    }
+
+    public function setShareHousehold(bool $shareHouseHold): self
+    {
+        $this->shareHouseHold = $shareHouseHold;
+
+        return $this;
+    }
+
+    public function getAllowHolder(): ?bool
+    {
+        return $this->allowHolder;
+    }
+
+    public function setAllowHolder(bool $allowHolder): self
+    {
+        $this->allowHolder = $allowHolder;
+
+        return $this;
+    }
+
+    public function getOrdering(): ?float
+    {
+        return $this->ordering;
+    }
+
+    public function setOrdering(float $ordering): self
+    {
+        $this->ordering = $ordering;
+
+        return $this;
+    }
+}

src/Bundle/ChillPersonBundle/Entity/Person.php

@@ -26,6 +26,7 @@ use ArrayIterator;
 use Chill\MainBundle\Entity\Center;
 use Chill\MainBundle\Entity\Country;
 use Chill\PersonBundle\Entity\MaritalStatus;
+use Chill\PersonBundle\Entity\Household\HouseholdMember;
 use Chill\MainBundle\Entity\HasCenterInterface;
 use Chill\MainBundle\Entity\Address;
 use DateTime;
@@ -272,6 +273,14 @@ class Person implements HasCenterInterface
      */
     private $fullnameCanonical;
 
+    /**
+     * @ORM\OneToMany(
+     *  targetEntity=HouseholdMember::class,
+     *  mappedBy="person"
+     * )
+     */
+    private Collection $householdParticipations;
+
     /**
      * Person constructor.
      *
@@ -284,6 +293,7 @@ class Person implements HasCenterInterface
         $this->addresses = new ArrayCollection();
         $this->altNames = new ArrayCollection();
         $this->otherPhoneNumbers = new ArrayCollection();
+        $this->householdParticipations = new ArrayCollection();
 
         if ($opening === null) {
             $opening = new \DateTime();
@@ -421,6 +431,31 @@ class Person implements HasCenterInterface
         return $this->accompanyingPeriodParticipations;
     }
 
+    /** 
+     * Return a collection of participation, where the participation
+     * is still opened, not a draft, and the period is still opened
+     */
+    public function getOpenedParticipations(): Collection
+    {
+        // create a criteria for filtering easily
+        $criteria = Criteria::create();
+        $criteria
+            ->andWhere(Criteria::expr()->eq('endDate', NULL))
+            ->orWhere(Criteria::expr()->gt('endDate', new \DateTime('now')))
+            ;
+
+        return $this->getAccompanyingPeriodParticipations()
+            ->matching($criteria)
+            ->filter(function (AccompanyingPeriodParticipation $app) {
+                $period = $app->getAccompanyingPeriod();
+                return (
+                        NULL === $period->getClosingDate() 
+                            || new \DateTime('now') < $period->getClosingDate()
+                    ) 
+                    && AccompanyingPeriod::STEP_DRAFT !== $period->getStep();
+            });
+    }
+
     /**
      * Get the accompanying periods of a give person with the chronological order.
      */
@@ -1155,4 +1190,16 @@ class Person implements HasCenterInterface
         $this->fullnameCanonical = $fullnameCanonical;
         return $this;
     }
+
+    public function addHouseholdParticipation(HouseholdMember $member): self
+    {
+        $this->householdParticipations[] = $member;
+
+        return $this;
+    }
+
+    public function getHouseholdParticipations(): Collection
+    {
+        return $this->householdParticipations;
+    }
 }

src/Bundle/ChillPersonBundle/Form/ChoiceLoader/PersonChoiceLoader.php

@@ -21,31 +21,19 @@ namespace Chill\PersonBundle\Form\ChoiceLoader;
 
 use Symfony\Component\Form\ChoiceList\Loader\ChoiceLoaderInterface;
 use Symfony\Component\Form\ChoiceList\ChoiceListInterface;
-use Doctrine\ORM\EntityRepository;
 use Chill\PersonBundle\Entity\Person;
+use Chill\PersonBundle\Repository\PersonRepository;
 
 /**
- * Class PersonChoiceLoader
- *
- * @package Chill\PersonBundle\Form\ChoiceLoader
- * @author Julien Fastré <julien.fastre@champs-libres.coop>
+ * Allow to load a list of person
  */
 class PersonChoiceLoader implements ChoiceLoaderInterface
 {
-    /**
-     * @var EntityRepository
-     */
-    protected $personRepository;
+    protected PersonRepository $personRepository;
     
-    /**
-     * @var array
-     */
-    protected $lazyLoadedPersons = [];
+    protected array $lazyLoadedPersons = [];
     
-    /**
-     * @var array
-     */
-    protected $centers = [];
+    protected array $centers = [];
     
     /**
      * PersonChoiceLoader constructor.
@@ -54,7 +42,7 @@ class PersonChoiceLoader implements ChoiceLoaderInterface
      * @param array|null $centers
      */
     public function __construct(
-        EntityRepository $personRepository,
+        PersonRepository $personRepository,
         array $centers = null
     ) {
         $this->personRepository = $personRepository;