Como eu posso registrar programaticamente um arquivo com o Redmine?

1

Eu gostaria de adicionar um arquivo a um servidor Redmine sem passar pela interface gráfica. Estou disponibilizando os arquivos para o servidor Redmine por um processo svn checkout separado, então só preciso poder adicionar os arquivos ao próprio banco de dados do Redmine.

Idealmente, gostaria de uma solução que pudesse ser executada assim:

./redmine-register-file /path/to/my/file.ext "with optional description"

Acredito que a parte relevante da interface está em redmine/apps/views/files/new.html.erb . Ele é acessado por index.html.erb , que tem uma pequena porção que acredito ser relevante:

<div class="contextual">
<%= link_to(l(:label_attachment_new), new_project_file_path(@project), :class => 'icon icon-add') if User.current.allowed_to?(:manage_files, @project) %>
</div>

Aqui está o conteúdo completo de new.html.erb :

<h2><%=l(:label_attachment_new)%></h2>

<%= error_messages_for 'attachment' %>
<%= form_tag(project_files_path(@project), :multipart => true, :class => "tabular") do %>
<div class="box">

<% if @versions.any? %>
<p><label for="version_id"><%=l(:field_version)%></label>
<%= select_tag "version_id", content_tag('option', '') +
                             options_from_collection_for_select(@versions, "id", "name") %></p>
<% end %>

<p><label><%=l(:label_attachment_plural)%></label><%= render :partial => 'attachments/form' %></p>
</div>
<%= submit_tag l(:button_add) %>
<% end %>

Eu não sei Ruby que bem em tudo (qualquer coisa além de print name.reverse está além de mim), mas eu sei que todos esses dois pontos indicam seletores. Que informações posso obter da interface padrão que me ajudará na minha tarefa e como pode ser uma solução completa?

Mais próximo de uma solução:

O Redmine usa um banco de dados MySQL para armazenar seus registros de arquivos. O banco de dados é chamado de redmine_production e usa o seguinte esquema:

mysql> SHOW COLUMNS FROM redmine_production.attachments;
+----------------+--------------+------+-----+---------+----------------+
| Field          | Type         | Null | Key | Default | Extra          |
+----------------+--------------+------+-----+---------+----------------+
| id             | int(11)      | NO   | PRI | NULL    | auto_increment |
| container_id   | int(11)      | YES  | MUL | NULL    |                |
| container_type | varchar(30)  | YES  |     | NULL    |                |
| filename       | varchar(255) | NO   |     |         |                |
| disk_filename  | varchar(255) | NO   |     |         |                |
| filesize       | int(11)      | NO   |     | 0       |                |
| content_type   | varchar(255) | YES  |     |         |                |
| digest         | varchar(40)  | NO   |     |         |                |
| downloads      | int(11)      | NO   |     | 0       |                |
| author_id      | int(11)      | NO   | MUL | 0       |                |
| created_on     | datetime     | YES  | MUL | NULL    |                |
| description    | varchar(255) | YES  |     | NULL    |                |
+----------------+--------------+------+-----+---------+----------------+
12 rows in set (0.00 sec)

Mais algumas fontes de Ruby

Talvez isso seja útil: attachment.rb

    
por Sean Allred 21.08.2013 / 16:35

1 resposta

1

Para quem passa por isso pelo Tópico do Redmine que criei: Eu tentei postar a solução lá também, mas o filtro de SPAM não me deixava acompanhar o tópico. É provavelmente porque não houve resposta intermediária (* lágrima *).

Demorou um pouco, mas percebi. (Eu fiz uma instância de teste do Redmine para não mexer em nada com nossa instância de produção, então esses valores são padrão e devem funcionar para qualquer um que tente fazer isso.)

Uma breve sinopse do processo:

  1. Encontre o ID interno do projeto ao qual você deseja adicionar os arquivos.
  2. Determine as estatísticas do arquivo.
  3. Inserir arquivo no banco de dados.

Na verdade, não há validação de banco de dados, por isso mesmo (2) é opcional. Como tal, não vou saber como obter essa informação. (Existem amplos recursos, mesmo neste site, sobre como obter essas informações.) O resto, no entanto, requer um pouco de conhecimento de como a Redmine tem seus bancos de dados configurados.

Para começar, conecte-se ao seu banco de dados MySQL de produção. (Geralmente, se nem sempre, redmine_production . Você pode listar todos os bancos de dados MySQL com o comando SHOW DATABASES; .)

Agora, encontre o ID do seu projeto ao qual você deseja adicionar o arquivo. Nas colunas listadas acima, isso será inserido como container_id .

mysql> SELECT * FROM projects;
+----+----------------+-------------+----------+-----------+-----------+---------------------+---------------------+----------------+--------+------+------+
| id | name           | description | homepage | is_public | parent_id | created_on          | updated_on          | identifier     | status | lft  | rgt  |
+----+----------------+-------------+----------+-----------+-----------+---------------------+---------------------+----------------+--------+------+------+
|  1 | git-helloworld | NULL        |          |         1 |      NULL | 2012-01-01 13:00:00 | 2012-01-01 13:00:00 | git-helloworld |      1 |    1 |    2 |
|  2 | bzr-helloworld | NULL        |          |         1 |      NULL | 2012-01-01 13:00:00 | 2012-01-01 13:00:00 | bzr-helloworld |      1 |    1 |    2 |
|  3 | hg-helloworld  | NULL        |          |         1 |      NULL | 2012-01-01 13:00:00 | 2012-01-01 13:00:00 | hg-helloworld  |      1 |    1 |    2 |
|  4 | svn-helloworld | NULL        |          |         1 |      NULL | 2012-01-01 13:00:00 | 2012-01-01 13:00:00 | svn-helloworld |      1 |    1 |    2 |
+----+----------------+-------------+----------+-----------+-----------+---------------------+---------------------+----------------+--------+------+------+
4 rows in set (0.00 sec)

Neste exemplo, queremos adicionar os arquivos a git-helloworld , então nosso ID é 1 . Então, para adicionar um arquivo ao banco de dados, vamos executar o comando SQL:

INSERT INTO attachments (container_id, container_type,
                         filename, disk_filename, digest) VALUES (
       1, 'Project',
       'Some File Name', 'file-name-on-disk', '0123456789abcdef');

Algumas notas sobre esses campos:

  • container_id : o ID do projeto no qual você deseja incluir o arquivo
  • container_type : o tipo de contêiner que é; para este propósito, é sempre Project
  • filename : a string exibe como o nome do arquivo
  • disk_filename : o caminho real do arquivo, relativo a /var/www/redmine/files/
  • digest : uma string representando a soma de verificação MD5 do arquivo.

Alguns campos não obrigatórios, mas recomendados:

  • filesize : o tamanho do arquivo como um inteiro. Eu suponho que isso seja feito em bytes ou kilobytes, mas não sei se isso importa.
  • author_id : um usuário para associar o arquivo a. Para os meus propósitos, vou usar admin . Observe que você pode obter uma lista completa de usuários do Redmine com SELECT * FROM users; .
  • description : uma descrição do arquivo. (Esta é a mesma descrição opcional usada na interface.)
  • content_type : Eu diria que este é um tipo de conteúdo MIME.
  • created_on : a data em que este arquivo foi criado.

Para os tipos explícitos de todos eles, consulte as colunas que aparecem na postagem original.

Em seguida, verifique se o caminho em disk_filename realmente existe em relação ao diretório redmine/files/ . (Observe que isso significa que você pode realmente organizá-lo!) Você não tem para fazer isso, mas você obviamente obterá um 404 se o arquivo não estiver lá.

Depois disso, você deve estar pronto para ir!

    
por 21.08.2013 / 19:59