Restructure things so that the application is now just another module.

Kohana makes this type of transition fairly straightforward in that
all controllers/helpers/etc are still located in the cascading
filesystem without any extra effort, except that I've temporarily
added a hack to force modules/gallery into the module path.

Rename what's left of "core" to be "application" so that it conforms
more closely to the Kohana standard (basically, just
application/config/config.php which is the minimal thing that you need
in the application directory)

There's still considerable work left to be done here.

1 files changed, 203 insertions, 0 deletions

diff --git a/modules/gallery/helpers/l10n_client.php b/modules/gallery/helpers/l10n_client.php
new file mode 100644
index 00000000..ec4c5429
--- /dev/null
+++ b/modules/gallery/helpers/l10n_client.php
@@ -0,0 +1,203 @@
+<?php defined("SYSPATH") or die("No direct script access.");
+/**
+ * Gallery - a web based photo album viewer and editor
+ * Copyright (C) 2000-2009 Bharat Mediratta
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or (at
+ * your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+class l10n_client_Core {
+
+  private static function _server_url() {
+    return "http://gallery.menalto.com/index.php";
+  }
+
+  static function server_api_key_url() {
+    return self::_server_url() . "?q=translations/userkey/" .
+      self::client_token();
+  }
+
+  static function client_token() {
+    return md5("l10n_client_client_token" . access::private_key());
+  }
+
+  static function api_key($api_key=null) {
+    if ($api_key !== null) {
+      module::set_var("core", "l10n_client_key", $api_key);
+    }
+    return module::get_var("core", "l10n_client_key", "");
+  }
+
+  static function server_uid($api_key=null) {
+    $api_key = $api_key == null ? self::api_key() : $api_key;
+    $parts = explode(":", $api_key);
+    return empty($parts) ? 0 : $parts[0];
+  }
+
+  private static function _sign($payload, $api_key=null) {
+    $api_key = $api_key == null ? self::api_key() : $api_key;
+    return md5($api_key . $payload . self::client_token());
+  }
+
+  static function validate_api_key($api_key) {
+    $version = "1.0";
+    $url = self::_server_url() . "?q=translations/status";
+    $signature = self::_sign($version, $api_key);
+
+    list ($response_data, $response_status) = remote::post(
+      $url, array("version" => $version,
+                  "client_token" => self::client_token(),
+                  "signature" => $signature,
+                  "uid" => self::server_uid($api_key)));
+    if (!remote::success($response_status)) {
+      return false;
+    }
+    return true;
+  }
+
+  static function fetch_updates() {
+    $request->locales = array();
+    $request->messages = new stdClass();
+
+    $locales = locale::installed();
+    foreach ($locales as $locale => $locale_data) {
+      $request->locales[] = $locale;
+    }
+
+    // @todo Batch requests (max request size)
+    foreach (Database::instance()
+             ->select("key", "locale", "revision", "translation")
+             ->from("incoming_translations")
+             ->get()
+             ->as_array() as $row) {
+      if (!isset($request->messages->{$row->key})) {
+        $request->messages->{$row->key} = 1;
+      }
+      if (!empty($row->revision) && !empty($row->translation)) {
+        if (!is_object($request->messages->{$row->key})) {
+          $request->messages->{$row->key} = new stdClass();
+        }
+        $request->messages->{$row->key}->{$row->locale} = $row->revision;
+      }
+    }
+    // @todo Include messages from outgoing_translations?
+
+    $request_data = json_encode($request);
+    $url = self::_server_url() . "?q=translations/fetch";
+    list ($response_data, $response_status) = remote::post($url, array("data" => $request_data));
+    if (!remote::success($response_status)) {
+      throw new Exception("@todo TRANSLATIONS_FETCH_REQUEST_FAILED " . $response_status);
+    }
+    if (empty($response_data)) {
+      log::info("translations", "Translations fetch request resulted in an empty response");
+      return;
+    }
+
+    $response = json_decode($response_data);
+
+    // Response format (JSON payload):
+    //   [{key:<key_1>, translation: <JSON encoded translation>, rev:<rev>, locale:<locale>},
+    //    {key:<key_2>, ...}
+    //   ]
+    $count = count($response);
+    log::info("translations", "Installed $count new / updated translation messages");
+
+    foreach ($response as $message_data) {
+      // @todo Better input validation
+      if (empty($message_data->key) || empty($message_data->translation) ||
+          empty($message_data->locale) || empty($message_data->rev)) {
+        throw new Exception("@todo TRANSLATIONS_FETCH_REQUEST_FAILED: Invalid response data");
+      }
+      $key = $message_data->key;
+      $locale = $message_data->locale;
+      $revision = $message_data->rev;
+      $translation = serialize(json_decode($message_data->translation));
+
+      // @todo Should we normalize the incoming_translations table into messages(id, key, message)
+      // and incoming_translations(id, translation, locale, revision)? Or just allow
+      // incoming_translations.message to be NULL?
+      $locale = $message_data->locale;
+      $entry = ORM::factory("incoming_translation")
+        ->where(array("key" => $key, "locale" => $locale))
+        ->find();
+      if (!$entry->loaded) {
+        // @todo Load a message key -> message (text) dict into memory outside of this loop
+        $root_entry = ORM::factory("incoming_translation")
+          ->where(array("key" => $key, "locale" => "root"))
+          ->find();
+        $entry->key = $key;
+        $entry->message = $root_entry->message;
+        $entry->locale = $locale;
+      }
+      $entry->revision = $revision;
+      $entry->translation = $translation;
+      $entry->save();
+    }
+  }
+
+  static function submit_translations() {
+    // Request format (HTTP POST):
+    //   client_token = <client_token>
+    //   uid = <l10n server user id>
+    //   signature = md5(user_api_key($uid, $client_token) . $data . $client_token))
+    //   data = // JSON payload
+    //
+    //     {<key_1>: {message: <JSON encoded message>
+    //                translations: {<locale_1>: <JSON encoded translation>,
+    //                               <locale_2>: ...}},
+    //      <key_2>: {...}
+    //     }
+
+    // @todo Batch requests (max request size)
+    // @todo include base_revision in submission / how to handle resubmissions / edit fights?
+    foreach (Database::instance()
+             ->select("key", "message", "locale", "base_revision", "translation")
+             ->from("outgoing_translations")
+             ->get() as $row) {
+      $key = $row->key;
+      if (!isset($request->{$key})) {
+        $request->{$key}->message = json_encode(unserialize($row->message));
+      }
+      $request->{$key}->translations->{$row->locale} = json_encode(unserialize($row->translation));
+    }
+
+    // @todo reduce memory consumpotion, e.g. free $request
+    $request_data = json_encode($request);
+    $url = self::_server_url() . "?q=translations/submit";
+    $signature = self::_sign($request_data);
+
+    list ($response_data, $response_status) = remote::post(
+      $url, array("data" => $request_data,
+                  "client_token" => self::client_token(),
+                  "signature" => $signature,
+                  "uid" => self::server_uid()));
+
+    if (!remote::success($response_status)) {
+      throw new Exception("@todo TRANSLATIONS_SUBMISSION_FAILED " . $response_status);
+    }
+    if (empty($response_data)) {
+      return;
+    }
+
+    $response = json_decode($response_data);
+    // Response format (JSON payload):
+    //   [{key:<key_1>, locale:<locale_1>, rev:<rev_1>, status:<rejected|accepted|pending>},
+    //    {key:<key_2>, ...}
+    //   ]
+
+    // @todo Move messages out of outgoing into incoming, using new rev?
+    // @todo show which messages have been rejected / are pending?
+  }
+}
\ No newline at end of file