try {

            //Read the bundle to see what kind of configuration we need to apply

            String finalBundlePath = ConfigUtils.getBundlePath() + File.separator + bundleFolder;

            File xml = new File( finalBundlePath + File.separator + "bundle.xml" );

            //Get the identifiers on this bundle

            assetsDetails = new HashMap<String, String>();

            if ( bundlerAssets != null && !bundlerAssets.isEmpty() ) {

                for ( PublishQueueElement asset : bundlerAssets ) {

                    assetsDetails.put( asset.getAsset(), asset.getType() );

                }

                //Read the bundle to see what kind of configuration we need to apply

                String bundlePath = ConfigUtils.getBundlePath() + File.separator + basicConfig.getId();

                File xml = new File( bundlePath + File.separator + "bundle.xml" );

                //We can not retry Received Bundles, just bundles that we are trying to send

                Boolean sending = sendingBundle( request, config, bundleId );

                if ( !sending ) {

                    appendMessage( responseMessage, "publisher_retry.error.cannot.retry.received", bundleId, true );

                    continue;

                }

                if ( status.getStatus().equals( Status.SUCCESS ) ) {

                    //Get the bundle

                    Bundle bundle = APILocator.getBundleAPI().getBundleById( bundleId );

                    if ( bundle == null ) {

                        Logger.error( this.getClass(), "No Bundle with id: " + bundleId + " found." );

                        appendMessage( responseMessage, "publisher_retry.error.not.found", bundleId, true );

                        continue;

                    }

                    bundle.setForcePush( true );

                    APILocator.getBundleAPI().updateBundle( bundle );

                }

                //Clean the number of tries, we want to try it again

                auditHistory.setNumTries( 0 );

                //Get the identifiers on this bundle

                HashSet<String> identifiers = new HashSet<String>();

                }

                if ( assets != null && !assets.isEmpty() ) {

                    for ( PublishQueueElement asset : assets ) {

                        identifiers.add( asset.getAsset() );

                    }

                }

                //Cleaning previous bundle folder and tar file to avoid sending modified data

                FileUtils.cleanDirectory(new File(bundlePath));

                bundleFile.delete();

               

                //Now depending of the operation lets add it to the queue job

                    publisherAPI.addContentsToPublish( new ArrayList<String>( identifiers ), bundleId, new Date(), getUser() );

                } else {

                    publisherAPI.addContentsToUnpublish( new ArrayList<String>( identifiers ), bundleId, new Date(), getUser() );

                }

     */

    @SuppressWarnings ("unchecked")

    private Map<String, Object> generateBundle ( String bundleId, PushPublisherConfig.Operation operation ) throws DotPublisherException, DotDataException, DotPublishingException, IllegalAccessException, InstantiationException, DotBundleException, IOException {

        PublisherAPI pubAPI = PublisherAPI.getInstance();

        List<PublishQueueElement> tempBundleContents = pubAPI.getQueueElementsByBundleId( bundleId );

        List<PublishQueueElement> assetsToPublish = new ArrayList<PublishQueueElement>(); // all assets but contentlets

        for ( PublishQueueElement c : tempBundleContents ) {

            if ( !c.getType().equals( "contentlet" ) ) {

                assetsToPublish.add( c );

            }

        }

        // all types of assets in the queue but contentlets are passed here, which are passed through lucene queries

        //Queries creation

        //BUNDLERS

        List<Class<IBundler>> bundlers = new ArrayList<Class<IBundler>>();

        List<IBundler> confBundlers = new ArrayList<IBundler>();

        Publisher publisher = new PushPublisher();

        publisher.init( pconf );

        //Add the bundles for this publisher

        for ( Class clazz : publisher.getBundlers() ) {

            if ( !bundlers.contains( clazz ) ) {

                bundlers.add( clazz );

            }

        }

        //Create a new bundle id for this generated bundle

        String newBundleId = UUID.randomUUID().toString();

        File bundleRoot = BundlerUtil.getBundleRoot( pconf );

        // Run bundlers

        BundlerUtil.writeBundleXML( pconf );

        for ( Class<IBundler> c : bundlers ) {

            IBundler bundler = c.newInstance();

            confBundlers.add( bundler );

            bundler.setConfig( pconf );

            BundlerStatus bundlerStatus = new BundlerStatus( bundler.getClass().getName() );

            //Generate the bundler

            bundler.generate( bundleRoot, bundlerStatus );

        }

        //Compressing bundle

        ArrayList<File> list = new ArrayList<File>();

        list.add( bundleRoot );

        Map<String, Object> bundleData = new HashMap<String, Object>();

        bundleData.put( "id", newBundleId );

        bundleData.put( "file", PushUtils.compressFiles( list, bundle, bundleRoot.getAbsolutePath() ) );

        return bundleData;

              assetsToPublish.add(c);

            }

            historyPojo.setAssets(assets);

            //Status

            status =  new PublishAuditStatus(tempBundleId);

            status.setStatusPojo(historyPojo);

            //Insert in Audit table

            pubAuditAPI.insertPublishAuditStatus(status);

            //Queries creation

                        if ( Integer.parseInt( bundle.get( "operation" ).toString() ) == PublisherAPI.ADD_OR_UPDATE_ELEMENT ) {

                        } else {

                        }

                        try {

                            APILocator.getPublisherAPI().publish( pconf );

                        } catch ( DotPublishingException e ) {

                            /*

                            If we are getting errors creating the bundle we should stop trying to publish it, this is not just a connection error,

                            there is something wrong with a bundler or creating the bundle.

                             */

                            Logger.error( PublisherQueueJob.class, "Unable to publish Bundle: " + e.getMessage(), e );

                        }

                    }

        }