PrsoAdvBrightCoveFtp

General App Functions.

Defined (1)

The class is defined in the following location(s).

/inc/VideoUploader/includes/inc_brightcove_ftp.php  
  1. class PrsoAdvBrightCoveFtp extends PrsoAdvVideoUploader { 
  2.      
  3.     private $ftp_server = NULL; 
  4.     private $username = NULL; 
  5.     private    $password = NULL; 
  6.     private $publisher_id = NULL; 
  7.     private    $preparer = NULL; 
  8.     private    $manifext_filename = 'myManifest'; 
  9.     private $ftp_conn_id = ''; 
  10.     private $callback_url = ''; 
  11.      
  12.     public function init_api( $validated_attachments ) { 
  13.          
  14.         //Init api and Process video uploads 
  15.         return $this->init_brightcove_ftp( $validated_attachments );; 
  16.          
  17.     } 
  18.      
  19.     public function get_video_url( $video_id = NULL ) { 
  20.      
  21.         //Init vars 
  22.         $bright_cove_url = 'http://www.brightcove.com'; 
  23.          
  24.         return $bright_cove_url; 
  25.          
  26.     } 
  27.      
  28.      
  29.     private function init_brightcove_ftp( $validated_attachments ) { 
  30.          
  31.         //Init vars 
  32.         $manifest_path = NULL; 
  33.         $ftp_conn_id = NULL; 
  34.         $upload_results = array(); 
  35.         $upload_manifest = FALSE; 
  36.         $plugin_options = array(); 
  37.          
  38.         //First try and get the plugin options 
  39.         if( isset($this->plugin_options_slug) ) { 
  40.             $plugin_options = get_option( $this->plugin_options_slug ); 
  41.         } 
  42.          
  43.         $this->plugin_error_log( $plugin_options ); 
  44.          
  45.         if( $plugin_options !== FALSE && isset($plugin_options['bc_server'], $plugin_options['bc_username'], $plugin_options['bc_password'], $plugin_options['bc_publisher_id'], $plugin_options['bc_preparer']) ) { 
  46.              
  47.             //Cache options values 
  48.             $this->ftp_server =    esc_attr( $plugin_options['bc_server'] ); 
  49.             $this->username =    esc_attr( $plugin_options['bc_username'] ); 
  50.             $this->password =    esc_attr( $plugin_options['bc_password'] ); 
  51.             $this->publisher_id =    esc_attr( $plugin_options['bc_publisher_id'] ); 
  52.             $this->preparer =    esc_attr( $plugin_options['bc_preparer'] ); 
  53.              
  54.             //Init process 
  55.             if( !empty($validated_attachments) && is_array($validated_attachments) ) { 
  56.              
  57.                 //Write xml manifest file for all validate video files 
  58.                 $manifest_path = $this->generate_manifest_xml( $validated_attachments ); 
  59.                  
  60.                 //Init ftp connection 
  61.                 if( $manifest_path !== FALSE && file_exists($manifest_path) ) { 
  62.                      
  63.                     $ftp_conn_id = $this->init_ftp_connection(); 
  64.                      
  65.                     //Error check connection 
  66.                     if( $ftp_conn_id !== FALSE ) { 
  67.                          
  68.                         //cache connection id 
  69.                         $this->ftp_conn_id = $ftp_conn_id; 
  70.                          
  71.                         //Upload video files 
  72.                         $upload_results = $this->upload_video_files( $validated_attachments ); 
  73.                          
  74.                         //Upload manifest xml file 
  75.                         if( !empty($upload_results) && is_array($upload_results) ) { 
  76.                             $upload_manifest = $this->upload_manifest_file( $manifest_path ); 
  77.                         } 
  78.                          
  79.                         //Final error check, make sure manifest uploaded ok 
  80.                         if( $upload_manifest === FALSE ) { 
  81.                              
  82.                             //Empty upload results array to ensure a redundant copy of 
  83.                             //video files remain in wp media library as backup 
  84.                             $upload_results = array(); 
  85.                              
  86.                         } 
  87.                          
  88.                     } 
  89.                      
  90.                 } 
  91.                  
  92.             } 
  93.              
  94.         } else { 
  95.             $this->plugin_error_log( 'Brightcove FTP:: Missing options for this api.' ); 
  96.         } 
  97.          
  98.          
  99.         //Return the array of succefully uploaded files to be updated in gforms 
  100.         //meta table and deleted from wp media library 
  101.         return $upload_results; 
  102.     } 
  103.      
  104.     /** 
  105.     * generate_manifest_xml 
  106.     *  
  107.     * Loops over all validate video files and creates 
  108.     * the mainfest xml file 
  109.     * 
  110.     * Video Array Format: 
  111.     *    Array 
  112.         ( 
  113.             [1] => Array //Each gravity forms upload field 
  114.                 ( 
  115.                     [0] => Array //Each video file uploaded via this field 
  116.                         ( 
  117.                             [wp_attachement_id] => 906 
  118.                             [mime_type] => video/quicktime 
  119.                             [file_path] => /Users/ben/Documents/Development/vhost/www.pressoholics.dev/wp-content/uploads/2013/03/cdeecad1844aca9e7b95fd66bc556df6.mov 
  120.                             [title] => Uploaded File: Form 6, Entry 4, File 0 
  121.                             [description] => This video was uploaded from your website, here are the details: Form 6, Entry 4, File 0 
  122.  ) 
  123.          
  124.  ) 
  125.          
  126.  ) 
  127.     *  
  128.     * @access     private 
  129.     * @author    Ben Moody 
  130.     */ 
  131.     private function generate_manifest_xml( $validated_attachments ) { 
  132.          
  133.         //Init vars 
  134.         $result = FALSE; 
  135.         $save_path = NULL; 
  136.         $wp_wpload_dir_info = array(); 
  137.         $doc = NULL; 
  138.         $type = 'VIDEO_FULL'; 
  139.         $encode_to = 'MP4'; 
  140.         $encode_multiple = 'true'; 
  141.         $conf_email = NULL; 
  142.          
  143.         //Cache local save path for manifest 
  144.         $wp_wpload_dir_info = wp_upload_dir(); 
  145.          
  146.         if( isset($wp_wpload_dir_info['basedir'], $this->manifext_filename) ) { 
  147.             $save_path = $wp_wpload_dir_info['basedir'] . '/' . $this->manifext_filename . '.xml'; 
  148.         } 
  149.          
  150.         //Cache confirmation email address 
  151.         $conf_email = get_option( 'prso_gforms_youtube_main_options', NULL ); 
  152.         if( isset($conf_email['confirmation_email']) ) { 
  153.             $conf_email = $conf_email['confirmation_email']; 
  154.         } 
  155.          
  156.         $this->plugin_error_log( 'Email: ' . $conf_email ); 
  157.          
  158.         //Start xml write process 
  159.         if( !empty($save_path) ) { 
  160.              
  161.             $doc = new DomDocument( '1.0', 'UTF-8' ); 
  162.              
  163.             //Create publisher-upload-manifest element 
  164.             $pub_manifest = $doc->createElement( 'publisher-upload-manifest' ); 
  165.             $pub_manifest_node = $doc->appendChild( $pub_manifest ); 
  166.              
  167.             //Add publisher-upload-manifest attributes 
  168.             $pub_manifest_node->setAttribute( 'publisher-id', $this->publisher_id ); 
  169.             $pub_manifest_node->setAttribute( 'preparer', $this->preparer ); 
  170.             $pub_manifest_node->setAttribute( 'report-success', 'true' ); 
  171.              
  172.             //Create notify element 
  173.             $notify = $doc->createElement( 'notify' ); 
  174.             $notify_node = $pub_manifest->appendChild( $notify ); 
  175.              
  176.             //Add callback attributes 
  177.             $notify_node->setAttribute( 'email', $conf_email ); 
  178.              
  179.              
  180.             //Create callback element 
  181.             //$callback = $doc->createElement( 'callback' ); 
  182.             //$callback_node = $pub_manifest->appendChild( $callback ); 
  183.              
  184.             //Add callback attributes 
  185.             //$callback_node->setAttribute( 'entity-url', $this->callback_url ); 
  186.              
  187.              
  188.              
  189.             //Create video file elements 
  190.             foreach( $validated_attachments as $field_id => $upload_fields ) { 
  191.                 foreach( $upload_fields as $key => $upload_data ) { 
  192.                      
  193.                     //Init vars 
  194.                     $file_path_info = NULL; 
  195.                     $basename = NULL; 
  196.                     $filename = NULL; 
  197.                     $ref_id = NULL; 
  198.                      
  199.                     if( isset($upload_data['file_path'], $upload_data['wp_attachement_id']) ) { 
  200.                          
  201.                         //Get file path info 
  202.                         $file_path_info = pathinfo( $upload_data['file_path'] ); 
  203.                          
  204.                         //Create and add Asset element for this file 
  205.                         if( isset($file_path_info['basename'], $file_path_info['filename']) ) { 
  206.                          
  207.                             $basename = $file_path_info['basename']; 
  208.                              
  209.                             $filename = $file_path_info['filename']; 
  210.                              
  211.                             //Cache ref_id - format:: podders_{$wp_attachement_id} 
  212.                             $ref_id = 'podders_' . rand(0, 1000) . '_' . $upload_data['wp_attachement_id']; 
  213.                              
  214.                             //Add Asset element to manifest for this file 
  215.                             $file_asset = $doc->createElement( 'asset' ); 
  216.                             $file_asset_node = $pub_manifest->appendChild( $file_asset ); 
  217.                              
  218.                             //Add Asset attributes 
  219.                             $file_asset_node->setAttribute( 'filename', $basename );     
  220.                             $file_asset_node->setAttribute( 'refid', $ref_id ); 
  221.                             $file_asset_node->setAttribute( 'type', $type ); 
  222.                             $file_asset_node->setAttribute( 'encode-to', $encode_to ); 
  223.                             $file_asset_node->setAttribute( 'encode-multiple', $encode_multiple ); 
  224.                                                      
  225.                         } 
  226.                          
  227.                         //Create and add Title element for this file 
  228.                         if( isset($ref_id, $upload_data['title'], $upload_data['description']) ) { 
  229.                              
  230.                             //Add Title element to manifest for this file 
  231.                             $file_title = $doc->createElement( 'title' ); 
  232.                             $file_title_node = $pub_manifest->appendChild( $file_title ); 
  233.                              
  234.                             //Add Title attributes 
  235.                             $file_title_node->setAttribute( 'name', $upload_data['title'] ); 
  236.                             $file_title_node->setAttribute( 'refid', $ref_id ); 
  237.                             $file_title_node->setAttribute( 'video-full-refid', $ref_id ); 
  238.                              
  239.                             //Create description element 
  240.                             $short_desc = $doc->createElement( 'short-description', $upload_data['description'] ); 
  241.                              
  242.                             //Append description to Title element 
  243.                             $file_title->appendChild( $short_desc ); 
  244.                              
  245.                         } 
  246.                          
  247.                     } 
  248.                      
  249.                 } 
  250.             } 
  251.              
  252.              
  253.             if( ($result = $doc->save( $save_path )) !== FALSE ) { 
  254.                 //Return full path to manifest xml file 
  255.                 $result = $save_path;     
  256.             } else { 
  257.                 $this->plugin_error_log( 'Brightcove FTP:: Error saving Manifest xml file.' ); 
  258.             } 
  259.              
  260.         } 
  261.          
  262.         return $result; 
  263.     } 
  264.      
  265.     private function init_ftp_connection() { 
  266.          
  267.         //Init vars 
  268.         $conn_id = FALSE; 
  269.         $login_result = FALSE; 
  270.          
  271.         if( isset($this->ftp_server, $this->username, $this->password) ) { 
  272.              
  273.             //Connect to FTP server (port 21) 
  274.             $conn_id = ftp_connect( $this->ftp_server, 21 ); 
  275.              
  276.             //Check for error 
  277.             if( $conn_id !== FALSE ) { 
  278.                  
  279.                 //Send access params 
  280.                 $login_result = ftp_login( $conn_id, $this->username, $this->password ); 
  281.                  
  282.                 //Detect result - allow return of conn_id if succesfull 
  283.                 if( $login_result === FALSE ) { 
  284.                     $conn_id = FALSE; 
  285.                     $this->plugin_error_log( 'Brightcove FTP:: Error in ftp_login.' ); 
  286.                 } 
  287.                  
  288.             } else { 
  289.                 $this->plugin_error_log( 'Brightcove FTP:: Error in ftp_connect.' ); 
  290.             } 
  291.              
  292.         } else { 
  293.             $this->plugin_error_log( 'Brightcove FTP:: Missing FTP credentials.' ); 
  294.         } 
  295.          
  296.         return $conn_id; 
  297.     } 
  298.      
  299.     private function upload_video_files( $validated_attachments ) { 
  300.          
  301.         //Init vars 
  302.         $result = FALSE; 
  303.          
  304.         //Loop validate video files array and upload each video found 
  305.         foreach( $validated_attachments as $field_id => $upload_fields ) { 
  306.             foreach( $upload_fields as $key => $upload_data ) { 
  307.                  
  308.                 //Reset result just to be sure 
  309.                 $result = FALSE; 
  310.                  
  311.                 //Try and upload file 
  312.                 if( isset($upload_data['file_path']) ) { 
  313.                  
  314.                     $result = $this->upload_file_ftp( $upload_data['file_path'] ); 
  315.                      
  316.                     //Error check, if there was an error remove video data from array 
  317.                     //This will ensure the file remains in wordpress as a backup 
  318.                     if( $result === FALSE ) { 
  319.                         unset( $validated_attachments[$field_id][$key] ); 
  320.                         $this->plugin_error_log( 'Upload Failed:: ' . $upload_data['file_path'] ); 
  321.                     } else { 
  322.                         $this->plugin_error_log( 'File Uploaded:: ' . $upload_data['file_path'] ); 
  323.                     } 
  324.                      
  325.                 } 
  326.                  
  327.             } 
  328.         } 
  329.          
  330.         //Return array of files successfully uploaded 
  331.         //These will be removed from the wordpress media library and server 
  332.         return $validated_attachments; 
  333.     } 
  334.      
  335.     private function upload_manifest_file( $manifest_path ) { 
  336.          
  337.         //Init vars 
  338.         $result = FALSE; 
  339.              
  340.         //Upload manifest file 
  341.         $result = $this->upload_file_ftp( $manifest_path ); 
  342.          
  343.         return $result; 
  344.     } 
  345.      
  346.     private function upload_file_ftp( $local_file_path ) { 
  347.          
  348.         //Init vars 
  349.         $remote_file = NULL; 
  350.         $result = FALSE; 
  351.          
  352.         //Check file exsits 
  353.         if( file_exists($local_file_path) && isset($this->ftp_conn_id) ) { 
  354.              
  355.             //First try and get remote_file value, this is the filename of upload 
  356.             $remote_file = pathinfo( $local_file_path ); 
  357.              
  358.             if( isset($remote_file['basename']) ) { 
  359.                 $remote_file = $remote_file['basename']; 
  360.             } else { 
  361.                 $remote_file = NULL; 
  362.             } 
  363.              
  364.             if( !empty($remote_file) ) { 
  365.                  
  366.                 //Turn on ftp passive mode 
  367.                 //ftp_pasv( $this->ftp_conn_id, TRUE ); 
  368.                  
  369.                 //Perform file upload 
  370.                 $result = ftp_put( $this->ftp_conn_id, $remote_file, $local_file_path, FTP_ASCII ); 
  371.                  
  372.             } else { 
  373.                 $this->plugin_error_log( 'Brightcove FTP:: Error getting file basename.' ); 
  374.             } 
  375.              
  376.         } else { 
  377.             $this->plugin_error_log( 'Brightcove FTP:: Can\'t find file to upload.' ); 
  378.         } 
  379.          
  380.         return $result; 
  381.     } 
  382.      
  383. }