Enviado por Alvaro Anaya M. sobre Sep 25, 2010 en Scripts | 21 comentarios
Una tarea que puede ser bastante común a la hora de escribir scripts o aplicaciones que trabajen con el sistema de archivos es la necesidad de descomponer una ruta completa del tipo «/directorio/subdirectorio/…/…/archivo.extension» para obtener por separado el nombre de archivo, la extensión y la ruta de directorios. De hecho, fue una de las necesidades que me ha surgido estos días, escribiendo un Shell Script un tanto grande en el que necesitaba obtener el nombre de un archivo de una ruta completa así como la estructura de directorios hasta el mismo.
Dado que me suele gustar, al escribir scripts de cierto tamaño, dividirlos por bloques de código independientes, voy a publicar este como una solución aislada para solventar el problema de descomponer rutas aunque cuando lo volváis a ver en el script que aún no he terminado aparecerá como una función por la comodidad que representan y porque facilitan mucho la lectura del código en scripts de muchas lineas. Sin más preámbulos, vamos manos a la obra:
Dado que este código ahora es independiente, he realizado algunos cambios como que tome la entrada de datos a modo de parametros tras el nombre del script por lo que la ruta a descomponer, deberá ir tras el nombre del script en lo que seria el parámetro $1, es decir, tendriamos que pasárselo de la siguiente manera:
1
| ./script.sh /ruta/que/queramos/descomponer/archivo.extension |
Por el mismo motivo, lo he dispuesto de forma que la salida del mismo sea la salida estándar mostrando el valor de cada una de las variables que intervienen en el proceso.
También he comentado las lineas relevantes ya que creo que será mejor explicar cada una de las lineas en el mismo punto donde aparece. Así pues, este es el script:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| #!/bin/bash
# Script para descomponer una ruta completa a un archivo o directorio, obteniendo
# el nombre de archivo y extensión (si existen) y ruta hasta los mismos
for RutaCompleta in $1
do
# Comenzamos extrayendo la parte derecha desde el ultimo caracter "/", es decir, el archivo
NombreArchivo="${RutaCompleta##*/}"
# Longitud de la ruta es el total de caracteres menos el largo del nombre de archivo
LargoRuta="${#RutaCompleta} - ${#NombreArchivo}"
# Extraermos la ruta desde el caracter 0 hasta el caracter final de largo de ruta
RutaSola="${RutaCompleta:0:$LargoRuta}"
# Lo siguiente es extraer nombre de archivo
NombreSolo="${NombreArchivo%.[^.]*}"
# Extension se obtiene eliminando del nombre completo el nombre mas el punto
Extension="${NombreArchivo:${#NombreSolo} + 1}"
# Las 2 lineas anteriores fallan si no hay extension por lo que es necesario comprobar que no
# se de el caso de que haya extension pero no nombre ya que en ese caso la ext seria el nombre
if [[ -z "$NombreSolo" && -n "$Extension" ]]; then
NombreSolo=".$Extension"
Extension=""
fi
done
# Este es el resultado del script
echo
echo "Este es el resultado del script:"
echo
echo La ruta completa es:
echo $RutaCompleta
echo
echo "Ruta.........: "$RutaSola""
echo "Nombre.......: "$NombreSolo""
echo "Extension....: "$Extension""
echo |
Si lo ejecutamos, la salida del mismo, según está, sería similar a esto:
1
| $ ./descomp.sh /dir1/subdir1/subdir2/archivo.txt |
Este es el resultado del script:
La ruta completa es:
/dir1/subdir1/subdir2/archivo.txt
Ruta………: «/dir1/subdir1/subdir2/»
Nombre…….: «archivo»
Extension….: «txt»
Ahora bien, hay que tener en cuenta que si lo vamos a utilizar como una función llamada desde otro script o simplemente como un bloque de código incrustado entre las lineas, habría que hacerle algunos cambios, pero dado que lo estoy utilizando en otro script que voy a publicar aquí también, no lo explicaré aún ya que es cuestión de tiempo que me toque hacerlo.
leer más
Enviado por Alvaro Anaya M. sobre Jul 16, 2010 en Scripts, Varios | 38 comentarios
————– Actualización ————–
Aunque el método usado en este artículo sigue siendo válido, con las nuevas versiones de VirtualBox ya es posible hacerlo todo desde el menu gráfico, cosa que se agradece bastante.
———————————————–
Últimamente, es bastante común montar servidores en máquinas virtuales y ese fue el caso que me ha llevado a crear este pequeño script que, en esta ocasión, es para sistemas Windows y con el conocido sistema de máquinas virtuales VIRTUALBOX.
En este mismo sistema, al igual que en muchos otros, existen varias opciones para la configuración de las tarjetas de red aunque para este caso en concreto nos centraremos en la opción por defecto y la tarjeta que, al menos antes, siempre se habilitaba por defecto, al menos en mi caso, que siempre es conexión mediante NAT y con la tarjeta PC NET.
Antes de nada diré que si ya está familiarizado con el NAT puede saltarse las siguientes lineas ya que, por si hay alguien a quien solamente «le suene» un poco o que directamente desconozca que es o como funciona, trataré de hacer una pequeña explicación.
Lo primero, como siempre es tener la maquina virtual funcionando (Evidentemente ;-)) y una vez tengamos la conexión mediante NAT, deberíamos poder conectarnos a Internet desde el sistema virtualizado sin ningún problema ni paso adicional que configurar la conexión en dicho sistema como si fuera una instalación física más, es decir, añadiendo una IP, máscara, puerta de enlace y DNS en el caso de que nos vayamos a conectar con una dirección estática o simplemente activando DHCP si tenemos algún dispositivo que nos permita una configuración de IPs dinámica. Sea cual sea el modo de conexión, nos es indiferente a la hora de montar el servidor virtualizado siempre y cuando la IP de nuestra máquina física, es decir, la que alberga la virtual tenga una IP fija o algún sistema que nos permita llamarla siempre de la misma forma aún siendo dinámica (Por ejemplo, algún sistema similar a DynDNS, NoIP de cara a internet o simplemente un router que de la posibilidad de asociar una dirección MAC a una direcc concreta de forma que aunque este configurado todo por DHCP siempre de la misma a la misma máquina ).
Se preguntará ¿¿Porque es necesario esto sobre todo cuando ya me conecto a internet?? pues bien, porque ahora mismo la máquina virtual conecta con «hacia fuera», por decirlo de alguna manera, pero no admite las peticiones que se le hagan desde la red como podrían ser las que se hacen a cualquier servidor así que es necesario realizar NAT (Network Address Translation) de forma que para acceder a este servidor virtualizado tendremos habilitar la correspondiente configuración en la maquina física que lo alberga para que al apuntar a esta (MAquina física) nos redirija a la máquina virtual. Como explicarme nunca fue mi fuerte, vamos con los ejemplos:
Tenemos los siguiente:
Máquina VIRTUAL:
– IP: 10.0.2.15
– Servidor WEB (Puerto 80)
– Servidor SSH (Puerto 22)
Máquina FISICA (Sobre la que corre la Virtual)
– IP: 192.168.1.10
Pues en este caso de supuestos, para poder ver las WEB del servidor virtualizado tendríamos que hacerlo poniendo la IP de la máquina FISICA, es decir, esta es la dirección que tendríamos que escribir en el navegador (A falta de configurar un dominio aunque fuese local, por supuesto):
Y para acceder a las sesiones SSH:
Esto es debido a que, con las instrucciones que veremos a continuación habilitaremos que, el propio VIRTUALBOX, realice una redirección de los datos enviados a los puertos que digamos hacia la tarjeta de red y puerto de la máquina virtual y ahora que ya tenemos claras las nociones básicas, procedemos con lo importante.
.Entre las muchas cosas que incorpora VirtualBox, hay un comando llamado VBOXMANAGE.EXE desde el que se puede hacer de todo y que es, precisamente, el que utilizaremos para que nuestra máquina virtual admita conexiones desde el exterior, es decir, para que nuestro servidor funcione como lo que es. Como decia, entre las multiples funciones de VBOXMANAGE está la de configurar que las peticiones a ciertos puertos de la máquina FISICA pasen a nuestra máquina virtual.
A continuación muestro el comando y explico sus parámetros para esta tarea pero quizás este un poco más claro en el ejemplo que hay debajo. El comando a ejecutar es:
1
| VBoxManage setextradata MAQUINA "VBoxInternal/Devices/pcnet/0/LUN#0/Config/PROCESO/"PUERTO O PROTOCOLO"" PUERTO |
Es muy importante fijarse en que, para pasarle la orden de que escuche las peticiones en un puerto de la máquina fisica, indicamos, no solo el puerto de la máquina virtual sino que también la tarjeta de red que recibirá los datos.
1
| VBoxInternal/Devices/pcnet/0/LUN#0/Conf... |
Para estar seguros del nombre de la máquina sin tener que abrir el virtualbox, podremos hacer un listado de todas las máquinas virtuales que tenemos gracias, como no, al polivalente comando VBoxManage de la siguiente manera:
El proceso para abrir el servidor a las conexiones externas, por ejemplo las peticiones a un servidor web consiste en aplicar 3 veces el comando anterior para indicar, además de la tarjeta de red, como ya indicamos:
- Nombre de servicio y puerto de la máquina fisica
- Nombre del servicio y puerto de la máquina virtual
- Nombre del servicio y PROTOCOLO usado (Normalmente TCP)
De esta misma manera no estaremos obligados a usar el mismo puerto en ambas máquinas. Esto quiere decir que si, casualmente la máquina física que contiene la virtual, tuviese además un pequeño servidor WEB en el puerto 80, podríamos establecer con el anterior comando que dicha máquina reenvíe solo las peticiones, por ejemplo del puerto 8080, al 80 (Puerto estándar) de la máquina virtual. En definitiva, no hay restricción alguna respecto a los puertos salvo la de que no esté en uso.
Como pequeña nota, solo queda añadir que si tenemos algun sistema de FIREWALL configurado ya sea en la maquina física como en la Virtual, tendríamos que hacer los pasos pertinentes para que no bloquease el tráfico por lo puertos que haya pensado utilizar.
Pues bien, esa fue la teoría y ahora, el como aplicarla ya es tarea suya. Puede simplemente experimentar por su cuenta con el comando basándose esta breve explicación y, como siempre, también tiene la opción cómoda de descargarse el SCRIPT que he creado para automatizar todo el proceso. He de decir que, al menos en mi caso, es lo que estoy usando siempre gracias a la comodidad y rapidez del mismo.
Este Script no tiene que editarlo para cambiar puertos, protocolo o el nombres de servicio ya que se lo preguntará durante la ejecución del mismo. Eso si, funciona teniendo en cuenta que VirtualBox estará instalado en la unidad C: y el directorio por defecto, es decir:
1
| C:\Archivos de programa\Oracle\VirtualBox |
Si ese no fuera su caso, entonces si tendría que editarlo para modificar las primeras lineas, pues son las únicas que hacen referencia a dicha carpeta. Por supuesto, tambien es totalmente libre de editarlo para ver como está hecho 😉
Enlace de descarga del SCRIPT: SCRIPT VIRTUALBOX a SERVER
Un saludo.
leer más
Enviado por Alvaro Anaya M. sobre Mar 6, 2010 en Scripts, Trucos | 23 comentarios
Este pequeño Script fue ideado para un caso muy concreto aunque se puede adaptar bastante más según las necesidades. En este caso, lo explicaré según el ámbito para el que fué ideado y que no es otro que el estar asociado a una regla de Outlook para activarse en cuanto llegue un correo de extrema importancia que no puede demorarse sin ser procesado.
Como he dicho antes, este VBScript fue diseñado para un entorno muy concreto que puedo resumir así:
- Existen varias máquinas virtuales destinadas a la monitorización con diferentes herramientas.
- Cada una de las máquinas tiene un Outlook configurado con la cuenta del cliente que representa.
- Evidentemente, las máquinas están monitorizando por lo que no pueden tener el Outlook en pantalla.
- Esto hace que, además de un equipo para trabajar, tengamos múltiples monitores con sus respectivas herramientas de monitorización abiertas de continuo.
En este entorno de trabajo se incorpora una nueva premisa: Si llegan correos de cierta aplicación, hay que procesarlos cuanto antes ya que tienen un tiempo de vida. En principio esto no es un problema pero dado que son varios monitores, que están a unos metros y que quienes los controlan tienen otras tareas, es relativamente sencillo que el paupérrimo aviso que nos muestra el Outlook se nos pase desapercibido de forma que solamente veremos ese correo tan urgente si hacemos un repaso máquina por máquina de forma manual, lo que tambien es bastante sencillo que transcurra más tiempo del debido entre repaso y repaso por lo que volvemos a influir negativamente en el tiempo de respuesta al correo urgente.
Si bien es cierto que las propias reglas del Outlook incluyen la posibilidad de mostrar un aviso en pantalla, este tampoco es realmente eficaz, al menos en este entorno, ya que no siempre se muestra encima de todas las ventanas (Haciéndolo quedar oculto) sino que alguna que otra vez falla y no sabemos porque, aunque con tanta máquina virtual, no es la primera aplicación que se nos vuelve loca. Así que tras barajar todas las posibilidades y probar algunas alternativas me he decantado por crear este pequeño VBScript que está resultando realmente eficaz y sencillo, combinación que lo hacen ser la solución perfecta, al menos en este caso. Además, gracias a su sencillez, es posible implementarlo en otros entornos haciendo unos cambios mínimos en el mensaje.
Veamos el Script:
Dim Shell : Set Shell = CreateObject("Shell.Application") : Shell.MinimizeAll
msgbox("Ha llegado un nuevo correo de APLICACION_ENVIADORA")
.Esta 2 lineas son el 75% de todo el proceso ya que el 25% restante es la regla que enlaza con este Script al darse la condición que le digamos.
La primera de las dos lineas lo que hará es ocultar TODAS las ventanas que tengamos visibles, es decir, es lo mismo que pulsar el boton de «Mostrar Escritorio».
Una vez que solo veamos el escritorio, nos mostrará un mensaje de advertencia informando de que ha llegado un nuevo correo de APLICACION_ENVIADORA. (Evidentemente la aplicación real no se llama así pero no creo que sea relevante para la explicación cual sea el nombre real de la aplicación).
Ahora solo nos queda ir al Outlook y entrar en:
Herramientas –> Reglas y alertas –> Nueva regla –> Comenzar regla en Blanco
Esto nos abrirá un pequeño asistente en el que podremos ir confeccionando los parámetros de la regla que, en este caso, quedarían así una vez terminada:
Aplicar esta regla a todos los mensajes procedentes
de APLICACION_ENVIADORA@loquesea.com
y solo en esta máquina
iniciar Script_AppEnviadora.vbs
La primera parte de la regla es la condición, que en este caso comprobará si se cumple que el remitente de cada nuevo correo sea APLICACION_ENVIADORA@loquesea.com que, en este caso, se trata de una aplicación y la parte otra parte de la regla, la relativa a la acción a desarrollar cuando se produzca la condición, es iniciar la ejecución de un programa, que en este caso, más que un programa es nuestro script de 2 lineas: Script_AppEnviadora.vbs.
Esta combinación funciona realmente bien, os lo puedo asegurar y en un entorno de monitorización no hay nada mejor para llamar la atención de quien esté en el puesto que ocultarle la herramienta con la que monitoriza, es infalible. Eso si, hay que tener en cuenta un punto realmente importante, esta regla que hemos creado es una regla de cliente y por tanto es completamente necesario que el cliente esté funcionando, es decir, es necesario tener el Outlook abierto para que se ejecute pero eso no lo voy a automatizar ya que mi intención es mejorar la efectividad y hacer más cómodo el trabajo, no sustituir a las personas por Scripts o automatizaciones, que ya hay bastante paro estos días en los que vivimos!!!!
Descargar el Script: SCRIPT.VBS
leer más
Enviado por Alvaro Anaya M. sobre Feb 24, 2010 en Scripts | 37 comentarios
Se imagina que, con solamente seleccionar un texto en inglés (en cualquier programa) y presionar una combinación de teclas (O dos clic de ratón, como prefiera) se traduzca en Google Translate?? ¿¿Se imagina que eso no tome recursos del ordenador porque no es ningún proceso en memoria, ni ejecutándose continuamente?? ¿¿Se imagina bajarlo ya preparado o haciéndolo usted mismo desde cero?? Pues si le está costando imaginárselo es que no ha leído aún el artículo «COMO CREAR UN SERVICIO DE TRADUCCION EN MAC» que hace no mucho tiempo he publicado y cuya nueva versión comenzaré a explicar a continuación.
Hace un par de días, uno de los lectores del Blog (Micropark) me comentaba que estaría bien que también se le pudiesen enviar direcciones WEB al traductor creado en el artículo antes mencionado para que se tradujesen como WEB completas. Como no era algo muy complejo, me puse a hacerlo y este es el resultado:
En este artículo no me pararé a explicar cada uno de los pasos y los detalles del porqué se hacen las cosas, ya que lo explico todo, paso por paso, en el ANTERIOR ARTÍCULO.
Ciertamente, Micropark tenía razón, si se seleccionaba un texto la traducción funcionaba perfectamente pero si seleccionábamos una dirección WEB el servicio se limitaba a traducirla como si se tratase de un texto normal, es decir, realizaba una traducción de la propia dirección y no del contenido.
La propia página del traductor de Google hace su distinción del texto que introducimos en ella para saber si se trata de un enlace o no, pero como en nuestro caso ya le enviamos una dirección concreta, la función de detección de enlaces de google no nos sirve. Teniendo esto en cuenta está claro el siguiente paso lógico que debemos de dar:
Tenemos que modificar el Servicio, o más bien el script del flujo de trabajo del automator, para que sea nuestro propio script el que distinga si se trata de una dirección WEB o de un texto normal para lo que nos basaremos en 3 reglas muy simples:
- Regla 1: Si el texto comienza por http, es una WEB
- Regla 2: Si comienza por www. también es una WEB
- Regla 3: Si no es ninguna de las anteriores es un texto normal.
Si se cumple alguna de las 2 primeras, formaremos la dirección a enviar al navegador WEB de la manera que el traductor de Google forma la URL cuando se trata de una WEB a traducir. En cambio, si es la regla 3 la que se cumple, enviamos la dirección tal y como lo hacíamos anteriormente (en la 1era versión del Script).
Así que el flujo de trabajo de automator queda exactamente igual salvo por el Script, que será así:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| on run {input}
set input to {input} as text
set LaDirecc to ""
set LaDireccCompleta to CompruebaLinks(input, LaDirecc)
tell application "Safari"
activate
set the URL of (make new document) to LaDireccCompleta
end tell
end run
on CompruebaLinks(input, LaDirecc)
set Comienzo to input as text
set Comienzo to characters 1 thru 4 of input as text
set EsEnlace to false
if Comienzo is "www." then set EsEnlace to true
if Comienzo is "http" then set EsEnlace to true
if EsEnlace is true then
set LaDirecc to "http://translate.google.es/translate?js=y&prev=_t&hl=es&ie=UTF-8&layout=1&eotf=1&u=" & input
else
set LaDirecc to "http://translate.google.com/#en|es|" & input
end if
set input to LaDirecc
return LaDirecc
end CompruebaLinks |
Si se fija un poco verá que para hacer la comprobación de las 3 reglas tampoco es necesario complicarse la vida mucho. De hecho, para hacerlo el único paso adicional realizado es comprobar los 4 primeros caracteres con los que comienza la cadena o texto a traducir. Como ya hemos dicho, si comienza por «http» o por «www.» (Fíjese que ambas cadenas son de 4 caracteres ya que en «www.» he incluido el punto) es una dirección web. Esto hace que si introducimos, por ejemplo: «archivoslog.es» no lo reconozca como dirección WEB pero realmente es la manera más simple de hacer la distinción ya que tratar de hacerlo por la terminación, además de complicar muchísimo el código del script debido a la gran cantidad de dominios existentes (.com, .es, .org, .ar, .eu…etc) seria relativamente sencillo encontrarnos fallos en textos con errores de sintaxis (Sin espacio tras el primer punto).
La diferencia más grande, además de la detección de enlaces, evidentemente, es que realizamos esta misma mediante una función llamada CompruebaLinks a la que le pasamos dos variables:
- input: Es la que contiene el texto seleccionado y que previamente convertimos al tipo «text» para poder manejarla a nuestro antojo.
- LaDirecc: Esta variable la enviamos vacía al proceso aunque es un pequeño truco para que la reconozca pero su principal misión es la de devolvernos el resultado de la función, es decir, la dirección final ya procesada para enviarla al navegador.
Y ya está, la verdad es que no ha sido complicado ¿verdad?. Ahora bien, como siempre, también está disponible el enlace de descarga del servicio ya completo al cual solamente le faltaría ubicarlo en la carpeta Servicios una vez descargado. Como último apunte, como en MAC hay 2 carpetas «servicios», os detallo la diferencia de ubicar nuestra pequeña creación en una u otra:
Para que todos los usuarios del sistema tengan acceso al servicio (Requiere autenticación):
- Disco principal/sistema/Librería/Servicios
Si quiere tener el servicio solo para el usuairo actual, la ruta es:
- Home del usuario/Librería/Servicios
Si tiene dudas de como realizar alguno de los pasos: VER EL ARTÍCULO ANTERIOR (Versión 1)
Servicio de traducción (Versión 2) Google para Snow Leopard: DESCARGAR
.
leer más
Enviado por Alvaro Anaya M. sobre Feb 6, 2010 en Scripts | 9 comentarios
Hoy día, a nada que busquemos en la red encontraremos miles de «milagrosas» aplicaciones para convertir los videos al formato iPhone para todas las plataformas. Lo cierto es que, en MAC, no es necesario recurrir a aplicaciones de terceros para realizar este proceso ya que, gracias a QuickTime X, podremos hacerlo facilmente a golpe de ratón (o de trackpad 😉 ) mediante un par de clics pero si eres como yo, un apasionado de los Scripts y de automatizar los procesos y tareas repetitivas, una vez más podremos recurrir a la versatilidad que nos ofrece Applescript para realizar estas tareas.
El proceso a recrear con nuestro Script, es decir, los pasos tal y como son realizados con el ratón en el entorno gráfico, serían los siguientes:
- Abrir un archivo con Quicktime
- Ir al menú superior –> Archivo –> Guardar como
- En la ventana que se nos abre podremos seleccionar el formato de salida que queramos. En este caso será iPhone*
*Nota!! Hay dos versiones de iPhone en el menú de «guardar como». La que necesitamos en esta ocasión es la que trae solamente iPhone ya que la otra está pensada para poder ser transmitida mediante straming y para ello lo que hace es rebajar el nivel de calidad del archivo, entre otras cosas.
Una vez seguidos estos pasos, nos generará un archivo de extensión .m4v que es el formato de video nativo del iPhone.
Ahora que ya tenemos clara la base o guión, sobre el que nos vamos a centrar para realizar nuestro Script, procedemos con el mismo. Como siempre, primero mostraré la versión corta, es decir, la que hace solamente lo que necesitamos y desde esta iremos ampliando poco a poco la funcionalidad del Script, así que vamos allá.
Tras pelearme unos minutos con la opción «save» que nos muestra el diccionario de applescript de la aplicación QuickTime, en cuyos parámetros vemos lo siguiente:
Extraido del diccionario de Applescript de la aplicación QuickTime Player…
save v : Save a document.
save specifier : The document(s) or window(s) to save.
[in file] : The file in which to save the document.
[as saveable file format] : The file format to use.
…he llegado a la conclusión de que es mejor olvidarse de ella. Más que nada lo digo por si hay alguien, empeñado como yo en hacer un «save as», que mejor no pierda el tiempo y haga uso de esta otra opción (Extraida también del diccionario Quicktime):
export v : Export a movie to another file
export document : the movie to export
in file : the destination file
using settings preset text : the name of the export settings preset to use
Teniendo en cuenta esta nueva opción,es mucho más facil llegar a conseguir que nos funcione el script que mediante el «save as» y esta es la prueba:
1
2
3
4
| Tell application "QuickTime Player"
Open (choose file)
export document 1 in "convertido.m4v" using settings preset "iPhone"
end tell |
Con esas simples lineas, ya tenemos nuestro convertidor de videos completamente operativo. Ahora vamos a perfeccionarlo un poco para que nos quede algo más «profesional» (Además, el video convertido lo deja en raiz del disco duro, y eso no queda muy bien que digamos y eso suponiendo que el usuairo que ejecuta el Script tenga permisos de escritura en dicha ruta)
Lo primero que vemos en el Script es que, tras llamar a la aplicación QuickTime, hacemos un…
Para los que nunca han programado nada (Uhmmm, y tampoco han leido ninguno de los muchos artículos de mi Blog 😛 ) les diré que esta linea es simplemente:
«OPEN» –> Comando del propio Quicktime para abrir un archivo
«Choose file» –> Esta orden invoca el diálogo de apertura de archivos de OSX.
Por lo tanto al combinarlas de esa manera lo que hacemos es básicamente:
abrir (El archivo que selecciones en esta ventana).
Perdonadme los que sepais de programación por esta explicación tan «cutre» pero creo que, a la gente que nunca ha hecho ni leido algo de este tema, les viene bien saber el porqué de cada linea.
Lo cierto es que, aunque el script según está funciona, tiene partes muy mejorables, como por ejemplo añadir una orden, similar a la de apertura de archivo (choose file) pero con el fin de guardar, en una ruta y con un nombre, el archivo convertido. Para esto, si escribimos simplemente «choose file» tal y como lo hemos hecho anteirormente, solo nos permitirá seleccionar un archivo existente, así que vamos a variar un poco esa orden para que nos permita introducir un nombre de archivo que no exista, a fin de crearlo nuevo. Además, para que no nos quede una linea demasiado larga y más dificil de comprender, vamos a hacerlo en dos veces, tal que así:
set Destino to (choose file name)
export document 1 in Destino using settings preset "iPhone"
Si nos fijamos, vemos que el comando usado para invocar el diálogo de apertura de archivos es ligeramente diferente, ya que hemos añadido la palabra «name». Esto hace que, cuando aparezca dicho diálogo, podramos escribir un nombre de archivo nuevo, tal y como mencionaba anteriormente. Dicho nombre de archivo junto con su ruta, será almacenado en la variable «Destino» para usarla en la siguiente linea como la salida de la exportación.
Bien, ahora si unimos lo que tenemos por ahora, veremos que nuestro pequeño script nos preguntará..
¿¿Que archivo queremos convertirt (Y donde está)??
¿¿Que archivo queremos crear (Y donde ubicarlo)??
Parece que lo básico, una vez más, está listo. ¡¡Pues no!! Aún tenemos un problema que deberemos de corregir si queremos crear un Script que pueda utilizar cualquier persona, ente o animal, sin que se le presente ni el más mínimo problema. El handicap que nos podemos encontrar es que, cuando introducimos el nombre del archivo destino, podemos obviar la extensión, es decir, si tratamos de introducirlo sin añadir «.m4v» al final del archivo, no nos encontraremos ningún problema para que se ejecute el Script pero el archivo resultante no será reconocido por el sistema (A pesar de que lo unico que le pasa es que carece de extensión). Para cualquier usuario medio o incluso nosotros mismos, esto no representa ningún problema y mucho menos sabiéndolo pero seamos francos, queda muy feo que pase eso y no cualquier usuario se dará cuenta de que si no puede usar el archivo es debido unicamente a la extensión. Así que ahora ya tenemos un nuevo objetivo para mejorar en nuestro pequeño conversor..
.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| set ExtensionesReales to {".avi", ".mov", ".mpg", ".mpeg", ".divx", ".qtm", ".rpm", ".wmv", ".m4v"}
set Destino to (choose file name)
set largo to length of Destino
set PosibleExtension to characters (largo - 3) thru largo of Destino as string
repeat with i from 1 to (count of items in ExtensionesReales)
set UnaExtension to (item i of ExtensionesReales) as string
if PosibleExtension is in UnaExtension then
set LargoExtension to length of (item i of ExtensionesReales)
set Destino to characters 1 thru (largo - LargoExtension) of Destino
end if
end repeat
set Destino to Destino & ".m4v" as string |
Vamos a explicar un poco el significado de estas lineas…
set ExtensionesReales to {".avi", ".mov", ".mpg", ".mpeg", ".divx", ".qtm", ".rpm", ".wmv", ".m4v"}
Lo primero que hacemos es crear una lista con las extensiones de archivos de video que podrían introducirse. En este caso la gemos declarado como una variable normal pero mas adelante lo haremos con la orden «property» antes de cualquier otra linea del script.
set largo to length of Destino
set PosibleExtension to characters (largo - 3) thru largo of Destino as string
Almacenamos en la variable «largo» el número total de caracteres que forman el archivo de destino para, en la siguiente linea, extraer los últimos 3 caracteres, es decir, lo que sería la extensión del archivo en el caso de que esta exista, cosa que aún no sabemos.
1
2
3
4
5
6
7
| repeat with i from 1 to (count of items in ExtensionesReales)
set UnaExtension to (item i of ExtensionesReales) as string
if PosibleExtension is in UnaExtension then
set LargoExtension to length of (item i of ExtensionesReales)
set Destino to characters 1 thru (largo - LargoExtension) of Destino
end if
end repeat |
Este es el corazón de la comprobación. Hacemos un pequeño bucle para ir comprobando si esos 3 caracteres que extraemos del final del archivo destino, coinciden con alguna de las extensiones de archivo de video, cuya lista hemos almacenado en la variable «ExtensionesReales». En el caso de que alguna coincida, el siguiente paso es comprobar cuantos caracteres mide dicha extensión (Esto es debido a que no todas las extensiones miden lo mismo porque podremos encontrarnos archivos .mpeg y .mpeg, por lo que también tendremos en cuenta esta posibilidad).
Una vez establecida la medida de la extensión el paso a seguir es extraer de la variable «Destino» (La que almacenaba la ruta completa y nombre del archivo que se generará) todos los caracteres comprendidos desde el primero hasta el final menos la medida de la extensión, o lo que es lo mismo, desechamos la extensión para quedarnos con todo lo demás.
set Destino to Destino & ".m4v" as string
Y para terminar, si el usuario ha añadido extensión al nombre de archivo destino, con los pasos anteriores se la hemos quitado. Si, por el contrario, no ha añadido extensión alguna, los pasos anteriores determinarán que esto es así, de forma que el resultado del proceso en este punto siempre será el mismo, es decir, tendremos en la variable «Destino» la ruta y nombre de archivo sin extensión alguna así que solamente nos queda añadirle la que queremos por lo que concatenamos «.m4v» al valor de la variable «Destino».
Ahora, por fin, podemos decir que nuestro pequeño conversor ya es semi-profesional y lo cierto es que es bastante operativo pero… ¿¿que seria de MAC si no tuviera esas maravillosas aplicaciones de arrastrar y soltar?? Pues eso, que vamos a convertir nuestra pequeña aplicación en Droplet, de forma que si el usuairo quiere usarlo tal y como haria con una aplicación común, es decir, pinchando con el ratón dos veces sobre su icono, podrá hacerlo, pero si ademas quiere utilizarlo tambien como droplet, arrastrando los archivos que quiera convertir hacia el icono, también será posible.
Además, para poder utilizar el mismo código que hemos escrito para eliminar la extensión del archivo, sin falta de tenerlo por duplicado en el script, crearemos con esas acciones una función a la que llamaremos siempre que necesitemos hacer uso de ella, de forma que con solo añadir la llamada a la misma nos ejecute todas sus lineas.
Vamos entonces manos a la obra de nuevo…
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
| on open LosElementos
try
tell application "QuickTime Player" to activate
set CuentaElementos to (count of items in LosElementos)
repeat with i from 1 to CuentaElementos
set ElementoUnico to (item i of LosElementos)
tell application "QuickTime Player" to open ElementoUnico
set ElementoUnico to ElementoUnico as string
set ArchivoDestino to RecortaExtensiones(ElementoUnico)
tell application "QuickTime Player" to export document 1 in ArchivoDestino using settings preset "iPhone"
end repeat
-- La siguiente linea es la gestión de errores, que tambien llamará a una función común a las 2 partes del Script
on error errmsg number errnum
GestionErrores(errmsg, errnum)
end try
end open
-- Aquí comienza la función para eliminar la posible extensión y añadir la nueva.
on RecortaExtensiones(ElementoUnico)
set largo to length of ElementoUnico
set PosibleExtension to characters (largo - 3) thru largo of ElementoUnico as string
repeat with i from 1 to (count of items in ExtensionesReales)
set UnaExtension to (item i of ExtensionesReales) as string
if PosibleExtension is in UnaExtension then
set LargoExtension to length of (item i of ExtensionesReales)
set ElementoUnico to characters 1 thru (largo - LargoExtension) of ElementoUnico
end if
end repeat
set ArchivoDestino to ElementoUnico & ".m4v" as string
return ArchivoDestino
end RecortaExtensiones
-- Procedemos con la función para evitar el aviso de "Cancelado por el usuario", que es el error -128 y que muestre el numero y mensaje de error en los otros casos
on GestionErrores(errmsg, errnum)
if errnum is not -128 then
tell me
activate
display dialog "OOOuuch!!!: Acabamos de encontrarnos un feo error" & return & return & errmsg & " (" & errnum & ")" buttons {"OK"} default button 1 with icon stop with title "Vaya por dios!!!!"
end tell
end if
end GestionErrores |
Realmente, además de los cambios visibles y comentados, en esta nueva parte del script lo que hemos hecho para hacer que reaccione a los archivos que podramos arrastrar es añadir al comienzo las lineas:
La primera, la que pone «on open» es la que convierte nuestra aplicación que un droplet y lo que sigue, es decir, la palabra «LosElementos» es una variable que almacenará la ruta y nombre de todo archivo que sea arrastrado hasta nuestra app. La siguiente linea «try», hace que si falla, por el motivo que sea, nos muestre el mensaje de error personalizado que hemos preparado.
La parte que tiene algo más de miga es la que está bajo «Activate» y es la encargada de, si lo que se arrastra es más de un archivo, ir aplicando las correspondientes órdenes a cada uno de ellos por separado de forma que comience con uno, lo procese y vuelva a comenzar al encontrarse el «end repeat», así hasta que llegue a «CuentaElementos» que es básicamente la variable en la que hemos almacenado el número total de elementos arrastrados (length of LosElementos).
En este caso, para hacer un poco diferente el script y que no sea exactamente igual una parte que otra, más que nada, a fin de aprender más con él, lo que hemos hecho es que, si los archivos a convertir son arrastrados al icono de la aplicación, los procese sin preguntar un nombre de destino. Evidentemente un nombre es obligatorio que tengan ya que no existe archivo alguno que no tenga nombre, así que mantendrá su nombre original (su ruta tambien) pero con una nueva extensión, es decir, cuando arrastremos uno o más archivos a nuestro convertidor, el archivo o archivos resultantes aparecerán en la misma ubicación que el original y con el mismo nombre pero su extensión será «.m4v».
Para finalizar la parte droplet, solamente tendremos que cerrar el «intento», es decir, el «try» que añadiamos al comienzo y el open:
Y ya casi tenemos todo un señor conversor terminado, solo nos quedaría amoldar la parte que teniamos para que sea ejecutada en caso de iniciar nuestro programa de la forma habitual o, lo que es lo mismo, para que reaccione cuando se haga doble clic sobre el icono, ya que esta parte deja de funcionar al introducir las lineas que lo convierten en droplet, así que vamos allá de nuevo añadiendo «on run» al comienzo de la primera parte y «end run» al final del misma.
Y si, ahora si está terminado nuestro conversor personal de archivos de video al formato iPhone. Este es el interior del mismo para quienes no quieran ir «juntando» los fragmentos que hemos ido explicando hasta ahora.
Por supuesto, al final del artículo, hay un enlace para descargar el archivo entero ya preparado.
Este es nuestro Script:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
| property ExtensionesReales : {".avi", ".mov", ".mpg", ".mpeg", ".divx", ".qtm", ".rpm", ".wmv", ".m4v"}
on open LosElementos
try
tell application "QuickTime Player" to activate
set CuentaElementos to (count of items in LosElementos)
repeat with i from 1 to CuentaElementos
set ElementoUnico to (item i of LosElementos) --as Unicode text
tell application "QuickTime Player" to open ElementoUnico
set ElementoUnico to ElementoUnico as string
set ArchivoDestino to RecortaExtensiones(ElementoUnico)
tell application "QuickTime Player" to export document 1 in ArchivoDestino using settings preset "iPhone"
end repeat
on error errmsg number errnum
GestionErrores(errmsg, errnum)
end try
end open
on run
try
set Origen to (choose file)
set ElementoUnico to (choose file name) as string
tell application "QuickTime Player" to open Origen
set Destinaco to RecortaExtensiones(ElementoUnico)
tell application "QuickTime Player" to export document 1 in Destinaco using settings preset "iPhone"
on error errmsg number errnum
GestionErrores(errmsg, errnum)
end try
end run
on RecortaExtensiones(ElementoUnico)
set largo to length of ElementoUnico
set PosibleExtension to characters (largo - 3) thru largo of ElementoUnico as string
repeat with i from 1 to (count of items in ExtensionesReales)
set UnaExtension to (item i of ExtensionesReales) as string
if PosibleExtension is in UnaExtension then
set LargoExtension to length of (item i of ExtensionesReales)
set ElementoUnico to characters 1 thru (largo - LargoExtension) of ElementoUnico
end if
end repeat
set ArchivoDestino to ElementoUnico & ".m4v" as string
return ArchivoDestino
end RecortaExtensiones
on GestionErrores(errmsg, errnum)
if errnum is not -128 then
tell me
activate
display dialog "OOOuuch!!!: Hemos tenido el siguiente problema:" & return & return & errmsg & " (" & errnum & ")" buttons {"OK"} default button 1 with icon stop with title "Oh, Vaya!!"
end tell
end if
end GestionErrores |
Descargar el script sin compilar: Conversor_iPhone
Descargar la aplicacion (Versión Final): Conversor_iPhone
.
leer más
