Va rapido. El siguiente paso es usar el plugin de SSL
Requirements. Primero se tienen que hacer los certificados… eso lo vi
en estas
paginas. http://developer.apple.com/internet/serverside/modssl.html

Obvio todo esto es solo para modo de development, despues Godaddy o
verisign nos va a dar un certificado de verdad.

La configuracion para el Apache es la siguiente:

Listen 80
Listen 443
NameVirtualHost *:80
NameVirtualHost *:443

ServerName localhost

LoadModule proxy_module /usr/lib/apache2/modules/mod_proxy.so
LoadModule proxy_http_module /usr/lib/apache2/modules/mod_proxy_http.so
LoadModule ssl_module /usr/lib/apache2/modules/mod_ssl.so
LoadModule headers_module /usr/lib/apache2/modules/mod_headers.so

# SSL configuration…
Include /etc/apache2/mods-available/ssl.conf:
# AddModule mod_ssl.c

SSLCertificateFile /etc/apache2/ssl.key/server.crt
SSLCertificateKeyFile /etc/apache2/ssl.key/server.key

# CustomLog logs/ssl_request_log "%t %h %{SSL_PROTOCOL}x %{SSL_CIPHER}x \"%r\" %b"

<VirtualHost localhost:80>
ServerName localhost
ServerAlias 127.0.0.1
DocumentRoot "/home/waldemarpc/proyectos/fatstudent/"
ProxyPass / http://localhost:3001/
ProxyPassReverse / http://localhost:3001/
ProxyPreserveHost On
</VirtualHost>

<VirtualHost *:443>
SSLEngine On
ServerName localhost
ServerAlias 127.0.0.1
DocumentRoot "/home/waldemarpc/proyectos/fatstudent/"
ProxyPass / http://localhost:3001/
ProxyPassReverse / http://localhost:3001
ProxyPreserveHost on
RequestHeader set X_FORWARDED_PROTO ‘https’
</VirtualHost>

# <IfModule ssl_module>
# SSLRandomSeed startup builtin
# SSLRandomSeed connect builtin
# </IfModule>

This is what I did to make it work: :O:O:O:O

production:
delivery_method: :smtp
smtp_settings:
address: smtpout.secureserver.net
port: 80
domain: smtpout.secureserver.net
authentication: :plain
user_name: "asdfasdf@maily.com"
password: "passswosadffasd"

Desde el 10 de agosto estoy creando una aplicacion con rails que me va a
servir para poder hacer posts en mejor forma desde emacs u otros
clientes. En este espacio voy a poner algunas de las ideas que he tenido
entorno al tema de publicar en internet.

1) Casi todos los CMS lo único que hacen es meter los posts dentro de
la base de datos o tienen archivos hechos en html los cuales se editan
para poder crear contenido. Lo de la base de datos esta bien, sin
embargo no es la solución completa, sino por que seguimos utilizando
software como word para expresar nuestras ideas y Google Docs para poder
compartir el mismo documento. La idea de Google Docs esta bien. Es
orthogonal al CSM, sin embargo el fin de Google Docs y Etherpad es dar
acceso al mismo documento a cierto número de personas
_dentro_de_un_browser_… (por cierto tengo que actualizar el calendario
de Google ahorita)……………….

2) El filesystem es completamente REST no? Por qué la forma a que
accedemos a recursos remotos y locales no puede ser más
transparente. (En estos momentos hay una personas en Rusia que está
haciendo algo parecido a lo que estoy tratando de hacer pero le está
saliendo mejor. Me gusta mucho el weblogger pero la tecnología a la
cuál alimenta esta muy limitada. No textile for example. No puedo
acceder a las cosas que posteo en un futuro. Los estilos me molesta.
Hace rato pensé que de trabajar algún día en un lugar de donde
trabajaran personas como las que están todo el tiempo en
news.ycombinator podría pensar "No sé cómo le hacen los gringos pero
cada vez que interactúan conmigo me siento como en Times Square".

3) Digresiones. Digresiones por todas partes. Por qué no hay CMSsss
orientados a digresiones. Por qué todo lo que se escribe en una
computadora tiene que sufrir la analogía del mandala como lo que dijo
John Resig sobre _why. Por qué es tan difícil publicar? Soy sólamente
yo?

Siempre se me olvida como es que se debe de instalar las rubygems en
Ubuntu. El problema es con Ubuntu sólamente debido a que se empiezan a
pelear apt-get y gems, ademas de que no se puede hacer ‘gem update
–system’ en debian. Entonces lo que hago es.

(Otra cosa tambien es que para poder hacer los posts a weblogger la
direccion del blog que se da es http://www.server.com/xmlrpc.php)

tar xzvf rubygems-1.0.1.tgz
cd rubygems-1.0.1
sudo ruby setup.rb
sudo ln -s /usr/bin/gem1.8 /usr/bin/gem
sudo gem update –system

solamente asi se puede jugar con las rubygems de forma más fácil.

De SO:
http://stackoverflow.com/questions/269487/how-to-deal-with-protectfromforgery-to-make-rails-applications-communicate

Por ejemplo:

curl -H "Content-Type: text/xml" -d "<essay><content>Holaaaaaaa</content><title>yeah</title></essay>" -X POST http://localhost:3000/essays.xml -i

Siempre tengo que hacer el set up de esto, la mejor forma que he
encontrado hasta ahora son las instrucciones que hay acá.
http://ubuntuforums.org/showthread.php?t=27811

quote:

1) $ sudo apt-get install uim anthy scim-gtk2-immodule scim-uim

2) Create a file called 75custom-write_japanese in /etc/X11/Xsession.d

3) Paste the following into it

export XMODIFIERS="@im=SCIM"
export GTK_IM_MODULE="scim"
export XIM_PROGRAM="scim -d"
export QT_IM_MODULE="scim"

4) sudo dpkg-reconfigure locales
Select en_US.UTF-8 as default, it may be already.

5)System->Preferences->Sessions (o Startup applications creo)
Startup Programs Add scim -d
I left the order at 50

5a)For KDE users/Kubuntu users
Create a file startscim in .kde/Autostart/
Paste the following text.
#!/bin/sh
scim -d

Then
chmod 744 startscim

6)Restart X or Reboot, Welcome to Japanese Input!

Y darle los permisos al 75custom-write_japanese, chmod 744
75custom-write_japanese

eso es todo ciao.

El problema: ActiveResource es muy bueno para hacer que dos aplicaciones
de Rails se comuniquen satisfactoriamente, sin embargo, una vez que se
habla de file uploads y de soporte para multipart, la cosa se complica
un poco, ya que ActiveResource no tien soporte para esto.

Contexto: Railsy-fu es una aplicacion que usa el plugin attachment-fu
para poder hacer file uploads. (Ver el post anterior). RailsyResource es
una aplicacion que usa los web services de de Railsy-fu. RailsyResource
es la que se va a encargar de hacer los file uploads.

En este ejemplo, una mensaje puede o no tener un attachment. Vamos a
tener que primero hacer el upload a Railsy-fu y después tomar el id de
ese file para relacionarlo con la aplicación.

Como no podemos usar ActiveResource, vamos a tener que hacer un post
desde RailsyResource a Railsy-fu con multipart. Para poder hacer esto,
existe la ‘gem httpclient’. (Instalarla… gem i httpclient).

El procedimiento es asi…

1) Instanciamos el objeto Httpclient
clnt = HTTPClient.new

2) El archivo que se va a ser uploaded, tiene un filename del tipo
RackMultipart0123456789 y se encuentra en /tmp/ comúnmente. Como es un
archivo temporal, no podemos renombrarlo ahi mismo en /tmp/ , entonces
debemos de copiar el archivo a una carpeta temporal dentro del
RAILS_ROOT
name = params[:message][:file].original_filename
directory = "#{RAILS_ROOT}/public/temp/"
path = File.join(directory, name)
File.open(path, "w+") { |f| f.write(params[:message][:file].read) }

3) Ya que ha sido creado el archivo con su nombre original, lo mandamos
por post/put a el web service de Railsy-fu.
body = { :uploaded_data => File.open("#{RAILS_ROOT}/public/temp/" + name), :message => ‘yeah!!!’, :apikey => ‘12312312312312312123123′}
res = clnt.post(‘http://railsyfu.com/files.xml’, body)

4) Necesitaremos el file_id de ese archivo que acabamos de guardar para
poder relacionarlo con el objeto. Para hacer esto vamos a parsear el
response (con libxml-ruby, es más rápido según esto).
doc = XML::Document.string(res.content)
file_id = doc.root.find_first(‘id’).content #por ejemplo <id> 145 </id>

5) Y se lo anhadimos al objeto message.
@message.file_id = file_id

Falta despues hacer revisar si es que se no se hizo un attachment, asi
que todo lo anterior deberia de estar dentro de un if que hace esta
verificacion.

Por ultimo, borramos el archivo temporal que hicimos.
if @message.save
File.delete("#{RAILS_ROOT}/public/temp/" + name) if params[:message][:file] and File.exists?("#{RAILS_ROOT}/public/temp/" + name)

Quick post de como hacer el testing a attachment fu:

1.- Hacemos una carpeta dentro de fixtures que se llame files:
mkdir test/fixtures/files

2.- …incluimos algun archivo doc, imagen lo que sea.

3.- Dentro del test hacemos el load de esta forma

test &quot;should create person&quot; do
fdata = fixture_file_upload(‘/files/doctestfile.doc’, ‘application/msword’)
assert_difference(‘Person.count’) do
post :create, :resume =&gt; {
:person_id =&gt; 1,
:uploaded_document =&gt; fdata
},:html =&gt; { :multipart =&gt; true }
end
end

y ya… creo que ya

Es muy parecido a lo de las imágenes.

Primero se instalamos el plugin…


ruby script/plugin install http://svn.techno-weenie.net/projects/plugins/attachment_fu

Se genera el modelo del documento…


ruby script/generate model Document record_id:integer record_type:string filename:string content_type:string size:integer


rake db:migrate para las migraciones. Y ahora se anhade lo siguiente al model de ‘Document’. Las opciones completas de lo que se puede hacer están acá: http://wiki.github.com/technoweenie/attachment_fu.


class Document < ActiveRecord::Base
belongs_to :record, :polymorphic => true
has_attachment :content_type => ['application/pdf', 'application/msword', 'text/plain'],
:storage => :file_system,
:path_prefix => 'public/records'

validates_as_attachment
end


Los últimos pasos son agregar el metodo uploaded_document= a los modelos que se relacionan con los archivos. Por ejemplo: Person.rb tiene un documento.


class Person < ActiveRecord::Base

has_one :document, :dependent => :destroy, :as => :record

validates_presence_of :title
validates_length_of :title, :in => 1..100
validates_length_of :rating, :in => 0..10, :allow_nil => true

def uploaded_document=(data)
unless data.blank?;
document.destroy if document
self.reload
create_document :uploaded_document => data ##dudas en esta parte... :uploaded_data???
end
end

end


Para aceptar uploads en la vista se tiene que incluir esto en la forma.


<% form_for @movie, :html => {:multipart => true} do |f| %>

...

Document
<%= f.file_field :uploaded_document %>

ejemplo de liga al documento: <%= link_to “Document”, person.document.public_filename if person.document %>

Bueno ciao.

Para las migraciones…

rake db:create
rake db:migrate

…

me salio este error…

undefined method `reenable’ for <Rake::Task db:schema:dump =>
[environment]>:Rake::Task

eso significa que tengo que actualizar rake probablemente…

(estoy en ubuntu)

sudo aptitude remove rake
sudo gem install rake