|
|
# -*- coding: utf-8 -*-
|
|
|
|
|
|
#class BKmanager:
|
|
|
# def __init__(self):
|
|
|
|
|
|
from subprocess import *
|
|
|
import sys
|
|
|
import os
|
|
|
import subprocess
|
|
|
import commands
|
|
|
import shutil
|
|
|
import functions2
|
|
|
|
|
|
#--------------------------------------------- Entero a cadena agregando ceros delante -------------------------------------------------
|
|
|
|
|
|
def i2s(var_n, var_length=4):
|
|
|
var_n2=str(var_n)
|
|
|
while len(var_n2) < var_length:
|
|
|
var_n2 = "0"+var_n2
|
|
|
return var_n2
|
|
|
|
|
|
|
|
|
#----------------------------------------- Se verifica que la ruta exista y sea un directorio -------------------------------------------------
|
|
|
|
|
|
def dir_exists(var_dir, self):
|
|
|
if os.path.isdir(var_dir):
|
|
|
return True
|
|
|
else:
|
|
|
self.txtInfo.append("Incorrect path:" + str(var_dir))
|
|
|
return False
|
|
|
|
|
|
|
|
|
#-------------------------------- Se buscan los archivos del tipo especificado y se cargan las fechas -----------------------------
|
|
|
|
|
|
def load_days(self):
|
|
|
|
|
|
self.var_list=[]
|
|
|
self.lstStartDay.clear()
|
|
|
self.lstStopDay.clear()
|
|
|
|
|
|
if self.statusDpath == False:
|
|
|
self.btnGbkp.setEnabled(False)
|
|
|
return
|
|
|
|
|
|
if self.var_Dtype == '':
|
|
|
return
|
|
|
|
|
|
var_cmd="find " + str(self.var_Dpath) + " -name *."+ str(self.var_Dtype) +" | awk -F/ '{print substr($NF,2,7)}' | sort| uniq"
|
|
|
output=commands.getstatusoutput(var_cmd)[1]
|
|
|
|
|
|
#Si no se encuentra ningun archivo
|
|
|
if len(output) == 0:
|
|
|
self.txtInfo.append("File not found")
|
|
|
self.btnGbkp.setEnabled(False)
|
|
|
return
|
|
|
|
|
|
#Se cargan las listas para seleccionar StartDay y StopDay (QComboBox)
|
|
|
for i in range(0, (len(output)+1)/8):
|
|
|
self.var_list.append(output[8*i:8*(i+1)-1])
|
|
|
|
|
|
for i in self.var_list:
|
|
|
self.lstStartDay.addItem(i)
|
|
|
self.lstStopDay.addItem(i)
|
|
|
self.lstStopDay.setCurrentIndex(self.lstStartDay.count()-1)
|
|
|
|
|
|
get_sub_list(self)
|
|
|
self.btnGbkp.setEnabled(True)
|
|
|
|
|
|
|
|
|
#-------------------------------------------------- Obtiene el rango de las fechas seleccionadas -----------------------------------------
|
|
|
|
|
|
def get_sub_list(self):
|
|
|
self.var_sublist=[]
|
|
|
for i in self.var_list[self.lstStartDay.currentIndex():self.lstStartDay.currentIndex() + self.lstStopDay.currentIndex()+1]:
|
|
|
self.var_sublist.append(i)
|
|
|
|
|
|
|
|
|
#----------------------------------------------------- Verifica los parametros faltantes -----------------------------------------------------------
|
|
|
|
|
|
def validate_parameters(self):
|
|
|
#Verifica que las ruta del proyecto sea valida
|
|
|
if self.statusRpath == False:
|
|
|
self.txtInfo.append("Incorrect proyect path")
|
|
|
return False
|
|
|
|
|
|
#Verifica la etiqueta
|
|
|
if len(self.var_Elabel) == 0:
|
|
|
self.txtInfo.append("Enter label")
|
|
|
return False
|
|
|
|
|
|
return True
|
|
|
|
|
|
|
|
|
#------------------------------------------------- Crea directorios en la ruta indicada -----------------------------------------------------------
|
|
|
|
|
|
def make_dirs(list_dirs, self):
|
|
|
"""
|
|
|
|
|
|
"""
|
|
|
|
|
|
for var_dir in list_dirs:
|
|
|
shutil.rmtree(self.var_Rpath+'/'+var_dir, True)
|
|
|
var_output=commands.getstatusoutput("mkdir -p "+self.var_Rpath+'/'+var_dir)[0]
|
|
|
if var_output != 0:
|
|
|
self.txtInfo.append("Error creating directory: "+var_dir+", output_error:" + str(var_output))
|
|
|
return False
|
|
|
self.txtInfo.append('Directories created correctly')
|
|
|
return True
|
|
|
|
|
|
|
|
|
#-------------------------------------------- Busca los archivos con los parametros de busqueda ---------------------------------------
|
|
|
|
|
|
def list_files(self):
|
|
|
var_files_list=[]
|
|
|
for var_doy in self.var_sublist:
|
|
|
var_cmd="find " + str(self.var_Dpath) + " -name ?"+var_doy+"???."+ str(self.var_Dtype) + " |sort"
|
|
|
var_output=commands.getstatusoutput(var_cmd)[1]
|
|
|
for var_file in var_output.split():
|
|
|
var_files_list.append(var_file) #Almacena cada archivo en la lista
|
|
|
return var_files_list
|
|
|
|
|
|
|
|
|
#--------------- Genera la lista de archivos .dat que contienen los archivos a grabar en cada DVD -----------------------
|
|
|
|
|
|
def make_files_dat(var_files_list, self):
|
|
|
var_Rpath_ppath=self.var_Rpath+"/ppath" #Ruta de los archivos a grabar
|
|
|
var_n=1 #Numero del DVD actual
|
|
|
var_tmp=0 #Se usa para acumular el tamaño de los archivos de la lista
|
|
|
var_files_list_2=[] #Se usa para almacenar la lista de archivos agrbar en cada DVD
|
|
|
|
|
|
for i in var_files_list: #Se asignan en i los archivos de la lista
|
|
|
|
|
|
var_size_i=os.path.getsize(i)/1024+1 #tamaño en KB del archivo de la lista, se suma 1 KB para evitar problemas al momento de sumar
|
|
|
var_tmp += var_size_i #Se acumulan el tamaño de los archivos de la lista
|
|
|
|
|
|
#Si el tamaño acumulado es mayor que el de el DVD
|
|
|
if var_tmp > (self.var_Dcapacity * 1024):
|
|
|
var_tmp -= var_size_i #se quita el tamaño sumado para mostrar el tamaño real
|
|
|
#se crea un archivo con numeral en el sufijo y extension .dat
|
|
|
var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","w")
|
|
|
#Se añade la lista de archivos a grabar en el DVD al archivo .dat
|
|
|
for line in var_files_list_2:
|
|
|
var_tmp_path=line.split(self.var_Dpath)[1][:-13]
|
|
|
var_file.write(var_tmp_path+'='+line+'\n')
|
|
|
var_file.close()
|
|
|
|
|
|
var_tmp = var_size_i #Se asigna a la variable el tamaño del archivo actual
|
|
|
var_files_list_2=[] #Se reinicia la lista
|
|
|
var_n += 1
|
|
|
var_files_list_2.append(i)
|
|
|
|
|
|
#se crea un archivo con numeral en el sufijo y extension .dat
|
|
|
var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","w")
|
|
|
#Se añade la lista de archivos a grabar en el DVD al archivo .dat
|
|
|
for line in var_files_list_2:
|
|
|
var_tmp_path=line.split(self.var_Dpath)[1][:-13]
|
|
|
var_file.write(var_tmp_path+'='+line+'\n')
|
|
|
var_file.close()
|
|
|
|
|
|
self.txtInfo.append("configuration files created")
|
|
|
return var_n
|
|
|
|
|
|
|
|
|
#------------------------------ Genera los archivos .print con los cuales se creara los postscript -----------------------------------
|
|
|
|
|
|
def make_files_print(self):
|
|
|
|
|
|
var_Rpath_ppath=self.var_Rpath+"/ppath" #Ruta de los archivos a grabar
|
|
|
var_Rpath_gpath=self.var_Rpath+"/gpath" #Ruta de los archivos postscript
|
|
|
var_labels=[]
|
|
|
for m in range (0, self.txtPSgraphic.value() - 1):
|
|
|
var_lines = "\n" * 9
|
|
|
var_labels.append(var_lines)
|
|
|
|
|
|
# Se leen todos los archivos .dat creados para crear las etiquetas en los archivos .print
|
|
|
for var_n in range(1, self.var_Discs + 1):
|
|
|
|
|
|
#se abren los archivos .dat en modo lectura
|
|
|
var_file = open(var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(var_n)+".dat","r")
|
|
|
lines=var_file.readlines() # Se lee las lineas en el archivo y se almacenan en la lista
|
|
|
var_file.close()
|
|
|
list_files=[]
|
|
|
var_lines=[]
|
|
|
|
|
|
for j in range(0, len(lines)):
|
|
|
|
|
|
if j == 0:
|
|
|
var_first_folder = lines[j].split('=')[0]
|
|
|
var_first_file = (lines[j].split('=')[1])[:-1]
|
|
|
continue
|
|
|
|
|
|
var_tmp_folder = lines[j].split('=')[0]
|
|
|
var_tmp_file = (lines[j].split('=')[1])[:-1]
|
|
|
|
|
|
# Si el subfolder superior o el DOY del archivo actual y el anterior son diferentes
|
|
|
if (var_tmp_folder != var_first_folder) or (var_tmp_file[0:-5] != var_first_file[0:-5]):
|
|
|
var_last_file = (lines[j-1].split('=')[1])[:-1]
|
|
|
list_files.append([var_first_folder, var_first_file, var_last_file])
|
|
|
|
|
|
var_first_folder = lines[j].split('=')[0]
|
|
|
var_first_file = (lines[j].split('=')[1])[:-1]
|
|
|
|
|
|
var_last_file = (lines[-1].split('=')[1])[:-1]
|
|
|
list_files.append([var_first_folder, var_first_file, var_last_file])
|
|
|
|
|
|
var_lines2 = lines_print(list_files, self.var_Elabel)
|
|
|
|
|
|
for k in range(0, len(var_lines2) / 5):
|
|
|
var_lines=["\n"]
|
|
|
var_lines.append(" "+self.var_Elabel+" "+i2s(var_n)+"/"+i2s(self.var_Discs)+"\n")
|
|
|
var_lines.append("Year Doy Folder"+" "*9+"Set"+" "*11+"Time range\n")
|
|
|
var_lines.extend(var_lines2[(5*k):(5*(k+1))])
|
|
|
var_lines.append("\n")
|
|
|
var_labels.append(var_lines)
|
|
|
|
|
|
for i in range(0, (len(var_labels) // 33) +1 ):
|
|
|
var_file=var_Rpath_gpath+"/"+self.var_Elabel+"_"+i2s(i+1)
|
|
|
file_ps = open(var_file+".print","w")
|
|
|
if i == (len(var_labels) // 33):
|
|
|
var_sub_labels = var_labels[33*i:]
|
|
|
else:
|
|
|
var_sub_labels = var_labels[33*i:33*(i+1)]
|
|
|
|
|
|
for label in var_sub_labels:
|
|
|
for line in label:
|
|
|
file_ps.write(line)
|
|
|
file_ps.close()
|
|
|
var_cmd="enscript "+var_file+".print -p "+var_file+".ps -f Times-Roman7 " \
|
|
|
+" -3R -j -B --margins=21.25:20.4:25.51:20 --media=A4"
|
|
|
var_output=commands.getstatusoutput(var_cmd)[0]
|
|
|
|
|
|
|
|
|
def lines_print(list_files, var_Elabel):
|
|
|
"""
|
|
|
Devuelve las lineas del rango de archivos de cada etiqueta segun el formato
|
|
|
"""
|
|
|
var_lines=[]
|
|
|
for i in list_files:
|
|
|
|
|
|
# Si el archivo se grabara directamente en la / del DVD y no en un /directorio/
|
|
|
# se usa la etiqueta para indicar la parte de la etiqueta donde va el subdirectorio
|
|
|
if i[0] == '/':
|
|
|
var_folder = var_Elabel
|
|
|
else:
|
|
|
var_folder = i[0].split('/')[-2]
|
|
|
|
|
|
var_first_file = i[1]
|
|
|
var_last_file = i[2]
|
|
|
|
|
|
var_date_first_file=commands.getstatusoutput("date -r "+var_first_file+" +'%T'")[1]
|
|
|
var_date_last_file=commands.getstatusoutput("date -r "+var_last_file+" +'%T'")[1]
|
|
|
|
|
|
var_lines.append(var_first_file[-12:-8]+" "+var_first_file[-8:-5]+" "+var_folder +" "+var_first_file[-5:-2]+"-"
|
|
|
+var_last_file[-5:-2]+" "+var_date_first_file+"-"+var_date_last_file+"\n")
|
|
|
#Nos aseguramos que sea un mutiplo de 5
|
|
|
while (len(var_lines) % 5) != 0:
|
|
|
var_lines.append("\n")
|
|
|
|
|
|
return var_lines
|
|
|
|
|
|
#---------------------------------------comandos para el proceso de grabacion ------------------------------------------
|
|
|
def cmd_iso(self):
|
|
|
var_Rpath_ppath=self.var_Rpath+"/ppath"
|
|
|
var_Rpath_iso=self.var_Rpath+"/iso"
|
|
|
#comando para la creacion del archivo.iso
|
|
|
file_dat=var_Rpath_ppath+"/"+self.var_Elabel+"_"+i2s(self.var_disc_n)+".dat"
|
|
|
file_iso=var_Rpath_iso+"/"+i2s(self.var_disc_n)+".iso"
|
|
|
var_cmd = 'genisoimage -hide-joliet-trans-tbl -joliet-long -r '
|
|
|
var_cmd += ' -A '+self.var_Elabel+' -V '+self.var_Elabel
|
|
|
var_cmd += ' -graft-points -path-list '+ file_dat+' -o '+file_iso
|
|
|
return var_cmd
|
|
|
|
|
|
def cmd_burn(self):
|
|
|
var_Rpath_iso=self.var_Rpath+"/iso"
|
|
|
file_iso=var_Rpath_iso+"/"+i2s(self.var_disc_n)+".iso"
|
|
|
|
|
|
var_index = ( ( (self.var_disc_n - 1) * self.var_Copys) + (self.var_copy_n - 1) - self.var_burned_discs ) % len(self.var_devices)
|
|
|
var_dev_tmp = self.var_devices[var_index]
|
|
|
|
|
|
var_cmd = "wodim -v dev="+var_dev_tmp+" speed=16 "+ file_iso
|
|
|
return var_cmd
|
|
|
|
|
|
def cmd_check(self):
|
|
|
var_cmd = "echo 'function check'"
|
|
|
return var_cmd
|
|
|
|
|
|
def remove_iso(self):
|
|
|
var_Rpath_iso=self.var_Rpath+"/iso"
|
|
|
file_iso=var_Rpath_iso+"/"+i2s(self.var_disc_n)+".iso"
|
|
|
# shutil.rmtree(self.var_Rpath+'/'+var_dir, True)
|
|
|
if os.path.isfile(file_iso):
|
|
|
os.remove(file_iso)
|
|
|
|
|
|
#Si es el ultimo disco se termina el proceso
|
|
|
def is_last_disc_and_copy(self):
|
|
|
if self.var_disc_n == self.var_Discs and self.var_copy_n == self.var_Copys:
|
|
|
self.function_final()
|
|
|
else:
|
|
|
next_disc(self)
|
|
|
|
|
|
#Define cual es el siguiente disco a grabar y que paso seguir
|
|
|
def next_disc(self, error = False):
|
|
|
if self.var_copy_n == self.var_Copys:
|
|
|
#borrado del iso
|
|
|
self.txtInfo.append("Deleting iso file: "+i2s(self.var_disc_n)+".iso")
|
|
|
remove_iso(self)
|
|
|
|
|
|
self.var_disc_n += 1
|
|
|
self.var_copy_n = 1
|
|
|
self.var_step = 0
|
|
|
|
|
|
else:
|
|
|
self.var_copy_n += 1
|
|
|
self.var_step = 1
|
|
|
|
|
|
functions2.make_burning_conf(self) # Si el proceso no ha sido detenido manualmente
|
|
|
#crea el archivo burning.conf para el seguimiento de los discos grabados
|
|
|
|
|
|
var_index = ( ( (self.var_disc_n - 1) * self.var_Copys) + (self.var_copy_n - 1) - self.var_burned_discs ) % len(self.var_devices)
|
|
|
|
|
|
self.txtInfo.append("NEXT DISC: "+str(self.var_disc_n)+" COPY: "+str(self.var_copy_n)
|
|
|
+" INDEX: "+str(var_index)+" STEP: "+str(self.var_step))
|
|
|
self.txtInfo.append("\n")
|
|
|
|
|
|
if var_index == 0 :
|
|
|
self.function_eject()
|
|
|
|
|
|
elif self.var_step == 0:
|
|
|
self.function_iso()
|
|
|
elif self.var_step == 1:
|
|
|
self.function_burn()
|
|
|
|
