API проверки правильности адресов: UPS

Исправляйте ошибки до того, как они застанут Вас врасплох

Добавьте веб-приложение для проверки правильности адресов США в Ваши интегрированные корпоративные приложения или в веб-сайт. API проверки правильности адресов выполняет непосредственную автоматическую интеграцию между Вашим веб-сайтом или корпоративной системой с UPS. С помощью  API Ваши клиенты смогут пользоваться широким спектром услуг и выбором возможностей от UPS, в то время как улучшенные процессы Вашего бизнеса станут более эффективными.

API проверки правильности адресов проверяет адрес клиента и предлагает альтернативы в случае обнаружения ошибки. Встроенный в веб-сайт или интегрированный в Ваши внутренние системы, этот инструмент поможет снизить эксплуатационные расходы и улучшить качество обслуживания клиентов.

Для кодировки и интеграции данного API потребуется помощь XML-программиста или программиста веб-сервисов. UPS предоставляет пакет разработчика, включающий руководство разработчика с информацией о способах интеграции и кодирования функций UPS в Ваши бизнес-приложения или Интернет-магазины.

Центр ресурсов разработчика

Разработчики: Загрузить API

Чем может быть полезен этот инструмент

API проверки правильности адресов доступен более чем в 40 странах и является ценным дополнением к любым корпоративным приложениям по отправке грузов в США. Например, если Ваш клиент в США ввел неверный почтовый индекс в ходе заполнения заказа в Интернете, ему будут предложены альтернативные адреса. Этот API также позволяет Вашим работникам по обслуживанию клиентов подтверждать и исправлять адреса во время разговора с клиентом по телефону.

Уменьшите вероятность доставки заказов по неверному адресу

Улучшите качество обслуживания клиентов, оказывая помощь покупателям с оформлением заказов. Уменьшите число задержек доставки по причине ввода неправильного адреса.

Индекс качества воздуха в режиме реального времени

Шкала AQI, используемая для индексации загрязнения в реальном времени на приведенной выше карте, основана на последнем

.

Благодаря всемирной организации EPA (Агенство по защите природы) удалось проделать всю важную работу в этой сфере. Просмотреть страницу можно по этой ссылке

.

Использование IndexedDB — Интерфейсы веб API

IndexedDB — это способ постоянного хранения данных внутри клиентского браузера, другими словами это NOSQL хранилище на стороне клиента. Что позволяет создавать веб-приложения с богатыми возможностями обращения к данным независимо от доступности сети, ваши приложения могут работать как онлайн, так и офлайн.

Это руководство по использованию асинхронного API для IndexedDB. Если вы не знакомы с IndexedDB, то обратитесь для начала к документу Basic Concepts About IndexedDB. .

Некоторые части документа не переведены, в основном это повсеместно принятые в программировании рекомендации, такие как обработка ошибок или что-то очевидное. Тем не менее вы можете/должны продолжить перевод. Главная цель перевода — понять основные концепции IndexedDB, обратить внимание на важные нюансы, прокомментировать исходный код и может быть добавить примеры.

Справочную документацию по IndexedDB API вы найдёте в документе IndexedDB. В нем описаны типы объектов, используемых в IndexedDB, а также синхронный и асинхронный API.

Обычная последовательность шагов при работе с IndexedDB :

1. Открыть базу данных.
2. Создать хранилище объектов в базе данных, над которой будут выполняться наши операции. 
3. Запустить транзакцию и выдать запрос на выполнение какой-либо операции с базой данных, например, добавление или извлечение данных.

4. Ждать завершения операции, обрабатывая событие DOM, на которое должен быть установлен наш обработчик.

5. Сделать что-то с результатами (которые могут быть найдены в возвращаемом по нашему запросу объекте ).

Теперь, получив общее представление, переходим к более конкретным деталям.

Так как спецификация пока ещё находится в процессе разработки, то текущие реализации IndexedDB отличаются у различных браузеров и могут содержать имена объектов, включающие в себя префиксы браузеров. Однако, как только стандарт будет принят,  префиксы будут удалены. К настоящему моменту префиксы уже удалены в реализациях IndexedDB в Internet Explorer 10, Firefox 16 и Chrome 24. Браузеры, построенные на базе Gecko пока ещё используют префикс moz, а браузеры на базе движка webkit используют префикс webkit.

Использование экспериментальной версии IndexedDB

Для того, чтобы протестировать ваше веб-приложение на браузерах, которые пока ещё не отказались от префикса, можно воспользоваться следующим кодом:

window.indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;


window.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction;
window.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;

Имейте в виду, что  реализации, в которых всё ещё используются префиксы, могут содержать ошибки, быть неполными или следовать устаревшей спецификации. Поэтому их не рекомендуется использовать в ваших рабочих проектах. Предпочтительнее отказаться от таких браузеров, чем получать от них ошибки:

 if (!window.indexedDB) {
    window.alert("Ваш браузер не поддерживает стабильную версию IndexedDB. Такие-то функции будут недоступны");
}

Открытие базы данных

Как-то так:

var request = window.indexedDB.open("MyTestDatabase", 3);

Видите? Открытие базы данных, подобно любым другим операциям, запускается запросом.

На  самом деле запрос открытия базы данных не приводит к немедленному открытию базы или запуску транзакции. Вызов функции open() вернёт объект IDBOpenDBRequest , содержащий результат (если успешно) или ошибку, которую вы можете обработать как событие. Большинство других асинхронных функций IndexedDB делает то же самое — возвращает объект IDBRequest  с результатом или ошибкой. Результат функции open всегда возвращает экземпляр объекта IDBDatabase.

Второй параметр метода open — это версия базы данных. Версия определяет схему базы данных — хранилище объектов  и их структуру . Если база данных ещё не существует, то она создаётся операцией open, затем срабатывает триггер события onupgradeneeded и после этого  ваш обработчик этого события создаёт схему базы данных. Если же база данных уже существует, а вы указываете новый номер версии, то сразу же срабатывает триггер события onupgradeneeded, позволяя вам обновить схему базы данных в обработчике. Подробнее об этом см. в Обновление версии базы данных ниже и на странице IDBFactory.open (en-US) справочника

Версия базы данных имеет внутреннее представление unsigned long long number (длинное длинное целое без знака), то есть может принимать очень большие целые значения. Имейте в виду также, что нет смысла использовать в качестве версии базы данных значение с плавающей точкой (float), потому что оно будет сконвертировано в ближайшее меньшее целое. В результате неожиданно может не запуститься транзакция или сработать триггер события upgradeneeded. Например, не используйте значение  2.4 как версию базы данных:

var request = indexedDB.open("MyTestDatabase", 2.4); 

Установка обработчиков

Первое, что понадобится сделать практически со всеми запросами, которые вы создаёте — это добавить обработчики событий успеха и ошибки:

request.onerror = function(event) {
  
};
request.onsuccess = function(event) {
  
};

Какая из двух функций - onsuccess() или onerror() — должна быть вызвана?  Если всё в порядке — то инициируется событие успеха (это событие DOM,  свойство type которого выставлено в "success")  с request в качестве target. Это вызывает запуск  функции onsuccess() объекта request  с событием успеха в качестве аргумента. В противном случае, если возникают какие-то проблемы, то происходит событие ошибки (то есть событие DOM, свойство type которого установлено в  "error") . Это приводит к запуску  функции onerror() с событием ошибки в качестве аргумента.

IndexedDB API разработан так, чтобы минимизировать необходимость обработки ошибок, поэтому скорее всего вы не встретите много событий ошибки запроса (по крайней мере если вы будете использовать этот API!). Однако при открытии базы данных есть несколько общих условий, которые генерируют события ошибок. Наиболее вероятной проблемой является запрет вашему веб-приложению на создание базы данных, установленный пользователем в браузере. Одной из основных целей разработки IndexedDB — это обеспечение возможности сохранения больших объёмов данных для использования офлайн. (Чтобы узнать,  сколько памяти вы можете использовать в разных браузерах, обратитесь к Ограничениям памяти).

Конечно же, браузеры стремятся не позволить назойливым рекламным сетям или вредоносным сайтам засорять ваш компьютер. Поэтому при первой попытке любого веб-приложения открыть хранилище IndexedDB, браузер запрашивает разрешение пользователя. Пользователь может выбрать — то ли разрешить, то ли запретить доступ. Кроме этого, в приватных режимах браузеров (частный просмотр для Firefox и режим инкогнито для Chrome), IndexedDB полностью запрещена для использования. Так как цель приватных режимов — не оставлять следов, то открытие базы данных невозможно в таких режимах.

А теперь предположим, что пользователь разрешил вашему запросу создать базу данных и состоялось событие успеха, запустившее обработчик события успеха. Что дальше? Так как ваш запрос был сгенерирован с вызовом метода indexedDB.open(), то request.result   является экземпляром объекта IDBDatabase и вы определённо захотите сохранить его для будущего использования. Ваш код может выглядеть примерно так:

var db;
var request = indexedDB.open("MyTestDatabase");
request.onerror = function(event) {
  alert("Почему вы не позволяете моему веб-приложению использовать IndexedDB?!");
};
request.onsuccess = function(event) {
  db = event.target.result;
};

Обработка ошибок

Как уже упоминалось выше, события ошибки всплывают. Событие ошибки нацелено (в фазе перехвата) на запрос, который сгенерировал ошибку, затем событие всплывает до уровня транзакции и наконец достигает уровня объекта базы данных. Если вы хотите избежать установки отдельных обработчиков на каждый запрос, то вы можете вместо этого установить один единственный обработчик на объект базы данных, например так:

db.onerror = function(event) {
  
  alert("Database error: " + event.target.errorCode);
};

Одной из возможных ошибок при открытии базы данных является VER_ERR. Она сигнализирует о том, что версия базы данных, сохранённая на диске, больше, чем версия, которую вы пытаетесь открыть. Такая ошибка должна быть в обязательном порядке обработана обработчиком ошибок. 

Создание или обновление версии базы данных

Когда вы создаёте новую базу данных или увеличиваете номер версии существующей базы данных (задавая больший номер версии, чем тот номер, который был вами указан при Opening a database) запускается событие onupgradeneeded. В обработчике этого события вы должны создать хранилище объектов, необходимое для этой версии базы данных:

request.onupgradeneeded = function(event) {
  var db = event.target.result;

  
  var objectStore = db.createObjectStore("name", { keyPath: "myKey" });
};

Версия числа без знака с длиной long long, может быть очень большим.

Так же вы не можете использовать float, его значение будет округлено до ближайшего целого, со всеми вытекающими из этого ошибками:

var request = indexedDB.open("MyTestDatabase", 2.4); 

Когда вы увеличиваете номер версии, будет инициировано событие onupgradeneeded. В этот момент БД будет хранить старые объекты. Но для всякого объекта прошлой версии стоит создать новый объект, совместимый с новой версией. Если вам необходимо исправить существующий объект в БД (например, для изменения keyPath), то вы можете удалить объект и создать его вновь с новыми параметрами (помните, что удаление стирает информацию, так что не забывайте сохранять то, что вам нужно).

WebKit поддерживает текущую версию спецификации в Google Chrome 23 и старше. Так что там нет события indexedDB.open(name, version).onupgradeneeded. Однако, вы можете ознакомиться с инструкцией о том, что делать со старым Webkit.

Структура базы данных

Now to structure the database. IndexedDB uses object stores rather than tables, and a single database can contain any number of object stores. Whenever a value is stored in an object store, it is associated with a key. There are several different ways that a key can be supplied depending on whether the object store uses a key path or a key generator.

The following table shows the different ways the keys are supplied. 

You can also create indices on any object store, provided the object store holds objects, not primitives. An index lets you look up the values stored in an object store using the value of a property of the stored object, rather than the object’s key.

Additionally, indexes have the ability to enforce simple constraints on the stored data. By setting the unique flag when creating the index, the index ensures that no two objects are stored with both having the same value for the index’s key path. So, for example, if you have an object store which holds a set of people, and you want to ensure that no two people have the same email address, you can use an index with the unique flag set to enforce this.

That may sound confusing, but this simple example should illustrate the concepts:

const customerData = [
  { ssn: "444-44-4444", name: "Bill", age: 35, email: "[email protected]" },
  { ssn: "555-55-5555", name: "Donna", age: 32, email: "[email protected]" }
];
const dbName = "the_name";

var request = indexedDB.open(dbName, 2);

request.onerror = function(event) {
  
};
request.onupgradeneeded = function(event) {
  var db = event.target.result;

  
  
  
  var objectStore = db.createObjectStore("customers", { keyPath: "ssn" });

  
  
  objectStore.createIndex("name", "name", { unique: false });

  
  
  objectStore.createIndex("email", "email", { unique: true });

  
  for (var i in customerData) {
    objectStore.add(customerData[i]);
  }
};

As mentioned previously, onupgradeneeded is the only place where you can alter the structure of the database. In it, you can create and delete object stores and build and remove indices.

Object stores are created with a single call to createObjectStore(). The method takes a name of the store, and a parameter object. Even though the parameter object is optional, it is very important, because it lets you define important optional properties and refine the type of object store you want to create. In our case, we’ve asked for an object store named «customers» and  defined a keyPath that is the property that makes an individual object in the store unique. That property in this example is «ssn» since a social security number is guaranteed to be unique. «ssn» must be present on every object that is stored in the objectStore. 

We’ve also asked for an index named «name» that looks at the name property of the stored objects. As with createObjectStore(), createIndex() takes an optional options object that refines the type of  index that you want to create. Adding objects that don’t have a name property still succeeds, but the object won’t appear in the «name» index.

We can now retrieve the stored customer objects using their ssn from the object store directly, or using their name by using the index. To learn how this is done, see the section on using an index.

Before you can do anything with your new database, you need to start a transaction. Transactions come from the database object, and you have to specify which object stores you want the transaction to span. Also, you need to decide if you’re going to make changes to the database or if you just need to read from it.  Although transactions have three modes (read-only, read/write, and versionchange), you’re better off using a read-only transaction when you can, because they can run concurrently

Adding data to the database

If you’ve just created a database, then you probably want to write to it. Here’s what that looks like:

var transaction = db.transaction(["customers"], "readwrite");

The transaction() function takes two arguments (though one is optional) and returns a transaction object. The first argument is a list of object stores that the transaction will span. You can pass an empty array if you want the transaction to span all object stores, but don’t do it because the spec says an empty array should generate an InvalidAccessError. If you don’t specify anything for the second argument, you get a read-only transaction. Since you want to write to it here you need to pass the "readwrite" flag.

Now that you have a transaction you need to understand its lifetime. Transactions are tied very closely to the event loop. If you make a transaction and return to the event loop without using it then the transaction will become inactive. The only way to keep the transaction active is to make a request on it. When the request is finished you’ll get a DOM event and, assuming that the request succeeded, you’ll have another opportunity to extend the transaction during that callback. If you return to the event loop without extending the transaction then it will become inactive, and so on. As long as there are pending requests the transaction remains active. Transaction lifetimes are really very simple but it might take a little time to get used to. A few more examples will help, too. If you start seeing TRANSACTION_INACTIVE_ERR error codes then you’ve messed something up.

Transactions can receive DOM events of three different types: error, abort, and complete. We’ve talked about the way that error events bubble, so a transaction  receives error events from any requests that are generated from it. A more subtle point here is that the default behavior of an error is to abort the transaction in which it occurred. Unless you handle the error by calling preventDefault() on the error event, the entire transaction is rolled back. This design forces you to  think about and handle errors, but you can always add a catchall error handler to the database if fine grained error handling is too cumbersome. If you don’t handle an error event or if you call abort() on the transaction, then the transaction is rolled back and an abort event is fired on the transaction. Otherwise, after all pending requests have completed, you’ll get a complete event. If you’re doing lots of database operations, then tracking the transaction rather than individual requests can certainly aide your sanity.

Now that you have a transaction, you’ll need to get the object store from it. Transactions only let you have an object store that you specified when creating the transaction. Then you can add all the data you need.

transaction.oncomplete = function(event) {
  alert("All done!");
};

transaction.onerror = function(event) {
  
};

var objectStore = transaction.objectStore("customers");
for (var i in customerData) {
  var request = objectStore.add(customerData[i]);
  request.onsuccess = function(event) {
    
  };
}

The result of a request generated from a call to add() is the key of the value that was added. So in this case, it should equal the ssn property of the object that was added, since the object store uses the ssn property for the key path. Note that the add() function requires that no object already be in the database with the same key. If you’re trying to modify an existing entry, or you don’t care if one exists already, use the put() function.

Removing data is very similar:

var request = db.transaction(["customers"], "readwrite")
                .objectStore("customers")
                .delete("444-44-4444");
request.onsuccess = function(event) {
  
};

Now that the database has some info in it, you can retrieve it in several ways. First, the simple get(). You need to provide the key to retrieve the value, like so:

var transaction = db.transaction(["customers"]);
var objectStore = transaction.objectStore("customers");
var request = objectStore.get("444-44-4444");
request.onerror = function(event) {
  
};
request.onsuccess = function(event) {
  
  alert("Name for SSN 444-44-4444 is " + request.result.name);
};

That’s a lot of code for a «simple» retrieval. Here’s how you can shorten it up a bit, assuming that you handle errors at the database level:

db.transaction("customers").objectStore("customers").get("444-44-4444").onsuccess = function(event) {
  alert("Name for SSN 444-44-4444 is " + event.target.result.name);
};

See how this works? Since there’s only one object store, you can avoid passing a list of object stores you need in your transaction and just pass the name as a string. Also, you’re only reading from the database, so you don’t need a "readwrite" transaction. Calling transaction() with no mode specified gives you a "readonly" transaction. Another subtlety here is that you don’t actually save the request object to a variable. Since the DOM event has the request as its target you can use the event to get to the result property. Easy, right?!

Using get() requires that you know which key you want to retrieve. If you want to step through all the values in your object store, then you can use a cursor. Here’s what it looks like:

var objectStore = db.transaction("customers").objectStore("customers");

objectStore.openCursor().onsuccess = function(event) {
  var cursor = event.target.result;
  if (cursor) {
    alert("Name for SSN " + cursor.key + " is " + cursor.value.name);
    cursor.continue();
  }
  else {
    alert("No more entries!");
  }
};

The openCursor() function takes several arguments. First, you can limit the range of items that are retrieved by using a key range object that we’ll get to in a minute. Second, you can specify the direction that you want to iterate. In the above example, we’re iterating over all objects in ascending order. The success callback for cursors is a little special. The cursor object itself is the result of the request (above we’re using the shorthand, so it’s event.target.result). Then the actual key and value can be found on the key and value properties of the cursor object. If you want to keep going, then you have to call continue() on the cursor. When you’ve reached the end of the data (or if there were no entries that matched your openCursor() request) you still get a success callback, but the result property is undefined.

One common pattern with cursors is to retrieve all objects in an object store and add them to an array, like this:

var customers = [];

objectStore.openCursor().onsuccess = function(event) {
  var cursor = event.target.result;
  if (cursor) {
    customers.push(cursor.value);
    cursor.continue();
  }
  else {
    alert("Got all customers: " + customers);
  }
};

Warning: The following function is not part of the IndexedDB standard!

Mozilla has also implemented getAll() to handle this case. It isn’t part of the IndexedDB standard, so it may disappear in the future. We’ve included it because we think it’s useful. The following code does precisely the same thing as above:

objectStore.getAll().onsuccess = function(event) {
  alert("Got all customers: " + event.target.result);
};

There is a performance cost associated with looking at the value property of a cursor, because the object is created lazily. When you use getAll(), Gecko must create all the objects at once. If you’re just interested in looking at each of the keys, for instance, it is much more efficient to use a cursor than to use getAll(). If you’re trying to get an array of all the objects in an object store, though, use getAll().

Using an index

Storing customer data using the SSN as a key is logical since the SSN uniquely identifies an individual. (Whether this is a good idea for privacy is a different question, outside the scope of this article.) If you need to look up a customer by name, however, you’ll need to iterate over every SSN in the database until you find the right one. Searching in this fashion would be very slow, so instead you can use an index.

var index = objectStore.index("name");
index.get("Donna").onsuccess = function(event) {
  alert("Donna's SSN is " + event.target.result.ssn);
};

The «name» cursor isn’t unique, so there could be more than one entry with the name set to "Donna". In that case you always get the one with the lowest key value.

If you need to access all the entries with a given name you can use a cursor. You can open two different types of cursors on indexes. A normal cursor maps the index property to the object in the object store. A key cursor maps the index property to the key used to store the object in the object store. The differences are illustrated here:

index.openCursor().onsuccess = function(event) {
  var cursor = event.target.result;
  if (cursor) {
    
    alert("Name: " + cursor.key + ", SSN: " + cursor.value.ssn + ", email: " + cursor.value.email);
    cursor.continue();
  }
};

index.openKeyCursor().onsuccess = function(event) {
  var cursor = event.target.result;
  if (cursor) {
    
    
    alert("Name: " + cursor.key + ", SSN: " + cursor.value);
    cursor.continue();
  }
};

Specifying the range and direction of cursors

If you would like to limit the range of values you see in a cursor, you can use a key range object and pass it as the first argument to openCursor() or openKeyCursor(). You can make a key range that only allows a single key, or one the has a lower or upper bound, or one that has both a lower and upper bound. The bound may be «closed» (i.e., the key range includes the given value) or «open» (i.e., the key range does not include the given value). Here’s how it works:

var singleKeyRange = IDBKeyRange.only("Donna");


var lowerBoundKeyRange = IDBKeyRange.lowerBound("Bill");


var lowerBoundOpenKeyRange = IDBKeyRange.lowerBound("Bill", true);


var upperBoundOpenKeyRange = IDBKeyRange.upperBound("Donna", true);


var boundKeyRange = IDBKeyRange.bound("Bill", "Donna", false, true);

index.openCursor(boundKeyRange).onsuccess = function(event) {
  var cursor = event.target.result;
  if (cursor) {
    
    cursor.continue();
  }
};

Sometimes you may want to iterate in descending order rather than in ascending order (the default direction for all cursors). Switching direction is accomplished by passing prev to the openCursor() function:

objectStore.openCursor(null, IDBCursor.prev).onsuccess = function(event) {
  var cursor = event.target.result;
  if (cursor) {
    
    cursor.continue();
  }
};

Since the «name» index isn’t unique, there might be multiple entries where name is the same. Note that such a situation cannot occur with object stores since the key must always be unique. If you wish to filter out duplicates during cursor iteration over indexes, you can pass nextunique (or prevunique if you’re going backwards) as the direction parameter. When nextunique or prevunique is used, the entry with the lowest key is always the one returned.

index.openKeyCursor(null, IDBCursor.nextunique).onsuccess = function(event) {
  var cursor = event.target.result;
  if (cursor) {
    
    cursor.continue();
  }
};

When your web app changes in such a way that a version change is required for your database, you need to consider what happens if the user has the old version of your app open in one tab and then loads the new version of your app in another. When you call open() with a greater version than the actual version of the database, all other open databases must explicitly acknowledge the request before you can start making changes to the database. Here’s how it works:

var openReq = mozIndexedDB.open("MyTestDatabase", 2);

openReq.onblocked = function(event) {
  
  
  alert("Please close all other tabs with this site open!");
};

openReq.onupgradeneeded = function(event) {
  
  db.createObjectStore();
  useDatabase(db);
}

openReq.onsuccess = function(event) {
  var db = event.target.result;
  useDatabase(db);
  return;
}

function useDatabase(db) {
  
  
  
  db.onversionchange = function(event) {
    db.close();
    alert("A new version of this page is ready. Please reload!");
  };

  
}

IndexedDB uses the same-origin principle, which means that it ties the store to the origin of the site that creates it (typically, this is the site domain or subdomain), so it cannot be accessed by any other origin.

It’s important to note that IndexedDB doesn’t work for content loaded into a frame from another site (either <frame> (en-US) or <iframe> (en-US). This is a security and privacy measure and can be considered analogous the blocking of 3rd-party cookies.  For more details, see баг 595307.

When the browser shuts down (e.g., when the user selects Exit or clicks the Close button),  any pending IndexedDB transactions are (silently) aborted — they will not complete, and they will not trigger the error handler.  Since the user can exit the browser at any time, this means that you cannot rely upon any particular transaction to complete or to know that it did not complete.  There are several implications of this behavior.

First, you should take care to always leave your database in a consistent state at the end of every transaction.  For example, suppose that you are using IndexedDB to store a list of items that you allow the user to edit.  You save the list after the edit by clearing the object store and then writing out the new list.  If you clear the object store in one transaction and write the new list in another transaction, there is a danger that the browser will close after the clear but before the write, leaving you with an empty database.  To avoid this, you should combine the clear and the write into a single transaction. 

Second, you should never tie database transactions to unload events.  If the unload event is triggered by the browser closing, any transactions created in the unload event handler will never complete.  An intuitive approach to maintaining some information across browser sessions is to read it from the database when the browser (or a particular page) is opened, update it as the user interacts with the browser, and then save it to the database when the browser (or page) closes.  However, this will not work.  The database transactions will be created in the unload event handler, but because they are asynchronous they will be aborted before they can execute.

In fact, there is no way to guarantee that IndexedDB transactions will complete, even with normal browser shutdown.  See баг 870645.

HTML Content

<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.8.3/jquery.min.js"></script>

    <h2>IndexedDB Demo: storing blobs, e-publication example</h2>
    <div>
      <p>
        Works and tested with:
      </p>
      <div>
      </div>
    </div>

    <div>
    </div>

    <form>
      <table>
        <tbody>
          <tr>
            <td>
              <label for="pub-title">
                Title:
              </label>
            </td>
            <td>
              <input type="text" name="pub-title" />
            </td>
          </tr>
          <tr>
            <td>
              <label for="pub-biblioid">
                Bibliographic ID:<br/>
                <span>(ISBN, ISSN, etc.)</span>
              </label>
            </td>
            <td>
              <input type="text" name="pub-biblioid"/>
            </td>
          </tr>
          <tr>
            <td>
              <label for="pub-year">
                Year:
              </label>
            </td>
            <td>
              <input type="number" name="pub-year" />
            </td>
          </tr>
        </tbody>
        <tbody>
          <tr>
            <td>
              <label for="pub-file">
                File image:
              </label>
            </td>
            <td>
              <input type="file"/>
            </td>
          </tr>
          <tr>
            <td>
              <label for="pub-file-url">
                Online-file image URL:<br/>
                <span>(same origin URL)</span>
              </label>
            </td>
            <td>
              <input type="text" name="pub-file-url"/>
            </td>
          </tr>
        </tbody>
      </table>

      <div>
        <input type="button" value="Add Publication" />
        <input type="reset"/>
      </div>
    </form>

    <form>
      <table>
        <tbody>
          <tr>
            <td>
              <label for="pub-biblioid-to-delete">
                Bibliographic ID:<br/>
                <span>(ISBN, ISSN, etc.)</span>
              </label>
            </td>
            <td>
              <input type="text"
                     name="pub-biblioid-to-delete" />
            </td>
          </tr>
          <tr>
            <td>
              <label for="key-to-delete">
                Key:<br/>
                <span>(for example 1, 2, 3, etc.)</span>
              </label>
            </td>
            <td>
              <input type="text"
                     name="key-to-delete" />
            </td>
          </tr>
        </tbody>
      </table>
      <div>
        <input type="button" value="Delete Publication" />
        <input type="button"
               value="Clear the whole store" />
      </div>
    </form>

    <form>
      <div>
        <input type="button"
               value="List database content" />
      </div>
    </form>

    <div>
      <div>
      </div>
      <div>
      </div>
      <ul>
      </ul>
    </div>

CSS Content

body {
  font-size: 0.8em;
  font-family: Sans-Serif;
}

form {
  background-color: #cccccc;
  border-radius: 0.3em;
  display: inline-block;
  margin-bottom: 0.5em;
  padding: 1em;
}

table {
  border-collapse: collapse;
}

input {
  padding: 0.3em;
  border-color: #cccccc;
  border-radius: 0.3em;
}

.required:after {
  content: "*";
  color: red;
}

.button-pane {
  margin-top: 1em;
}

#pub-viewer {
  float: right;
  width: 48%;
  height: 20em;
  border: solid #d092ff 0.1em;
}
#pub-viewer iframe {
  width: 100%;
  height: 100%;
}

#pub-list {
  width: 46%;
  background-color: #eeeeee;
  border-radius: 0.3em;
}
#pub-list li {
  padding-top: 0.5em;
  padding-bottom: 0.5em;
  padding-right: 0.5em;
}

#msg {
  margin-bottom: 1em;
}

.action-success {
  padding: 0.5em;
  color: #00d21e;
  background-color: #eeeeee;
  border-radius: 0.2em;
}

.action-failure {
  padding: 0.5em;
  color: #ff1408;
  background-color: #eeeeee;
  border-radius: 0.2em;
}

.note {
  font-size: smaller;
}

.destructive {
  background-color: orange;
}
.destructive:hover {
  background-color: #ff8000;
}
.destructive:active {
  background-color: red;
}

JavaScript Content

(function () {
  var COMPAT_ENVS = [
    ['Firefox', ">= 16.0"],
    ['Google Chrome',
     ">= 24.0 (you may need to get Google Chrome Canary), NO Blob storage support"]
  ];
  var compat = $('#compat');
  compat.empty();
  compat.append('<ul></ul>');
  COMPAT_ENVS.forEach(function(val, idx, array) {
    $('#compat-list').append('<li>' + val[0] + ': ' + val[1] + '</li>');
  });

  const DB_NAME = 'mdn-demo-indexeddb-epublications';
  const DB_VERSION = 1; 
  const DB_STORE_NAME = 'publications';

  var db;

  
  var current_view_pub_key;

  function openDb() {
    console.log("openDb ...");
    var req = indexedDB.open(DB_NAME, DB_VERSION);
    req.onsuccess = function (evt) {
      
      
      
      db = this.result;
      console.log("openDb DONE");
    };
    req.onerror = function (evt) {
      console.error("openDb:", evt.target.errorCode);
    };

    req.onupgradeneeded = function (evt) {
     console.log("openDb.onupgradeneeded");
     var thisDB = evt.target.result;
     if (!thisDB.objectStoreNames.contains(DB_STORE_NAME)) {
      var store = thisDB.createObjectStore(
          DB_STORE_NAME, { keyPath: 'id', autoIncrement: true });

        store.createIndex('biblioid', 'biblioid', { unique: true });
        store.createIndex('title', 'title', { unique: false });
        store.createIndex('year', 'year', { unique: false });
      }
    };
  }

  
  function getObjectStore(store_name, mode) {
    var tx = db.transaction(store_name, mode);
    return tx.objectStore(store_name);
  }

  function clearObjectStore(store_name) {
    var store = getObjectStore(DB_STORE_NAME, 'readwrite');
    var req = store.clear();
    req.onsuccess = function(evt) {
      displayActionSuccess("Store cleared");
      displayPubList(store);
    };
    req.onerror = function (evt) {
      console.error("clearObjectStore:", evt.target.errorCode);
      displayActionFailure(this.error);
    };
  }

  function getBlob(key, store, success_callback) {
    var req = store.get(key);
    req.onsuccess = function(evt) {
      var value = evt.target.result;
      if (value)
        success_callback(value.blob);
    };
  }

  
  function displayPubList(store) {
    console.log("displayPubList");

    if (typeof store == 'undefined')
      store = getObjectStore(DB_STORE_NAME, 'readonly');

    var pub_msg = $('#pub-msg');
    pub_msg.empty();
    var pub_list = $('#pub-list');
    pub_list.empty();
    
    newViewerFrame();

    var req;
    req = store.count();
    
    
    
    
    req.onsuccess = function(evt) {
      pub_msg.append('<p>There are <strong>' + evt.target.result +
                     '</strong> record(s) in the object store.</p>');
    };
    req.onerror = function(evt) {
      console.error("add error", this.error);
      displayActionFailure(this.error);
    };

    var i = 0;
    req = store.openCursor();
    req.onsuccess = function(evt) {
      var cursor = evt.target.result;

      
      if (cursor) {
        console.log("displayPubList cursor:", cursor);
        req = store.get(cursor.key);
        req.onsuccess = function (evt) {
          var value = evt.target.result;
          var list_item = $('<li>' +
                            '[' + cursor.key + '] ' +
                            '(biblioid: ' + value.biblioid + ') ' +
                            value.title +
                            '</li>');
          if (value.year != null)
            list_item.append(' - ' + value.year);

          if (value.hasOwnProperty('blob') &&
              typeof value.blob != 'undefined') {
            var link = $('<a href="' + cursor.key + '">File</a>');
            link.on('click', function() { return false; });
            link.on('mouseenter', function(evt) {
                      setInViewer(evt.target.getAttribute('href')); });
            list_item.append(' / ');
            list_item.append(link);
          } else {
            list_item.append(" / No attached file");
          }
          pub_list.append(list_item);
        };

        
        cursor.continue();

        
        i++;
      } else {
        console.log("No more entries");
      }
    };
  }

  function newViewerFrame() {
    var viewer = $('#pub-viewer');
    viewer.empty();
    var iframe = $('<iframe />');
    viewer.append(iframe);
    return iframe;
  }

  function setInViewer(key) {
    console.log("setInViewer:", arguments);
    key = Number(key);
    if (key == current_view_pub_key)
      return;

    current_view_pub_key = key;

    var store = getObjectStore(DB_STORE_NAME, 'readonly');
    getBlob(key, store, function(blob) {
      console.log("setInViewer blob:", blob);
      var iframe = newViewerFrame();

      
      
      if (blob.type == 'text/html') {
        var reader = new FileReader();
        reader.onload = (function(evt) {
          var html = evt.target.result;
          iframe.load(function() {
            $(this).contents().find('html').html(html);
          });
        });
        reader.readAsText(blob);
      } else if (blob.type.indexOf('image/') == 0) {
        iframe.load(function() {
          var img_id = 'image-' + key;
          var img = $('<img/>');
          $(this).contents().find('body').html(img);
          var obj_url = window.URL.createObjectURL(blob);
          $(this).contents().find('#' + img_id).attr('src', obj_url);
          window.URL.revokeObjectURL(obj_url);
        });
      } else if (blob.type == 'application/pdf') {
        $('*').css('cursor', 'wait');
        var obj_url = window.URL.createObjectURL(blob);
        iframe.load(function() {
          $('*').css('cursor', 'auto');
        });
        iframe.attr('src', obj_url);
        window.URL.revokeObjectURL(obj_url);
      } else {
        iframe.load(function() {
          $(this).contents().find('body').html("No view available");
        });
      }

    });
  }

  
  function addPublicationFromUrl(biblioid, title, year, url) {
    console.log("addPublicationFromUrl:", arguments);

    var xhr = new XMLHttpRequest();
    xhr.open('GET', url, true);
    
    
    xhr.responseType = 'blob';
    xhr.onload = function (evt) {
                           if (xhr.status == 200) {
                             console.log("Blob retrieved");
                             var blob = xhr.response;
                             console.log("Blob:", blob);
                             addPublication(biblioid, title, year, blob);
                           } else {
                             console.error("addPublicationFromUrl error:",
                                           xhr.responseText, xhr.status);
                           }
                         };
    xhr.send();

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
  }

  
  function addPublication(biblioid, title, year, blob) {
    console.log("addPublication arguments:", arguments);
    var obj = { biblioid: biblioid, title: title, year: year };
    if (typeof blob != 'undefined')
      obj.blob = blob;

    var store = getObjectStore(DB_STORE_NAME, 'readwrite');
    var req;
    try {
      req = store.add(obj);
    } catch (e) {
      if (e.name == 'DataCloneError')
        displayActionFailure("This engine doesn't know how to clone a Blob, " +
                             "use Firefox");
      throw e;
    }
    req.onsuccess = function (evt) {
      console.log("Insertion in DB successful");
      displayActionSuccess();
      displayPubList(store);
    };
    req.onerror = function() {
      console.error("addPublication error", this.error);
      displayActionFailure(this.error);
    };
  }

  
  function deletePublicationFromBib(biblioid) {
    console.log("deletePublication:", arguments);
    var store = getObjectStore(DB_STORE_NAME, 'readwrite');
    var req = store.index('biblioid');
    req.get(biblioid).onsuccess = function(evt) {
      if (typeof evt.target.result == 'undefined') {
        displayActionFailure("No matching record found");
        return;
      }
      deletePublication(evt.target.result.id, store);
    };
    req.onerror = function (evt) {
      console.error("deletePublicationFromBib:", evt.target.errorCode);
    };
  }

  
  function deletePublication(key, store) {
    console.log("deletePublication:", arguments);

    if (typeof store == 'undefined')
      store = getObjectStore(DB_STORE_NAME, 'readwrite');

    
    
    
    
    var req = store.get(key);
    req.onsuccess = function(evt) {
      var record = evt.target.result;
      console.log("record:", record);
      if (typeof record == 'undefined') {
        displayActionFailure("No matching record found");
        return;
      }
      
      
      
      req = store.delete(key);
      req.onsuccess = function(evt) {
        console.log("evt:", evt);
        console.log("evt.target:", evt.target);
        console.log("evt.target.result:", evt.target.result);
        console.log("delete successful");
        displayActionSuccess("Deletion successful");
        displayPubList(store);
      };
      req.onerror = function (evt) {
        console.error("deletePublication:", evt.target.errorCode);
      };
    };
    req.onerror = function (evt) {
      console.error("deletePublication:", evt.target.errorCode);
      };
  }

  function displayActionSuccess(msg) {
    msg = typeof msg != 'undefined' ? "Success: " + msg : "Success";
    $('#msg').html('<span>' + msg + '</span>');
  }
  function displayActionFailure(msg) {
    msg = typeof msg != 'undefined' ? "Failure: " + msg : "Failure";
    $('#msg').html('<span>' + msg + '</span>');
  }
  function resetActionStatus() {
    console.log("resetActionStatus ...");
    $('#msg').empty();
    console.log("resetActionStatus DONE");
  }

  function addEventListeners() {
    console.log("addEventListeners");

    $('#register-form-reset').click(function(evt) {
      resetActionStatus();
    });

    $('#add-button').click(function(evt) {
      console.log("add ...");
      var title = $('#pub-title').val();
      var biblioid = $('#pub-biblioid').val();
      if (!title || !biblioid) {
        displayActionFailure("Required field(s) missing");
        return;
      }
      var year = $('#pub-year').val();
      if (year != '') {
        
        if (isNaN(year))  {
          displayActionFailure("Invalid year");
          return;
        }
        year = Number(year);
      } else {
        year = null;
      }

      var file_input = $('#pub-file');
      var selected_file = file_input.get(0).files[0];
      console.log("selected_file:", selected_file);
      
      
      
      
      var file_url = $('#pub-file-url').val();
      if (selected_file) {
        addPublication(biblioid, title, year, selected_file);
      } else if (file_url) {
        addPublicationFromUrl(biblioid, title, year, file_url);
      } else {
        addPublication(biblioid, title, year);
      }

    });

    $('#delete-button').click(function(evt) {
      console.log("delete ...");
      var biblioid = $('#pub-biblioid-to-delete').val();
      var key = $('#key-to-delete').val();

      if (biblioid != '') {
        deletePublicationFromBib(biblioid);
      } else if (key != '') {
        
        if (key == '' || isNaN(key))  {
          displayActionFailure("Invalid key");
          return;
        }
        key = Number(key);
        deletePublication(key);
      }
    });

    $('#clear-store-button').click(function(evt) {
      clearObjectStore();
    });

    var search_button = $('#search-list-button');
    search_button.click(function(evt) {
      displayPubList();
    });

  }

  openDb();
  addEventListeners();

})(); 

Test the online live demo

If you want to start tinkering with the API, jump in to the reference documentation and checking out the different methods.

Reference

Tutorials

Related articles

Firefox

Информационные блоки:Для разработчиков

NPS (Индекс потребительской лояльности) — КОММУНИКАЦИИ

NPS (Индекс потребительской лояльности) для оценки работы менеджера клиентом.
Чтобы включить и настроить NPS, нужно перейти в раздел «Настройки» — «Коммуникации». Качество работы с клиентом можно оценить по десятибалльной шкале. Пользователь может выбрать критическую оценку, меньше или равная которой оценка считается неудовлетворительной.

Для настройки понадобится:

1. Указать текст сообщения, который будет отправлен клиенту при закрытии беседы;
2. Руководителя, которому будет приходить уведомление в центр уведомлений в случае получения оценки ниже установленной;
3. Оценка, ниже которой руководитель будет получать уведомление.

При включенном режиме NPS и после закрытия беседы, нажав на номер беседы и выбрав «Закрыть беседу», автоматически отправляется настроенное сообщение от бота с просьбой оценить работу сотрудника. Сообщение приходит клиенту в ту социальную сеть, из которой он писал.
Если клиент поставит оценку меньше или равную критической, то руководителю придет нотификация, даже если он не подписан на карточку (сделки или покупателя, где прикреплен чат). Если клиент поставит оценку выше критической, то Бот отправит сообщение «Спасибо за оценку».

Автоматические сообщения для клиента и руководителя, которые приходят от Бота после оценки работы менеджера клиентом, нельзя редактировать. Текст автоматических сообщений:

• Сообщение для клиента, если оценка выше установленной критической оценки: «Спасибо за оценку»;
• Сообщение для клиента, если оценка равна или ниже критической: «Спасибо за оценку, мы сообщим об этом руководителю»;
• Сообщение для руководителя, если оценка неудовлетворительная: «Клиент оценил качество обслуживания ниже установленного уровня.

Статистика — процентное соотношение оценок клиентов по NPS будет отображена на рабочем столе, для этого нужно добавить соответствующий блок через настройки рабочего стола.

Index API | Руководство по Elasticsearch [7.14]

Вы можете проиндексировать новый документ JSON с помощью ресурса _doc или _create . С использованием _create гарантирует, что документ будет проиндексирован только в том случае, если он еще не существовать. Чтобы обновить существующий документ, необходимо использовать ресурс _doc .

Автоматически создавать потоки данных и индексыправить

Если цель запроса не существует и соответствует шаблон индекса с data_stream По определению, операция индексации автоматически создает поток данных.Видеть Настроить поток данных .

Если цель не существует и не соответствует шаблону потока данных, операция автоматически создает индекс и применяет любое соответствие индексные шаблоны.

Если отображение не существует, операция индексации создает динамическое отображение. По умолчанию новые поля и объекты автоматически добавляется в сопоставление при необходимости. Для получения дополнительной информации о поле сопоставление, см. сопоставление и API сопоставления обновлений.

Автоматическое создание индекса управляется действием .auto_create_index параметр. По умолчанию для этого параметра установлено значение , истинное значение , что позволяет создавать любой индекс. автоматически. Вы можете изменить этот параметр, чтобы явно разрешить или заблокировать автоматическое создание индексов, соответствующих указанным шаблонам, или установка для него false , чтобы полностью отключить автоматическое создание индекса. Укажите список шаблонов, разделенных запятыми, которые вы хотите разрешить, или добавьте к каждому шаблону префикс + или - , чтобы указать, следует ли его разрешить или заблокировать.Когда список указано, поведение по умолчанию — запретить.

Параметр action.auto_create_index влияет только на автоматический создание индексов. Это не влияет на создание потоков данных.

 PUT _cluster / настройки
{
  "настойчивый": {
    "action.auto_create_index": "my-index-000001, index10, -index1 *, + ind *" 
  }
}

PUT _cluster / настройки
{
  "настойчивый": {
    "action.auto_create_index": "false" 
  }
}

PUT _cluster / настройки
{
  "настойчивый": {
    "действие.auto_create_index ":" true "
  }
} 

Ставить при отсутствии

Вы можете принудительно выполнить операцию создания с помощью ресурса _create или установив для параметра op_type значение , создайте . В таком случае, операция индексации не выполняется, если документ с указанным идентификатором уже существует в индексе.

Создавать идентификаторы документов автоматически редактировать

При использовании формата запроса POST / / _doc / используется op_type . автоматически устанавливается на , создает , и операция индекса генерирует уникальный идентификатор для документ.

 ЗАПИСЬ my-index-000001 / _doc /
{
  "@timestamp": "2099-11-15T13: 12: 00",
  "message": "GET / search HTTP / 1.1 200 1070000",
  "Пользователь": {
    "id": "кимчы"
  }
} 

API возвращает следующий результат:

 {
  "_shards": {
    «всего»: 2,
    «не удалось»: 0,
    «успешно»: 2
  },
  "_index": "мой-индекс-000001",
   "_type": "_doc",
  "_id": "W0tpsmIBdwcYyG50zbta",
  "_version": 1,
  "_seq_no": 0,
  "_primary_term": 1,
  "результат": "создано"
} 

Оптимистичный контроль параллелизма

Индексные операции могут быть условными и выполняться только в том случае, если последний модификации к документу был присвоен порядковый номер и первичный термин, указанный параметрами if_seq_no и if_primary_term .Если несоответствие обнаружено, операция приведет к VersionConflictException и код состояния 409. Дополнительные сведения см. в разделе Оптимистичное управление параллелизмом.

Маршрутизацияправить

По умолчанию размещение сегментов — или маршрутизация — контролируется с помощью хэш значения идентификатора документа. Для более точного управления значение вводится в хэш-функцию, используемую маршрутизатором, может быть напрямую указан для каждой операции с использованием параметра routing .Например:

 POST my-index-000001 / _doc? Routing = kimchy
{
  "@timestamp": "2099-11-15T13: 12: 00",
  "message": "GET / search HTTP / 1.1 200 1070000",
  "Пользователь": {
    "id": "кимчы"
  }
} 

В этом примере документ направляется в осколок на основе параметр маршрутизации предоставил: «кимчы».

При настройке явного сопоставления можно также использовать поле _routing чтобы направить операцию индекса для извлечения значения маршрутизации из документ.Это происходит за (очень минимальную) стоимость дополнительный проход парсинга документа. Если определено отображение _routing и установлено значение , требуется , операция индекса завершится неудачно, если маршрутизация не выполняется. значение предоставляется или извлекается.

Потоки данных не поддерживают настраиваемую маршрутизацию. Вместо этого нацельтесь на соответствующий индекс поддержки для потока.

Распространяетсяправить

Операция индексации направлена ​​на первичный осколок на основе его маршрута. (см. раздел «Маршрутизация» выше) и выполняется на фактическом узле. содержащий этот осколок.После того, как основной шард завершит операцию, при необходимости обновление распространяется на соответствующие реплики.

Активный осколокправить

Для повышения отказоустойчивости записи в систему операции индексации можно настроить на ожидание определенного количества активных копий шарда прежде чем приступить к операции. Если необходимое количество активных копии осколков недоступны, тогда операция записи должна подождать и повторить попытку, пока не будут запущены необходимые копии сегментов или не истечет время ожидания. имеет место.По умолчанию операции записи ждут только основных шардов. быть активным перед продолжением (т. е. wait_for_active_shards = 1 ). Это значение по умолчанию можно динамически переопределить в настройках индекса. установив index.write.wait_for_active_shards . Чтобы изменить это поведение для каждой операции можно использовать параметр запроса wait_for_active_shards .

Допустимые значения: все или любое положительное целое число вплоть до общего числа. настроенных копий на сегмент в индексе (что составляет число_реплик + 1 ).Указание отрицательного значения или числа, превышающего количество Копии осколков вызовут ошибку.

Например, предположим, что у нас есть кластер из трех узлов: A , B и C и мы создаем индекс , индекс с количеством реплик, равным 3 (в результате 4 копии шарда, на одну копию больше, чем узлов). Если мы попытаться выполнить операцию индексации, по умолчанию операция будет только гарантировать перед продолжением доступна первичная копия каждого осколка.Это означает что даже если B и C выйдут из строя, а на A будут размещены первичные копии шарда, операция индексации по-прежнему будет продолжаться только с одной копией данных. Если wait_for_active_shards установлен в запросе на 3 (и все 3 узла работают), то для операции индексирования потребуется 3 активных копии шарда. прежде, чем продолжить, требование, которое должно быть выполнено, потому что есть 3 активные узлы в кластере, каждый из которых содержит копию осколка.Однако, если мы установим wait_for_active_shards на все (или на 4 , что то же самое), операция индексации не будет продолжена, поскольку у нас нет всех 4 копий каждый шард активен в индексе. Время ожидания операции истечет если в кластере не будет создан новый узел для размещения четвертой копии осколок.

Важно отметить, что этот параметр значительно снижает вероятность операция записи не записывает необходимое количество копий шарда, но это не исключает полностью возможности, потому что эта проверка происходит до начала операции записи.Как только операция записи выполняется, репликация все еще может завершиться неудачно на любом количестве shard копирует, но все равно успешно работает на основном сервере. Раздел _shards Ответ операции записи показывает количество копий осколка, на которых репликация прошла успешно / не удалось.

 {
  "_shards": {
    «всего»: 2,
    «не удалось»: 0,
    «успешно»: 2
  }
} 

Обновить

Указывает, когда изменения, внесенные этим запросом, видны для поиска. Видеть обновить.

Обновления Noopправить

При обновлении документа с помощью index API новая версия документа всегда создается, даже если документ не менялся. Если это неприемлемо используйте API _update с detect_noop , установленным в значение true. Этот вариант не доступный в API индексации, поскольку API индекса не извлекает старый источник и не может сравнить его с новым источником.

Не существует строгого правила о том, когда никакие обновления недопустимы.Это сочетание множества факторов, например, как часто ваш источник данных отправляет обновления, которые на самом деле являются noops и сколько запросов в секунду Elasticsearch работает на шарде, получающем обновления.

Timeoutedit

Первичный сегмент, назначенный для выполнения операции с индексом, может не быть доступен при выполнении операции индексации. Некоторые причины для этого может случиться так, что первичный осколок в настоящее время восстанавливается через шлюз или в процессе переезда. По умолчанию операция индексации будет ждать первичный осколок станет доступным на срок до 1 минуты, прежде чем произойдет сбой и отвечает с ошибкой.Параметр тайм-аут может использоваться для явно укажите, как долго он ждет. Вот пример его настройки до 5 минут:

 PUT my-index-000001 / _doc / 1? Таймаут = 5 мин.
{
  "@timestamp": "2099-11-15T13: 12: 00",
  "message": "GET / search HTTP / 1.1 200 1070000",
  "Пользователь": {
    "id": "кимчы"
  }
} 

Редактирование редакции

Каждому проиндексированному документу присваивается номер версии. По умолчанию, используется внутреннее управление версиями, которое начинается с 1 и увеличивается с каждым обновлением включается удаление.При желании номер версии может быть установлен на внешнее значение (например, если поддерживается в база данных). Чтобы включить эту функцию, для version_type должно быть установлено значение внешний . Предоставленное значение должно быть числовым длинным значением, большим или равным 0, и меньше, чем около 9,2e + 18.

При использовании внешнего типа версии система проверяет, не номер версии, переданный в запрос индекса, больше, чем версия текущего сохраненного документа.Если это правда, документ будет проиндексировано и используется новый номер версии. Если предоставленное значение меньше чем или равно номеру версии сохраненного документа, версия произойдет конфликт, и операция с индексом завершится ошибкой. Например:

 PUT my-index-000001 / _doc / 1? Version = 2 & version_type = external
{
  "Пользователь": {
    "id": "elkbee"
  }
} 

Управление версиями осуществляется полностью в реальном времени, и на него не влияют аспекты поисковых операций в режиме, близком к реальному времени. Если версия не указана, тогда операция выполняется без каких-либо проверок версии.

В предыдущем примере операция завершится успешно, поскольку предоставленный версия 2 выше, чем текущая версия документа 1. Если документ уже был обновлен и его версия была установлена ​​на 2 или выше, команда индексирования завершится ошибкой и приведет к конфликту (код состояния 409 http).

Приятным побочным эффектом является то, что нет необходимости поддерживать строгий порядок. операций асинхронного индексирования, выполняемых в результате изменений в источнике база данных, если используются номера версий из исходной базы данных.Даже простой случай обновления индекса Elasticsearch с использованием данных из база данных упрощается, если используется внешнее управление версиями, так как только последняя версия будет использоваться, если операции с индексами поступают не по порядку для по какой-то причине.

Типы версийправить

В дополнение к типу внешней версии , Elasticsearch также поддерживает другие типы для конкретных случаев использования:

external или external_gt

Индексируйте документ только в том случае, если данная версия строго выше чем версия сохраненного документа или , если документ не существует.Данный версия будет использоваться как новая версия и будет сохранена вместе с новым документом. Поставляемый версия должна быть неотрицательным длинным числом.

external_gte

Индексируйте документ только в том случае, если данная версия равна или выше чем версия сохраненного документа. Если нет существующего документа операция также пройдет успешно. Данная версия будет использоваться как новая версия и будет сохранен с новым документом. Поставляемая версия должна быть неотрицательным длинным числом.

Тип версии external_gte предназначен для особых случаев использования и следует использовать с осторожностью. При неправильном использовании это может привести к потере данных. Есть еще один вариант, force , который устарел, потому что он может вызвать первичный и репликационный сегменты расходятся.

Отправьте следующий HTTP-запрос POST на https: // indexing.googleapis.com/v3/urlNotifications:publish endpoint
{
  "url": "https://careers.google.com/jobs/google/technical-writer",
  "type": "URL_UPDATED"
} 

Отправьте следующий HTTP-запрос POST на https://indexing.googleapis.com/v3/urlNotifications:publish конечную точку
{
  "url": "https://careers.google.com/jobs/google/technical-writer",
  "тип": "URL_DELETED"
} 

Отправьте HTTP-запрос GET на https: // indexing.googleapis.com/v3/urlNotifications/metadata endpoint 

https://indexing.googleapis.com/batch 

POST / пакетный HTTP / 1.1
Хост: indexing.googleapis.com
Content-Length:  content_length 
Content-Type: составной / смешанный; border = "=============== 7330845974216740156 =="
Авторизация: предъявитель  oauth3_token 

- =============== 7330845974216740156 ==
Тип содержимого: application / http
Content-Transfer-Encoding: двоичный
Идентификатор содержимого: 

POST / v3 / urlNotifications: опубликовать   [1]  
Тип содержимого: приложение / json
принять: приложение / json
длина содержимого: 58

{"url": "http: // пример.ru / jobs / 42 "," type ":" URL_UPDATED "}
- =============== 7330845974216740156 ==
Тип содержимого: application / http
Content-Transfer-Encoding: двоичный
Идентификатор содержимого: 

POST / v3 / urlNotifications: опубликовать   [2]  
Тип содержимого: приложение / json
принять: приложение / json
длина содержимого: 75

{"url": "http://example.com/widgets/1", "type": "URL_UPDATED"}
- =============== 7330845974216740156 ==
Тип содержимого: application / http
Content-Transfer-Encoding: двоичный
Идентификатор содержимого: 

POST / v3 / urlNotifications: опубликовать   [3]  
Тип содержимого: приложение / json
принять: приложение / json
длина содержимого: 58

{"url": "http: // пример.ru / jobs / 43 "," type ":" URL_DELETED "}
- =============== 7330845974216740156 ==