Family.pm

# -*- indent-tabs-mode: nil; -*-
# vim:ft=perl:et:sw=4
# $Id$

# Sympa - SYsteme de Multi-Postage Automatique
#
# Copyright (c) 1997, 1998, 1999 Institut Pasteur & Christophe Wolfhugel
# Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
# 2006, 2007, 2008, 2009, 2010, 2011 Comite Reseau des Universites
# Copyright (c) 2011, 2012, 2013, 2014, 2015, 2016, 2017 GIP RENATER
# Copyright 2017 The Sympa Community. See the AUTHORS.md file at the top-level
# directory of this distribution and at
# <https://github.com/sympa-community/sympa.git>.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

=encoding utf-8

#=head1 NAME 
#
#I<Family.pm> - Handles list families

=head1 DESCRIPTION 

Sympa allows lists creation and management by sets. These are the families, sets of lists sharing common properties. This module gathers all the family-specific operations.

=cut 

package Sympa::Family;

use strict;
use warnings;
use English qw(-no_match_vars);
use File::Copy qw();
use Term::ProgressBar;
use XML::LibXML;

use Sympa;
use Sympa::Admin;
use Conf;
use Sympa::Config_XML;
use Sympa::Constants;
use Sympa::DatabaseManager;
use Sympa::Language;
use Sympa::List;
use Sympa::Log;
use Sympa::Regexps;
use Sympa::Scenario;
use Sympa::Tools::File;

my $language = Sympa::Language->instance;
my $log      = Sympa::Log->instance;

my %list_of_families;
my @uncompellable_param = (
    'msg_topic.keywords',
    'owner_include.source_parameters',
    'editor_include.source_parameters'
);

=pod 

=head1 SUBFUNCTIONS 

This is the description of the subfunctions contained by Family.pm

=cut 

=pod 

=head1 Class methods 

=cut 

## Class methods
################

=head2 sub get_families(Robot $robot)

Returns the list of existing families in the Sympa installation.

=head3 Arguments 

=over 

=item * I<$robot>, the robot the family list of which we want to get.

=back 

=head3 Returns

=over 

=item * An arrayref containing all the robot's family names.

=back 

=cut

sub get_families {
    my $robot_id = shift;

    my @families;

    foreach my $dir (
        reverse @{Sympa::get_search_path($robot_id, subdir => 'families')}) {
        next unless -d $dir;

        unless (opendir FAMILIES, $dir) {
            $log->syslog('err', 'Can\'t open dir %s: %m', $dir);
            next;
        }

        # If we can create a Sympa::Family object with what we find in the
        # family directory, then it is worth being added to the list.
        foreach my $subdir (grep !/^\.\.?$/, readdir FAMILIES) {
            next unless -d ("$dir/$subdir");
            if (my $family = Sympa::Family->new($subdir, $robot_id)) {
                push @families, $family;
            }
        }
    }

    return \@families;
}

sub get_available_families {
    my $robot_id = shift;
    my $families;
    my %hash;
    if ($families = get_families($robot_id)) {
        foreach my $family (@$families) {
            if (ref $family eq 'Sympa::Family') {
                $hash{$family->{'name'}} = $family;
            }
        }
        return %hash;
    } else {
        return undef;
    }
}

=head1 Instance methods 

=cut 

## Instance methods
###################

=pod 

=head2 sub new(STRING $name, STRING $robot)

Creates a new Sympa::Family object of name $name, belonging to the robot $robot.

=head3 Arguments 

=over 

=item * I<$class>, the class in which we're supposed to create the object (namely "Sympa::Family"),

=item * I<$name>, a character string containing the family name,

=item * I<$robot>, a character string containing the name of the robot which the family is/will be installed in.

=back 

=head3 Return 

=over 

=item * I<$self>, the Sympa::Family object 

=back 

=cut

#########################################
# new
#########################################
# constructor of the class Sympa::Family :
#   check family existence (required files
#   and directory)
#
# IN : -$class
#      -$name : family name
#      -robot : family robot
# OUT : -$self
#########################################
sub new {
    my $class = shift;
    my $name  = shift;
    my $robot = shift;
    $log->syslog('debug2', '(%s, %s)', $name, $robot);

    my $self = {};

    if ($list_of_families{$robot}{$name}) {
        # use the current family in memory and update it
        $self = $list_of_families{$robot}{$name};
###########
        # the robot can be different from latest new ...
        if ($robot eq $self->{'robot'}) {
            return $self;
        } else {
            $self = {};
        }
    }
    # create a new object family
    bless $self, $class;
    $list_of_families{$robot}{$name} = $self;

    my $family_name_regexp = Sympa::Regexps::family_name();

    ## family name
    unless ($name && ($name =~ /^$family_name_regexp$/io)) {
        $log->syslog('err', 'Incorrect family name "%s"', $name);
        return undef;
    }

    ## Lowercase the family name.
    $name =~ tr/A-Z/a-z/;
    $self->{'name'} = $name;

    $self->{'robot'} = $robot;

    ## Adding configuration related to automatic lists.
    my $all_families_config =
        Conf::get_robot_conf($robot, 'automatic_list_families');
    my $family_config = $all_families_config->{$name};
    foreach my $key (keys %{$family_config}) {
        $self->{$key} = $family_config->{$key};
    }

    ## family directory
    $self->{'dir'} = $self->_get_directory();
    unless (defined $self->{'dir'}) {
        $log->syslog('err', '(%s, %s) The family directory does not exist',
            $name, $robot);
        return undef;
    }

    ## family files
    if (my $file_names = $self->_check_mandatory_files()) {
        $log->syslog('err',
            '(%s, %s) Definition family files are missing: %s',
            $name, $robot, $file_names);
        return undef;
    }

    ## file mtime
    $self->{'mtime'}{'param_constraint_conf'} = undef;

    ## hash of parameters constraint
    $self->{'param_constraint_conf'} = undef;

    ## state of the family for the use of check_param_constraint : 'no_check'
    ## or 'normal'
    ## check_param_constraint  only works in state "normal"
    $self->{'state'} = 'normal';
    return $self;
}

=pod 

=head2 sub add_list(FILE_HANDLE $data, BOOLEAN $abort_on_error)

Adds a list to the family. List description can be passed either through a hash of data or through a file handle.

=head3 Arguments 

=over 

=item * I<$self>, the Sympa::Family object,

=item * I<$data>, a file handle on an XML B<list> description file or a hash of data,

=item * I<$abort_on_error>: if true, the function won't create lists in status error_config.

=back 

=head3 Return 

=over 

=item * I<$return>, a hash containing the execution state of the method. If everything went well, the "ok" key must be associated to the value "1".

=back 

=cut

#########################################
# add_list
#########################################
# add a list to the family under to current robot:
# (list described by the xml file)
#
# IN : -$self
#      -$data : file handle on an xml file or hash of data
#      -$abort_on_error : if true won't create list in status error_config
# OUT : -$return->{'ok'} = 1(pas d'erreur fatale) or undef(erreur fatale)
#       -$return->{'string'} : string of results
#########################################
sub add_list {
    my ($self, $data, $abort_on_error) = @_;

    $log->syslog('info', '(%s)', $self->{'name'});

    $self->{'state'} = 'no_check';
    my $return;
    $return->{'ok'}           = undef;
    $return->{'string_info'}  = undef;    ## info and simple errors
    $return->{'string_error'} = undef;    ## fatal errors

    my $hash_list;

    if (ref($data) eq "HASH") {
        $hash_list = {config => $data};
    } else {
        #copy the xml file in another file
        unless (open FIC, '>', $self->{'dir'} . '/_new_list.xml') {
            $log->syslog('err',
                'Impossible to create the temp file %s/_new_list.xml: %m',
                $self->{'dir'});
        }
        while (<$data>) {
            print FIC ($_);
        }
        close FIC;

        # get list data
        open(FIC, '<:raw', $self->{'dir'} . '/_new_list.xml');
        my $config = Sympa::Config_XML->new(\*FIC);
        close FIC;
        unless (defined $config->createHash()) {
            push @{$return->{'string_error'}},
                "Error in representation data with these xml data";
            return $return;
        }

        $hash_list = $config->getHash();
    }

    # Check length
    if (Sympa::Constants::LIST_LEN() <
        length($hash_list->{'config'}{'listname'})) {
        $log->syslog('err', 'Too long value of param "listname"');
        push @{$return->{'string_error'}}, 'Too long list name';
        return $return;
    }

    #list creation
    my $result = Sympa::Admin::create_list($hash_list->{'config'},
        $self, $self->{'robot'}, $abort_on_error);
    unless (defined $result) {
        push @{$return->{'string_error'}},
            "Error during list creation, see logs for more information";
        return $return;
    }
    unless (defined $result->{'list'}) {
        push @{$return->{'string_error'}},
            "Errors : no created list, see logs for more information";
        return $return;
    }
    my $list = $result->{'list'};

    ## aliases
    if ($result->{'aliases'} == 1) {
        push @{$return->{'string_info'}},
            "List $list->{'name'} has been created in $self->{'name'} family";
    } else {
        push @{$return->{'string_info'}},
            "List $list->{'name'} has been created in $self->{'name'} family, required aliases : $result->{'aliases'} ";
    }

    # config_changes
    unless (open FILE, '>', "$list->{'dir'}/config_changes") {
        $list->set_status_error_config('error_copy_file', $self->{'name'});
        push @{$return->{'string_info'}},
            'Impossible to create file %s/config_changes : %s, the list is set in status error_config',
            $list->{'dir'}, $ERRNO;
    }
    close FILE;

    # info parameters
    $list->{'admin'}{'latest_instantiation'}{'email'} =
        Sympa::get_address($self, 'listmaster');
    $list->{'admin'}{'latest_instantiation'}{'date_epoch'} = time;
    $list->save_config(Sympa::get_address($self, 'listmaster'));
    $list->{'family'} = $self;

    ## check param_constraint.conf
    $self->{'state'} = 'normal';
    my $error = $self->check_param_constraint($list);
    $self->{'state'} = 'no_check';

    unless (defined $error) {
        $list->set_status_error_config('no_check_rules_family',
            $self->{'name'});
        push @{$return->{'string_error'}},
            "Impossible to check parameters constraint, see logs for more information. The list is set in status error_config";
        return $return;
    }

    if (ref($error) eq 'ARRAY') {
        $list->set_status_error_config('no_respect_rules_family',
            $self->{'name'});
        push @{$return->{'string_info'}},
            "The list does not respect the family rules : "
            . join(", ", @{$error});
    }

    ## copy files in the list directory : xml file
    unless (ref($data) eq "HASH") {
        unless ($self->_copy_files($list->{'dir'}, "_new_list.xml")) {
            $list->set_status_error_config('error_copy_file',
                $self->{'name'});
            push @{$return->{'string_info'}},
                "Impossible to copy the xml file in the list directory, the list is set in status error_config.";
        }
    }

    ## Synchronize list members if required
    if ($list->has_include_data_sources()) {
        $log->syslog('notice', "Synchronizing list members...");
        $list->sync_include();
    }

    ## END
    $self->{'state'} = 'normal';
    $return->{'ok'}  = 1;

    return $return;
}

=pod 

=head2 sub modify_list(FILE_HANDLE $fh)

Adds a list to the family.

=head3 Arguments 

=over 

=item * I<$self>, the Sympa::Family object,

=item * I<$fh>, a file handle on the XML B<list> configuration file.

=back 

=head3 Return 

=over 

=item * I<$return>, a ref to a hash containing the execution state of the method. If everything went well, the "ok" key must be associated to the value "1".

=back 

=cut

#########################################
# modify_list
#########################################
# modify a list that belongs to the family
#  under to current robot:
# (the list modifications are described by the xml file)
#
# IN : -$self
#      -$fh : file handle on the xml file
# OUT : -$return->{'ok'} = 1(pas d'erreur fatale) or undef(erreur fatale)
#       -$return->{'string'} : string of results
#########################################
sub modify_list {
    my $self = shift;
    my $fh   = shift;
    $log->syslog('info', '(%s)', $self->{'name'});

    $self->{'state'} = 'no_check';
    my $return;
    $return->{'ok'}           = undef;
    $return->{'string_info'}  = undef;    ## info and simple errors
    $return->{'string_error'} = undef;    ## fatal errors

    #copy the xml file in another file
    unless (open FIC, '>', $self->{'dir'} . '/_mod_list.xml') {
        $log->syslog('err',
            'Impossible to create the temp file %s/_mod_list.xml: %m',
            $self->{'dir'});
    }
    while (<$fh>) {
        print FIC ($_);
    }
    close FIC;

    # get list data
    open(FIC, '<:raw', $self->{'dir'} . '/_mod_list.xml');
    my $config = Sympa::Config_XML->new(\*FIC);
    close FIC;
    unless (defined $config->createHash()) {
        push @{$return->{'string_error'}},
            "Error in representation data with these xml data";
        return $return;
    }

    my $hash_list = $config->getHash();

    #getting list
    my $list;
    unless (
        $list = Sympa::List->new(
            $hash_list->{'config'}{'listname'}, $self->{'robot'}
        )
        ) {
        push @{$return->{'string_error'}},
            "The list $hash_list->{'config'}{'listname'} does not exist.";
        return $return;
    }

    ## check family name
    if (defined $list->{'admin'}{'family_name'}) {
        unless ($list->{'admin'}{'family_name'} eq $self->{'name'}) {
            push @{$return->{'string_error'}},
                "The list $list->{'name'} already belongs to family $list->{'admin'}{'family_name'}.";
            return $return;
        }
    } else {
        push @{$return->{'string_error'}},
            "The orphan list $list->{'name'} already exists.";
        return $return;
    }

    ## get allowed and forbidden list customizing
    my $custom = $self->_get_customizing($list);
    unless (defined $custom) {
        $log->syslog('err', 'Impossible to get list %s customizing',
            $list->{'name'});
        push @{$return->{'string_error'}},
            "Error during updating list $list->{'name'}, the list is set in status error_config.";
        $list->set_status_error_config('modify_list_family', $self->{'name'});
        return $return;
    }
    my $config_changes = $custom->{'config_changes'};
    my $old_status     = $list->{'admin'}{'status'};

    ## list config family updating
    my $result = Sympa::Admin::update_list($list, $hash_list->{'config'},
        $self, $self->{'robot'});
    unless (defined $result) {
        $log->syslog('err', 'No object list resulting from updating list %s',
            $list->{'name'});
        push @{$return->{'string_error'}},
            "Error during updating list $list->{'name'}, the list is set in status error_config.";
        $list->set_status_error_config('modify_list_family', $self->{'name'});
        return $return;
    }
    $list = $result;

    ## set list customizing
    foreach my $p (keys %{$custom->{'allowed'}}) {
        $list->{'admin'}{$p} = $custom->{'allowed'}{$p};
        delete $list->{'admin'}{'defaults'}{$p};
        $log->syslog('info', 'Customizing: Keeping values for parameter %s',
            $p);
    }

    ## info file
    unless ($config_changes->{'file'}{'info'}) {
        $hash_list->{'config'}{'description'} =~ s/\r\n|\r/\n/g;

        unless (open INFO, '>', "$list->{'dir'}/info") {
            push @{$return->{'string_info'}},
                sprintf('Impossible to create new %s/info file: %s',
                $list->{'dir'}, $ERRNO);
        }
        print INFO $hash_list->{'config'}{'description'};
        close INFO;
    }

    foreach my $f (keys %{$config_changes->{'file'}}) {
        $log->syslog('info', 'Customizing: This file has been changed: %s',
            $f);
    }

    ## rename forbidden files
    #foreach my $f (@{$custom->{'forbidden'}{'file'}}) {
    #    unless (rename "$list->{'dir'}"."/"."info",
    #        "$list->{'dir'}"."/"."info.orig") {
    #        ###############
    #    }
    #    if ($f eq 'info') {
    #        $hash_list->{'config'}{'description'} =~ s/\r\n|\r/\n/g;
    #        unless (open INFO, '>', "$list_dir/info") {
    #            ###############
    #        }
    #        print INFO $hash_list->{'config'}{'description'};
    #        close INFO;
    #    }
    #}

    ## notify owner for forbidden customizing
    if (    #(scalar $custom->{'forbidden'}{'file'}) ||
        (scalar @{$custom->{'forbidden'}{'param'}})
        ) {
        #my $forbidden_files = join(',',@{$custom->{'forbidden'}{'file'}});
        my $forbidden_param = join(',', @{$custom->{'forbidden'}{'param'}});
        $log->syslog('notice',
            "These parameters aren't allowed in the new family definition, they are erased by a new instantiation family : \n $forbidden_param"
        );

        $list->send_notify_to_owner('erase_customizing',
            [$self->{'name'}, $forbidden_param]);
    }

    ## status
    $result = $self->_set_status_changes($list, $old_status);

    if ($result->{'aliases'} == 1) {
        push @{$return->{'string_info'}},
            "The $list->{'name'} list has been modified.";

    } elsif ($result->{'install_remove'} eq 'install') {
        push @{$return->{'string_info'}},
            "List $list->{'name'} has been modified, required aliases :\n $result->{'aliases'} ";

    } else {
        push @{$return->{'string_info'}},
            "List $list->{'name'} has been modified, aliases need to be removed : \n $result->{'aliases'}";

    }

    ## config_changes
    foreach my $p (@{$custom->{'forbidden'}{'param'}}) {

        if (defined $config_changes->{'param'}{$p}) {
            delete $config_changes->{'param'}{$p};
        }

    }

    unless (open FILE, '>', "$list->{'dir'}/config_changes") {
        $list->set_status_error_config('error_copy_file', $self->{'name'});
        push @{$return->{'string_info'}},
            sprintf
            'Impossible to create file %s/config_changes : %s, the list is set in status error_config.',
            $list->{'dir'}, $ERRNO;
    }
    close FILE;

    my @kept_param = keys %{$config_changes->{'param'}};
    $list->update_config_changes('param', \@kept_param);
    my @kept_files = keys %{$config_changes->{'file'}};
    $list->update_config_changes('file', \@kept_files);

    $list->{'admin'}{'latest_instantiation'}{'email'} =
        Sympa::get_address($self, 'listmaster');
    $list->{'admin'}{'latest_instantiation'}{'date_epoch'} = time;
    $list->save_config(Sympa::get_address($self, 'listmaster'));
    $list->{'family'} = $self;

    ## check param_constraint.conf
    $self->{'state'} = 'normal';
    my $error = $self->check_param_constraint($list);
    $self->{'state'} = 'no_check';

    unless (defined $error) {
        $list->set_status_error_config('no_check_rules_family',
            $self->{'name'});
        push @{$return->{'string_error'}},
            "Impossible to check parameters constraint, see logs for more information. The list is set in status error_config";
        return $return;
    }

    if (ref($error) eq 'ARRAY') {
        $list->set_status_error_config('no_respect_rules_family',
            $self->{'name'});
        push @{$return->{'string_info'}},
            "The list does not respect the family rules : "
            . join(", ", @{$error});
    }

    ## copy files in the list directory : xml file

    unless ($self->_copy_files($list->{'dir'}, "_mod_list.xml")) {
        $list->set_status_error_config('error_copy_file', $self->{'name'});
        push @{$return->{'string_info'}},
            "Impossible to copy the xml file in the list directory, the list is set in status error_config.";
    }

    ## Synchronize list members if required
    if ($list->has_include_data_sources()) {
        $log->syslog('notice', "Synchronizing list members...");
        $list->sync_include();
    }

    ## END
    $self->{'state'} = 'normal';
    $return->{'ok'}  = 1;

    return $return;
}

=pod 

=head2 sub close_family()

Closes every list family.

=head3 Arguments 

=over 

=item * I<$self>, the Sympa::Family object

=back 

=head3 Return 

=over 

=item * I<$string>, a character string containing a message to display describing the results of the sub.

=back 

=cut

#########################################
# close_family
#########################################
# closure family action :
#  - close every list family
#
# IN : -$self
# OUT : -$string
#########################################
sub close_family {
    my $self = shift;
    $log->syslog('info', '(%s)', $self->{'name'});

    my $family_lists = Sympa::List::get_lists($self);
    my @impossible_close;
    my @close_ok;

    foreach my $list (@{$family_lists}) {
        my $listname = $list->{'name'};

        unless (defined $list) {
            $log->syslog(
                'err',
                'The %s list belongs to %s family but the list does not exist',
                $listname,
                $self->{'name'}
            );
            next;
        }

        unless (
            $list->set_status_family_closed('close_list', $self->{'name'})) {
            push(@impossible_close, $list->{'name'});
            next;
        }
        push(@close_ok, $list->{'name'});
    }
    my $string =
        "\n\n******************************************************************************\n";
    $string .=
        "\n******************** CLOSURE of $self->{'name'} FAMILY ********************\n";
    $string .=
        "\n******************************************************************************\n\n";

    unless ($#impossible_close < 0) {
        $string .= "\nImpossible list closure for : \n  "
            . join(", ", @impossible_close) . "\n";
    }

    $string .= "\n****************************************\n";

    unless ($#close_ok < 0) {
        $string .=
            "\nThese lists are closed : \n  " . join(", ", @close_ok) . "\n";
    }

    $string .=
        "\n******************************************************************************\n";

    return $string;
}

=pod 

=head2 sub instantiate(FILEHANDLE $fh,
[ close_unknown =E<gt> 1 ], [ quiet =E<gt> 1 ] )

Creates family lists or updates them if they exist already.

=head3 Arguments 

=over 

=item * I<$self>, the Sympa::Family object corresponding to the family to create / update

=back 

=head3 Return 

=over 

=item * I<$string>, a character string containing a message to display describing the results of the sub,

=item * I<$fh>, a file handle on the B<family> XML file,

=item * I<$close_unknown>: if true, the function will close old lists undefined in the new instantiation.

=back 

=cut

#########################################
# instantiate
#########################################
# instantiate family action :
#  - create family lists if they are not
#  - update family lists if they already exist
#
# IN : -$self
#      -$xml_fh : file handle on the xml file
#      -%options
#        - close_unknown : true if must close old lists undefined in new
#                          instantiation
#        - quiet         :
# OUT : -1 or undef
#########################################
sub instantiate {
    $log->syslog('debug2', '(%s, %s, ...)', @_);
    my $self     = shift;
    my $xml_file = shift;
    my %options  = @_;

    ## all the description variables are emptied.
    $self->_initialize_instantiation();

    ## set impossible checking (used by list->load)
    $self->{'state'} = 'no_check';

    ## get the currently existing lists in the family
    my $previous_family_lists =
        {(map { $_->{name} => $_ } @{Sympa::List::get_lists($self) || []})};

    ## Splits the family description XML file into a set of list description
    ## xml files
    ## and collects lists to be created in $self->{'list_to_generate'}.
    unless ($self->_split_xml_file($xml_file)) {
        $log->syslog('err', 'Errors during the parsing of family xml file');
        return undef;
    }

    my $created = 0;
    my $total;
    my $progress;
    unless ($self->{'list_to_generate'}) {
        $log->syslog('err', 'No list found in XML file %s.', $xml_file);
        $self->{'list_to_generate'} = [];
        $total = 0;
    } else {
        $total    = scalar @{$self->{'list_to_generate'}};
        $progress = Term::ProgressBar->new(
            {   name  => 'Creating lists',
                count => $total,
                ETA   => 'linear'
            }
        );
        $progress->max_update_rate(1);
    }
    my $next_update = 0;
    my $aliasmanager_output_file =
        $Conf::Conf{'tmpdir'} . '/aliasmanager.stdout.' . $PID;
    my $output_file =
        $Conf::Conf{'tmpdir'} . '/instantiate_family.stdout.' . $PID;
    my $output = '';

    ## EACH FAMILY LIST
    foreach my $listname (@{$self->{'list_to_generate'}}) {

        my $list = Sympa::List->new($listname, $self->{'robot'});

        ## get data from list XML file. Stored into $config (class
        ## Sympa::Config_XML).
        my $xml_fh;
        open $xml_fh, '<:raw', $self->{'dir'} . "/" . $listname . ".xml";
        my $config = Sympa::Config_XML->new($xml_fh);
        close $xml_fh;
        unless (defined $config->createHash()) {
            push(
                @{$self->{'errors'}{'create_hash'}},
                "$self->{'dir'}/$listname.xml"
            );
            if ($list) {
                $list->set_status_error_config('instantiation_family',
                    $self->{'name'});
            }
            next;
        }

        ## stores the list config into the hash referenced by $hash_list.
        my $hash_list = $config->getHash();

        if ($list) {
            ## LIST ALREADY EXISTING

            delete $previous_family_lists->{$list->{'name'}};

            ## check family name
            if (defined $list->{'admin'}{'family_name'}) {
                unless ($list->{'admin'}{'family_name'} eq $self->{'name'}) {
                    push(
                        @{$self->{'errors'}{'listname_already_used'}},
                        $list->{'name'}
                    );
                    $log->syslog('err',
                        'The list %s already belongs to family %s',
                        $list->{'name'}, $list->{'admin'}{'family_name'});
                    next;
                }
            } else {
                push(
                    @{$self->{'errors'}{'listname_already_used'}},
                    $list->{'name'}
                );
                $log->syslog('err', 'The orphan list %s already exists',
                    $list->{'name'});
                next;
            }

            ## Update list config
            my $result = $self->_update_existing_list($list, $hash_list);
            unless (defined $result) {
                push(@{$self->{'errors'}{'update_list'}}, $list->{'name'});
                $list->set_status_error_config('instantiation_family',
                    $self->{'name'});
                next;
            }
            $list = $result;
        } else {
            # FIRST LIST CREATION

            # Check length
            if (Sympa::Constants::LIST_LEN() <
                length($hash_list->{'config'}{'listname'})) {
                $log->syslog('err', 'Too long value of param "listname"');
                push @{$self->{'errors'}{'create_list'}},
                    $hash_list->{'config'}{'listname'};
                next;
            }

            ## Create the list
            my $result = Sympa::Admin::create_list($hash_list->{'config'},