Callbacks: a simple way to get notified of events in your localization project

At POEditor, we are comitted to find the best ways to achieve localization automation for our users.

To make devs’ lives easy, we thought it would be nice to offer a way to trigger an external link on particular events. As usual, our users’ feedback weighed heavily in deciding to add this new feature. So without further ado, we give you POEditor callbacks.

POEditor Integrations
POEditor integrations

What are callbacks and why use them

Callbacks are simple way to get notications about specific events in POEditor localization projects. They can be set up by the project owner and admins.

They are a good way to save resources, because you no longer need to poll the API at certain intervals. When the events are triggered, POEditor fires a request to a specific URL you set for that event.

How to set up and track callbacks

Setting up a callback is easy. You need to first access Account Settings > Integrations > Callbacks. Here, choose a localization project and the event that should trigger the callback, then add the web address you want fired when the event is triggered.

Currently there are three events you can choose:
• Language Completed
• Language Proofread (which requires Proofreading to be enabled in Project Settings )
• New Terms

POEditor callbacks form
POEditor callbacks form

To protect the endpoint, it is possible to also add a secret to the calls. The call will have a “X-Callback-Secret” header added with that value.

After you set your callback, you can send a test to your endpoint:

{
    "event": {
        "name": "test"
    }
}

The JSON payload examples we send for each event:

{
    "event": {
        "name": "language.completed"
    },
    "project": {
        "id": ******,
        "name": "Load data #2",
        "public": 0,
        "open": 0,
        "created": "2019-05-17T10:31:50+0000"
    },
    "language": {
        "name": "German",
        "code": "de"
    },
    "stats": {
        "strings": {
            "translated": 3,
            "fuzzy": 0,
            "proofread": 0
        }
    }
}
{
    "event": {
        "name": "language.proofread"
    },
    "project": {
        "id": ******,
        "name": "Android localization",
        "public": 1,
        "open": 0,
        "created": "2015-08-13T09:39:32+0000"
    },
    "language": {
        "name": "English",
        "code": "en"
    }
}
{
    "event": {
        "name": "new_terms.added"
    },
    "project": {
        "id": ******,
        "name": "Android localization",
        "public": 1,
        "open": 0,
        "created": "2015-08-13T09:39:32+0000"
    }
}

You can track your callbacks activity with your callbacks log. The log is available for the last the last 10 days.

Observations

The data is sent via POST and the JSON is put in a payload parameter.

Keep in mind that we listen for a response with HTTP status code 200 when we send the callback only for a short time (30 seconds at this point). If we don’t get a reply, a timeout error is generated after this,

Also, please make sure you don’t do all your processing on that endpoint and create a separate process for it. If we don’t get a 200 HTTP code when we fire the callback we try again 2 more times. After that we stop trying.

Localization project notifications on Microsoft Teams

Plenty of things happen when you localize software and keeping up to date with the events in your localization projects is key to maintaining a smooth workflow. Since nothing beats realtime notifications in terms of communicating events efficiently to the members of your localization team, we decided to make it possible to connect to another popular chat software – Microsoft Teams.

How to connect POEditor to Microsoft Teams

Connecting to Microsoft Teams is pretty easy and straightforward. If you need help with this, you can find the steps described in detail in our Knowledge Base.

Note that only the POEditor user hosting the localization projects needs to make the setup with Microsoft Teams. The other localization team members need just to join the Teams channel designated to receive notifications about the localization projects.

Microsoft Teams integration settings - POEditor translation and localization management system

Supported localization project events

You can choose what events in your localization projects to push notifications to your preferred Microsoft Teams channel.

The Teams integration sends an immediate notification when:

  • a project was created/deleted
  • a language was added/completed/deleted/proofread
  • strings were imported
  • a contributor was added/removed/joined the project
  • a comment was added
  • Automatic Translation characters were used
  • a translation order was completed
  • translations were flushed from a languages
  • all terms and translations were flushed from the project
  • translations were updated via API
  • a term was manually added in the user interface
  • terms were added via API
  • terms were synced via API
  • new terms were added (regardless of how)
  • the string limit was reached
  • the subscription renewal failed

If you and your colleagues are using Microsoft Teams, this new feature should make internal communication much more fluent. We are open to suggestions for other event notifications and to any kind of feedback, so don’t be shy to leave a comment if you have something on your mind.

Continuous localization with GitHub and POEditor

Why continuous localization

In today’s digital world, more and more software is becoming alive. This is due to a shift in the software industry from a linear approach to software development to an angile approach. Apps and websites are updated all the time, in small chunks, instead of being built in long development cycles, culminating with big releases. Thus, when the software product is launched, it is no longer the end of the development process for it, but the beginning. 

Naturally, if you are continuously developing your multilingual software product, you should also continuously localize it. You don’t want to leave behind any of your users when you roll out new features. Nor do you want to look unprofessional, by not localizing parts of your software in certain languages. So it’s a good idea to aim for a continuous approach on localization.

What is POEditor

POEditor is an online localization service and translation management system, designed to help all parties involved in the localization process on their quest to achieve a continuous workflow.

As a freemium SaaS, POEditor offers free and paid accounts and supports free of charge the localization of open source software with an OSI-approved licence.

If you use a translation and localization management service like POEditor, you’re likely to see better collaboration between team members, an increase in automation and productivity, and more streamlined workflows all around.

Using POEditor’s integration with GitHub for continuous localization

Connecting POEditor to GitHub, it becomes a lot easier for translation teams to receive string updates from dev teams. Also, dev teams find out in real time when new translations are ready and add them to the software.

Setting up a localization project at POEditor

To start integrating POEditor into your localization workflow, first register or log in to your POEditor account. Then add a project in your Dashboard and the languages your software currently supports (including the source language). Then add the languages you want to further localize into.

Setting up the GitHub integration

POEditor can connect with both GitHub and GitHub Enterprise. To connect, follow the instructions in the GitHub Integrations page, accessible in Account Settings.

GitHub Integration - POEditor localization platform

Once you set up the connection, you can start linking the languages in your POEditor project with the localization files in your repos.

Import the terms and the translations from the source file and from here on, you can start customizing things.

Each linked language has its own settings. In settings, you can tag particular groups of string on import (all, new, obsolete, with changed translations) or to set filters for exporting to GitHub.

POEditor GitHub Integration Page

For a plus of automation, you can use Webhooks. They help to keep the files in your repos in sync with your POEditor projects. With a webhook, you or anyone in your team can update from anywhere the strings in your source language in POEditor. You can also signal (with the fuzzy flag) if translations in the other languages need revision.

POEditor Webhooks page

Translation options

To translate the strings brought from your files on GitHub, POEditor offers multiple translation options:

  1. Assigning translators to specific languages (by adding them as contributors)
  2. Crowdsourcing translations from your community (using public projects)
  3. Ordering human translation services
  4. Machine translation

According to your resources and needs, you can combine the available translation options in whatever way suits you best.

Improved POEditor webhooks

We have recently changed the way webhoooks work with POEditor in order to improve security. On March the 1st, 2019, we will discontinue the former webhooks format. This is just a change in the format of the webhooks, the funtionality remains the same, as described below.

How webhooks work

Webhooks work in the same way for all the code hosting services supported by POEditor: GitHub, Bitbucket, GitLab or Visual Studio Teams Service – VSTS. They can be called from anywhere, and can be maintained, modified and managed by any third-party users. In your account, you can access the webhooks page via the Add/Manage webhooks link in the bottom right corner of the integration page.

POEditor GitHub Integration Page

Webhooks work on a project / language basis. So, if you have several files linked to a language, it’s enough to run one webhook with an operation and that operation will be executed for all the files linked to that language.

You can create webhooks for the following operations:

  • Import new terms: Brings the terms (without the translations) from GitHub to POEditor.
  • Import translations: Brings the translations from the GitHub file to POEditor for the matching terms.
  • Import terms and translations: Brings the terms and the translations from the GitHub file to the POEditor project.
  • Synce terms and translations: Brings the terms and translations from the GitHub file to POEditor, deleting the obsolete terms from the project.
  • Export terms and translations: Takes the terms and translations from POEditor to GitHub, overwriting the original file.

The Import translations, Import terms and translations and Synce terms and translations webhooks have two options you can also check:

  • Overwrite Translations: overwrites the translations in the project with those in the file for the matching terms.
  • Mark corresponding translations from the other languages as fuzzy for the updated values: puts a fuzzy flag on the translations in all the languages in the project, which correspod to the term with the updated value.

POEditor Webhooks page

We strongly recommend that you do not use the sync webhook if you have multiple files linked to the source language. The sync webhook deletes the terms which are in the project, but are not in the connected file. So you may end up losing terms you imported from other files. The terms from the file last synced is what remains in your POEditor project.

Webhooks – a tool for localization project admins to manage data

Webhooks are a simple solution to allow an admin or someone else to manage the data between POEditor projects the GitHub, Bitbucket, GitLab or VSTS account connected with the localization project owner’s POEditor account.

First, the project owner should set the links between the language file in your repo and the corresponding language in POEditor. After this, anyone can trigger the updates both ways: to get the terms (and translations) from the repos and to export the translations in POEditor to the linked file in your repos.

How to track webhooks

You can easily observe your webhooks activity with the help of the Webhooks log which stores for 30 days all the requests that can be identified as being yours (using a webhook generated from your account).

If you are not using webhooks but are looking for a solution to automate the synchronization between the POEditor localization platform and your repos, then we encourage you to give these “user-defined HTTP callbacks” a try. If you’re using them and have not already switched to the new format, we encourage you to do so, for better security and in order not to experience any interruptions in your workflow.

For any questions or feedback, feel free to drop us a comment or an email at info@poeditor.com.

VSTS and TFS, now integrated with POEditor

VSTS integration with POEditor

You’ve been asking for it and we’ve heard you, so here it is! The Visual Studio Team Services (VSTS) and Team Foundation Server (TFS) integration is the latest entry on our list of integrated code hosting platforms. Among integrations with other great players, such as GitHub, Bitbucket and GitLab, it is here to make your life easier.

How to set up the integration with VSTS/TFS

The setup takes just a few clicks. Since this is an account-level feature, the integration can only be made by the account (and, thus, project-) owner. We describe how to connect your POEditor account with both Microsoft services here.

How the ingrations works

The integration with VSTS and TFS functions similarly to the other integrations with code hosting platforms supported by POEditor. To get a quick idea of the functionality, check out this article.

Automation and webhooks

Just like with GitHub, GitLab and Bitbucket, you can automate your work with this integration using webhooks. You can trigger the webhooks from anywhere to send data from the localization files in your repos to the assigned languages/projects on POEditor.

Webhooks are also useful if a project owner wants to let an admin take over the file management, after they make the connection between the POEditor account and the VSTS account.

Where to send your impressions

If you have any questions or comments about the newest kid on our block of integrations, just drop a few lines in the comments below. Also, feel free to show us some love on our Visual Studio Marketplace page if your work with Visual Studio Team Services or Team Foundation Server and this feature is useful to you.

Auditing a POEditor account with Logs

To audit your POEditor account, you can access the Logs section in Account Settings. The Logs section is divided into three sub-sections: Activity Log, API Log and Webhooks Log.

POEditor Logs (Account Settings) - POEditor Translation Management System

The Activity Log

The Activity Log tracks events related to translation, project management, API activity, integrations with code hosting services, settings changes (both project and account settings) and other events relevant to the user.

To more easily find the events of interest, use the search bar at the top of the Activity Log page. You can also filter events by user, language and project.

We keep most tracked events for 15 days. The ones which have to do with data deletion are kept for 30 days.

Activity Log - POEditor Translation Management System

The API Log

To check your API activity, go to Account Settings > Logs > API Log.
The API Log stores for 15 days all the requests that POEditor can identify as yours (using an API token generated from your account).
You can filter the API logs by date, using the date range picker at the top right corner of the page.

API Log - POEditor Translation Management Platform

The Webhooks Log

As a POEditor user, you can see what actions have been triggered in your account using webhooks. For this, go to Account Settings > Logs > Webhooks Log.
The Webhooks Log stores for 30 days all the requests that POEditor can identify yours (using a webhook generated from your account).
To filter the webhook logs by date, use the date range picker at the top right corner of the page.

Webhooks Log - POEditor Translation Management Platform

Note: POEditor uses UTC to express the time when an event took place.

Bitbucket commit, now available with POEditor integration

A Bitbucket push method for our integration is something we’ve all been expecting for years.

Up until recently, the Bitbucket API did not support this method, unlike GitHub and GitLab. But, thanks to many Bitbucket users asking for it, your preferred code hosting platform has finally added this feature!

Upon hearing the news, we’ve immediately made it our main priority to update the Bitbucket integration. So, now, we’re happy to announce that you can export translations from your POEditor localization projects to your repos with just a few clicks.

We’ve also updated the Webhooks generator to reflect the implementation of the commit.

Bitbucket commit - POEditor localization platform

If you’re new to the Bitbucket integration, you can learn how to set it up here. More information about how to manage localization files between POEditor and Bitbucket is available here.

Cheers to all of you who took the time to push for this change! Don’t be shy to let us know if you have any feedback.

 

Translation options with the localization platform POEditor

According to the nature of your project and the localization resources you have available, you can choose to translate strings with POEditor using one or a combination of the translation options below.

Assigning contributors to specific languages

Whether your company has its own translation department, you collaborate with a translation agency or you have some friends willing to help with the translation, this option is for you. You know exactly who will be translating the project into what language.

Add contributor - POEditor localization management platform

Assigning a contributor to a language in a POEditor project is easy. There’s an ‘Add contributor’ button in the Project page for each project language, and one in each Language page. Click on one of these buttons and type in the name and email of the person you want to assign to the language. They will receive an invitation to join your localization project, which will allow them to start translating right away.

You can add contributors to a localization project via API also.

Human translation orders

If your project needs to be localized into a language quickly and professionally, and you don’t have a translator to assign to your project, the human translation order module is what you’re looking for.

Human translation module - POEditor localization management platform

 

At POEditor, we offer an integrated translation order system, which allows you to seamlessly send strings to professional human translators. Once the translations are completed, the localized strings are sent back to your POEditor account and you can import them to your project with a few clicks. No need to send localization files back and forth, or for any external accounts/keys/credits.

Sounds easy? It is.

Crowdsourced translation (community translation)

Have an active community, who you would trust with localizing your project? That’s where public projects come in.

After you make your localization project public in Project Settings, you can share a link to its public join page, where anyone can volunteer to translate into one or more languages.

A public join page for a crowsourced localization project

There are ways to control the access to your crowdsourced localization project. For new contributors, check the options available in Project Settings > Advanced Settings. For current contributors, see the Contributors page. More information about public projects is available here.

Machine Translation

For pseudolocalization purposes, or for the translation of short, simple strings, you can always opt to use machine translation engines. We offer two vendors for automatic translation, Google and Microsoft Translate.

To access the Automatic Translation feature, click the button with the same name in any Language page.

As handy as it can be in some cases, and as much as it may have advanced over the years, we would advise you to use human translation for production environments.

Have you decided upon the localization strategy you are going to use for your project? Feel free share your thoughts by leaving a comment below.

Angular 2 Localization: How to Translate App Strings

Translating Angular 2 apps can be simple. All you need is an .xmb file with your source language from your Angular 2 app and a POEditor account. The rest is just a matter of choosing the localization strategy which best suit your needs, from the ones our localization management platform has to offer.Angular 2 localization

How to set up an Angular 2 translation project

Setting up the translation project for your Angular 2 app is as simple as 1, 2, 3:

Step 1. Create the project in your account and add the source language and the languages desired for localization.

Step 2. Import terms to the project and translations in the source language from the .xmb file. Do this using the Import Terms button in the project page (don’t forget to choose to ‘Also import translations in…’ your source language).

Step 3. Set a Default Reference Language in Project Settings.

Angular 2 xmb import

After going through these simple steps, your project is set and you can proceed to choosing which way you want to translate your Angular 2 strings.

Localization strategies to choose from

The POEditor localization platform lets you combine various ways of translating strings.

You can use (unlimited) in-house translators (added as contributors), order human translations from one of our partners, crowdsource translations from your community (using public projects), as well as use Machine Translation (Google/Microsoft).

Because we wanted to make things as straightforward as possible, everything is manageable from within your POEditor account. So, you won’t need any external accounts/keys/credits to make use of these translation options.

How to automate the localization process

For automating translation, I’ve already mentioned the option to order professional human translation services and to use the Automatic Translation feature. But there are also features like the Translation Memory, which can considerably reduce the translation workload. Memorizing all your translations, including the deleted ones, the TM lets you recycle translations in your current and future localization projects, saving you valuable resources.

The file management can also be automated, with the GitHub, Bitbucket or GitLab integration.

Integrations page - POEditor localization management platform

You can track the localization progress with statistics per language and per contributor. You can also get real-time notifications about project activity with the help of our Realtime Translation System and our Slack integration.

If you want to automate everything, check out the POEditor API.

When necessary, you can export the localized strings to any of the formats supported by POEditor, including .xtb. Do this from the language page, using the API, or with the help of one of the code hosting platform integrations.

POEditor localization API improvements

The POEditor dev team has been very busy lately, tinkering with the localization API (among others). Below are described the improvements you can find in API v2.

New API methods

Besides completely refreshing the look (structure) of the API, we’ve also completed it with a few methods. Now, we can say it better mirrors the functionalities in the localization interface.
  • Update terms. This is the equivalent of the View or Add Terms in the localization interface. It lets you change the text, context, reference, plural and tags.
  • Remove contributor. This method removes a contributor from a project language or an admin from a project, if the language is not specified.
  • Delete projectIt deletes the project from the account. You must be the owner of the project.
  • Update project settings. The method lets you set or delete a Default Reference Language, as well as edit the name and/or description of the project.

Other improvements

We’ve also updated some already existing methods in the localization API, as follows:
  • View Project Details now also shows the number of terms in the project.
  • List project terms supports plurals.
  • Update project language gained the fuzzy trigger (and can mark as fuzzy the translations in the other languages).

That’s all folks! We hope you enjoy API v2 and look forward to your feedback on it.