#!/bin/bash
# Ultima modificación: [arturo@2020-4-1]

# FICHVARS="/etc/default/vx-dga-variables/vx-dga-variables-general.conf"
# [ -f "${FICHVARS}" ] && . "${FICHVARS}"

USUARIOGRAFICO="$(vx-usuario-grafico)"

# Declaramos todas las funciones que se definen posteriormente para evitar ejecuciones indeseadas:
declare -a MYFUNCS
MYFUNCS=(vx-check_inicio_automatico
    vx-obtener_lista_usuarios
    vx-lista-usuarios-iniciado-sesion
    vx-conf_idioma_usuario
    vx-check_exit_users
    vx-check_exit_groups
    vx-check_sesion_grafica
    vx-checkusername
    vx-funcs-users-help
    vx-reset_users
    vx-resetear_usuarios
    vx-grupo_primario
    vx-anadir_a_grupos_secundarios
    vx-imponer_grupos
    vx-modificar_password
    vx-anadir_a_grupo
    vx-usuario_inicio_auto
    vx-usuario_inicio_deshabilitado
    vx-nopasswdlogin
    vx-crear_usuario_uid_gid
    vx-crear_usuario
    vx-crear_usuario_ex_idioma
    vx-borrar_usuario
)

# Configuramos el autocomplete:
complete -W "${MYFUNCS[*]}" "$(basename "${0}")"

# Mostramos la lista de funciones disponibles en el caso de que se pase como parámetro "-h" o "--help":
MIREGEX='^-h$|^--help$'
[[ "${1}" =~ ${MIREGEX} ]] && echo "${MYFUNCS[@]}" | tr -s " " "\n" | sort | more

# Definición de las funciones:

function vx-lista-usuarios-iniciado-sesion() {
    # Devolvemos una lista de usuarios que han iniciado sesión en el equipo:
    # Por defecto los devuelve separados por defecto por un " "
    # Se puede pasar como parámetro el carácter separador de la lista de usuarios
    # Puede obtenerse mediante el comando last o loginctl:
    [[ ! -z "${1}" && "${#1}" -eq 1 ]] && SEPARADOR="${1}" || SEPARADOR=" "
    for sessionid in $(loginctl list-sessions --no-legend | awk '{ print $1 }'); do
        loginctl show-session \
            -p Id -p Name -p User -p State -p Type -p Remote "${sessionid}" |
            sort
    done |
        awk -F= '/Name/ { name = $2 } \
        /User/ { user = $2 } \
        /State/ { state = $2 } \
        /Type/ { type = $2 } \
        /Remote/ { remote = $2 } \
        /User/ && remote == "no" && \
        user > 999 && \
        ( state == "active" || state == "closing" || state == "online" ) && \
        (type == "x11" || type == "wayland") \
    { print user":"name }' |
        sort | uniq | cut -d":" -f2 | tr -s "\n" "${SEPARADOR}"
    return 0
}

function vx-check_sesion_grafica() {
    # Devuelve un 0 si se detecta que hay una sesión gráfica de usuario iniciada:
    # 1) Listamos todas las sesiones que se han iniciado en el equipo para saber si hay alguna activa:
    RESULTADO=$(for sessionid in $(loginctl list-sessions --no-legend | awk '{ print $1 }'); do
        # 2) El parámetro "State" de show-sessions indica si la sesión se cerró (closing), esta iniciada pero no es la activa (online) o esta iniciada (active)
        # State=closing|online|active (el estado de la sesión: puede haber más de una activa, una x11|wayland y otra tty vía ssh)
        # Type=tty|x11|wayland (tty es el valor que adopta cuando accedemos vía ssh)
        # Remote=no|yes (vía ssh es yes)
        # Name=alumno|profesor|cau (el nombre del usuario)
        # User=0|1100|1200|1201 (el uid del usuario)
        # Id=c1|c3|2|c7|c10 (identificador de la sesión: precede una c cuando es gráfica tipo x11)
        loginctl show-session \
            -p Id -p Name -p User -p State -p Type -p Remote "${sessionid}" |
            sort
    done |
        awk -F= '/Name/ { name = $2 } \
    /User/ { user = $2 } \
    /State/ { state = $2 } \
    /Type/ { type = $2 } \
    /Remote/ { remote = $2 } \
    /User/ && \
    remote == "no" && \
    state == "active" && \
    (type == "x11" || type == "wayland") \
    { print user":"name }')
    IDUSUARIO="${RESULTADO//:*/}"
    NAMEUSUARIO="${RESULTADO##*:}"
    # 3) El IDUSUARIO devuelto puede ser de un usuario gráfico (> 999) o de lightdm (106):
    if vx-funcs-bash vx-check_is_integer "${IDUSUARIO}" &&
        (("${IDUSUARIO}" > 999)); then
        [ -z "${1}" ] && return 0
        case "${1}" in
        "-uid")
            echo "${IDUSUARIO}"
            ;;
        "-name")
            echo "${NAMEUSUARIO}"
            ;;
        esac
        return 0
    else
        return 1
    fi
}

function vx-check_inicio_automatico() {
    # Devuelve 0 si esta configurado un inicio de sesión automático:
    local FICHERO="/etc/lightdm/lightdm.conf"
    [ ! -f "${FICHERO}" ] && return 1
    local USUARIO="$(grep "^autologin-user=" "${FICHERO}" | cut -d"=" -f2)"
    vx-check_exit_users "${USUARIO}" && return 0 || return 1
}

function vx-checkusername() {
    # Devuelve 0 si es un nombre de usuario válido. 1 en caso contrario
    #  Un nombre de usuario debe cumplir las siguientes premisas:
    #  1) Clasicamente debería empezar por: [a-z] => ^[[:lower:]], pero ahora se permiten también mayúsculas: [a-zA-Z] o ([[:lower:]]|[[:upper:]])
    #  2) Le puede seguir [a-zA-Z], "-", ".", "_" (el "|" es una OR lógica) => ([a-zA-Z]|[[:digit:]]|-|_|\.)
    #  3) A priori no hay límite en la longitud del nombre de usuario
    # Si hubiera límite de 16 carac: REGEXP="^[[:lower:]]([[:lower:]]|[[:digit:]]|-|_|\.){2,15}$"
    #
    REGEXP="^[a-zA-Z]([a-zA-Z]|[[:digit:]]|-|_|\.)*$"
    [[ "${1}" =~ $REGEXP ]] && return 0 || return 1
}

function vx-obtener_lista_usuarios() {
    # Si NºParametros=0 y Ejecutor=root: devuelve la lista completa de usuarios gráficos
    # Si NºParametros=0 y Ejecutor!=root: devuelve el ejecutor que ha llamado a la función
    # Si NºParametros!=0 y Ejecutor=root:
    # # Si primer parámetro es "-ug": devuelve el usuario gráfico
    # # Si 1parámetro es "-u" y 2parametro "usu1,usu2,...": devuelve la lista de usuarios pasados sin comas
    # # Si 1parámetro es "-g" y 2parametro "grupo1,grupo2,...": devuelve la lista de usuarios sin comas pertenecientes a los grupos indicados
    # # Si no es ninguna de las anteriores comprueba la lista de usuarios pasada por parámetros y devuelve la lista de usarios reales
    local USUARIO="$(whoami)"
    local LISTA_USUARIOS=()
    if [[ ! -z "${1}" && "${USUARIO}" == "root" && "${1}" == "-ug" ]]; then
        LISTA_USUARIOS=("$(vx-usuario-grafico)")
    elif [[ ! -z "${1}" && "${USUARIO}" == "root" && "${1}" == "-u" ]]; then
        # -u: Se pasa como segundo parámetro una lista de usuarios separados por comas:
        for USU in ${2//,/ }; do
            vx-check_exit_users "${USU}" &&
                LISTA_USUARIOS+=("${USU}")
        done
    elif [[ ! -z "${1}" && "${USUARIO}" == "root" && "${1}" == "-g" ]]; then
        # -g: Se pasa como segundo parámetro una lista de grupos separados por comas:
        LISTA_GRUPOS=(${2//,/ })
        for GRUPO in ${LISTA_GRUPOS[@]}; do
            vx-funcs-users vx-check_exit_groups "${GRUPO}" &&
                LISTA_USUARIOS+=($(members "${GRUPO}"))
        done
    elif [[ ! -z "${1}" && "${USUARIO}" == "root" ]]; then
        for USU in ${@}; do
            vx-check_exit_users "${USU}" &&
                LISTA_USUARIOS+=("${USU}")
        done
    elif [[ "${USUARIO}" == "root" ]]; then
        LISTA_USUARIOS=($(vx-usuarios-graficos))
    else
        LISTA_USUARIOS=("${USUARIO}")
    fi
    echo "$(vx-funcs-bash vx-lista_uniq ${LISTA_USUARIOS[@]})"
}

function vx-conf_idioma_usuario() {
    # Require 3 parametros: usuario, lenguaje (en) y formatslocale (en_GB.UTF-8)
    local USUARIO="${1}"
    USUARIO="$(vx-check-usu-igualdad "${USUARIO}")"
    ! vx-check_exit_users "${USUARIO}" &&
        echo "=> ¡¡Error!! El usuario no existe: ${USUARIO}" && exit 1
    local HOMEUSU="$(vx-home-usuario-grafico "${USUARIO}")"
    local LENGUAJE="${2}"
    local FORMATOLOCAL="${3}"
    # Establecer el idioma elegido por defecto del lightdm:
    cat >"/var/lib/AccountsService/users/${USUARIO}" <<EOF
[User]
#Language=en
Language=${LENGUAJE}
#FormatsLocale=en_GB.UTF-8
FormatsLocale=${FORMATOLOCAL}
XSession=Lubuntu
SystemAccount=false
EOF
    # Establecer el idioma elegido en el PAM environment:
    cat >"${HOMEUSU}/.pam_environment" <<EOF
LANGUAGE=${LENGUAJE}
LANG=${FORMATOLOCAL}
LC_TIME=${FORMATOLOCAL}
EOF
    # Ajustamos el propietario del pam_environment:
    chown "${USUARIO}".sudo "${HOMEUSU}/.pam_environment"

    return 0
}

function vx-check_exit_users() {
    local USERSOK="true"
    until [ -z "${1}" ]; do
        ! getent passwd "${1}" >/dev/null 2>&1 && USERSOK="false"
        shift
    done
    "${USERSOK}" && return 0 || return 1
}

function vx-check_exit_groups() {
    local GRUPOSOK="true"
    until [ -z "${1}" ]; do
        ! getent group "${1}" >/dev/null 2>&1 && GRUPOSOK="false"
        shift
    done
    "${GRUPOSOK}" && return 0 || return 1
}

function vx-funcs-users-help() {
    local FICHFUNCS="/usr/bin/vx-funcs-users"
    for FUNCION in $(sed -n "s/^function \(.*\)().*/\1/gp" "${FICHFUNCS}"); do
        [[ "${1}" != "--help" ]] && echo "${FUNCION} --help" && continue
        [[ "${FUNCION}" != "vx-help-funcs-users" ]] &&
            echo ":== Función ${FUNCION} ==:" &&
            "${FUNCION}" --help
        echo "--"
    done
}

function vx-reset_users() {
    local AYUDA="# Función: Elimina y vuelve a crear la lista de usuarios pasados por parametro, separados por espacio en blanco o \":\"."
    AYUDA+="\nSi se indica como parámetro \"all\" se hará con todos los usuarios gráficos."
    AYUDA+="\n# Uso: vx-reset_users [all|usu1] [usu2] ..."
    AYUDA+="\n# Uso: vx-reset_users profesor dga"
    AYUDA+="\n# Uso: vx-reset_users profesor:dga:cau"
    AYUDA+="\n# Uso: vx-reset_users all"
    ([[ "${1}" == "--help" ]] || [[ -z "${1}" ]]) &&
        echo -e "${AYUDA}" && return 0
    [[ "${1}" == "all" ]] && LISTA_USUARIOS=($(vx-usuarios-graficos)) || LISTA_USUARIOS=(${*//:/ })
    echo "vx-reset_users => la lista de cuentas de usuario afectadas es: ${LISTA_USUARIOS[*]}"
    for USU in "${LISTA_USUARIOS[@]}"; do
        USU="$(vx-check-usu-igualdad "${USU}")"
        ! vx-check_exit_users "${USU}" && continue
        echo "vx-reset-users => va a eliminarse la cuenta de usuario: ${USU}"
        userdel -rf "${USU}" &&
            echo "=> Eliminamos el usuario ${USU}" ||
            echo "=> Problemas para eliminar ${USU}"
        vx-crear-usuarios-default "${USU}" &&
            echo "=> Creamos la cuenta de usuario: ${USU}" ||
            echo "=> No es una cuenta de usuario por defecto, se crearán al aplicar la configuración del centro: ${USU}"
    done
    COMANDO="vx-conf-centro-general-cli"
    if eval ${COMANDO} >/dev/null 2>&1; then
        echo "=> Se ha aplicado la configuración de centro para restablecer usuarios/passwords: ${NOMBRE}"
    else
        echo "=> Problemas para aplicar la configuración de centro y restablecer usuarios/passwords: ${NOMBRE}"
    fi
}

function vx-resetear_usuarios() {
    local AYUDA="# Función: Elimina todos los usuarios a excepción de los usuarios pasados por parametro"
    AYUDA+="\n# Uso: vx-resetear_usuarios [usu1] [usu2] ..."
    AYUDA+="\n# Uso: vx-resetear_usuarios profesor dga"
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    local LISTA_USUARIOS_A_CONSERVAR=(${*})
    local USUARIOS_A_BORRAR=($(vx-usuarios-graficos))
    # echo "Todos usuarios gráficos actuales: ${USUARIOS_A_BORRAR[@]}"
    # echo "Usuarios a conservar: ${LISTA_USUARIOS_A_CONSERVAR[@]}"

    # Para eliminar elementos de un array: https://stackoverflow.com/questions/16860877/remove-an-element-from-a-bash-array
    # Si sólo deseamos eliminar uno: array=( "${array[@]/$delete}" ) #Quotes when working with strings
    for INDICE in ${!USUARIOS_A_BORRAR[@]}; do
        for USU in ${LISTA_USUARIOS_A_CONSERVAR[@]}; do
            # Quitamos del array los usuarios que queremos conservar:
            # USUARIOS_A_BORRAR=("${USUARIOS_A_BORRAR[@]/$USU}")
            USU="$(vx-check-usu-igualdad "${USU}")"
            if test "${USU}" == "${USUARIOS_A_BORRAR[INDICE]}"; then
                # echo "Quitamos a ${USUARIOS_A_BORRAR[INDICE]}"
                unset 'USUARIOS_A_BORRAR[INDICE]'
            fi
        done
    done

    #echo "Listado resultante de usuarios a borrar: ${USUARIOS_A_BORRAR[@]}"

    for USU in ${USUARIOS_A_BORRAR[@]}; do
        if test "${USU}" != "$USUARIOGRAFICO"; then
            /usr/sbin/userdel -rf "${USU}"
        fi
    done
}

function vx-grupo_primario() {
    local AYUDA="# Función: Asocia a un usuario un grupo primario de pertenencia"
    AYUDA+="\n# Uso: vx-grupo_primario [usuario] [grupo] ... ..."
    AYUDA+="\n# Uso: vx-grupo_primario profesories sudo alumno1A alumno"
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    # $1: Primer parametro es el usuario
    # $2: Segundo parametro, grupo primario de pertenencia

    # Creamos por si acaso el grupo alumno (no vaya a estar borrado)
    ! (getent group 1200 >/dev/null 2>&1) &&
        (/usr/sbin/groupadd -g 1200 alumno >/dev/null 2>&1)
    # Creamos por si acaso el grupo profesor (no vaya a estar borrado)
    ! (getent group 1100 >/dev/null 2>&1) &&
        (/usr/sbin/groupadd -g 1100 profesor >/dev/null 2>&1)

    (($(getent group profesor | cut -d ":" -f 3) != 1100)) && groupmod -g 1100 profesor
    (($(getent group alumno | cut -d ":" -f 3) != 1200)) && groupmod -g 1200 alumno

    [ -z "${1}" ] && return 1

    until test -z "${1}"; do
        # Comprobamos que el usuario a asignarle un grupo existe:
        ! (getent passwd "${1}" >/dev/null 2>&1) && return 1
        # Creamos el grupo primario en caso de no existir:
        ! (getent group "${2}" >/dev/null 2>&1) && /usr/sbin/groupadd "${2}"
        # Asignamos al usuario como grupo primario el grupo indicado:
        /usr/sbin/usermod -g "${2}" "${1}"
        shift 2
    done

}

function vx-anadir_a_grupos_secundarios() {
    AYUDA="# Función: Añade un usuario a un conjunto de grupos secundarios"
    AYUDA+="\n# Uso: vx-anadir_a_grupos_secundarios [usuario] [grupo1] [grupo2] ... ..."
    AYUDA+="\n# Uso: vx-anadir_a_grupos_secundarios profesories sudo sambafs ..."
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    # Añade un usuario a un conjunto de grupos secundarios
    # $1: usuario
    # $2,3,4,...: grupos a los que añadir
    [ -z "${1}" ] && return 1
    # Comprobamos que el usuario a asignarle un grupo existe:
    ! (getent passwd "${1}" >/dev/null 2>&1) && return 1
    USU="${1}"
    USU="$(vx-check-usu-igualdad "${USU}")"
    shift
    until test -z "${1}"; do
        # Creamos el grupo en caso de no existir:
        ! (getent group "${1}" >/dev/null 2>&1) && /usr/sbin/groupadd "${1}"
        # Asignamos al usuario como grupo primario el grupo indicado:
        /usr/sbin/usermod -aG "${1}" "${USU}"
        shift
    done
}

function vx-imponer_grupos() {
    AYUDA="# Función: Impone, no añade, a un usuario un conjunto de grupos secundarios"
    AYUDA+="\n# Uso: vx-imponer_grupos [usuario] [grupo1] [grupo2] ... ..."
    AYUDA+="\n# Uso: vx-imponer_grupos profesories sudo sambafs ..."
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    # Impone los grupos indicados al usuario
    # $1: usuario
    # $2,3,4,...: grupos
    [ -z "${1}" ] && return 1
    # Comprobamos que el usuario a asignarle un grupo existe:
    ! (getent passwd "${1}" >/dev/null 2>&1) && return 1
    USU="${1}"
    USU="$(vx-check-usu-igualdad "${USU}")"
    shift
    GRUPOS=$(echo "${@}" | tr -s " " ",")
    until test -z "${1}"; do
        # Creamos el grupo en caso de no existir:
        ! (getent group "${1}" >/dev/null 2>&1) && /usr/sbin/groupadd "${1}"
        # Asignamos al usuario como grupo primario el grupo indicado:
    done
    /usr/sbin/usermod -G "${GRUPOS}" "${USU}"
}

function vx-modificar_password() {
    AYUDA="# Función: Modifica la password del usuario indicado"
    AYUDA+="# Si la longitud de la password es mayor a 80 caracteres se entiende que ya viene encriptada"
    AYUDA+="\n# Uso: vx-modificar_password [usu1] [pass1] [usu2] [pass2] ..."
    AYUDA+="\n# Uso: vx-modificar_password profe pass1 ..."
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    # Modifica la password del usuario indicado
    # $1: usuario
    # $2: nueva password
    # [[ -z "${1}" || -z "${2}" ]] && return 1
    ((${#} % 2)) &&
        echo -e "=> Error: vx-modificar_passwords requiere parametros pares. Se han recibido ${#} parametros. \nEstos son: ${@}" && return 1

    until [[ -z "${1}" || -z "${2}" ]]; do
        # Comprobamos que el usuario existe para modificarle la password:
        USU="${1}"
        USU="$(vx-check-usu-igualdad "${USU}")"
        if (getent passwd "${USU}" >/dev/null 2>&1); then
            ((${#2} > 80)) && PASS="${2}" || PASS="$(mkpasswd -s -m sha-512 "${2}")"
            usermod -p "${PASS}" "${USU}"
        fi
        shift 2
    done
    return 0
}

function vx-anadir_a_grupo() {
    AYUDA="# Función: Añade un usuario a un grupo secundario"
    AYUDA+="\n# Uso: vx-anadir_a_grupo [usu1] [gru1] [usu2] [gru2] ..."
    AYUDA+="\n# Uso: vx-anadir_a_grupo profe sudo ..."
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    # Añade un usuario a un grupo secundario
    # $1: usuario
    # $2: grupo al que añadir
    # [ -z "${1}" ] && return 1

    until [[ -z "${1}" || -z "${2}" ]]; do
        USU="${1}"
        USU="$(vx-check-usu-igualdad "${USU}")"
        # Comprobamos que el usuario a asignarle un grupo existe:
        ! (getent passwd "${USU}" >/dev/null 2>&1) && return 1
        # Creamos el grupo en caso de no existir:
        ! (getent group "${2}" >/dev/null 2>&1) && /usr/sbin/groupadd "${2}"
        # Asignamos al usuario como grupo primario el grupo indicado:
        /usr/sbin/usermod -aG "${2}" "${USU}"
        shift 2
    done

}

function vx-usuario_inicio_auto() {
    AYUDA="# Función: Indica el usuario con el que iniciará automáticamente el equipo"
    AYUDA+="\n# Uso: vx-usuario_inicio_auto alumno"
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    [ -z "${1}" ] && return 1
    # Comprobamos que el usuario existe:
    USU="${1}"
    USU="$(vx-check-usu-igualdad "${USU}")"
    ! (getent passwd "${1}" >/dev/null 2>&1) && return 1

    FICHERO="/etc/lightdm/lightdm.conf"
    if test -f "${FICHERO}"; then
        if grep "autologin-user=" "${FICHERO}" >/dev/null 2>&1; then
            sed -i "s/autologin-user=.*/autologin-user=${USU}/g" "${FICHERO}"
        else
            echo "autologin-user=${USU}" >>"${FICHERO}"
        fi
    fi
}

function vx-usuario_inicio_deshabilitado() {
    AYUDA="# Función: Deshabilita el inicio de sesión automático"
    AYUDA+="\n# Uso: vx-usuario_inicio_deshabilitado"
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    FICHERO="/etc/lightdm/lightdm.conf"
    if grep -q "autologin-user=" "${FICHERO}" >/dev/null 2>/dev/null; then
        sed -i "s/^autologin-user=.*/autologin-user=SIN-INICIO-AUTOMATICO/g" "${FICHERO}"
    else
        echo "autologin-user=SIN-INICIO-AUTOMATICO" >>"${FICHERO}"
    fi
}

function vx-nopasswdlogin() {
    AYUDA="# Función: Permite que se pueda iniciar sesión con un usuario sin password"
    AYUDA+="\n# Uso: vx-nopasswdlogin alumno profesor dga ..."
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    [ -z "${1}" ] && return 1

    until test -z "${1}"; do
        USU="${1}"
        USU="$(vx-check-usu-igualdad "${USU}")"
        # Comprobamos que el USU existe:
        (getent passwd "${USU}" >/dev/null 2>&1) &&
            /usr/sbin/usermod -aG "nopasswdlogin" "${USU}"
        shift
    done
}

function vx-crear_usuario_uid_gid() {
    AYUDA="# Función: Crea un usuario con un uid y gid concretos"
    AYUDA+="\n# Uso: vx-crear_usuario_uid_gid [usu] [pass] [uid] [grupo] [gid]"
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    # Ejemplo de llamada a la función:
    # Crear_Usuario "TEC-1" "faraday" "1301" "profesor" "1100" \
    # "TEC-2" "ampere" "1302" "profesor" "1100"
    # La variable FICH global indicará el fichero LOG de salida
    until ((${#} < 5)); do
        USUARIO="${1}"
        PASSWORD="${2}"
        USERID="${3}"
        GPRIMARIO="${4}"
        GRUPOID="${5}"
        # echo "Se va a crear el usuario ${USUARIO} con password ${PASSWORD}"
        if ! (getent passwd "${USUARIO}" >/dev/null 2>/dev/null); then
            if /usr/sbin/useradd -m -d "/home/${USUARIO}" \
                -s /bin/bash -c "Usuari@ ${USUARIO}" \
                -u "${USERID}" \
                -p "$(printf "${PASSWORD}" | mkpasswd -s -m sha-512)" "${USUARIO}" >/dev/null 2>&1; then
                echo "$(date) - Se ha creado el usuario ${USUARIO}"
            fi
        fi
        # Comprobamos la existencia del usuario en el grupo propuesto:
        if ! (getent group "${GPRIMARIO}" >/dev/null 2>/dev/null); then
            groupadd -g "${GRUPOID}" "${GPRIMARIO}" >/dev/null 2>&1
        fi
        if ! (id "${USUARIO}" | grep -q "${GPRIMARIO}") &&
            /usr/sbin/usermod -aG "${GPRIMARIO}" "${USUARIO}" >/dev/null 2>&1; then
            echo "$(date) - Se ha añadido al usuario ${USUARIO} al grupo ${GPRIMARIO} ..."
        fi
        # En el caso de ser un servidor Caché crearemos el usuario de Samba:
        if (vx-migasfree-tags -g | grep -q "CHE-"); then
            if ! (pdbedit -Lw | grep -q "${USUARIO}"); then
                (
                    echo "${PASSWORD}"
                    echo "${PASSWORD}"
                ) | smbpasswd -as "${USUARIO}" >/dev/null 2>&1
            fi
        fi

        shift 5
    done
}

function vx-crear_usuario() {
    AYUDA="# Función: Crea un usuario"
    AYUDA+="\n# Uso: vx-crear_usuario [usu] [pass]"
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    until [[ -z "${1}" || -z "${2}" ]]; do
        #echo "Creando usuario: $1"
        NUEVOUSUARIO="${1}"
        NUEVAPASS="${2}"
        if ! (getent passwd "${NUEVOUSUARIO}" >/dev/null 2>&1) &&
            /usr/sbin/useradd -m -d "/home/$NUEVOUSUARIO" \
                -s /bin/bash -c "Usuari@ ${NUEVOUSUARIO}" \
                -p "$(echo -n "${NUEVAPASS}" | mkpasswd -s -m sha-512)" "${NUEVOUSUARIO}"; then
            echo "$(date) - Se ha creado el usuario ${NUEVOUSUARIO}"
        fi
        shift 2
    done
}

function vx-crear_usuario_ex_idioma() {
    AYUDA="# Función: Crea un usuario con perfil en otro idioma al español"
    AYUDA+="\n# Uso: vx-crear_usuario_ex_idioma [usu] [pass] [Language] [FormatLocale]"
    AYUDA+="\n# Uso: vx-crear_usuario_ex_idioma alum1A mipass en en_GB.UTF-8"
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    until ((${#} < 4)); do
        LOG="/var/log/vitalinux/falla-crear-usuarios-ingles-${1}.log"
        NUEVOUSUARIO="${1}"
        NUEVAPASS="${2}"
        # Creamos la cuenta de usuario:
        if ! (getent passwd "${NUEVOUSUARIO}" >/dev/null 2>&1) &&
            /usr/sbin/useradd \
                -m -d "/home/${NUEVOUSUARIO}" \
                -s /bin/bash \
                -c "User ${NUEVOUSUARIO}" \
                -p "$(echo -n "${NUEVAPASS}" | mkpasswd -s -m sha-512)" "${NUEVOUSUARIO}" \
                &>>"${LOG}"; then
            echo "$(date) - Se ha creado el usuario con perfil de inglés: $NUEVOUSUARIO"
            # Establecer el idioma elegido por defecto del lightdm:
            cat >"/var/lib/AccountsService/users/${NUEVOUSUARIO}" <<EOF
[User]
#Language=en
Language=${3}
#FormatsLocale=en_GB.UTF-8
FormatsLocale=${4}
XSession=Lubuntu
SystemAccount=false
EOF
            # Establecer el idioma elegido en el PAM environment:
            cat >"/home/${NUEVOUSUARIO}/.pam_environment" <<EOF
LANGUAGE=${3}
LANG=${4}
LC_TIME=${4}
EOF
            # Ajustamos el propietario del pam_environment:
            chown "${NUEVOUSUARIO}".sudo "/home/${NUEVOUSUARIO}/.pam_environment"
        fi
        # Desplazamos 2 posiciones los parámetros para coger el siguiente usu/pass:
        shift 2
    done
}

function vx-borrar_usuario() {
    AYUDA="# Función: Elimina usuarios a excepción del usuario gráfico"
    AYUDA+="\n# Uso: vx-borrar_usuario [usu1] [usu2] ..."
    [ "${1}" == "--help" ] &&
        echo -e "${AYUDA}" && return 0

    [ -z "${1}" ] && return 1

    USUARIOGRAFICO="$(vx-usuario-grafico)"
    USUARIOS="$*"
    for USUARIO in ${USUARIOS}; do
        USUARIO="$(vx-check-usu-igualdad "${USUARIO}")"
        if test "${USUARIOGRAFICO}" != "${USUARIO}"; then
            if getent passwd "${USUARIO}" >/dev/null 2>&1; then
                /usr/sbin/userdel -fr "${USUARIO}" &&
                    echo "=> Se ha eliminado el usuario: ${USUARIO}"
            else
                echo "=> El usuario ${USUARIO} no existe en el sistema ..."
            fi
        fi
    done
}

# Comprobamos si los parámetros pasados se corresponden con la llamada a una de las funciones para ejecutarla
# En caso de que el parámetro no sea una de las funciones definidas sólo se quieren importar, no ejecutar
LISTADO_FUNCIONES=":${MYFUNCS[*]}:"
LISTADO_FUNCIONES="${LISTADO_FUNCIONES// /:}"
MIREGEX=":${1}:"
[[ "${LISTADO_FUNCIONES}" =~ ${MIREGEX} ]] &&
    "$@" 2>/dev/null
