<?php

use App\Seeder as AppSeeder;
use Database\Seeders\AddIncapacidadPaymentMethodSeeder;
use Database\Seeders\DisableButtonEnableSection;
use Database\Seeders\RenameClubContentModuleSeeder;
use Database\Seeders\TermsSeeder;
use Database\Seeders\TicketParametersQRCodeSettingsSeeder;
use Database\Seeders\TicketParametersSeeder;
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;

class DatabaseSeeder extends Seeder
{

    private function getBatch()
    {
        $result = AppSeeder::select(DB::raw('MAX(batch) AS batch'))->first();
        $batch = 0;
        if ($result->batch)
            $batch = $result->batch;
        return $batch + 1;
    }

    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        /**
         * CARGA DE DATOS SEEDERS
         **/

        $batch = $this->getBatch();

        // DefaultSeeder
        if (!AppSeeder::where('seeder', 'DefaultSeeder')->first()) {
            $this->call(DefaultSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DefaultSeeder', 'batch' => $batch]);
        }

        // Seeder cobro de servicio
        if (!AppSeeder::where('seeder', 'ServiceChargesSeeder')->first()) {
            $this->call(ServiceChargesSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ServiceChargesSeeder', 'batch' => $batch]);
        }

        // Seeder reestructuración modulos
        if (!AppSeeder::where('seeder', 'ModulesRestructuringSeeder')->first()) {
            $this->call(ModulesRestructuringSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ModulesRestructuringSeeder', 'batch' => $batch]);
        }

        // Seeder calificación directorio de negocios
        if (!AppSeeder::where('seeder', 'AddModuleBusinessRatingSeeder')->first()) {
            $this->call(AddModuleBusinessRatingSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleBusinessRatingSeeder', 'batch' => $batch]);
        }

        // Seeder calificaciones por defecto
        if (!AppSeeder::where('seeder', 'BusinessRatingsDataSeeder')->first()) {
            $this->call(BusinessRatingsDataSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'BusinessRatingsDataSeeder', 'batch' => $batch]);
        }

        // Seeder diapositivas tutorial APP
        if (!AppSeeder::where('seeder', 'TutorialSlidesSeeder')->first()) {
            $this->call(TutorialSlidesSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TutorialSlidesSeeder', 'batch' => $batch]);
        }

        // Seeder Modificar nombre item menu
        if (!AppSeeder::where('seeder', 'UpdateDataInTypeActionSeeder')->first()) {
            $this->call(UpdateDataInTypeActionSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'UpdateDataInTypeActionSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo tipo de configuración eventos boleteria
        if (!AppSeeder::where('seeder', 'CreateLabelTicketsForStageTypesSeeder')->first()) {
            $this->call(CreateLabelTicketsForStageTypesSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'CreateLabelTicketsForStageTypesSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo torneos de academias
        if (!AppSeeder::where('seeder', 'AcademyTournamentsSeeder')->first()) {
            $this->call(AcademyTournamentsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyTournamentsSeeder', 'batch' => $batch]);
        }

        // Seeder fijar los iconos y botones principales del home para el APP
        if (!AppSeeder::where('seeder', 'AdjustBottonHomeIconsFromAppSectionSeeder')->first()) {
            $this->call(AdjustBottonHomeIconsFromAppSectionSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AdjustBottonHomeIconsFromAppSectionSeeder', 'batch' => $batch]);
        }

        // Seeder dato de parametro por defecto ceder boleta
        if (!AppSeeder::where('seeder', 'TicketsParametersData')->first()) {
            $this->call(TicketsParametersData::class);
            AppSeeder::updateOrCreate(['seeder' => 'TicketsParametersData', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo de lista de boletas cedidas
        if (!AppSeeder::where('seeder', 'AddModuleListTicketUserLogSeeder')->first()) {
            $this->call(AddModuleListTicketUserLogSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleListTicketUserLogSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo de parametros
        if (!AppSeeder::where('seeder', 'AddModuleTicketsParametersSeeder')->first()) {
            $this->call(AddModuleTicketsParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleTicketsParametersSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo cuentas oficiales
        if (!AppSeeder::where('seeder', 'SocialNetworkAccountsSeeder')->first()) {
            $this->call(SocialNetworkAccountsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'SocialNetworkAccountsSeeder', 'batch' => $batch]);
        }

        // Seeder fecha de asistencia
        if (!AppSeeder::where('seeder', 'AcademyAttendanceDate')->first()) {
            $this->call(AcademyAttendanceDate::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyAttendanceDate', 'batch' => $batch]);
        }

        // Seeder de nuevos modulos en boleteria
        if (!AppSeeder::where('seeder', 'AddModulesTicketOffice')->first()) {
            $this->call(AddModulesTicketOffice::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModulesTicketOffice', 'batch' => $batch]);
        }

        // Seeder de nuevo modulos de creditos billetera
        if (!AppSeeder::where('seeder', 'AddModuleCreditCoinsSeeder')->first()) {
            $this->call(AddModuleCreditCoinsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleCreditCoinsSeeder', 'batch' => $batch]);
        }

        // Seeder de nuevo modulo de reporte redenciones
        if (!AppSeeder::where('seeder', 'ReportRedemptionsSeeder')->first()) {
            $this->call(ReportRedemptionsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ReportRedemptionsSeeder', 'batch' => $batch]);
        }

        // Seeder para fijar tipo de documento por defecto a los usuarios
        if (!AppSeeder::where('seeder', 'DocumentTypeDefaulSeeder')->first()) {
            $this->call(DocumentTypeDefaulSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DocumentTypeDefaulSeeder', 'batch' => $batch]);
        }

        // Seeder dato de secciones home
        if (!AppSeeder::where('seeder', 'HomeSectionDataSeeder')->first()) {
            $this->call(HomeSectionDataSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'HomeSectionDataSeeder', 'batch' => $batch]);
        }

        // Seeder academia adultos
        if (!AppSeeder::where('seeder', 'AdultAcademySeeder')->first()) {
            $this->call(AdultAcademySeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AdultAcademySeeder', 'batch' => $batch]);
        }

        // Seeder administración modulo
        if (!AppSeeder::where('seeder', 'AdministrationLogsModule')->first()) {
            $this->call(AdministrationLogsModule::class);
            AppSeeder::updateOrCreate(['seeder' => 'AdministrationLogsModule', 'batch' => $batch]);
        }

        // Seeder modulo métodos de pago
        if (!AppSeeder::where('seeder', 'PaymentMethodSeeder')->first()) {
            $this->call(PaymentMethodSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'PaymentMethodSeeder', 'batch' => $batch]);
        }

        // Seeder reporte de academias
        if (!AppSeeder::where('seeder', 'AcademyReportSeeder')->first()) {
            $this->call(AcademyReportSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyReportSeeder', 'batch' => $batch]);
        }

        // Seeder para habilitar botón para adjuntar soportes de pago
        if (!AppSeeder::where('seeder', 'EnableAttachSupportButtonSeeder')->first()) {
            $this->call(EnableAttachSupportButtonSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'EnableAttachSupportButtonSeeder', 'batch' => $batch]);
        }

        //seder para renovacion de matricula
        if (!AppSeeder::where('seeder', 'AddModuleRegistrationRenewal')->first()) {
            $this->call(AddModuleRegistrationRenewal::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddModuleRegistrationRenewal', 'batch' => $batch]);
        }

        //seder para agregar la opcion de activar el boton de "renovar matricula"
        if (!AppSeeder::where('seeder', 'AcademyParameterAppComponentRegistrationRenewal')->first()) {
            $this->call(AcademyParameterAppComponentRegistrationRenewal::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyParameterAppComponentRegistrationRenewal', 'batch' => $batch]);
        }

        //seeder para crear estado renovacion matricula
        if (!AppSeeder::where('seeder', 'AcademyStateRegistrationRenewal')->first()) {
            $this->call(AcademyStateRegistrationRenewal::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyStateRegistrationRenewal', 'batch' => $batch]);
        }

        //seeder para generar un academy state duplicado para activar la revisión a partir de la renovación
        if (!AppSeeder::where('seeder', 'TagsPeaceAndSafetySeeder')->first()) {
            $this->call(TagsPeaceAndSafetySeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TagsPeaceAndSafetySeeder', 'batch' => $batch]);
        }

        //seeder para generar academy state flow map
        if (!AppSeeder::where('seeder', 'AcademyStateFlowMapSeeder')->first()) {
            $this->call(AcademyStateFlowMapSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyStateFlowMapSeeder', 'batch' => $batch]);
        }

        // Seeder de estados de academia
        if (!AppSeeder::where('seeder', 'ErrorDocumentsSeeder')->first()) {
            $this->call(ErrorDocumentsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ErrorDocumentsSeeder', 'batch' => $batch]);
        }

        // Seeder para actualizar logs de ticketing
        if (!AppSeeder::where('seeder', 'UpdateLogTicketingSeeder')->first()) {
            $this->call(UpdateLogTicketingSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'UpdateLogTicketingSeeder', 'batch' => $batch]);
        }

        // Seeder para módulo logs erp
        if (!AppSeeder::where('seeder', 'AddErpLogsModuleSeeder')->first()) {
            $this->call(AddErpLogsModuleSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddErpLogsModuleSeeder', 'batch' => $batch]);
        }

        // Seeder para documentos persona juridica
        if (!AppSeeder::where('seeder', 'AcademyDocumentsJuridicPersonSeeder')->first()) {
            $this->call(AcademyDocumentsJuridicPersonSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyDocumentsJuridicPersonSeeder', 'batch' => $batch]);
        }

        // Seeder para actualizar tipo de documento de all a NATURAL_PERSON
        if (!AppSeeder::where('seeder', 'updateTypeDocumentsSeeder')->first()) {
            $this->call(UpdateTypeDocumentsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'updateTypeDocumentsSeeder', 'batch' => $batch]);
        }

        // Seeder para módulo terminos y condiciones
        if (!AppSeeder::where('seeder', 'TermsConditionsSeeder')->first()) {
            $this->call(TermsConditionsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TermsConditionsSeeder', 'batch' => $batch]);
        }

        // Seeder para crear parametro de fecha de inscripciones en academia parametros
        if (!AppSeeder::where('seeder', 'CreateRegistrationStartDateAcademyParameters')->first()) {
            $this->call(CreateRegistrationStartDateAcademyParameters::class);
            AppSeeder::updateOrCreate(['seeder' => 'CreateRegistrationStartDateAcademyParameters', 'batch' => $batch]);
        }

        // Seeder para crear tipos de academia en parametros
        if (!AppSeeder::where('seeder', 'UniformTypeAcademyParameters')->first()) {
            $this->call(UniformTypeAcademyParameters::class);
            AppSeeder::updateOrCreate(['seeder' => 'UniformTypeAcademyParameters', 'batch' => $batch]);
        }

        // Seeder para actualizar clase antigua de la pasarela wompi
        if (!AppSeeder::where('seeder', 'UpdateWompiGatewayClass')->first()) {
            $this->call(UpdateWompiGatewayClass::class);
            AppSeeder::updateOrCreate(['seeder' => 'UpdateWompiGatewayClass', 'batch' => $batch]);
        }

        // Seeder para novedades academias
        if (!AppSeeder::where('seeder', 'AcademyNewsSeeder')->first()) {
            $this->call(AcademyNewsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyNewsSeeder', 'batch' => $batch]);
        }

        // Seeder para crear nuevo estado firmar documentos en academia
        if (!AppSeeder::where('seeder', 'SignAcademyDocuments')->first()) {
            $this->call(SignAcademyDocuments::class);
            AppSeeder::updateOrCreate(['seeder' => 'SignAcademyDocuments', 'batch' => $batch]);
        }

        // Seeder para crear modulo repositorio documental adultos
        if (!AppSeeder::where('seeder', 'ModuleRegistrationRenewalAdult')->first()) {
            $this->call(ModuleRegistrationRenewalAdult::class);
            AppSeeder::updateOrCreate(['seeder' => 'ModuleRegistrationRenewalAdult', 'batch' => $batch]);
        }

        // Seeder para parametros erp
        if (!AppSeeder::where('seeder', 'ERPParametersSeeder')->first()) {
            $this->call(ERPParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ERPParametersSeeder', 'batch' => $batch]);
        }

        // Seeder para hepldesk
        if (!AppSeeder::where('seeder', 'HelpdeskSeeder')->first()) {
            $this->call(HelpdeskSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'HelpdeskSeeder', 'batch' => $batch]);
        }

        // Seeder para crear botón tienda en academia
        if (!AppSeeder::where('seeder', 'StoreAcademy')->first()) {
            $this->call(StoreAcademy::class);
            AppSeeder::updateOrCreate(['seeder' => 'StoreAcademy', 'batch' => $batch]);
        }

        // Seeder para crear parametros de día de pago academia
        if (!AppSeeder::where('seeder', 'CreateMaximumPaymentDayMonthAcademyParameters')->first()) {
            $this->call(CreateMaximumPaymentDayMonthAcademyParameters::class);
            AppSeeder::updateOrCreate(['seeder' => 'CreateMaximumPaymentDayMonthAcademyParameters', 'batch' => $batch]);
        }

        // Seeder para crear nuevo tipo de reestricción tribuna
        if (!AppSeeder::where('seeder', 'CreateExclusiveTribuneStageType')->first()) {
            $this->call(CreateExclusiveTribuneStageType::class);
            AppSeeder::updateOrCreate(['seeder' => 'CreateExclusiveTribuneStageType', 'batch' => $batch]);
        }

        // Seeder añadir para añadir Certificado de salud APP
        if (!AppSeeder::where('seeder', 'AcademyDocumentsSeeder')->first()) {
            $this->call(AcademyDocumentsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyDocumentsSeeder', 'batch' => $batch]);
        }

        // Seeder configuraciones/titulo PowerBI
        if (!AppSeeder::where('seeder', 'PowerBISeeder')->first()) {
            $this->call(PowerBISeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'PowerBISeeder', 'batch' => $batch]);
        }

        // Seeder para la creacion de modulos contenido del club
        if (!AppSeeder::where('seeder', 'ClubContentSeeder')->first()) {
            $this->call(ClubContentSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ClubContentSeeder', 'batch' => $batch]);
        }

        // Seeder para la creacion de configuracion del club
        if (!AppSeeder::where('seeder', 'ClubParametersSeeder')->first()) {
            $this->call(ClubParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ClubParametersSeeder', 'batch' => $batch]);
        }

        //Publication dashboard seeder
        if (!AppSeeder::where('seeder', 'PublicationDashboardSeeder')->first()) {
            $this->call(PublicationDashboardSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'PublicationDashboardSeeder', 'batch' => $batch]);
        }

        // Seeder data policy
        if (!AppSeeder::where('seeder', 'DataPolicySeeder')->first()) {
            $this->call(DataPolicySeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DataPolicySeeder', 'batch' => $batch]);
        }

        // Seeder para añadir configuración en tickets/parameter
        if (!AppSeeder::where('seeder', 'addTicketConfigurationInParametersSeeder')->first()) {
            $this->call(AddTicketConfigurationInParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'addTicketConfigurationInParametersSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir una app section y actualizar con dos meses en las fechas de parametros para club
        if (!AppSeeder::where('seeder', 'AppSectionAndUpdateVariableSeeder')->first()) {
            $this->call(AppSectionAndUpdateVariableSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AppSectionAndUpdateVariableSeeder', 'batch' => $batch]);
        }

        // Seeder para modificar Contenido del club
        if (!AppSeeder::where('seeder', 'DisableButtonEnableSection')->first()) {
            $this->call(DisableButtonEnableSection::class);
            AppSeeder::updateOrCreate(['seeder' => 'DisableButtonEnableSection', 'batch' => $batch]);
        }

        // Seeder para experiencia web ticketing
        if (!AppSeeder::where('seeder', 'AddWebTicketingExperienceModuleSeeder')->first()) {
            $this->call(AddWebTicketingExperienceModuleSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddWebTicketingExperienceModuleSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir Incapacidad a la tabla de payment_methods
        if (!AppSeeder::where('seeder', 'AddIncapacidadPaymentMethodSeeder')->first()) {
            $this->call(AddIncapacidadPaymentMethodSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AddIncapacidadPaymentMethodSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir terminos y condiciones de ticket_parameters
        if (!AppSeeder::where('seeder', 'TicketParametersSeeder')->first()) {
            $this->call(TicketParametersSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TicketParametersSeeder', 'batch' => $batch]);
        }

        // Seeder para cambiar nombre de contenido club a contenido exclusivo
        if (!AppSeeder::where('seeder', 'AppSectionAndUpdateVariableToExclusiveContentSeeder')->first()) {
            $this->call(AppSectionAndUpdateVariableToExclusiveContentSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AppSectionAndUpdateVariableToExclusiveContentSeeder', 'batch' => $batch]);
        }

        // Seeder para desactivar el contenido exclusivo
        if (!AppSeeder::where('seeder', 'DisableButtonEnableExclusiveContentSectionSeeder')->first()) {
            $this->call(DisableButtonEnableExclusiveContentSectionSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DisableButtonEnableExclusiveContentSectionSeeder', 'batch' => $batch]);
        }

        // Seeder para cambiar nombre de contenido club a contenido exclusivo
        if (!AppSeeder::where('seeder', 'RenameClubContentModuleSeeder')->first()) {
            $this->call(RenameClubContentModuleSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'RenameClubContentModuleSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir módilo de membresias
        if (!AppSeeder::where('seeder', 'MembershipsSeeder')->first()) {
            $this->call(MembershipsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'MembershipsSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir modulo de experiencias
        if (!AppSeeder::where('seeder', 'ExperienceSeeder')->first()) {
            $this->call(ExperienceSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ExperienceSeeder', 'batch' => $batch]);
        }

        // Seeder para poblar la tabla de ciudades de servientrega
        if (!AppSeeder::where('seeder', 'ServientregaCitiesSeeder')->first()) {
            $this->call(ServientregaCitiesSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ServientregaCitiesSeeder', 'batch' => $batch]);
        }

        // Seeder para poblar la tabla divipola
        if (!AppSeeder::where('seeder', 'DivipolaTableSeeder')->first()) {
            $this->call(DivipolaTableSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DivipolaTableSeeder', 'batch' => $batch]);
        }

        // Seeder parametros por defecto SAP
        if (!AppSeeder::where('seeder', 'ERPParamsSeeder')->first()) {
            $this->call(ERPParamsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ERPParamsSeeder', 'batch' => $batch]);
        }

        // Seeder para fijar los precios de servicio de servientrega
        if (!AppSeeder::where('seeder', 'ServientregaServiceFixPrices')->first()) {
            $this->call(ServientregaServiceFixPrices::class);
            AppSeeder::updateOrCreate(['seeder' => 'ServientregaServiceFixPrices', 'batch' => $batch]);
        }

        // Seeder para actualizar modulo de validacion de referencias
        if (!AppSeeder::where('seeder', 'AdjustModulePaymentsValidator')->first()) {
            $this->call(AdjustModulePaymentsValidator::class);
            AppSeeder::updateOrCreate(['seeder' => 'AdjustModulePaymentsValidator', 'batch' => $batch]);
        }

        // Seeder para actualizar modulo de validacion de referencias
        if (!AppSeeder::where('seeder', 'TermsSeeder')->first()) {
            $this->call(TermsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TermsSeeder', 'batch' => $batch]);
        }
        // Seeder para crear reporte de analitica de documentos
        if (!AppSeeder::where('seeder', 'DocumentAnalyticSeeder')->first()) {
            $this->call(DocumentAnalyticSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DocumentAnalyticSeeder', 'batch' => $batch]);
        }

        // Seeder para añadir sección de preguntas para opciones en el APP
        if (!AppSeeder::where('seeder', 'FaqSeederFix')->first()) {
            $this->call(FaqSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'FaqSeederFix', 'batch' => $batch]);
        }

        // Seeder para crear proveedor de facturacion electronica pagopass
        if (!AppSeeder::where('seeder', 'PagoPassSeeder')->first()) {
            $this->call(PagoPassSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'PagoPassSeeder', 'batch' => $batch]);
        }

        // Seeder para crear proveedor de firma electronica zapsign
        if (!AppSeeder::where('seeder', 'ZapSignSeeder')->first()) {
            $this->call(ZapSignSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ZapSignSeeder', 'batch' => $batch]);
        }

        // Seeder para actualizar patron de validacion de tipos de documento
        if (!AppSeeder::where('seeder', 'DocumentTypePatternSeeder')->first()) {
            $this->call(DocumentTypePatternSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DocumentTypePatternSeeder', 'batch' => $batch]);
        }

        //SAP prod
        if (!AppSeeder::where('seeder', 'ERPSapParamsSeeder')->first()) {
            $this->call(ERPSapParamsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ERPSapParamsSeeder', 'batch' => $batch]);
        }

        // Seeder para actualizar mostrar en tipos de documento
        if (!AppSeeder::where('seeder', 'DocumentTypeShowInSeeder')->first()) {
            $this->call(DocumentTypeShowInSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DocumentTypeShowInSeeder', 'batch' => $batch]);
        }

        // Seeder para crear proveedor de firma electronica zapsign para produccion
        if (!AppSeeder::where('seeder', 'ZapSignSeederProduction')->first()) {
            $this->call(ZapSignSeederProduction::class);
            AppSeeder::updateOrCreate(['seeder' => 'ZapSignSeederProduction', 'batch' => $batch]);
        }

        // Seeder para actualizar patron de validacion para que permita ceros al inicio de los tipos de documentos
        if (!AppSeeder::where('seeder', 'UpdateDocumentTypesPatternSeeder')->first()) {
            $this->call(UpdateDocumentTypesPatternSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'UpdateDocumentTypesPatternSeeder', 'batch' => $batch]);
        }

        // Seeder para crear modulo de tipos de documentos
        if (!AppSeeder::where('seeder', 'DocumentTypesModuleSeeder')->first()) {
            $this->call(DocumentTypesModuleSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'DocumentTypesModuleSeeder', 'batch' => $batch]);
        }

        // Seeder modulo de items personalizados de factuación
        if (!AppSeeder::where('seeder', 'ERPCustomItemsSeeder')->first()) {
            $this->call(ERPCustomItemsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ERPCustomItemsSeeder', 'batch' => $batch]);
        }

        // Seeder Siesa Sandbox
        if (!AppSeeder::where('seeder', 'ERPSiesaSandboxParamsSeeder')->first()) {
            $this->call(ERPSiesaSandboxParamsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ERPSiesaSandboxParamsSeeder', 'batch' => $batch]);
        }
        // Seeder para agregar condicion de nuevo campo advisor_property_name en datos parametros de preregistro de academia
        if (!AppSeeder::where('seeder', 'AdvisorPropertyNameSeeder')->first()) {
            $this->call(AdvisorPropertyNameSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'AdvisorPropertyNameSeeder', 'batch' => $batch]);
        }

        // Seeder Siesa Prod
        if (!AppSeeder::where('seeder', 'ERPSiesaProdParamsSeeder')->first()) {
            $this->call(ERPSiesaProdParamsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ERPSiesaProdParamsSeeder', 'batch' => $batch]);
        }

        // Seeder para agregar nuevo modulo de reporte de tickets
        if (!AppSeeder::where('seeder', 'TicketingReportModules')->first()) {
            $this->call(TicketingReportModules::class);
            AppSeeder::updateOrCreate(['seeder' => 'TicketingReportModules', 'batch' => $batch]);
        }

        // Seeder para crear nuevo tipo de reestricción bloqueo de sillas no abonados
        if (!AppSeeder::where('seeder', 'CreateBlockNonSubscribersSeatsStageType')->first()) {
            $this->call(CreateBlockNonSubscribersSeatsStageType::class);
            AppSeeder::updateOrCreate(['seeder' => 'CreateBlockNonSubscribersSeatsStageType', 'batch' => $batch]);
        }

        // Seeder para fijar COP como moneda por defecto en corporate identity
        if (!AppSeeder::where('seeder', 'UpdateCorporateIdentitySetCurrencySeeder')->first()) {
            $this->call(UpdateCorporateIdentitySetCurrencySeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'UpdateCorporateIdentitySetCurrencySeeder', 'batch' => $batch]);
        }

        // Seeder para crear parametros de QR codes para tickets
        if (!AppSeeder::where('seeder', 'TicketParametersQRCodeSettingsSeeder')->first()) {
            $this->call(TicketParametersQRCodeSettingsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'TicketParametersQRCodeSettingsSeeder', 'batch' => $batch]);
        }

        // Seeder valor por defecto parametro para mostrar term del pago
        if (!AppSeeder::where('seeder', 'ShowPaymentTermSeeder')->first()) {
            $this->call(ShowPaymentTermSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ShowPaymentTermSeeder', 'batch' => $batch]);
        }

        // Seeder para agregar nuevo modulo de cortesias
        if (!AppSeeder::where('seeder', 'ComplimentaryTicketsSeeder')->first()) {
            $this->call(ComplimentaryTicketsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ComplimentaryTicketsSeeder', 'batch' => $batch]);
        }

        // Seeder para actualizar texto inscripto por inscrito
        if (!AppSeeder::where('seeder', 'ChangeInscriptoTagSeeder')->first()) {
            $this->call(ChangeInscriptoTagSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ChangeInscriptoTagSeeder', 'batch' => $batch]);
        }

        // Seeder para crear parametros de cortesias de academias
        if (!AppSeeder::where('seeder', 'AcademyCourtesyParametersData')->first()) {
            $this->call(AcademyCourtesyParametersData::class);
            AppSeeder::updateOrCreate(['seeder' => 'AcademyCourtesyParametersData', 'batch' => $batch]);
        }

        // Seeder para agregar esquema de pagos en parametros de academias
        if (!AppSeeder::where('seeder', 'PaymentScheduleAcademyParameterSeeder')->first()) {
            $this->call(PaymentScheduleAcademyParameterSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'PaymentScheduleAcademyParameterSeeder', 'batch' => $batch]);
        }

        // Seeder experiencias logs modulo
        if (!AppSeeder::where('seeder', 'ExperienceLogsSeeder')->first()) {
            $this->call(ExperienceLogsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ExperienceLogsSeeder', 'batch' => $batch]);
        }

        // Seeder membresias logs modulo
        if (!AppSeeder::where('seeder', 'MembershipLogsSeeder')->first()) {
            $this->call(MembershipLogsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'MembershipLogsSeeder', 'batch' => $batch]);
        }

        // Seeder boton perfil en academia
        if (!AppSeeder::where('seeder', 'ProfileButttonInAppComponentsSeeder')->first()) {
            $this->call(ProfileButttonInAppComponentsSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'ProfileButttonInAppComponentsSeeder', 'batch' => $batch]);
        }

        // Sincronizar experiencia con ERP parametro
        if (!AppSeeder::where('seeder', 'SyncExperienceWithErpParameterSeeder')->first()) {
            $this->call(SyncExperienceWithErpParameterSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'SyncExperienceWithErpParameterSeeder', 'batch' => $batch]);
        }
        // Seeder Unidades de negocio
        if (!AppSeeder::where('seeder', 'BusinessUnitSeeder')->first()) {
            $this->call(BusinessUnitSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'BusinessUnitSeeder', 'batch' => $batch]);
        }

        // Seeder para notificaciones de pagos no confirmados
        if (!AppSeeder::where('seeder', 'NotifyUnconfirmedPaymentSeeder')->first()) {
            $this->call(NotifyUnconfirmedPaymentSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'NotifyUnconfirmedPaymentSeeder', 'batch' => $batch]);
        }

        // Seeder whatsapp api config
        if (!AppSeeder::where('seeder', 'WhatsAppSeeder')->first()) {
            $this->call(WhatsAppSeeder::class);
            AppSeeder::updateOrCreate(['seeder' => 'WhatsAppSeeder', 'batch' => $batch]);
        }

        // Seeder campos de formulario de academia
        if (!AppSeeder::where('seeder', 'DefaultAcademyFormFields')->first()) {
            $this->call(DefaultAcademyFormFields::class);
            AppSeeder::updateOrCreate(['seeder' => 'DefaultAcademyFormFields', 'batch' => $batch]);
        }
    }
}